@rawnodes/logger 1.6.0 → 1.8.0

package/dist/index.js

@@ -4,11 +4,14 @@ var winston = require('winston');
 var async_hooks = require('async_hooks');
 var DailyRotateFile = require('winston-daily-rotate-file');
 var util = require('util');
+var TransportStream = require('winston-transport');
+var clientCloudwatchLogs = require('@aws-sdk/client-cloudwatch-logs');
 var crypto = require('crypto');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var DailyRotateFile__default = /*#__PURE__*/_interopDefault(DailyRotateFile);
+var TransportStream__default = /*#__PURE__*/_interopDefault(TransportStream);
 
 // src/state.ts
 var LoggerStore = class {
@@ -21,6 +24,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",
@@ -175,6 +198,20 @@ function maskSecretsFormat(options) {
     return maskSecrets(info, options);
   })();
 }
+function createFilterFormat(defaultLevel, rules, store) {
+  if (!rules?.length && defaultLevel === void 0) {
+    return winston.format((info) => info)();
+  }
+  return winston.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 winston.format.combine(
     winston.format.errors({ stack: true }),
@@ -239,17 +276,457 @@ 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__default.default {
+  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 clientCloudwatchLogs.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 clientCloudwatchLogs.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 clientCloudwatchLogs.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 clientCloudwatchLogs.CreateLogGroupCommand({
+          logGroupName: this.config.logGroupName
+        })
+      );
+    } catch (error) {
+      if (!this.isResourceAlreadyExistsError(error)) {
+        throw error;
+      }
+    }
+  }
+  async createLogStreamIfNotExists() {
+    try {
+      await this.client.send(
+        new clientCloudwatchLogs.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 clientCloudwatchLogs.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 createTransports(config, store) {
   const result = [
     new winston.transports.Console({
-      format: createFormat(config.console.format, store)
+      format: winston.format.combine(
+        createFilterFormat(config.console.level, config.console.rules, store),
+        createFormat(config.console.format, store)
+      )
     })
   ];
   if (config.file) {
     result.push(
       new DailyRotateFile__default.default({
-        format: createFormat(config.file.format, store),
+        format: winston.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",
@@ -259,6 +736,30 @@ function createTransports(config, store) {
       })
     );
   }
+  if (config.discord) {
+    const discord = new DiscordTransport(config.discord);
+    discord.format = winston.format.combine(
+      createFilterFormat(config.discord.level, config.discord.rules, store),
+      winston.format.timestamp()
+    );
+    result.push(discord);
+  }
+  if (config.telegram) {
+    const telegram = new TelegramTransport(config.telegram);
+    telegram.format = winston.format.combine(
+      createFilterFormat(config.telegram.level, config.telegram.rules, store),
+      winston.format.timestamp()
+    );
+    result.push(telegram);
+  }
+  if (config.cloudwatch) {
+    const cloudwatch = new CloudWatchTransport(config.cloudwatch);
+    cloudwatch.format = winston.format.combine(
+      createFilterFormat(config.cloudwatch.level, config.cloudwatch.rules, store),
+      winston.format.timestamp()
+    );
+    result.push(cloudwatch);
+  }
   return result;
 }
 function createExceptionHandlers(config, store) {
@@ -283,28 +784,21 @@ 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") {
+    assertLogLevel(level);
+    return { defaultLevel: level, rules: [] };
   }
+  assertLogLevel(level.default);
+  const rules = (level.rules ?? []).map((rule) => {
+    assertLogLevel(rule.level);
+    return { match: rule.match, level: rule.level, readonly: true };
+  });
+  return { defaultLevel: level.default, rules };
 }
-
-// src/state.ts
 function createState(config, store) {
-  assertLogLevel(config.level);
+  const { defaultLevel, rules } = parseLevelConfig(config.level);
   const loggerStore = store ?? new LoggerStore();
   const exceptionHandlers = createExceptionHandlers(config, loggerStore);
   const winston$1 = winston.createLogger({
@@ -315,11 +809,16 @@ function createState(config, store) {
     rejectionHandlers: exceptionHandlers,
     exitOnError: false
   });
+  const levelOverrides = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const key = JSON.stringify(rule.match);
+    levelOverrides.set(key, rule);
+  }
   return {
     winston: winston$1,
     store: loggerStore,
-    defaultLevel: config.level,
-    levelOverrides: /* @__PURE__ */ new Map()
+    defaultLevel,
+    levelOverrides
   };
 }
 function shouldLog(state, level, context) {
@@ -364,10 +863,18 @@ var Logger = class _Logger {
   }
   removeLevelOverride(match) {
     const key = JSON.stringify(match);
-    this.state.levelOverrides.delete(key);
+    const override = this.state.levelOverrides.get(key);
+    if (override?.readonly) {
+      return false;
+    }
+    return this.state.levelOverrides.delete(key);
   }
   clearLevelOverrides() {
-    this.state.levelOverrides.clear();
+    for (const [key, override] of this.state.levelOverrides) {
+      if (!override.readonly) {
+        this.state.levelOverrides.delete(key);
+      }
+    }
   }
   getLevelOverrides() {
     return Array.from(this.state.levelOverrides.values());
@@ -519,9 +1026,14 @@ function getOrGenerateRequestId(headers, options = {}) {
   return extractRequestId(headers) ?? generateRequestId(options);
 }
 
+exports.BaseHttpTransport = BaseHttpTransport;
+exports.CloudWatchTransport = CloudWatchTransport;
+exports.DiscordTransport = DiscordTransport;
 exports.LOG_LEVELS = LOG_LEVELS;
 exports.Logger = Logger;
 exports.LoggerStore = LoggerStore;
+exports.MessageBuffer = MessageBuffer;
+exports.TelegramTransport = TelegramTransport;
 exports.assertLogLevel = assertLogLevel;
 exports.createMasker = createMasker;
 exports.createSingletonLogger = createSingletonLogger;
@@ -533,6 +1045,7 @@ exports.generateRequestId = generateRequestId;
 exports.getOrGenerateRequestId = getOrGenerateRequestId;
 exports.isValidLogLevel = isValidLogLevel;
 exports.maskSecrets = maskSecrets;
+exports.matchesContext = matchesContext;
 exports.measureAsync = measureAsync;
 exports.measureSync = measureSync;
 //# sourceMappingURL=index.js.map