@rawnodes/logger 1.9.1 → 2.0.0

package/dist/index.js

@@ -1,18 +1,18 @@
 'use strict';
 
-var winston = require('winston');
+var pino = require('pino');
 var async_hooks = require('async_hooks');
-var DailyRotateFile = require('winston-daily-rotate-file');
-var util = require('util');
-var TransportStream = require('winston-transport');
+var stream = require('stream');
+var promises = require('fs/promises');
+var rotatingFileStream = require('rotating-file-stream');
+var events = require('events');
 var clientCloudwatchLogs = require('@aws-sdk/client-cloudwatch-logs');
 var zod = require('zod');
 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);
+var pino__default = /*#__PURE__*/_interopDefault(pino);
 
 // src/state.ts
 var LoggerStore = class {
@@ -45,238 +45,6 @@ function assertLogLevel(level) {
   }
 }
 
-// src/utils/mask-secrets.ts
-var DEFAULT_SECRET_PATTERNS = [
-  "password",
-  "secret",
-  "token",
-  "apikey",
-  "api_key",
-  "api-key",
-  "auth",
-  "credential",
-  "private"
-];
-var DEFAULT_MASK = "***";
-function isSecretKey(key, patterns) {
-  const lowerKey = key.toLowerCase();
-  return patterns.some((pattern) => lowerKey.includes(pattern.toLowerCase()));
-}
-function maskUrlCredentials(url, mask) {
-  try {
-    const parsed = new URL(url);
-    if (parsed.password) {
-      parsed.password = mask;
-    }
-    if (parsed.username && parsed.password) {
-      parsed.username = mask;
-    }
-    return parsed.toString();
-  } catch {
-    return url;
-  }
-}
-function maskSecrets(obj, options = {}) {
-  const { patterns = DEFAULT_SECRET_PATTERNS, mask = DEFAULT_MASK, deep = true } = options;
-  if (obj === null || obj === void 0) {
-    return obj;
-  }
-  if (typeof obj === "string") {
-    if (obj.startsWith("http://") || obj.startsWith("https://")) {
-      return maskUrlCredentials(obj, mask);
-    }
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return deep ? obj.map((item) => maskSecrets(item, options)) : obj;
-  }
-  if (typeof obj === "object") {
-    const result = {};
-    for (const sym of Object.getOwnPropertySymbols(obj)) {
-      result[sym] = obj[sym];
-    }
-    for (const [key, value] of Object.entries(obj)) {
-      if (isSecretKey(key, patterns)) {
-        result[key] = mask;
-      } else if (deep && typeof value === "object" && value !== null) {
-        result[key] = maskSecrets(value, options);
-      } else if (typeof value === "string") {
-        result[key] = maskSecrets(value, options);
-      } else {
-        result[key] = value;
-      }
-    }
-    return result;
-  }
-  return obj;
-}
-function createMasker(options = {}) {
-  return (obj) => maskSecrets(obj, options);
-}
-
-// src/formatters.ts
-var DEFAULT_CONTEXT = "APP";
-var LEVEL_COLORS = {
-  error: "\x1B[31m",
-  // red
-  warn: "\x1B[33m",
-  // yellow
-  info: "\x1B[32m",
-  // green
-  http: "\x1B[35m",
-  // magenta
-  verbose: "\x1B[36m",
-  // cyan
-  debug: "\x1B[34m",
-  // blue
-  silly: "\x1B[90m"
-  // grey
-};
-var RESET = "\x1B[0m";
-function colorizeLevel(level) {
-  const color = LEVEL_COLORS[level] || "";
-  return color ? `${color}${level}${RESET}` : level;
-}
-function formatMeta(meta, colors) {
-  return Object.entries(meta).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => {
-    if (typeof value === "object") {
-      const inspected = util.inspect(value, { depth: 4, colors, compact: false });
-      return `
-  ${key}: ${inspected.split("\n").join("\n  ")}`;
-    }
-    return `
-  ${key}: ${value}`;
-  }).join("");
-}
-function flattenObject(obj, prefix = "") {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    const newKey = prefix ? `${prefix}.${key}` : key;
-    if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Error)) {
-      Object.assign(result, flattenObject(value, newKey));
-    } else {
-      result[newKey] = value;
-    }
-  }
-  return result;
-}
-function formatLogfmtValue(value) {
-  if (value === null || value === void 0) {
-    return "";
-  }
-  if (typeof value === "string") {
-    if (value.includes(" ") || value.includes('"') || value.includes("=")) {
-      return `"${value.replace(/"/g, '\\"')}"`;
-    }
-    return value;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  if (value instanceof Error) {
-    return `"${value.message.replace(/"/g, '\\"')}"`;
-  }
-  if (Array.isArray(value)) {
-    return `"${JSON.stringify(value).replace(/"/g, '\\"')}"`;
-  }
-  return `"${JSON.stringify(value).replace(/"/g, '\\"')}"`;
-}
-function formatLogfmt(data) {
-  const flattened = flattenObject(data);
-  return Object.entries(flattened).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${formatLogfmtValue(value)}`).join(" ");
-}
-function addStoreContext(store) {
-  return winston.format((info) => {
-    const storeContext = store.getStore();
-    if (storeContext) {
-      return { ...info, ...storeContext };
-    }
-    return info;
-  })();
-}
-function maskSecretsFormat(options) {
-  return winston.format((info) => {
-    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 }),
-    winston.format.timestamp(),
-    addStoreContext(store),
-    maskSecretsFormat(),
-    winston.format.printf(({ timestamp, level, context, message, ...meta }) => {
-      const formattedMeta = formatMeta(meta, true);
-      const coloredLevel = colorizeLevel(level);
-      return `[${timestamp}] ${coloredLevel} [${context || DEFAULT_CONTEXT}] ${message}${formattedMeta}`;
-    })
-  );
-}
-function createJsonFormat(store) {
-  return winston.format.combine(
-    winston.format.errors({ stack: true }),
-    winston.format.timestamp(),
-    addStoreContext(store),
-    maskSecretsFormat(),
-    winston.format.json()
-  );
-}
-function createLogfmtFormat(store) {
-  return winston.format.combine(
-    winston.format.errors({ stack: true }),
-    winston.format.timestamp(),
-    addStoreContext(store),
-    maskSecretsFormat(),
-    winston.format.printf(({ timestamp, level, context, message, ...meta }) => {
-      const data = {
-        level,
-        msg: message,
-        context: context || DEFAULT_CONTEXT,
-        ts: timestamp,
-        ...meta
-      };
-      return formatLogfmt(data);
-    })
-  );
-}
-function createSimpleFormat(store) {
-  return winston.format.combine(
-    winston.format.errors({ stack: true }),
-    winston.format.timestamp(),
-    addStoreContext(store),
-    maskSecretsFormat(),
-    winston.format.printf(({ timestamp, level, message }) => {
-      return `[${timestamp}] ${level}: ${message}`;
-    })
-  );
-}
-function createFormat(logFormat, store) {
-  switch (logFormat) {
-    case "plain":
-      return createPlainFormat(store);
-    case "json":
-      return createJsonFormat(store);
-    case "logfmt":
-      return createLogfmtFormat(store);
-    case "simple":
-      return createSimpleFormat(store);
-  }
-}
-
 // src/transports/buffer.ts
 var MessageBuffer = class {
   constructor(options) {
@@ -358,7 +126,7 @@ var DEFAULT_OPTIONS = {
   maxRetries: 3,
   retryDelay: 1e3
 };
-var BaseHttpTransport = class extends TransportStream__default.default {
+var BaseHttpTransport = class extends events.EventEmitter {
   buffer;
   constructor(opts = {}) {
     super();
@@ -384,7 +152,7 @@ var BaseHttpTransport = class extends TransportStream__default.default {
     return {
       level,
       message: String(message),
-      timestamp: timestamp ? new Date(String(timestamp)) : /* @__PURE__ */ new Date(),
+      timestamp: timestamp instanceof Date ? timestamp : timestamp ? new Date(String(timestamp)) : /* @__PURE__ */ new Date(),
       context,
       meta: Object.keys(meta).length > 0 ? meta : void 0
     };
@@ -409,6 +177,16 @@ var DEFAULT_EMBED_COLORS = {
   debug: 3447003,
   silly: 9807270
 };
+var LEVEL_EMOJI = {
+  off: "\u26AB",
+  error: "\u{1F534}",
+  warn: "\u{1F7E1}",
+  info: "\u{1F7E2}",
+  http: "\u{1F535}",
+  verbose: "\u{1F7E3}",
+  debug: "\u26AA",
+  silly: "\u26AB"
+};
 var DiscordTransport = class extends BaseHttpTransport {
   config;
   constructor(config) {
@@ -421,6 +199,13 @@ var DiscordTransport = class extends BaseHttpTransport {
     this.config = config;
   }
   async sendBatch(messages) {
+    if (this.config.format === "markdown") {
+      await this.sendMarkdownBatch(messages);
+    } else {
+      await this.sendEmbedBatch(messages);
+    }
+  }
+  async sendEmbedBatch(messages) {
     const chunks = this.chunkArray(messages, 10);
     for (const chunk of chunks) {
       const payload = {
@@ -431,6 +216,51 @@ var DiscordTransport = class extends BaseHttpTransport {
       await this.sendWebhook(payload);
     }
   }
+  async sendMarkdownBatch(messages) {
+    const content = messages.map((msg) => this.formatMarkdown(msg)).join("\n\n---\n\n");
+    const chunks = this.splitContent(content, 1900);
+    for (const chunk of chunks) {
+      const payload = {
+        username: this.config.username,
+        avatar_url: this.config.avatarUrl,
+        content: chunk
+      };
+      await this.sendWebhook(payload);
+    }
+  }
+  formatMarkdown(msg) {
+    const emoji = LEVEL_EMOJI[msg.level];
+    const level = msg.level.toUpperCase();
+    const context = msg.context || "APP";
+    const timestamp = this.config.includeTimestamp !== false ? `\`${msg.timestamp.toISOString()}\`` : "";
+    let text = `${emoji} **${level}** [${context}] ${timestamp}
+${msg.message}`;
+    if (this.config.includeMeta !== false && msg.meta && Object.keys(msg.meta).length > 0) {
+      text += "\n```json\n" + JSON.stringify(msg.meta, null, 2) + "\n```";
+    }
+    return text;
+  }
+  splitContent(content, maxLength) {
+    if (content.length <= maxLength) return [content];
+    const chunks = [];
+    let current = content;
+    while (current.length > 0) {
+      if (current.length <= maxLength) {
+        chunks.push(current);
+        break;
+      }
+      let splitAt = current.lastIndexOf("\n", maxLength);
+      if (splitAt === -1 || splitAt < maxLength / 2) {
+        splitAt = current.lastIndexOf(" ", maxLength);
+      }
+      if (splitAt === -1 || splitAt < maxLength / 2) {
+        splitAt = maxLength;
+      }
+      chunks.push(current.slice(0, splitAt));
+      current = current.slice(splitAt).trimStart();
+    }
+    return chunks;
+  }
   createEmbed(msg) {
     const color = this.config.embedColors?.[msg.level] ?? DEFAULT_EMBED_COLORS[msg.level];
     const embed = {
@@ -487,7 +317,7 @@ var DiscordTransport = class extends BaseHttpTransport {
 };
 
 // src/transports/telegram.ts
-var LEVEL_EMOJI = {
+var LEVEL_EMOJI2 = {
   off: "",
   error: "\u{1F534}",
   warn: "\u{1F7E1}",
@@ -515,7 +345,7 @@ var TelegramTransport = class extends BaseHttpTransport {
     await this.sendMessage(text, messages);
   }
   formatBatchMessage(messages) {
-    const parseMode = this.config.parseMode ?? "Markdown";
+    const parseMode = this.config.parseMode ?? "HTML";
     return messages.map((msg) => {
       if (parseMode === "HTML") {
         return this.formatHtml(msg);
@@ -524,9 +354,10 @@ var TelegramTransport = class extends BaseHttpTransport {
     }).join("\n\n---\n\n");
   }
   formatMarkdown(msg, v2) {
-    const emoji = LEVEL_EMOJI[msg.level];
+    const emoji = LEVEL_EMOJI2[msg.level];
     const escape = v2 ? this.escapeMarkdownV2.bind(this) : (s) => s;
-    let text = `${emoji} *${msg.level.toUpperCase()}* \\[${escape(msg.context || "APP")}\\]
+    const bracket = v2 ? ["\\[", "\\]"] : ["[", "]"];
+    let text = `${emoji} *${msg.level.toUpperCase()}* ${bracket[0]}${escape(msg.context || "APP")}${bracket[1]}
 `;
     text += escape(msg.message);
     if (msg.meta && Object.keys(msg.meta).length > 0) {
@@ -536,7 +367,7 @@ var TelegramTransport = class extends BaseHttpTransport {
     return text;
   }
   formatHtml(msg) {
-    const emoji = LEVEL_EMOJI[msg.level];
+    const emoji = LEVEL_EMOJI2[msg.level];
     let text = `${emoji} <b>${msg.level.toUpperCase()}</b> [${this.escapeHtml(msg.context || "APP")}]
 `;
     text += this.escapeHtml(msg.message);
@@ -556,7 +387,7 @@ var TelegramTransport = class extends BaseHttpTransport {
     const body = {
       chat_id: this.config.chatId,
       text,
-      parse_mode: this.config.parseMode ?? "Markdown",
+      parse_mode: this.config.parseMode ?? "HTML",
       disable_notification: this.shouldMute(messages)
     };
     if (this.config.threadId) {
@@ -711,85 +542,224 @@ var CloudWatchTransport = class extends BaseHttpTransport {
   }
 };
 
-// src/transports.ts
-function toArray(value) {
-  if (!value) return [];
-  return Array.isArray(value) ? value : [value];
+// src/streams.ts
+function parseLogLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function getLevelName(levelNum) {
+  if (levelNum >= 50) return "error";
+  if (levelNum >= 40) return "warn";
+  if (levelNum >= 30) return "info";
+  if (levelNum >= 25) return "http";
+  if (levelNum >= 20) return "debug";
+  return "silly";
+}
+function shouldPassTransport(log, level, rules, store) {
+  const logLevel = getLevelName(log.level);
+  const context = log.context;
+  const storeContext = store.getStore();
+  const matchingRule = rules?.find((rule) => matchesContext(storeContext, context, rule.match));
+  const effectiveLevel = matchingRule?.level ?? level ?? "silly";
+  if (effectiveLevel === "off") return false;
+  return LOG_LEVELS[logLevel] <= LOG_LEVELS[effectiveLevel];
+}
+function formatLog(log, format, store) {
+  const levelName = getLevelName(log.level);
+  const timestamp = new Date(log.time).toISOString();
+  const context = log.context || "APP";
+  const message = log.msg || "";
+  const storeContext = store.getStore();
+  const meta = {};
+  for (const [key, value] of Object.entries(log)) {
+    if (!["level", "time", "msg", "context"].includes(key)) {
+      meta[key] = value;
+    }
+  }
+  if (storeContext) {
+    Object.assign(meta, storeContext);
+  }
+  if (format === "json") {
+    return JSON.stringify({
+      level: levelName,
+      timestamp,
+      context,
+      message,
+      ...meta
+    }) + "\n";
+  }
+  if (format === "plain") {
+    const LEVEL_COLORS = {
+      error: "\x1B[31m",
+      warn: "\x1B[33m",
+      info: "\x1B[32m",
+      http: "\x1B[35m",
+      verbose: "\x1B[36m",
+      debug: "\x1B[34m",
+      silly: "\x1B[90m"
+    };
+    const RESET = "\x1B[0m";
+    const color = LEVEL_COLORS[levelName] || "";
+    const coloredLevel = color ? `${color}${levelName}${RESET}` : levelName;
+    const metaStr = Object.keys(meta).length > 0 ? "\n  " + Object.entries(meta).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join("\n  ") : "";
+    return `[${timestamp}] ${coloredLevel} [${context}] ${message}${metaStr}
+`;
+  }
+  if (format === "logfmt") {
+    const parts = [`level=${levelName}`, `msg="${message}"`, `context=${context}`, `ts=${timestamp}`];
+    for (const [k, v] of Object.entries(meta)) {
+      parts.push(`${k}=${JSON.stringify(v)}`);
+    }
+    return parts.join(" ") + "\n";
+  }
+  return `[${timestamp}] ${levelName}: ${message}
+`;
 }
-function createTransports(config, store) {
-  const result = [
-    new winston.transports.Console({
-      format: winston.format.combine(
-        createFilterFormat(config.console.level, config.console.rules, store),
-        createFormat(config.console.format, store)
-      )
-    })
-  ];
+function createFormattedFilterStream(format, level, rules, store, destination) {
+  return new stream.Transform({
+    transform(chunk, _encoding, callback) {
+      const line = chunk.toString().trim();
+      if (!line) {
+        callback();
+        return;
+      }
+      const log = parseLogLine(line);
+      if (!log) {
+        callback();
+        return;
+      }
+      if (!shouldPassTransport(log, level, rules, store)) {
+        callback();
+        return;
+      }
+      const formatted = formatLog(log, format, store);
+      destination.write(formatted);
+      callback();
+    }
+  });
+}
+function createStreams(config, store) {
+  const streams = [];
+  const consoleStream = createFormattedFilterStream(
+    config.console.format,
+    config.console.level,
+    config.console.rules,
+    store,
+    process.stdout
+  );
+  streams.push({
+    level: "trace",
+    stream: consoleStream
+  });
   if (config.file) {
-    result.push(
-      new DailyRotateFile__default.default({
-        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",
-        zippedArchive: config.file.zippedArchive ?? false,
-        maxSize: config.file.maxSize ?? "20m",
-        maxFiles: config.file.maxFiles ?? "14d"
-      })
+    const fileConfig = config.file;
+    promises.mkdir(fileConfig.dirname, { recursive: true }).catch(() => {
+    });
+    const rotatingStream = rotatingFileStream.createStream(
+      (time, index) => {
+        const date = time instanceof Date ? time : /* @__PURE__ */ new Date();
+        const dateStr = date.toISOString().split("T")[0];
+        const base = fileConfig.filename.replace(".log", "");
+        return `${base}-${dateStr}${index ? `.${index}` : ""}.log`;
+      },
+      {
+        path: fileConfig.dirname,
+        size: fileConfig.maxSize || "20M",
+        interval: fileConfig.datePattern === "YYYY-MM-DD-HH" ? "1h" : "1d",
+        compress: fileConfig.zippedArchive ? "gzip" : false,
+        maxFiles: parseInt(fileConfig.maxFiles?.replace("d", "") || "14")
+      }
     );
+    const fileStream = createFormattedFilterStream(
+      fileConfig.format,
+      fileConfig.level,
+      fileConfig.rules,
+      store,
+      rotatingStream
+    );
+    streams.push({
+      level: "trace",
+      stream: fileStream
+    });
   }
   for (const discordConfig of toArray(config.discord)) {
-    const discord = new DiscordTransport(discordConfig);
-    discord.format = winston.format.combine(
-      createFilterFormat(discordConfig.level, discordConfig.rules, store),
-      winston.format.timestamp()
-    );
-    result.push(discord);
+    const transport = new DiscordTransport(discordConfig);
+    const discordStream = createHttpTransportStream(transport, discordConfig.level, discordConfig.rules, store);
+    streams.push({
+      level: "trace",
+      stream: discordStream
+    });
   }
   for (const telegramConfig of toArray(config.telegram)) {
-    const telegram = new TelegramTransport(telegramConfig);
-    telegram.format = winston.format.combine(
-      createFilterFormat(telegramConfig.level, telegramConfig.rules, store),
-      winston.format.timestamp()
-    );
-    result.push(telegram);
+    const transport = new TelegramTransport(telegramConfig);
+    const telegramStream = createHttpTransportStream(transport, telegramConfig.level, telegramConfig.rules, store);
+    streams.push({
+      level: "trace",
+      stream: telegramStream
+    });
   }
   for (const cloudwatchConfig of toArray(config.cloudwatch)) {
-    const cloudwatch = new CloudWatchTransport(cloudwatchConfig);
-    cloudwatch.format = winston.format.combine(
-      createFilterFormat(cloudwatchConfig.level, cloudwatchConfig.rules, store),
-      winston.format.timestamp()
-    );
-    result.push(cloudwatch);
+    const transport = new CloudWatchTransport(cloudwatchConfig);
+    const cwStream = createHttpTransportStream(transport, cloudwatchConfig.level, cloudwatchConfig.rules, store);
+    streams.push({
+      level: "trace",
+      stream: cwStream
+    });
   }
-  return result;
+  return pino__default.default.multistream(streams);
 }
-function createExceptionHandlers(config, store) {
-  const result = [
-    new winston.transports.Console({
-      format: createFormat(config.console.format, store)
-    })
-  ];
-  if (config.file) {
-    result.push(
-      new DailyRotateFile__default.default({
-        format: createFormat(config.file.format, store),
-        dirname: config.file.dirname,
-        filename: `exceptions-${config.file.filename}`,
-        datePattern: config.file.datePattern ?? "YYYY-MM-DD",
-        zippedArchive: config.file.zippedArchive ?? false,
-        maxSize: config.file.maxSize ?? "20m",
-        maxFiles: config.file.maxFiles ?? "14d"
-      })
-    );
-  }
-  return result;
+function toArray(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function createHttpTransportStream(transport, level, rules, store) {
+  return new stream.Writable({
+    write(chunk, _encoding, callback) {
+      const line = chunk.toString().trim();
+      if (!line) {
+        callback();
+        return;
+      }
+      const log = parseLogLine(line);
+      if (!log) {
+        callback();
+        return;
+      }
+      if (!shouldPassTransport(log, level, rules, store)) {
+        callback();
+        return;
+      }
+      const levelName = getLevelName(log.level);
+      const storeContext = store.getStore();
+      const meta = {};
+      for (const [key, value] of Object.entries(log)) {
+        if (!["level", "time", "msg", "context"].includes(key)) {
+          meta[key] = value;
+        }
+      }
+      if (storeContext) {
+        Object.assign(meta, storeContext);
+      }
+      transport.log({
+        level: levelName,
+        message: log.msg || "",
+        context: log.context,
+        timestamp: new Date(log.time),
+        ...meta
+      }, callback);
+    }
+  });
 }
 
 // src/state.ts
+var CUSTOM_LEVELS = {
+  http: 25,
+  verbose: 25,
+  silly: 10
+};
 function parseLevelConfig(level) {
   if (typeof level === "string") {
     assertLogLevel(level);
@@ -802,37 +772,64 @@ function parseLevelConfig(level) {
   });
   return { defaultLevel: level.default, rules };
 }
+function buildIndexes(overrides) {
+  const contextIndex = /* @__PURE__ */ new Map();
+  const complexRules = [];
+  for (const override of overrides.values()) {
+    const keys = Object.keys(override.match);
+    if (keys.length === 1 && keys[0] === "context" && typeof override.match.context === "string") {
+      contextIndex.set(override.match.context, override);
+    } else {
+      complexRules.push(override);
+    }
+  }
+  return { contextIndex, complexRules };
+}
 function createState(config, store) {
   const { defaultLevel, rules } = parseLevelConfig(config.level);
   const loggerStore = store ?? new LoggerStore();
-  const exceptionHandlers = createExceptionHandlers(config, loggerStore);
-  const winston$1 = winston.createLogger({
-    level: "silly",
-    // Accept all, we filter in shouldLog()
-    transports: createTransports(config, loggerStore),
-    exceptionHandlers,
-    rejectionHandlers: exceptionHandlers,
-    exitOnError: false
-  });
   const levelOverrides = /* @__PURE__ */ new Map();
   for (const rule of rules) {
     const key = JSON.stringify(rule.match);
     levelOverrides.set(key, rule);
   }
+  const { contextIndex, complexRules } = buildIndexes(levelOverrides);
+  const streams = createStreams(config, loggerStore);
+  const options = {
+    level: "trace",
+    // Accept all, we filter in shouldLog()
+    customLevels: CUSTOM_LEVELS,
+    base: void 0
+    // Disable pid and hostname
+  };
+  const pinoLogger = pino__default.default(options, streams);
   return {
-    winston: winston$1,
+    pino: pinoLogger,
     store: loggerStore,
     defaultLevel,
-    levelOverrides
+    levelOverrides,
+    contextIndex,
+    complexRules
   };
 }
+function rebuildIndexes(state) {
+  const { contextIndex, complexRules } = buildIndexes(state.levelOverrides);
+  state.contextIndex = contextIndex;
+  state.complexRules.length = 0;
+  state.complexRules.push(...complexRules);
+}
 function shouldLog(state, level, context) {
   const effectiveLevel = getEffectiveLevel(state, context);
+  if (effectiveLevel === "off") return false;
   return LOG_LEVELS[level] <= LOG_LEVELS[effectiveLevel];
 }
 function getEffectiveLevel(state, loggerContext) {
+  if (loggerContext) {
+    const indexed = state.contextIndex.get(loggerContext);
+    if (indexed) return indexed.level;
+  }
   const storeContext = state.store.getStore();
-  for (const { match, level } of state.levelOverrides.values()) {
+  for (const { match, level } of state.complexRules) {
     if (matchesContext(storeContext, loggerContext, match)) {
       return level;
     }
@@ -890,6 +887,7 @@ var DiscordConfigSchema = zod.z.object({
   maxRetries: zod.z.number().int().nonnegative().optional(),
   retryDelay: zod.z.number().int().positive().optional(),
   webhookUrl: zod.z.string().url("webhookUrl must be a valid URL"),
+  format: zod.z.enum(["embed", "markdown"]).optional(),
   username: zod.z.string().optional(),
   avatarUrl: zod.z.string().url().optional(),
   embedColors: zod.z.record(zod.z.string(), zod.z.number().int()).optional(),
@@ -955,6 +953,7 @@ var Logger = class _Logger {
     this.state = state;
     this.context = context;
   }
+  profileTimers = /* @__PURE__ */ new Map();
   static create(config, store) {
     const validatedConfig = validateConfig(config);
     const state = createState(validatedConfig, store);
@@ -971,6 +970,7 @@ var Logger = class _Logger {
     assertLogLevel(level);
     const key = JSON.stringify(match);
     this.state.levelOverrides.set(key, { match, level });
+    rebuildIndexes(this.state);
   }
   removeLevelOverride(match) {
     const key = JSON.stringify(match);
@@ -978,26 +978,50 @@ var Logger = class _Logger {
     if (override?.readonly) {
       return false;
     }
-    return this.state.levelOverrides.delete(key);
+    const deleted = this.state.levelOverrides.delete(key);
+    if (deleted) {
+      rebuildIndexes(this.state);
+    }
+    return deleted;
   }
   clearLevelOverrides() {
+    let changed = false;
     for (const [key, override] of this.state.levelOverrides) {
       if (!override.readonly) {
         this.state.levelOverrides.delete(key);
+        changed = true;
       }
     }
+    if (changed) {
+      rebuildIndexes(this.state);
+    }
   }
   getLevelOverrides() {
     return Array.from(this.state.levelOverrides.values());
   }
   // Profiling
   profile(id, meta) {
-    this.state.winston.profile(id, meta);
+    const existing = this.profileTimers.get(id);
+    if (existing) {
+      const duration = Date.now() - existing;
+      this.profileTimers.delete(id);
+      this.info(`${id} completed`, { ...meta, durationMs: duration });
+    } else {
+      this.profileTimers.set(id, Date.now());
+    }
   }
   // Logging methods
-  error(message, error, meta) {
+  error(errorOrMessage, messageOrMeta, meta) {
     if (!shouldLog(this.state, "error", this.context)) return;
-    this.log("error", message, meta, error);
+    if (errorOrMessage instanceof Error) {
+      if (typeof messageOrMeta === "string") {
+        this.log("error", messageOrMeta, meta, errorOrMessage);
+      } else {
+        this.log("error", errorOrMessage.message, messageOrMeta, errorOrMessage);
+      }
+    } else {
+      this.log("error", errorOrMessage, messageOrMeta);
+    }
   }
   warn(message, meta) {
     if (!shouldLog(this.state, "warn", this.context)) return;
@@ -1027,13 +1051,41 @@ var Logger = class _Logger {
   log(level, message, meta, error) {
     const resolved = typeof meta === "function" ? meta() : meta;
     const logMeta = { context: this.context, ...resolved };
+    const storeContext = this.state.store.getStore();
+    if (storeContext) {
+      Object.assign(logMeta, storeContext);
+    }
     if (error instanceof Error) {
       logMeta.errorMessage = error.message;
       logMeta.stack = error.stack;
     } else if (error !== void 0) {
       logMeta.error = error;
     }
-    this.state.winston.log(level, message, logMeta);
+    const pinoMethod = this.getPinoMethod(level);
+    pinoMethod.call(this.state.pino, logMeta, message);
+  }
+  getPinoMethod(level) {
+    switch (level) {
+      case "error":
+        return this.state.pino.error.bind(this.state.pino);
+      case "warn":
+        return this.state.pino.warn.bind(this.state.pino);
+      case "info":
+        return this.state.pino.info.bind(this.state.pino);
+      case "http":
+      case "verbose":
+        return (obj, msg) => {
+          this.state.pino[level](obj, msg);
+        };
+      case "debug":
+        return this.state.pino.debug.bind(this.state.pino);
+      case "silly":
+        return (obj, msg) => {
+          this.state.pino.silly(obj, msg);
+        };
+      default:
+        return this.state.pino.info.bind(this.state.pino);
+    }
   }
 };
 
@@ -1137,6 +1189,114 @@ function getOrGenerateRequestId(headers, options = {}) {
   return extractRequestId(headers) ?? generateRequestId(options);
 }
 
+// src/utils/mask-secrets.ts
+var DEFAULT_SECRET_PATTERNS = [
+  "password",
+  "secret",
+  "token",
+  "apikey",
+  "api_key",
+  "api-key",
+  "auth",
+  "credential",
+  "private"
+];
+var DEFAULT_MASK = "***";
+function isSecretKey(key, patterns) {
+  const lowerKey = key.toLowerCase();
+  return patterns.some((pattern) => lowerKey.includes(pattern.toLowerCase()));
+}
+function maskUrlCredentials(url, mask) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.password) {
+      parsed.password = mask;
+    }
+    if (parsed.username && parsed.password) {
+      parsed.username = mask;
+    }
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
+function maskSecrets(obj, options = {}) {
+  const { patterns = DEFAULT_SECRET_PATTERNS, mask = DEFAULT_MASK, deep = true } = options;
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj === "string") {
+    if (obj.startsWith("http://") || obj.startsWith("https://")) {
+      return maskUrlCredentials(obj, mask);
+    }
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return deep ? obj.map((item) => maskSecrets(item, options)) : obj;
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const sym of Object.getOwnPropertySymbols(obj)) {
+      result[sym] = obj[sym];
+    }
+    for (const [key, value] of Object.entries(obj)) {
+      if (isSecretKey(key, patterns)) {
+        result[key] = mask;
+      } else if (deep && typeof value === "object" && value !== null) {
+        result[key] = maskSecrets(value, options);
+      } else if (typeof value === "string") {
+        result[key] = maskSecrets(value, options);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  return obj;
+}
+function createMasker(options = {}) {
+  return (obj) => maskSecrets(obj, options);
+}
+
+// src/formatters.ts
+function flattenObject(obj, prefix = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Error)) {
+      Object.assign(result, flattenObject(value, newKey));
+    } else {
+      result[newKey] = value;
+    }
+  }
+  return result;
+}
+function formatLogfmtValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    if (value.includes(" ") || value.includes('"') || value.includes("=")) {
+      return `"${value.replace(/"/g, '\\"')}"`;
+    }
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value instanceof Error) {
+    return `"${value.message.replace(/"/g, '\\"')}"`;
+  }
+  if (Array.isArray(value)) {
+    return `"${JSON.stringify(value).replace(/"/g, '\\"')}"`;
+  }
+  return `"${JSON.stringify(value).replace(/"/g, '\\"')}"`;
+}
+function formatLogfmt(data) {
+  const flattened = flattenObject(data);
+  return Object.entries(flattened).filter(([, value]) => value !== void 0 && value !== null).map(([key, value]) => `${key}=${formatLogfmtValue(value)}`).join(" ");
+}
+
 exports.BaseHttpTransport = BaseHttpTransport;
 exports.CloudWatchConfigSchema = CloudWatchConfigSchema;
 exports.CloudWatchTransport = CloudWatchTransport;