#日志 (Logger)

import { defineRoutes } from "vextjs";

export default defineRoutes((app) => {
  app.get("/users", async (req, res) => {
    app.logger.info("获取用户列表");
    app.logger.debug({ page: 1, limit: 20 }, "查询参数");

    const users = await app.services.user.findAll();
    app.logger.info({ count: users.length }, "查询完成");

    res.json(users);
  });
});

// src/config/default.ts
export default {
  logger: {
    level: "debug", // 开发环境输出所有级别
  },
};

// src/config/production.ts
export default {
  logger: {
    level: "info", // 生产环境只输出 info 及以上
  },
};

export default {
  logger: {
    level: "info",
    lifecycleLevel: "concise", // "concise" | "verbose"
  },
};

// 纯消息
app.logger.info("服务启动");

// 对象 + 消息（推荐）
app.logger.info({ port: 3000, adapter: "native" }, "服务启动");

// 对象（无消息）
app.logger.info({ event: "startup", port: 3000 });

// src/config/default.ts
export default {
  logger: {
    level: "debug",
    pretty: true, // 开发环境使用 pretty 格式（默认行为）
  },
};

// src/config/production.ts
export default {
  logger: {
    level: "info",
    pretty: false, // 生产环境使用 JSON 格式（默认行为）
  },
};

// src/config/default.ts — 默认行为（单行输出）
export default {
  logger: {
    pretty: true,
    // prettySingleLine 默认值: true
    // 输出: [14:23:05] INFO: Seed data loaded {"count":3,"service":"UserService"}
  },
};

// src/config/development.ts — 多行展开
export default {
  logger: {
    pretty: true,
    prettySingleLine: false,
    // 输出:
    // [14:23:05] INFO  Seed data loaded
    //     count: 3
    //     service: "UserService"
  },
};

// src/config/default.ts — 默认行为（requestId 被隐藏）
export default {
  logger: {
    pretty: true,
    // prettyIgnore 默认值: "pid,hostname,requestId"
  },
};

// src/config/development.ts — 显示 requestId
export default {
  logger: {
    pretty: true,
    prettyIgnore: "pid,hostname", // 不再忽略 requestId
  },
};

// 隐藏 requestId + 自定义字段
export default {
  logger: {
    prettyIgnore: "pid,hostname,requestId,traceId,spanId",
  },
};

async function processPayment(orderId: string, amount: number) {
  try {
    const result = await paymentGateway.charge(amount);
    app.logger.info({ orderId, amount, chargeId: result.id }, "支付成功");
    return result;
  } catch (err) {
    app.logger.error({ err, orderId, amount, gateway: "stripe" }, "支付失败");
    throw err;
  }
}

setLogger(wrapper: (original: VextLogger) => VextLogger): void;

// src/plugins/otel.ts
import { opentelemetryPlugin } from "vextjs-opentelemetry/vextjs";

export default opentelemetryPlugin({
  endpoint: "grpc://collector:4317",
  protocol: "grpc",
  logs: {
    bridgeAppLogger: true, // 默认 true（endpoint 有效时自动开启）
    globalAttributes: {
      "app.version": "1.2.0",
    },
  },
});
// → app.logger.info("xxx") 同时上报到 OTel Collector + 输出到 stdout

import { definePlugin } from "vextjs";
import type { VextLogger } from "vextjs";

export default definePlugin({
  name: "sentry-logger",
  setup(app) {
    app.setLogger((original) => ({
      ...original,
      error(...args: unknown[]) {
        // 上报 error 级别日志到 Sentry
        const msg = typeof args[0] === "string" ? args[0] : String(args[1] ?? "");
        Sentry.captureMessage(msg, "error");
        // 原始 pino 输出不变
        (original.error as (...a: unknown[]) => void)(...args);
      },
      // child logger 保持原逻辑
      child: (bindings) => original.child(bindings),
    }));
  },
});

import pino from "pino";

const transport = pino.transport({
  target: "pino/file",
  options: {
    destination: "./logs/app.log",
    mkdir: true, // 自动创建 logs/ 目录
  },
});

// 在 VextJS 中，可以通过插件在 logger 创建后替换
// 或在 src/index.ts 启动前配置

import pino from "pino";

const logger = pino(
  {
    level: "info",
    timestamp: pino.stdTimeFunctions.isoTime,
  },
  pino.transport({
    target: "pino-roll",
    options: {
      file: "./logs/app.log", // 日志文件路径
      size: "10m", // 单个文件最大 10MB
      limit: {
        count: 10, // 最多保留 10 个历史文件
      },
      mkdir: true, // 自动创建目录
    },
  }),
);

import pino from "pino";

const logger = pino(
  {
    level: "info",
    timestamp: pino.stdTimeFunctions.isoTime,
  },
  pino.transport({
    target: "pino-roll",
    options: {
      file: "./logs/app.log",
      frequency: "daily", // 每天轮转一次（也支持 'hourly'）
      dateFormat: "yyyy-MM-dd", // 历史文件名中的日期格式
      limit: {
        count: 30, // 保留最近 30 天
      },
      mkdir: true,
    },
  }),
);

