@rawnodes/logger 1.7.0 → 1.9.0

package/dist/index.mjs

@@ -2,6 +2,9 @@ import { createLogger, transports, format } from 'winston';
 import { AsyncLocalStorage } from 'async_hooks';
 import DailyRotateFile from 'winston-daily-rotate-file';
 import { inspect } from 'util';
+import TransportStream from 'winston-transport';
+import { CloudWatchLogsClient, PutLogEventsCommand, CreateLogGroupCommand, CreateLogStreamCommand, DescribeLogStreamsCommand } from '@aws-sdk/client-cloudwatch-logs';
+import { z } from 'zod';
 import { randomUUID } from 'crypto';
 
 // src/state.ts
@@ -15,6 +18,26 @@ var LoggerStore = class {
   }
 };
 
+// src/types.ts
+var LOG_LEVELS = {
+  off: -1,
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  verbose: 4,
+  debug: 5,
+  silly: 6
+};
+function isValidLogLevel(level) {
+  return level in LOG_LEVELS;
+}
+function assertLogLevel(level) {
+  if (!isValidLogLevel(level)) {
+    throw new Error(`Invalid log level: "${level}". Valid levels: ${Object.keys(LOG_LEVELS).join(", ")}`);
+  }
+}
+
 // src/utils/mask-secrets.ts
 var DEFAULT_SECRET_PATTERNS = [
   "password",
@@ -169,6 +192,20 @@ function maskSecretsFormat(options) {
     return maskSecrets(info, options);
   })();
 }
