鸿蒙日志、崩溃分析与调试实战：从问题定位到线上治理

import hilog from '@ohos.hilog';

const DOMAIN = 0x0001; // 自定义域
const TAG = 'MyApp';

// 日志级别：DEBUG < INFO < WARN < ERROR < FATAL
hilog.debug(DOMAIN, TAG, '调试信息：%{public}s', 'value');
hilog.info(DOMAIN, TAG, '普通信息');
hilog.warn(DOMAIN, TAG, '警告：%{public}d', count);
hilog.error(DOMAIN, TAG, '错误：%{public}s', error.message);

// logger.ets
import hilog from '@ohos.hilog';

const DOMAIN = 0x1001;

export class Logger {
  private tag: string;
  private isDebug: boolean = false; // 从构建配置读取

  constructor(tag: string) {
    this.tag = tag;
  }

  debug(format: string, ...args: any[]) {
    if (this.isDebug) {
      hilog.debug(DOMAIN, this.tag, format, ...args);
    }
  }

  info(format: string, ...args: any[]) {
    hilog.info(DOMAIN, this.tag, format, ...args);
  }

  warn(format: string, ...args: any[]) {
    hilog.warn(DOMAIN, this.tag, format, ...args);
  }

  error(format: string, ...args: any[]) {
    hilog.error(DOMAIN, this.tag, format, ...args);
  }

  // 带错误栈的日志
  logError(message: string, error: Error) {
    hilog.error(DOMAIN, this.tag, '%{public}s: %{public}s\nStack: %{public}s',
      message, error.message, error.stack);
  }
}

// 使用
const logger = new Logger('NetworkModule');
logger.info('请求开始：%{public}s', url);

// EntryAbility.ets
import errorManager from '@ohos.app.ability.errorManager';
import hilog from '@ohos.hilog';

export default class EntryAbility extends UIAbility {
  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam) {
    // 注册全局错误监听
    errorManager.on('error', {
      onUnhandledException: (errMsg: string) => {
        hilog.error(0x0001, 'CrashHandler', 'Unhandled exception: %{public}s', errMsg);
        this.uploadCrashLog(errMsg);
      }
    });
  }

  private uploadCrashLog(errMsg: string) {
    // 上报到服务器或本地持久化
    try {
      // 示例：保存到沙箱文件
      const context = this.context;
      const filePath = `${context.filesDir}/crash_${Date.now()}.log`;
      fs.writeTextSync(filePath, errMsg);
    } catch (e) {
      hilog.error(0x0001, 'CrashHandler', 'Failed to save crash log');
    }
  }

  onDestroy() {
    errorManager.off('error');
  }
}

// 监听 unhandledrejection
errorManager.on('error', {
  onUnhandledException: (errMsg: string) => {
    // 处理同步异常
  },
  onException: (errObject: Error) => {
    // 处理 Promise rejection
    hilog.error(0x0001, 'PromiseError', 'Unhandled rejection: %{public}s', errObject.message);
  }
});

# 实时查看日志
hdc shell hilog

# 按 Tag 过滤
hdc shell hilog -t MyApp

# 按级别过滤（只看 Error 和 Fatal）
hdc shell hilog -L E

# 清空日志
hdc shell hilog -r

# 导出日志到文件
hdc shell hilog > app.log

@Entry
@Component
struct LeakDemo {
  private timer: number = -1;

  aboutToAppear() {
    // ❌ 错误：未清理定时器
    this.timer = setInterval(() => {
      console.log('tick');
    }, 1000);
  }

  aboutToDisappear() {
    // ✅ 正确：清理定时器
    if (this.timer !== -1) {
      clearInterval(this.timer);
      this.timer = -1;
    }
  }
}

export class SecureLogger {
  static maskPhone(phone: string): string {
    return phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2');
  }

  static maskIdCard(idCard: string): string {
    return idCard.replace(/(\d{6})\d{8}(\w{4})/, '$1********$2');
  }

  static logUserAction(action: string, userId: string) {
    hilog.info(0x0001, 'UserAction', '%{public}s, userId: %{public}s',
      action, this.maskUserId(userId));
  }
}

export class LogUploader {
  static uploadIfNeeded(level: string, message: string) {
    if (level === 'ERROR' || level === 'FATAL') {
      // 立即上报
      this.uploadToServer({
        level,
        message,
        timestamp: Date.now(),
        deviceInfo: this.getDeviceInfo()
      });
    } else if (level === 'WARN') {
      // 批量上报
      this.addToBuffer(message);
    }
  }

  private static uploadToServer(log: object) {
    // 调用网络接口上报
  }
}

export class SamplingLogger {
  private static sampleRate = 0.1; // 10% 采样率

  static shouldLog(): boolean {
    return Math.random() < this.sampleRate;
  }

  static debug(tag: string, message: string) {
    if (this.shouldLog()) {
      hilog.debug(0x0001, tag, message);
    }
  }
}

崩溃率 = 崩溃用户数 / 活跃用户数