import pino from "pino";

const logger = pino(
  {
    level: "info",
    timestamp: pino.stdTimeFunctions.isoTime,
  },
  pino.transport({
    target: "pino-roll",
    options: {
      file: "./logs/app.log",
      frequency: "daily",
      size: "50m", // 单日内超过 50MB 也会切割
      dateFormat: "yyyy-MM-dd",
      limit: {
        count: 30,
      },
      mkdir: true,
    },
  }),
);

import pino from "pino";

const logger = pino(
  {
    level: "info",
    timestamp: pino.stdTimeFunctions.isoTime,
  },
  pino.transport({
    targets: [
      // 控制台 pretty 输出（开发体验）
      {
        target: "pino-pretty",
        options: { colorize: true, translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l" },
        level: "debug",
      },
      // 文件轮转（所有级别）
      {
        target: "pino-roll",
        options: {
          file: "./logs/app.log",
          size: "10m",
          limit: { count: 10 },
          mkdir: true,
        },
        level: "info",
      },
      // 错误日志单独文件
      {
        target: "pino-roll",
        options: {
          file: "./logs/error.log",
          size: "10m",
          limit: { count: 20 },
          mkdir: true,
        },
        level: "error",
      },
    ],
  }),
);

import pino from "pino";

const logger = pino(
  {
    level: "info",
    timestamp: pino.stdTimeFunctions.isoTime,
  },
  pino.transport({
    target: "pino-elasticsearch",
    options: {
      index: "myapp", // 索引名前缀（自动追加日期）
      node: "http://localhost:9200",
      esVersion: 8, // Elasticsearch 版本
      flushBytes: 1000, // 缓冲区达到 1000 字节后批量写入
      flushInterval: 5000, // 或每 5 秒写入一次
      auth: {
        username: process.env.ELASTIC_USER,
        password: process.env.ELASTIC_PASSWORD,
      },
      // 可选：自定义索引名（按天分割）
      "op.type": "create",
    },
  }),
);

import pino from "pino";

const logger = pino(
  {
    level: "info",
    timestamp: pino.stdTimeFunctions.isoTime,
  },
  pino.transport({
    targets: [
      {
        target: "pino-pretty",
        options: { colorize: true },
        level: "debug",
      },
      {
        target: "pino-elasticsearch",
        options: {
          index: "myapp",
          node: process.env.ELASTICSEARCH_URL || "http://localhost:9200",
          esVersion: 8,
          flushBytes: 1000,
          flushInterval: 5000,
        },
        level: "info",
      },
    ],
  }),
);

// src/config/production.ts
import { trace } from "@opentelemetry/api";

export default {
  logger: {
    level: "info",
    mixin() {
      const span = trace.getActiveSpan();
      if (!span?.isRecording()) return {};
      const ctx = span.spanContext();
      return {
        trace_id: ctx.traceId, // 注入到每条日志的 trace_id 字段（OTEL 语义约定）
        span_id: ctx.spanId, // 注入到每条日志的 span_id 字段
      };
    },
  },
};

interface VextLogger {
  info(...args: unknown[]): void;
  warn(...args: unknown[]): void;
  error(...args: unknown[]): void;
  debug(...args: unknown[]): void;
  fatal(...args: unknown[]): void;
  child(bindings: Record<string, unknown>): VextLogger;
}

import type { VextLogger } from "vextjs";

class PaymentService {
  private logger: VextLogger;

  constructor(app: VextApp) {
    this.logger = app.logger.child({ service: "PaymentService" });
  }
}

// ✅ 结构化字段 — 可索引、可过滤
app.logger.info({ userId, action: "login", ip: req.ip }, "用户登录");

// ❌ 字符串拼接 — 难以解析和过滤
app.logger.info(`用户 ${userId} 从 ${req.ip} 登录`);

// ✅ 推荐 — 日志自动携带 service 标识
this.logger = app.logger.child({ service: 'OrderService' });

// ❌ 避免 — 每条日志都要手动加 service
app.logger.info({ service: 'OrderService', ... }, 'xxx');

// ✅ 安全
app.logger.info({ userId, action: "password_change" }, "密码已修改");

// ❌ 危险 — 密码泄漏到日志
app.logger.info({ userId, newPassword }, "密码已修改");

// ❌ 危险 — token 泄漏到日志
app.logger.debug({ token: req.headers.authorization }, "认证信息");

// debug — 详细调试信息（生产环境不输出）
app.logger.debug({ sql: query, params }, "执行数据库查询");

// info — 重要业务事件
app.logger.info({ orderId, total }, "订单创建成功");

// warn — 需要关注但不影响运行
app.logger.warn({ retryCount: 3, url }, "请求重试");

// error — 出错了
app.logger.error({ err, orderId }, "支付处理失败");

// fatal — 应用无法继续运行
app.logger.fatal({ err }, "数据库连接断开，无法恢复");