@feizk/logger 1.7.0 → 2.0.0

package/dist/index.mjs

@@ -1,201 +1,327 @@
-// src/utils.ts
-import chalk from "chalk";
-var TIMESTAMP_TYPES = {
-  ISO: "iso",
-  Locale: "locale",
-  Custom: "custom"
+// src/constants.ts
+var LOG_LEVEL_PRIORITIES = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5
+};
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m",
+  white: "\x1B[37m",
+  bgRed: "\x1B[41m"
+};
+var LEVEL_COLORS = {
+  trace: ANSI.gray,
+  debug: ANSI.cyan,
+  info: ANSI.blue,
+  warn: ANSI.yellow,
+  error: ANSI.red,
+  fatal: `${ANSI.bgRed}${ANSI.white}${ANSI.bold}`
+};
+var LEVEL_LABELS = {
+  trace: "[TRACE]",
+  debug: "[DEBUG]",
+  info: "[INFO]",
+  warn: "[WARN]",
+  error: "[ERROR]",
+  fatal: "[FATAL]"
 };
-function formatTimestamp(formatTimestampFn, types, date = /* @__PURE__ */ new Date()) {
-  const [, timestamp] = formatTimestampFn(types, date);
-  return timestamp;
+var CONSOLE_METHODS = {
+  trace: "trace",
+  debug: "debug",
+  info: "log",
+  warn: "warn",
+  error: "error",
+  fatal: "error"
+};
+var TIMESTAMP_PRESETS = {
+  iso: (date) => date.toISOString(),
+  locale: (date) => date.toLocaleString()
+};
+
+// src/utils.ts
+var coloredLabelCache = /* @__PURE__ */ new Map();
+function getColoredLabel(level, enableColors) {
+  const cacheKey = `${level}:${enableColors}`;
+  const cached = coloredLabelCache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  const label = LEVEL_LABELS[level];
+  if (!enableColors) {
+    coloredLabelCache.set(cacheKey, label);
+    return label;
+  }
+  const color = LEVEL_COLORS[level];
+  const result = `${color}${label}${ANSI.reset}`;
+  coloredLabelCache.set(cacheKey, result);
+  return result;
 }
-function getColor(level, enableColors) {
-  if (!enableColors) return level;
-  const colors = {
-    "[INFO]": chalk.blue(level),
-    "[WARN]": chalk.yellow(level),
-    "[ERROR]": chalk.red(level),
-    "[DEBUG]": chalk.gray(level)
-  };
-  return colors[level] || level;
+function formatTimestamp(option, date = /* @__PURE__ */ new Date()) {
+  if (typeof option === "function") {
+    return option(date);
+  }
+  const preset = TIMESTAMP_PRESETS[option];
+  return preset(date);
 }
-function getDiscordColor(level) {
-  const colors = {
-    debug: 9807270,
-    info: 3447003,
-    warn: 15965202,
-    error: 15158332
+function formatJson(entry) {
+  const message = entry.args.map((arg) => {
+    if (typeof arg === "string") return arg;
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }).join(" ");
+  const output = {
+    level: entry.level,
+    timestamp: entry.timestamp,
+    message
   };
-  return colors[level];
-}
-function generateId() {
-  return Math.random().toString(36).substr(2, 8).toUpperCase();
-}
-function formatLog(level, timestamp, args, options) {
-  const { formatLog: formatLog2, enableColors = true } = options;
-  const coloredLevel = getColor(level, enableColors);
-  if (formatLog2) {
-    return [formatLog2(coloredLevel, timestamp, args)];
+  if (entry.prefix) {
+    output.prefix = entry.prefix;
+  }
+  if (Object.keys(entry.context).length > 0) {
+    output.context = entry.context;
   }
-  return [`${coloredLevel} ${timestamp}`, ...args];
+  return JSON.stringify(output);
+}
+function buildMessage(args) {
+  return args.map((arg) => {
+    if (typeof arg === "string") return arg;
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }).join(" ");
 }
 
 // src/logger.ts
-var defaultFormatTimestamp = (types, date = /* @__PURE__ */ new Date()) => [types.ISO, date.toISOString()];
-var LOG_LEVEL_PRIORITIES = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-var Logger = class {
+var Logger = class _Logger {
+  /**
+   * Create a new Logger instance.
+   * @param options - Configuration options
+   */
   constructor(options = {}) {
-    this.discordQueue = [];
-    this.isProcessing = false;
     this.options = {
+      level: options.level ?? "debug",
+      silent: options.silent ?? false,
       enableColors: options.enableColors ?? true,
-      formatTimestamp: options.formatTimestamp ?? defaultFormatTimestamp,
-      formatLog: options.formatLog,
-      discord: options.discord
+      timestamp: options.timestamp ?? "iso",
+      formatter: options.formatter,
+      json: options.json ?? false,
+      transports: [...options.transports ?? []],
+      prefix: options.prefix,
+      context: { ...options.context ?? {} }
     };
-    this.level = options.level ?? "debug";
+    this.transports = this.options.transports;
+    this.prefix = this.options.prefix;
+    this.context = this.options.context;
   }
+  // ============================================================================
+  // Public Log Methods
+  // ============================================================================
   /**
-   * Sets the minimum log level for filtering messages.
-   * @param level - The log level to set.
+   * Log a trace message (most verbose).
+   * @param args - Arguments to log
+   */
+  trace(...args) {
+    this.log("trace", args);
+  }
+  /**
+   * Log a debug message.
+   * @param args - Arguments to log
+   */
+  debug(...args) {
+    this.log("debug", args);
+  }
+  /**
+   * Log an info message.
+   * @param args - Arguments to log
+   */
+  info(...args) {
+    this.log("info", args);
+  }
+  /**
+   * Log a warning message.
+   * @param args - Arguments to log
+   */
+  warn(...args) {
+    this.log("warn", args);
+  }
+  /**
+   * Log an error message.
+   * @param args - Arguments to log
+   */
+  error(...args) {
+    this.log("error", args);
+  }
+  /**
+   * Log a fatal message (most severe).
+   * @param args - Arguments to log
+   */
+  fatal(...args) {
+    this.log("fatal", args);
+  }
+  // ============================================================================
+  // Level Management
+  // ============================================================================
+  /**
+   * Set the minimum log level.
+   * @param level - The log level to set
    */
   setLevel(level) {
-    this.level = level;
+    this.options.level = level;
   }
   /**
-   * Sends a log message to Discord via webhook if configured.
-   * @param level - The log level.
-   * @param timestamp - The formatted timestamp.
-   * @param args - The log arguments.
+   * Get the current log level.
+   * @returns The current log level
    */
-  sendToDiscord(level, timestamp, args) {
-    const discord = this.options.discord;
-    if (!discord?.enable) return;
-    try {
-      new URL(discord.webhookURL);
-    } catch {
-      return;
-    }
-    const message = args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg)).join(" ");
-    const title = `${level.toUpperCase()}-${generateId()}`;
-    const embed = discord.formatEmbed ? discord.formatEmbed(level, timestamp, message) : {
-      title,
-      description: message,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      color: getDiscordColor(level)
-    };
-    this.discordQueue.push({ embed, retryCount: 0 });
-    if (!this.isProcessing) {
-      this.isProcessing = true;
-      setTimeout(() => this.processQueue(), 0);
-    }
+  getLevel() {
+    return this.options.level;
   }
+  // ============================================================================
+  // Transport Management
+  // ============================================================================
   /**
-   * Processes the Discord queue by sending batches of embeds.
+   * Add a transport to the logger.
+   * @param transport - The transport to add
    */
-  processQueue() {
-    if (this.discordQueue.length === 0) {
-      this.isProcessing = false;
-      return;
+  addTransport(transport) {
+    this.transports.push(transport);
+  }
+  /**
+   * Remove a transport from the logger.
+   * @param transport - The transport to remove
+   */
+  removeTransport(transport) {
+    const index = this.transports.indexOf(transport);
+    if (index !== -1) {
+      this.transports.splice(index, 1);
     }
-    this.isProcessing = true;
-    const discord = this.options.discord;
-    const batchSize = discord.batchSize ?? 10;
-    const batch = this.discordQueue.splice(0, batchSize);
-    this.sendBatch(batch.map((item) => item.embed)).then(() => {
-      const delay = discord.batchDelay ?? 2e3;
-      this.processTimeout = setTimeout(() => this.processQueue(), delay);
-    }).catch(() => {
-      const maxRetries = discord.maxRetries ?? 3;
-      const retryItems = batch.filter((item) => item.retryCount < maxRetries).map((item) => ({
-        ...item,
-        retryCount: item.retryCount + 1
-      }));
-      this.discordQueue.unshift(...retryItems);
-      const retryDelayBase = discord.retryDelayBase ?? 1e3;
-      const delay = retryDelayBase * Math.pow(2, batch[0]?.retryCount ?? 0);
-      this.processTimeout = setTimeout(() => this.processQueue(), delay);
-    });
   }
+  // ============================================================================
+  // Child Logger
+  // ============================================================================
   /**
-   * Sends a batch of embeds to Discord.
-   * @param embeds - The embeds to send.
+   * Create a child logger with additional prefix and context.
+   * @param options - Child logger options
+   * @returns A new Logger instance
    */
-  async sendBatch(embeds) {
-    const discord = this.options.discord;
-    await fetch(discord.webhookURL, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ embeds })
+  child(options = {}) {
+    const combinedPrefix = options.prefix ? this.prefix ? `${this.prefix}:${options.prefix}` : options.prefix : this.prefix;
+    const combinedContext = {
+      ...this.context,
+      ...options.context ?? {}
+    };
+    return new _Logger({
+      level: options.level ?? this.options.level,
+      silent: options.silent ?? this.options.silent,
+      enableColors: this.options.enableColors,
+      timestamp: this.options.timestamp,
+      formatter: this.options.formatter,
+      json: this.options.json,
+      transports: this.transports.slice(),
+      prefix: combinedPrefix,
+      context: combinedContext
     });
   }
+  // ============================================================================
+  // Cleanup
+  // ============================================================================
   /**
-   * Checks if a log level should be output based on the current log level.
-   * @param level - The log level to check.
-   * @returns True if the message should be logged.
+   * Destroy the logger and all its transports.
+   * Calls destroy() on all registered transports.
    */
-  shouldLog(level) {
-    return LOG_LEVEL_PRIORITIES[level] >= LOG_LEVEL_PRIORITIES[this.level];
+  async destroy() {
+    const destroyPromises = this.transports.map(async (transport) => {
+      if (typeof transport.destroy === "function") {
+        await transport.destroy();
+      }
+    });
+    await Promise.all(destroyPromises);
+    this.transports.length = 0;
   }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
   /**
-   * Logs an info message.
-   * @param args - The arguments to log.
+   * Core logging method - all public methods delegate here.
+   * @param level - The log level
+   * @param args - The arguments to log
    */
-  info(...args) {
-    if (!this.shouldLog("info")) return;
-    const timestamp = formatTimestamp(
-      this.options.formatTimestamp,
-      TIMESTAMP_TYPES
-    );
-    console.log(...formatLog("[INFO]", timestamp, args, this.options));
-    this.sendToDiscord("info", timestamp, args);
+  log(level, args) {
+    if (!this.shouldLog(level)) return;
+    const entry = {
+      level,
+      timestamp: formatTimestamp(this.options.timestamp),
+      args,
+      prefix: this.prefix,
+      context: this.context
+    };
+    if (!this.options.silent) {
+      this.writeToConsole(level, entry);
+    }
+    for (const transport of this.transports) {
+      this.dispatchToTransport(transport, entry);
+    }
   }
   /**
-   * Logs a warning message.
-   * @param args - The arguments to log.
+   * Write a log entry to the console.
+   * @param level - The log level
+   * @param entry - The log entry
    */
-  warn(...args) {
-    if (!this.shouldLog("warn")) return;
-    const timestamp = formatTimestamp(
-      this.options.formatTimestamp,
-      TIMESTAMP_TYPES
-    );
-    console.log(...formatLog("[WARN]", timestamp, args, this.options));
-    this.sendToDiscord("warn", timestamp, args);
+  writeToConsole(level, entry) {
+    const method = CONSOLE_METHODS[level];
+    if (this.options.formatter) {
+      console[method](this.options.formatter(entry));
+      return;
+    }
+    if (this.options.json) {
+      console[method](formatJson(entry));
+      return;
+    }
+    const label = getColoredLabel(entry.level, this.options.enableColors);
+    const prefixStr = entry.prefix ? ` [${entry.prefix}]` : "";
+    const message = buildMessage(entry.args);
+    console[method](`${label} ${entry.timestamp}${prefixStr}`, message);
   }
   /**
-   * Logs an error message.
-   * @param args - The arguments to log.
+   * Dispatch a log entry to a transport.
+   * @param transport - The transport
+   * @param entry - The log entry
    */
-  error(...args) {
-    if (!this.shouldLog("error")) return;
-    const timestamp = formatTimestamp(
-      this.options.formatTimestamp,
-      TIMESTAMP_TYPES
-    );
-    console.log(...formatLog("[ERROR]", timestamp, args, this.options));
-    this.sendToDiscord("error", timestamp, args);
+  dispatchToTransport(transport, entry) {
+    try {
+      const result = transport.log(entry);
+      if (result instanceof Promise) {
+        result.catch(() => {
+        });
+      }
+    } catch {
+    }
   }
   /**
-   * Logs a debug message.
-   * @param args - The arguments to log.
+   * Check if a log level should be output.
+   * @param level - The log level to check
+   * @returns True if the message should be logged
    */
-  debug(...args) {
-    if (!this.shouldLog("debug")) return;
-    const timestamp = formatTimestamp(
-      this.options.formatTimestamp,
-      TIMESTAMP_TYPES
-    );
-    console.log(...formatLog("[DEBUG]", timestamp, args, this.options));
-    this.sendToDiscord("debug", timestamp, args);
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITIES[level] >= LOG_LEVEL_PRIORITIES[this.options.level];
   }
 };
 export {
-  Logger,
-  TIMESTAMP_TYPES
+  LEVEL_LABELS,
+  LOG_LEVEL_PRIORITIES,
+  Logger
 };

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@feizk/logger",
-  "version": "1.7.0",
-  "description": "A simple logger package with colored outputs and timestamps",
-  "main": "dist/index.js",
+  "version": "2.0.0",
+  "description": "A lightweight, pluggable logger with colored outputs, structured logging, and transport support",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "chalk": "^5.3.0"
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  },
+  "engines": {
+    "node": ">=18"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -22,7 +28,9 @@
     "logger",
     "console",
     "colors",
-    "timestamps"
+    "timestamps",
+    "structured-logging",
+    "transports"
   ],
   "author": "feizk",
   "license": "MIT",