@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/logging/index.js

@@ -0,0 +1,557 @@
+// src/logging/types.ts
+var LOG_LEVEL_PRIORITY = {
+  emergency: 0,
+  alert: 1,
+  critical: 2,
+  error: 3,
+  warning: 4,
+  notice: 5,
+  info: 6,
+  debug: 7
+};
+
+// src/logging/Logger.ts
+var DEFAULT_FILTER_KEYS = [
+  "password",
+  "password_confirmation",
+  "token",
+  "secret",
+  "credit_card",
+  "creditCard",
+  "card_number",
+  "cardNumber",
+  "cvv",
+  "ssn",
+  "authorization"
+];
+function filterSensitiveData(data, filterKeys, replacement = "[FILTERED]") {
+  if (filterKeys.length === 0) return data;
+  const keySet = new Set(filterKeys.map((k) => k.toLowerCase()));
+  return filterObject(data, keySet, replacement);
+}
+function filterObject(obj, keySet, replacement) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (keySet.has(key.toLowerCase())) {
+      result[key] = replacement;
+    } else if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = filterObject(value, keySet, replacement);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map(
+        (item) => item !== null && typeof item === "object" && !Array.isArray(item) ? filterObject(item, keySet, replacement) : item
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var Logger = class _Logger {
+  channels;
+  baseContext;
+  filterKeys;
+  replacement;
+  constructor(channels, context = {}, options = {}) {
+    this.channels = channels;
+    this.baseContext = context;
+    this.filterKeys = options.filterKeys ?? DEFAULT_FILTER_KEYS;
+    this.replacement = options.replacement ?? "[FILTERED]";
+  }
+  /**
+   * Log at emergency level (system is unusable).
+   */
+  emergency(message, context = {}) {
+    this.log("emergency", message, context);
+  }
+  /**
+   * Log at alert level (action must be taken immediately).
+   */
+  alert(message, context = {}) {
+    this.log("alert", message, context);
+  }
+  /**
+   * Log at critical level (critical conditions).
+   */
+  critical(message, context = {}) {
+    this.log("critical", message, context);
+  }
+  /**
+   * Log at error level (error conditions).
+   */
+  error(message, context = {}) {
+    this.log("error", message, context);
+  }
+  /**
+   * Log at warning level (warning conditions).
+   */
+  warning(message, context = {}) {
+    this.log("warning", message, context);
+  }
+  /**
+   * Alias for warning().
+   */
+  warn(message, context = {}) {
+    this.warning(message, context);
+  }
+  /**
+   * Log at notice level (normal but significant conditions).
+   */
+  notice(message, context = {}) {
+    this.log("notice", message, context);
+  }
+  /**
+   * Log at info level (informational messages).
+   */
+  info(message, context = {}) {
+    this.log("info", message, context);
+  }
+  /**
+   * Log at debug level (debug-level messages).
+   */
+  debug(message, context = {}) {
+    this.log("debug", message, context);
+  }
+  /**
+   * Log a message at the specified level.
+   */
+  log(level, message, context = {}) {
+    const merged = { ...this.baseContext, ...context };
+    const filtered = this.filterKeys.length > 0 ? filterSensitiveData(merged, this.filterKeys, this.replacement) : merged;
+    const entry = {
+      level,
+      message,
+      context: filtered,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    for (const channel of this.channels) {
+      try {
+        channel.log(entry);
+      } catch (error) {
+        console.error("Logging error:", error);
+      }
+    }
+  }
+  /**
+   * Create a new logger with additional context.
+   */
+  withContext(context) {
+    return new _Logger(this.channels, { ...this.baseContext, ...context }, {
+      filterKeys: this.filterKeys,
+      replacement: this.replacement
+    });
+  }
+  /**
+   * Create a child logger with additional context (alias for withContext).
+   */
+  child(context) {
+    return this.withContext(context);
+  }
+  /**
+   * Close all channels.
+   */
+  async close() {
+    for (const channel of this.channels) {
+      if (channel.close) {
+        await channel.close();
+      }
+    }
+  }
+};
+
+// src/logging/channels/ConsoleChannel.ts
+var LEVEL_COLORS = {
+  emergency: "\x1B[41m\x1B[37m",
+  // White on red background
+  alert: "\x1B[41m\x1B[37m",
+  // White on red background
+  critical: "\x1B[31m",
+  // Red
+  error: "\x1B[31m",
+  // Red
+  warning: "\x1B[33m",
+  // Yellow
+  notice: "\x1B[36m",
+  // Cyan
+  info: "\x1B[32m",
+  // Green
+  debug: "\x1B[90m"
+  // Gray
+};
+var RESET = "\x1B[0m";
+var ConsoleChannel = class {
+  config;
+  minLevel;
+  constructor(config) {
+    this.config = {
+      colors: true,
+      timestamps: true,
+      format: "text",
+      ...config
+    };
+    this.minLevel = LOG_LEVEL_PRIORITY[this.config.level ?? "debug"];
+  }
+  log(entry) {
+    const entryLevel = LOG_LEVEL_PRIORITY[entry.level];
+    if (entryLevel > this.minLevel) {
+      return;
+    }
+    const output = this.format(entry);
+    if (entryLevel <= LOG_LEVEL_PRIORITY.error) {
+      console.error(output);
+    } else if (entryLevel <= LOG_LEVEL_PRIORITY.warning) {
+      console.warn(output);
+    } else if (entryLevel <= LOG_LEVEL_PRIORITY.info) {
+      console.info(output);
+    } else {
+      console.log(output);
+    }
+  }
+  format(entry) {
+    if (this.config.format === "json") {
+      return JSON.stringify({
+        timestamp: entry.timestamp.toISOString(),
+        level: entry.level,
+        message: entry.message,
+        ...entry.context
+      });
+    }
+    const parts = [];
+    if (this.config.timestamps) {
+      const time = entry.timestamp.toISOString();
+      parts.push(this.config.colors ? `\x1B[90m[${time}]\x1B[0m` : `[${time}]`);
+    }
+    const levelStr = entry.level.toUpperCase().padEnd(9);
+    if (this.config.colors) {
+      parts.push(`${LEVEL_COLORS[entry.level]}${levelStr}${RESET}`);
+    } else {
+      parts.push(levelStr);
+    }
+    parts.push(entry.message);
+    if (Object.keys(entry.context).length > 0) {
+      const contextStr = JSON.stringify(entry.context);
+      if (this.config.colors) {
+        parts.push(`\x1B[90m${contextStr}${RESET}`);
+      } else {
+        parts.push(contextStr);
+      }
+    }
+    return parts.join(" ");
+  }
+};
+
+// src/logging/channels/FileChannel.ts
+import * as fs from "fs";
+import * as path from "path";
+var FileChannel = class {
+  config;
+  minLevel;
+  initialized = false;
+  constructor(config) {
+    this.config = {
+      format: "text",
+      ...config
+    };
+    this.minLevel = LOG_LEVEL_PRIORITY[this.config.level ?? "debug"];
+  }
+  log(entry) {
+    const entryLevel = LOG_LEVEL_PRIORITY[entry.level];
+    if (entryLevel > this.minLevel) {
+      return;
+    }
+    const line = this.format(entry) + "\n";
+    this.write(line);
+  }
+  write(data) {
+    if (!this.initialized) {
+      this.ensureDirectory();
+      this.initialized = true;
+    }
+    fs.appendFileSync(this.config.path, data);
+  }
+  ensureDirectory() {
+    const dir = path.dirname(this.config.path);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+  format(entry) {
+    if (this.config.format === "json") {
+      return JSON.stringify({
+        timestamp: entry.timestamp.toISOString(),
+        level: entry.level,
+        message: entry.message,
+        ...entry.context
+      });
+    }
+    const timestamp = entry.timestamp.toISOString();
+    const level = entry.level.toUpperCase().padEnd(9);
+    const context = Object.keys(entry.context).length > 0 ? " " + JSON.stringify(entry.context) : "";
+    return `[${timestamp}] ${level} ${entry.message}${context}`;
+  }
+  close() {
+  }
+};
+
+// src/logging/channels/DailyFileChannel.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var DailyFileChannel = class {
+  config;
+  minLevel;
+  currentDate = null;
+  currentFilePath = null;
+  constructor(config) {
+    this.config = {
+      days: 14,
+      format: "text",
+      ...config
+    };
+    this.minLevel = LOG_LEVEL_PRIORITY[this.config.level ?? "debug"];
+  }
+  log(entry) {
+    const entryLevel = LOG_LEVEL_PRIORITY[entry.level];
+    if (entryLevel > this.minLevel) {
+      return;
+    }
+    const dateStr = this.getDateString(entry.timestamp);
+    if (this.currentDate !== dateStr) {
+      this.rotate(dateStr);
+    }
+    const line = this.format(entry) + "\n";
+    this.write(line);
+  }
+  write(data) {
+    if (this.currentFilePath) {
+      fs2.appendFileSync(this.currentFilePath, data);
+    }
+  }
+  rotate(dateStr) {
+    this.currentDate = dateStr;
+    this.currentFilePath = this.getFilePath(dateStr);
+    this.ensureDirectory(this.currentFilePath);
+    this.cleanup();
+  }
+  getFilePath(dateStr) {
+    const { dir, name, ext } = path2.parse(this.config.path);
+    return path2.join(dir, `${name}-${dateStr}${ext}`);
+  }
+  getDateString(date) {
+    return date.toISOString().split("T")[0];
+  }
+  ensureDirectory(filePath) {
+    const dir = path2.dirname(filePath);
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+  }
+  cleanup() {
+    const { dir, name, ext } = path2.parse(this.config.path);
+    if (!fs2.existsSync(dir)) {
+      return;
+    }
+    const files = fs2.readdirSync(dir);
+    const pattern = new RegExp(`^${name}-(\\d{4}-\\d{2}-\\d{2})${ext.replace(".", "\\.")}$`);
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setDate(cutoff.getDate() - (this.config.days ?? 14));
+    for (const file of files) {
+      const match = file.match(pattern);
+      if (match) {
+        const fileDate = new Date(match[1]);
+        if (fileDate < cutoff) {
+          fs2.unlinkSync(path2.join(dir, file));
+        }
+      }
+    }
+  }
+  format(entry) {
+    if (this.config.format === "json") {
+      return JSON.stringify({
+        timestamp: entry.timestamp.toISOString(),
+        level: entry.level,
+        message: entry.message,
+        ...entry.context
+      });
+    }
+    const timestamp = entry.timestamp.toISOString();
+    const level = entry.level.toUpperCase().padEnd(9);
+    const context = Object.keys(entry.context).length > 0 ? " " + JSON.stringify(entry.context) : "";
+    return `[${timestamp}] ${level} ${entry.message}${context}`;
+  }
+  close() {
+  }
+};
+
+// src/logging/LogManager.ts
+var LogManager = class {
+  config;
+  channelFactories = /* @__PURE__ */ new Map();
+  channelInstances = /* @__PURE__ */ new Map();
+  loggers = /* @__PURE__ */ new Map();
+  loggerOptions;
+  constructor(config) {
+    this.config = config;
+    this.loggerOptions = {
+      filterKeys: config.filterKeys,
+      replacement: config.filterReplacement
+    };
+    this.registerDefaultDrivers();
+  }
+  registerDefaultDrivers() {
+    this.registerDriver("console", (config) => {
+      return new ConsoleChannel(config);
+    });
+    this.registerDriver("file", (config) => {
+      return new FileChannel(config);
+    });
+    this.registerDriver("daily", (config) => {
+      return new DailyFileChannel(config);
+    });
+    this.registerDriver("stack", (config) => {
+      return this.createStackChannel(config);
+    });
+  }
+  createStackChannel(config) {
+    const channels = config.channels.map((name) => this.resolveChannel(name));
+    return {
+      log: (entry) => {
+        for (const channel of channels) {
+          channel.log(entry);
+        }
+      },
+      close: async () => {
+        for (const channel of channels) {
+          if (channel.close) {
+            await channel.close();
+          }
+        }
+      }
+    };
+  }
+  /**
+   * Register a custom channel driver.
+   */
+  registerDriver(name, factory) {
+    this.channelFactories.set(name, factory);
+  }
+  /**
+   * Get a logger for a specific channel.
+   */
+  channel(name) {
+    const channelName = name ?? this.config.default;
+    if (!this.loggers.has(channelName)) {
+      const channel = this.resolveChannel(channelName);
+      this.loggers.set(channelName, new Logger([channel], {}, this.loggerOptions));
+    }
+    return this.loggers.get(channelName);
+  }
+  /**
+   * Get a logger that writes to multiple channels.
+   */
+  stack(channelNames) {
+    const key = `stack:${channelNames.join(",")}`;
+    if (!this.loggers.has(key)) {
+      const channels = channelNames.map((name) => this.resolveChannel(name));
+      this.loggers.set(key, new Logger(channels, {}, this.loggerOptions));
+    }
+    return this.loggers.get(key);
+  }
+  resolveChannel(name) {
+    if (this.channelInstances.has(name)) {
+      return this.channelInstances.get(name);
+    }
+    const config = this.config.channels[name];
+    if (!config) {
+      throw new Error(`Log channel [${name}] is not defined`);
+    }
+    const factory = this.channelFactories.get(config.driver);
+    if (!factory) {
+      throw new Error(`Log driver [${config.driver}] is not supported`);
+    }
+    const channel = factory(config);
+    this.channelInstances.set(name, channel);
+    return channel;
+  }
+  /**
+   * Create a logger with additional context using the default channel.
+   */
+  withContext(context) {
+    return this.channel().withContext(context);
+  }
+  // Convenience methods that delegate to default channel
+  emergency(message, context) {
+    this.channel().emergency(message, context);
+  }
+  alert(message, context) {
+    this.channel().alert(message, context);
+  }
+  critical(message, context) {
+    this.channel().critical(message, context);
+  }
+  error(message, context) {
+    this.channel().error(message, context);
+  }
+  warning(message, context) {
+    this.channel().warning(message, context);
+  }
+  warn(message, context) {
+    this.channel().warn(message, context);
+  }
+  notice(message, context) {
+    this.channel().notice(message, context);
+  }
+  info(message, context) {
+    this.channel().info(message, context);
+  }
+  debug(message, context) {
+    this.channel().debug(message, context);
+  }
+  /**
+   * Close all channel instances.
+   */
+  async close() {
+    for (const channel of this.channelInstances.values()) {
+      if (channel.close) {
+        await channel.close();
+      }
+    }
+    this.channelInstances.clear();
+    this.loggers.clear();
+  }
+  /**
+   * Get the default channel name.
+   */
+  getDefaultChannel() {
+    return this.config.default;
+  }
+  /**
+   * Get available channel names.
+   */
+  getChannelNames() {
+    return Object.keys(this.config.channels);
+  }
+};
+function createLogManager(config) {
+  return new LogManager(config);
+}
+var globalLogManager = null;
+function setLogManager(manager) {
+  globalLogManager = manager;
+}
+function getLogManager() {
+  if (!globalLogManager) {
+    throw new Error("Log manager has not been initialized. Call setLogManager() first.");
+  }
+  return globalLogManager;
+}
+export {
+  ConsoleChannel,
+  DailyFileChannel,
+  FileChannel,
+  LOG_LEVEL_PRIORITY,
+  LogManager,
+  Logger,
+  createLogManager,
+  filterSensitiveData,
+  getLogManager,
+  setLogManager
+};