+function createFilterFormat(defaultLevel, rules, store) {
+  if (!rules?.length && defaultLevel === void 0) {
+    return format((info) => info)();
+  }
+  return format((info) => {
+    const logLevel = info.level;
+    const context = info.context;
+    const storeContext = store.getStore();
+    const matchingRule = rules?.find((rule) => matchesContext(storeContext, context, rule.match));
+    const effectiveLevel = matchingRule?.level ?? defaultLevel ?? "silly";
+    if (effectiveLevel === "off") return false;
+    return LOG_LEVELS[logLevel] <= LOG_LEVELS[effectiveLevel] ? info : false;
+  })();
+}
 function createPlainFormat(store) {
   return format.combine(
     format.errors({ stack: true }),
@@ -233,17 +270,461 @@ function createFormat(logFormat, store) {
   }
 }
 
+// src/transports/buffer.ts
+var MessageBuffer = class {
+  constructor(options) {
+    this.options = options;
+  }
+  queue = [];
+  timer = null;
+  flushing = false;
+  closed = false;
+  add(message) {
+    if (this.closed) return;
+    this.queue.push(message);
+    if (this.queue.length >= this.options.batchSize) {
+      void this.flush();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  async flush() {
+    if (this.flushing || this.queue.length === 0) return;
+    this.flushing = true;
+    this.clearTimer();
+    const messages = this.queue.splice(0, this.options.batchSize);
+    try {
+      await this.sendWithRetry(messages);
+    } catch (error) {
+      this.options.onError?.(error, messages);
+    } finally {
+      this.flushing = false;
+      if (this.queue.length > 0 && !this.closed) {
+        void this.flush();
+      }
+    }
+  }
+  async close() {
+    this.closed = true;
+    this.clearTimer();
+    while (this.queue.length > 0) {
+      await this.flush();
+    }
+  }
+  scheduleFlush() {
+    if (this.timer || this.closed) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.flush();
+    }, this.options.flushInterval);
+  }
+  clearTimer() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  async sendWithRetry(messages) {
+    let lastError = null;
+    for (let attempt = 0; attempt < this.options.maxRetries; attempt++) {
+      try {
+        await this.options.onFlush(messages);
+        return;
+      } catch (error) {
+        lastError = error;
+        if (attempt < this.options.maxRetries - 1) {
+          await this.delay(this.options.retryDelay * Math.pow(2, attempt));
+        }
+      }
+    }
+    throw lastError;
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/transports/base-http.ts
+var DEFAULT_OPTIONS = {
+  batchSize: 10,
+  flushInterval: 5e3,
+  maxRetries: 3,
+  retryDelay: 1e3
+};
+var BaseHttpTransport = class extends TransportStream {
+  buffer;
+  constructor(opts = {}) {
+    super();
+    this.buffer = new MessageBuffer({
+      batchSize: opts.batchSize ?? DEFAULT_OPTIONS.batchSize,
+      flushInterval: opts.flushInterval ?? DEFAULT_OPTIONS.flushInterval,
+      maxRetries: opts.maxRetries ?? DEFAULT_OPTIONS.maxRetries,
+      retryDelay: opts.retryDelay ?? DEFAULT_OPTIONS.retryDelay,
+      onFlush: this.sendBatch.bind(this),
+      onError: this.handleError.bind(this)
+    });
+  }
+  log(info, callback) {
+    const message = this.transformMessage(info);
+    this.buffer.add(message);
+    callback();
+  }
+  close() {
+    return this.buffer.close();
+  }
+  transformMessage(info) {
+    const { level, message, timestamp, context, ...meta } = info;
+    return {
+      level,
+      message: String(message),
+      timestamp: timestamp ? new Date(String(timestamp)) : /* @__PURE__ */ new Date(),
+      context,
+      meta: Object.keys(meta).length > 0 ? meta : void 0
+    };
+  }
+  handleError(error, messages) {
+    console.error(
+      `[${this.constructor.name}] Failed to send ${messages.length} messages:`,
+      error.message
+    );
+    this.emit("error", error);
+  }
+};
+
+// src/transports/discord.ts
+var DEFAULT_EMBED_COLORS = {
+  off: 0,
+  error: 15548997,
+  warn: 16705372,
+  info: 5763719,
+  http: 5793266,
+  verbose: 10181046,
+  debug: 3447003,
+  silly: 9807270
+};
+var DiscordTransport = class extends BaseHttpTransport {
+  config;
+  constructor(config) {
+    super({
+      batchSize: config.batchSize ?? 10,
+      flushInterval: config.flushInterval ?? 2e3,
+      maxRetries: config.maxRetries,
+      retryDelay: config.retryDelay
+    });
+    this.config = config;
+  }
+  async sendBatch(messages) {
+    const chunks = this.chunkArray(messages, 10);
+    for (const chunk of chunks) {
+      const payload = {
+        username: this.config.username,
+        avatar_url: this.config.avatarUrl,
+        embeds: chunk.map((msg) => this.createEmbed(msg))
+      };
+      await this.sendWebhook(payload);
+    }
+  }
+  createEmbed(msg) {
+    const color = this.config.embedColors?.[msg.level] ?? DEFAULT_EMBED_COLORS[msg.level];
+    const embed = {
+      title: `[${msg.level.toUpperCase()}] ${msg.context || "APP"}`,
+      description: msg.message.slice(0, 4096),
+      // Discord limit
+      color
+    };
+    if (this.config.includeTimestamp !== false) {
+      embed.timestamp = msg.timestamp.toISOString();
+    }
+    if (this.config.includeMeta !== false && msg.meta) {
+      embed.fields = this.metaToFields(msg.meta);
+    }
+    return embed;
+  }
+  metaToFields(meta) {
+    const maxFields = this.config.maxEmbedFields ?? 25;
+    const fields = [];
+    for (const [key, value] of Object.entries(meta)) {
+      if (fields.length >= maxFields) break;
+      let strValue;
+      if (typeof value === "object") {
+        strValue = "```json\n" + JSON.stringify(value, null, 2).slice(0, 1e3) + "\n```";
+      } else {
+        strValue = String(value).slice(0, 1024);
+      }
+      fields.push({
+        name: key.slice(0, 256),
+        value: strValue,
+        inline: typeof value !== "object" && String(value).length < 50
+      });
+    }
+    return fields;
+  }
+  async sendWebhook(payload) {
+    const response = await fetch(this.config.webhookUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Discord webhook failed: ${response.status} ${text}`);
+    }
+  }
+  chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+};
+
+// src/transports/telegram.ts
+var LEVEL_EMOJI = {
+  off: "",
+  error: "\u{1F534}",
+  warn: "\u{1F7E1}",
+  info: "\u{1F7E2}",
+  http: "\u{1F535}",
+  verbose: "\u{1F7E3}",
+  debug: "\u26AA",
+  silly: "\u26AB"
+};
+var TelegramTransport = class extends BaseHttpTransport {
+  config;
+  apiUrl;
+  constructor(config) {
+    super({
+      batchSize: config.batchSize ?? 20,
+      flushInterval: config.flushInterval ?? 1e3,
+      maxRetries: config.maxRetries,
+      retryDelay: config.retryDelay
+    });
+    this.config = config;
+    this.apiUrl = `https://api.telegram.org/bot${config.botToken}`;
+  }
+  async sendBatch(messages) {
+    const text = this.formatBatchMessage(messages);
+    await this.sendMessage(text, messages);
+  }
+  formatBatchMessage(messages) {
+    const parseMode = this.config.parseMode ?? "Markdown";
+    return messages.map((msg) => {
+      if (parseMode === "HTML") {
+        return this.formatHtml(msg);
+      }
+      return this.formatMarkdown(msg, parseMode === "MarkdownV2");
+    }).join("\n\n---\n\n");
+  }
+  formatMarkdown(msg, v2) {
+    const emoji = LEVEL_EMOJI[msg.level];
+    const escape = v2 ? this.escapeMarkdownV2.bind(this) : (s) => s;
+    let text = `${emoji} *${msg.level.toUpperCase()}* \\[${escape(msg.context || "APP")}\\]
+`;
+    text += escape(msg.message);
+    if (msg.meta && Object.keys(msg.meta).length > 0) {
+      const metaStr = JSON.stringify(msg.meta, null, 2);
+      text += "\n```json\n" + metaStr + "\n```";
+    }
+    return text;
+  }
+  formatHtml(msg) {
+    const emoji = LEVEL_EMOJI[msg.level];
+    let text = `${emoji} <b>${msg.level.toUpperCase()}</b> [${this.escapeHtml(msg.context || "APP")}]
+`;
+    text += this.escapeHtml(msg.message);
+    if (msg.meta && Object.keys(msg.meta).length > 0) {
+      const metaStr = JSON.stringify(msg.meta, null, 2);
+      text += "\n<pre>" + this.escapeHtml(metaStr) + "</pre>";
+    }
+    return text;
+  }
+  shouldMute(messages) {
+    if (this.config.disableNotification !== void 0) {
+      return this.config.disableNotification;
+    }
+    return !messages.some((m) => m.level === "error");
+  }
+  async sendMessage(text, messages) {
+    const body = {
+      chat_id: this.config.chatId,
+      text,
+      parse_mode: this.config.parseMode ?? "Markdown",
+      disable_notification: this.shouldMute(messages)
+    };
+    if (this.config.threadId) {
+      body.message_thread_id = this.config.threadId;
+    }
+    if (this.config.replyToMessageId) {
+      body.reply_to_message_id = this.config.replyToMessageId;
+    }
+    const response = await fetch(`${this.apiUrl}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const result = await response.json();
+      throw new Error(`Telegram API failed: ${response.status} ${JSON.stringify(result)}`);
+    }
+  }
+  escapeMarkdownV2(text) {
+    return text.replace(/[_*[\]()~`>#+\-=|{}.!]/g, "\\$&");
+  }
+  escapeHtml(text) {
+    const entities = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;"
+    };
+    return text.replace(/[&<>"']/g, (c) => entities[c] || c);
+  }
+};
+var CloudWatchTransport = class extends BaseHttpTransport {
+  config;
+  client;
+  sequenceToken;
+  initialized = false;
+  initPromise = null;
+  constructor(config) {
+    super({
+      batchSize: config.batchSize ?? 100,
+      flushInterval: config.flushInterval ?? 1e3,
+      maxRetries: config.maxRetries,
+      retryDelay: config.retryDelay
+    });
+    this.config = config;
+    this.client = new CloudWatchLogsClient({
+      region: config.region,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey
+      }
+    });
+  }
+  async sendBatch(messages) {
+    await this.ensureInitialized();
+    const logEvents = messages.map((msg) => ({
+      timestamp: msg.timestamp.getTime(),
+      message: JSON.stringify({
+        level: msg.level,
+        message: msg.message,
+        context: msg.context,
+        ...msg.meta
+      })
+    }));
+    logEvents.sort((a, b) => (a.timestamp ?? 0) - (b.timestamp ?? 0));
+    const command = new PutLogEventsCommand({
+      logGroupName: this.config.logGroupName,
+      logStreamName: this.config.logStreamName,
+      logEvents,
+      sequenceToken: this.sequenceToken
+    });
+    try {
+      const response = await this.client.send(command);
+      this.sequenceToken = response.nextSequenceToken;
+    } catch (error) {
+      if (this.isInvalidSequenceTokenError(error)) {
+        await this.fetchSequenceToken();
+        const retryCommand = new PutLogEventsCommand({
+          logGroupName: this.config.logGroupName,
+          logStreamName: this.config.logStreamName,
+          logEvents,
+          sequenceToken: this.sequenceToken
+        });
+        const response = await this.client.send(retryCommand);
+        this.sequenceToken = response.nextSequenceToken;
+      } else {
+        throw error;
+      }
+    }
+  }
+  async ensureInitialized() {
+    if (this.initialized) return;
+    if (!this.initPromise) {
+      this.initPromise = this.initialize();
+    }
+    await this.initPromise;
+  }
+  async initialize() {
+    if (this.config.createLogGroup) {
+      await this.createLogGroupIfNotExists();
+    }
+    if (this.config.createLogStream !== false) {
+      await this.createLogStreamIfNotExists();
+    }
+    await this.fetchSequenceToken();
+    this.initialized = true;
+  }
+  async createLogGroupIfNotExists() {
+    try {
+      await this.client.send(
+        new CreateLogGroupCommand({
+          logGroupName: this.config.logGroupName
+        })
+      );
+    } catch (error) {
+      if (!this.isResourceAlreadyExistsError(error)) {
+        throw error;
+      }
+    }
+  }
+  async createLogStreamIfNotExists() {
+    try {
+      await this.client.send(
+        new CreateLogStreamCommand({
+          logGroupName: this.config.logGroupName,
+          logStreamName: this.config.logStreamName
+        })
+      );
+    } catch (error) {
+      if (!this.isResourceAlreadyExistsError(error)) {
+        throw error;
+      }
+    }
+  }
+  async fetchSequenceToken() {
+    const response = await this.client.send(
+      new DescribeLogStreamsCommand({
+        logGroupName: this.config.logGroupName,
+        logStreamNamePrefix: this.config.logStreamName,
+        limit: 1
+      })
+    );
+    const stream = response.logStreams?.find((s) => s.logStreamName === this.config.logStreamName);
+    this.sequenceToken = stream?.uploadSequenceToken;
+  }
+  isResourceAlreadyExistsError(error) {
+    return typeof error === "object" && error !== null && "name" in error && error.name === "ResourceAlreadyExistsException";
+  }
+  isInvalidSequenceTokenError(error) {
+    return typeof error === "object" && error !== null && "name" in error && error.name === "InvalidSequenceTokenException";
+  }
+};
+
 // src/transports.ts
+function toArray(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
 function createTransports(config, store) {
   const result = [
     new transports.Console({
-      format: createFormat(config.console.format, store)
+      format: format.combine(
+        createFilterFormat(config.console.level, config.console.rules, store),
+        createFormat(config.console.format, store)
+      )
     })
   ];
   if (config.file) {
     result.push(
       new DailyRotateFile({
-        format: createFormat(config.file.format, store),
+        format: format.combine(
+          createFilterFormat(config.file.level, config.file.rules, store),
+          createFormat(config.file.format, store)
+        ),
         dirname: config.file.dirname,
         filename: config.file.filename,
         datePattern: config.file.datePattern ?? "YYYY-MM-DD",
@@ -253,6 +734,30 @@ function createTransports(config, store) {
       })
     );
   }
+  for (const discordConfig of toArray(config.discord)) {
+    const discord = new DiscordTransport(discordConfig);
+    discord.format = format.combine(
+      createFilterFormat(discordConfig.level, discordConfig.rules, store),
+      format.timestamp()
+    );
+    result.push(discord);
+  }
+  for (const telegramConfig of toArray(config.telegram)) {
+    const telegram = new TelegramTransport(telegramConfig);
+    telegram.format = format.combine(
+      createFilterFormat(telegramConfig.level, telegramConfig.rules, store),
+      format.timestamp()
+    );
+    result.push(telegram);
+  }
+  for (const cloudwatchConfig of toArray(config.cloudwatch)) {
+    const cloudwatch = new CloudWatchTransport(cloudwatchConfig);
+    cloudwatch.format = format.combine(
+      createFilterFormat(cloudwatchConfig.level, cloudwatchConfig.rules, store),
+      format.timestamp()
+    );
+    result.push(cloudwatch);
+  }
   return result;
 }
 function createExceptionHandlers(config, store) {
@@ -277,25 +782,6 @@ function createExceptionHandlers(config, store) {
   return result;
 }
 
-// src/types.ts
-var LOG_LEVELS = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  http: 3,
-  verbose: 4,
-  debug: 5,
-  silly: 6
-};
-function isValidLogLevel(level) {
-  return level in LOG_LEVELS;
-}
-function assertLogLevel(level) {
-  if (!isValidLogLevel(level)) {
-    throw new Error(`Invalid log level: "${level}". Valid levels: ${Object.keys(LOG_LEVELS).join(", ")}`);
-  }
-}
-
 // src/state.ts
 function parseLevelConfig(level) {
   if (typeof level === "string") {
@@ -350,6 +836,81 @@ function matchesContext(storeContext, loggerContext, match) {
   const combined = { ...storeContext, context: loggerContext };
   return Object.entries(match).every(([key, value]) => combined[key] === value);
 }
+var LogLevelSchema = z.enum(["off", "error", "warn", "info", "http", "verbose", "debug", "silly"]);
+var LogFormatSchema = z.enum(["json", "plain", "logfmt", "simple"]);
+var LevelRuleSchema = z.object({
+  match: z.record(z.string(), z.unknown()),
+  level: LogLevelSchema
+});
+var ConsoleConfigSchema = z.object({
+  format: LogFormatSchema,
+  level: LogLevelSchema.optional(),
+  rules: z.array(LevelRuleSchema).optional()
+});
+var FileConfigSchema = z.object({
+  format: LogFormatSchema,
+  level: LogLevelSchema.optional(),
+  rules: z.array(LevelRuleSchema).optional(),
+  dirname: z.string().min(1, "dirname is required"),
+  filename: z.string().min(1, "filename is required"),
+  datePattern: z.string().optional(),
+  zippedArchive: z.boolean().optional(),
+  maxSize: z.string().optional(),
+  maxFiles: z.string().optional()
+});
+var HttpTransportBaseConfigSchema = z.object({
+  level: LogLevelSchema.optional(),
+  rules: z.array(LevelRuleSchema).optional(),
+  batchSize: z.number().int().positive().optional(),
+  flushInterval: z.number().int().positive().optional(),
+  maxRetries: z.number().int().nonnegative().optional(),
+  retryDelay: z.number().int().positive().optional()
+});
+var DiscordConfigSchema = HttpTransportBaseConfigSchema.extend({
+  webhookUrl: z.url("webhookUrl must be a valid URL"),
+  username: z.string().optional(),
+  avatarUrl: z.url().optional(),
+  embedColors: z.record(z.string(), z.number().int()).optional(),
+  includeTimestamp: z.boolean().optional(),
+  includeMeta: z.boolean().optional(),
+  maxEmbedFields: z.number().int().min(1).max(25).optional()
+});
+var TelegramConfigSchema = HttpTransportBaseConfigSchema.extend({
+  botToken: z.string().min(1, "botToken is required"),
+  chatId: z.union([z.string(), z.number()]),
+  parseMode: z.enum(["Markdown", "MarkdownV2", "HTML"]).optional(),
+  disableNotification: z.boolean().optional(),
+  threadId: z.number().int().optional(),
+  replyToMessageId: z.number().int().optional()
+});
+var CloudWatchConfigSchema = HttpTransportBaseConfigSchema.extend({
+  logGroupName: z.string().min(1, "logGroupName is required"),
+  logStreamName: z.string().min(1, "logStreamName is required"),
+  region: z.string().min(1, "region is required"),
+  accessKeyId: z.string().min(1, "accessKeyId is required"),
+  secretAccessKey: z.string().min(1, "secretAccessKey is required"),
+  createLogGroup: z.boolean().optional(),
+  createLogStream: z.boolean().optional()
+});
+var LevelConfigObjectSchema = z.object({
+  default: LogLevelSchema,
+  rules: z.array(LevelRuleSchema).optional()
+});
+var LevelConfigSchema = z.union([LogLevelSchema, LevelConfigObjectSchema]);
+var LoggerConfigSchema = z.object({
+  level: LevelConfigSchema,
+  console: ConsoleConfigSchema,
+  file: FileConfigSchema.optional(),
+  discord: z.union([DiscordConfigSchema, z.array(DiscordConfigSchema)]).optional(),
+  telegram: z.union([TelegramConfigSchema, z.array(TelegramConfigSchema)]).optional(),
+  cloudwatch: z.union([CloudWatchConfigSchema, z.array(CloudWatchConfigSchema)]).optional()
+});
+function validateConfig(config) {
+  return LoggerConfigSchema.parse(config);
+}
+function safeValidateConfig(config) {
+  return LoggerConfigSchema.safeParse(config);
+}
 
 // src/logger.ts
 var Logger = class _Logger {
@@ -358,7 +919,8 @@ var Logger = class _Logger {
     this.context = context;
   }
   static create(config, store) {
-    const state = createState(config, store);
+    const validatedConfig = validateConfig(config);
+    const state = createState(validatedConfig, store);
     return new _Logger(state, "APP");
   }
   for(context) {
@@ -538,6 +1100,6 @@ function getOrGenerateRequestId(headers, options = {}) {
   return extractRequestId(headers) ?? generateRequestId(options);
 }
 
-export { LOG_LEVELS, Logger, LoggerStore, assertLogLevel, createMasker, createSingletonLogger, extractRequestId, flattenObject, formatLogfmt, formatLogfmtValue, generateRequestId, getOrGenerateRequestId, isValidLogLevel, maskSecrets, measureAsync, measureSync };
+export { BaseHttpTransport, CloudWatchConfigSchema, CloudWatchTransport, ConsoleConfigSchema, DiscordConfigSchema, DiscordTransport, FileConfigSchema, HttpTransportBaseConfigSchema, LOG_LEVELS, LevelConfigObjectSchema, LevelConfigSchema, LevelRuleSchema, LogFormatSchema, LogLevelSchema, Logger, LoggerConfigSchema, LoggerStore, MessageBuffer, TelegramConfigSchema, TelegramTransport, assertLogLevel, createMasker, createSingletonLogger, extractRequestId, flattenObject, formatLogfmt, formatLogfmtValue, generateRequestId, getOrGenerateRequestId, isValidLogLevel, maskSecrets, matchesContext, measureAsync, measureSync, safeValidateConfig, validateConfig };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map