@octaviaflow/logger 1.0.0

package/dist/presets/index.js

@@ -0,0 +1,1163 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/presets/index.ts
+var exports_presets = {};
+__export(exports_presets, {
+  createUILogger: () => createUILogger,
+  createEngineLogger: () => createEngineLogger,
+  createBackendLogger: () => createBackendLogger
+});
+module.exports = __toCommonJS(exports_presets);
+
+// src/constants.ts
+var LOG_LEVELS = {
+  fatal: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4,
+  trace: 5
+};
+var COLORS = {
+  fatal: "\x1B[35m",
+  error: "\x1B[31m",
+  warn: "\x1B[33m",
+  info: "\x1B[36m",
+  debug: "\x1B[32m",
+  trace: "\x1B[37m",
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m"
+};
+var DEFAULT_MAX_FILE_SIZE = "10m";
+var DEFAULT_MAX_FILES = 10;
+var DEFAULT_DATE_PATTERN = "YYYY-MM-DD";
+var SIZE_UNITS = {
+  b: 1,
+  k: 1024,
+  m: 1024 * 1024,
+  g: 1024 * 1024 * 1024
+};
+
+// src/transports/base.ts
+class BaseTransport {
+  config;
+  formatter;
+  constructor(config) {
+    this.config = config;
+  }
+  setFormatter(formatter) {
+    this.formatter = formatter;
+  }
+  shouldLog(level) {
+    if (!this.config.enabled)
+      return false;
+    const transportLevel = this.config.level || "trace";
+    return LOG_LEVELS[level] <= LOG_LEVELS[transportLevel];
+  }
+}
+// src/transports/console.ts
+class ConsoleTransport extends BaseTransport {
+  log(message, meta) {
+    if (!this.shouldLog(meta.level))
+      return;
+    const formatted = this.formatter ? this.formatter.format(message, meta) : JSON.stringify({ message, ...meta });
+    switch (meta.level) {
+      case "fatal":
+      case "error":
+        console.error(formatted);
+        break;
+      case "warn":
+        console.warn(formatted);
+        break;
+      case "debug":
+        console.debug(formatted);
+        break;
+      case "trace":
+        console.trace(formatted);
+        break;
+      default:
+        console.log(formatted);
+    }
+  }
+  async flush() {}
+  async close() {}
+}
+// src/utils/helpers.ts
+var import_node_os = __toESM(require("node:os"));
+function parseSize(size) {
+  const match = size.toLowerCase().match(/^(\d+)([bkmg]?)$/);
+  if (!match) {
+    throw new Error(`Invalid size format: ${size}`);
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2] || "b";
+  return value * (SIZE_UNITS[unit] ?? 1);
+}
+function formatDuration(ms) {
+  if (ms < 1)
+    return `${ms.toFixed(3)}ms`;
+  if (ms < 1000)
+    return `${ms.toFixed(0)}ms`;
+  if (ms < 60000)
+    return `${(ms / 1000).toFixed(2)}s`;
+  if (ms < 3600000)
+    return `${(ms / 60000).toFixed(2)}m`;
+  return `${(ms / 3600000).toFixed(2)}h`;
+}
+function getHostname() {
+  return import_node_os.default.hostname();
+}
+function getPid() {
+  return process.pid;
+}
+function sanitize(obj, fields = ["password", "token", "apiKey", "secret", "authorization"], replacement = "[REDACTED]") {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj !== "object")
+    return obj;
+  if (Array.isArray(obj)) {
+    return obj.map((item) => sanitize(item, fields, replacement));
+  }
+  const sanitized = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const lowerKey = key.toLowerCase();
+    const shouldRedact = fields.some((field) => lowerKey.includes(field.toLowerCase()));
+    if (shouldRedact) {
+      sanitized[key] = replacement;
+    } else if (typeof value === "object" && value !== null) {
+      sanitized[key] = sanitize(value, fields, replacement);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+function formatDateForFile(date, pattern) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hour = String(date.getHours()).padStart(2, "0");
+  const minute = String(date.getMinutes()).padStart(2, "0");
+  return pattern.replace("YYYY", String(year)).replace("MM", month).replace("DD", day).replace("HH", hour).replace("mm", minute);
+}
+function safeStringify(obj, space) {
+  const seen = new WeakSet;
+  return JSON.stringify(obj, (key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    if (value instanceof Error) {
+      return {
+        name: value.name,
+        message: value.message,
+        stack: value.stack
+      };
+    }
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    if (typeof value === "function") {
+      return "[Function]";
+    }
+    return value;
+  }, space);
+}
+async function ensureDir(dirPath) {
+  const fs = await import("node:fs/promises");
+  try {
+    await fs.mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+function isDevelopment() {
+  return true;
+}
+
+// src/transports/file.ts
+var import_node_path = __toESM(require("node:path"));
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_fs = require("node:fs");
+var import_node_zlib = require("node:zlib");
+var import_node_util = require("node:util");
+var gzipAsync = import_node_util.promisify(import_node_zlib.gzip);
+
+class FileTransport extends BaseTransport {
+  writeStream;
+  currentSize = 0;
+  currentDate = "";
+  writeQueue = [];
+  isWriting = false;
+  isClosed = false;
+  async log(message, meta) {
+    if (!this.shouldLog(meta.level) || this.isClosed)
+      return;
+    const formatted = this.formatter ? this.formatter.format(message, meta) : JSON.stringify({ message, ...meta });
+    this.writeQueue.push(formatted + `
+`);
+    await this.processQueue();
+  }
+  async processQueue() {
+    if (this.isWriting || this.writeQueue.length === 0)
+      return;
+    this.isWriting = true;
+    try {
+      while (this.writeQueue.length > 0) {
+        const entry = this.writeQueue.shift();
+        if (!entry)
+          continue;
+        await this.ensureStream();
+        await this.writeToStream(entry);
+      }
+    } finally {
+      this.isWriting = false;
+    }
+  }
+  async ensureStream() {
+    const fileConfig = this.config.file;
+    if (!fileConfig) {
+      throw new Error("File transport requires file configuration");
+    }
+    const maxSize = parseSize(fileConfig.maxSize || DEFAULT_MAX_FILE_SIZE);
+    const datePattern = fileConfig.datePattern || DEFAULT_DATE_PATTERN;
+    const currentDate = formatDateForFile(new Date, datePattern);
+    const needsRotation = this.currentSize >= maxSize || this.currentDate && this.currentDate !== currentDate;
+    if (needsRotation || !this.writeStream) {
+      await this.rotate();
+    }
+    this.currentDate = currentDate;
+  }
+  async writeToStream(data) {
+    return new Promise((resolve, reject) => {
+      if (!this.writeStream) {
+        reject(new Error("Write stream not initialized"));
+        return;
+      }
+      const canWrite = this.writeStream.write(data);
+      this.currentSize += Buffer.byteLength(data);
+      if (canWrite) {
+        resolve();
+      } else {
+        this.writeStream.once("drain", () => resolve());
+      }
+    });
+  }
+  async rotate() {
+    if (this.writeStream) {
+      await this.closeStream();
+    }
+    const fileConfig = this.config.file;
+    const logDir = import_node_path.default.dirname(fileConfig.path);
+    const logName = import_node_path.default.basename(fileConfig.path, import_node_path.default.extname(fileConfig.path));
+    const logExt = import_node_path.default.extname(fileConfig.path);
+    await ensureDir(logDir);
+    const datePattern = fileConfig.datePattern || DEFAULT_DATE_PATTERN;
+    const dateStr = formatDateForFile(new Date, datePattern);
+    const currentLogPath = import_node_path.default.join(logDir, `${logName}-${dateStr}${logExt}`);
+    try {
+      const stats = await import_promises.default.stat(currentLogPath);
+      const maxSize = parseSize(fileConfig.maxSize || DEFAULT_MAX_FILE_SIZE);
+      if (stats.size >= maxSize) {
+        await this.rotateFiles(logDir, logName, logExt);
+      }
+    } catch {}
+    this.writeStream = import_node_fs.createWriteStream(currentLogPath, { flags: "a" });
+    this.currentSize = 0;
+    this.writeStream.on("error", (error) => {
+      console.error("File transport write error:", error);
+    });
+  }
+  async rotateFiles(logDir, logName, logExt) {
+    const fileConfig = this.config.file;
+    const maxFiles = fileConfig.maxFiles || DEFAULT_MAX_FILES;
+    try {
+      const files = await import_promises.default.readdir(logDir);
+      const logFiles = files.filter((f) => f.startsWith(logName) && f.endsWith(logExt)).sort().reverse();
+      if (logFiles.length >= maxFiles) {
+        const filesToDelete = logFiles.slice(maxFiles - 1);
+        await Promise.all(filesToDelete.map((f) => import_promises.default.unlink(import_node_path.default.join(logDir, f)).catch(() => {})));
+      }
+      if (fileConfig.compress) {
+        const filesToCompress = logFiles.slice(1, maxFiles - 1);
+        await Promise.all(filesToCompress.map((f) => this.compressFile(import_node_path.default.join(logDir, f))));
+      }
+    } catch (error) {
+      console.error("Error rotating files:", error);
+    }
+  }
+  async compressFile(filePath) {
+    if (filePath.endsWith(".gz"))
+      return;
+    try {
+      const content = await import_promises.default.readFile(filePath);
+      const compressed = await gzipAsync(content);
+      await import_promises.default.writeFile(`${filePath}.gz`, compressed);
+      await import_promises.default.unlink(filePath);
+    } catch (error) {
+      console.error(`Error compressing file ${filePath}:`, error);
+    }
+  }
+  async closeStream() {
+    return new Promise((resolve) => {
+      if (!this.writeStream) {
+        resolve();
+        return;
+      }
+      this.writeStream.end(() => {
+        this.writeStream = undefined;
+        resolve();
+      });
+    });
+  }
+  async flush() {
+    while (this.writeQueue.length > 0 || this.isWriting) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    if (this.writeStream) {
+      await new Promise((resolve) => {
+        this.writeStream.write("", () => resolve());
+      });
+    }
+  }
+  async close() {
+    this.isClosed = true;
+    await this.flush();
+    await this.closeStream();
+  }
+}
+// src/transports/http.ts
+class HTTPTransport extends BaseTransport {
+  batch = { logs: [], timestamp: Date.now() };
+  flushTimer;
+  isClosed = false;
+  constructor(config) {
+    super(config);
+    this.startFlushTimer();
+  }
+  async log(message, meta) {
+    if (!this.shouldLog(meta.level) || this.isClosed)
+      return;
+    const httpConfig = this.config.http;
+    if (!httpConfig) {
+      throw new Error("HTTP transport requires http configuration");
+    }
+    this.batch.logs.push({ message, meta });
+    const batchSize = httpConfig.batchSize || 10;
+    if (this.batch.logs.length >= batchSize) {
+      await this.flush();
+    }
+  }
+  startFlushTimer() {
+    const httpConfig = this.config.http;
+    if (!httpConfig)
+      return;
+    const flushInterval = httpConfig.flushInterval || 5000;
+    this.flushTimer = setInterval(() => {
+      if (this.batch.logs.length > 0) {
+        this.flush().catch((error) => {
+          console.error("HTTP transport flush error:", error);
+        });
+      }
+    }, flushInterval);
+  }
+  async flush() {
+    if (this.batch.logs.length === 0)
+      return;
+    const httpConfig = this.config.http;
+    if (!httpConfig)
+      return;
+    const logsToSend = [...this.batch.logs];
+    this.batch = { logs: [], timestamp: Date.now() };
+    const payload = logsToSend.map((log) => ({
+      message: log.message,
+      ...log.meta
+    }));
+    await this.sendWithRetry(httpConfig.url, payload, httpConfig.retry);
+  }
+  async sendWithRetry(url, payload, retryConfig) {
+    const httpConfig = this.config.http;
+    const maxAttempts = retryConfig?.attempts || 3;
+    const retryDelay = retryConfig?.delay || 1000;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      try {
+        const response = await fetch(url, {
+          method: httpConfig.method || "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...httpConfig.headers
+          },
+          body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        return;
+      } catch (error) {
+        if (attempt === maxAttempts) {
+          console.error(`HTTP transport failed after ${maxAttempts} attempts:`, error);
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, retryDelay * attempt));
+      }
+    }
+  }
+  async close() {
+    this.isClosed = true;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = undefined;
+    }
+    await this.flush();
+  }
+}
+// src/formatters/index.ts
+class JSONFormatter {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  format(message, meta) {
+    const logEntry = {
+      ...meta,
+      message
+    };
+    return this.options.prettyPrint ? safeStringify(logEntry, 2) : safeStringify(logEntry);
+  }
+}
+
+class PrettyFormatter {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  format(message, meta) {
+    const { colorize = true, includeTimestamp = true } = this.options;
+    const { level, service, timestamp } = meta;
+    const parts = [];
+    if (includeTimestamp) {
+      const time = new Date(timestamp).toISOString();
+      parts.push(colorize ? `${COLORS.dim}${time}${COLORS.reset}` : time);
+    }
+    const levelStr = level.toUpperCase().padEnd(5);
+    if (colorize) {
+      const color = COLORS[level] || COLORS.reset;
+      parts.push(`${color}${COLORS.bold}${levelStr}${COLORS.reset}`);
+    } else {
+      parts.push(levelStr);
+    }
+    parts.push(`[${service}]`);
+    parts.push(message);
+    const additionalMeta = this.extractAdditionalMeta(meta);
+    if (Object.keys(additionalMeta).length > 0) {
+      const metaStr = safeStringify(additionalMeta);
+      parts.push(colorize ? `${COLORS.dim}${metaStr}${COLORS.reset}` : metaStr);
+    }
+    return parts.join(" ");
+  }
+  extractAdditionalMeta(meta) {
+    const {
+      timestamp,
+      level,
+      service,
+      hostname,
+      pid,
+      version,
+      environment,
+      ...additional
+    } = meta;
+    return additional;
+  }
+}
+
+class CompactFormatter {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  format(message, meta) {
+    const { level, service, timestamp } = meta;
+    const time = new Date(timestamp).toISOString().split("T")[1]?.split(".")[0] || "";
+    return `${time} ${level.charAt(0).toUpperCase()} [${service}] ${message}`;
+  }
+}
+
+class ECSFormatter {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  format(message, meta) {
+    const ecsLog = {
+      "@timestamp": meta.timestamp,
+      "log.level": meta.level,
+      message,
+      service: {
+        name: meta.service,
+        version: meta.version,
+        environment: meta.environment
+      },
+      host: {
+        hostname: meta.hostname
+      },
+      process: {
+        pid: meta.pid
+      },
+      labels: this.extractLabels(meta),
+      ...this.extractECSFields(meta)
+    };
+    return safeStringify(ecsLog);
+  }
+  extractLabels(meta) {
+    const labels = {};
+    if (meta.correlation?.traceId) {
+      labels.trace_id = meta.correlation.traceId;
+    }
+    if (meta.correlation?.spanId) {
+      labels.span_id = meta.correlation.spanId;
+    }
+    if (meta.user?.userId) {
+      labels.user_id = meta.user.userId;
+    }
+    if (meta.workflow?.workflowId) {
+      labels.workflow_id = meta.workflow.workflowId;
+    }
+    return labels;
+  }
+  extractECSFields(meta) {
+    const fields = {};
+    if (meta.request) {
+      fields.http = {
+        request: {
+          method: meta.request.method,
+          id: meta.request.requestId
+        },
+        url: {
+          path: meta.request.path,
+          query: meta.request.query
+        }
+      };
+      fields.client = {
+        ip: meta.request.ip,
+        user_agent: meta.request.userAgent
+      };
+    }
+    if (meta.user) {
+      fields.user = {
+        id: meta.user.userId,
+        name: meta.user.username,
+        email: meta.user.email,
+        roles: meta.user.roles
+      };
+      fields.organization = {
+        id: meta.user.organizationId
+      };
+    }
+    return fields;
+  }
+}
+function createFormatter(format, options = {}) {
+  switch (format) {
+    case "json":
+      return new JSONFormatter(options);
+    case "pretty":
+      return new PrettyFormatter(options);
+    case "compact":
+      return new CompactFormatter(options);
+    case "ecs":
+      return new ECSFormatter(options);
+    default:
+      return new JSONFormatter(options);
+  }
+}
+
+// src/context/manager.ts
+var import_node_async_hooks = require("node:async_hooks");
+
+class ContextManager {
+  storage = new import_node_async_hooks.AsyncLocalStorage;
+  run(context, fn) {
+    return this.storage.run(context, fn);
+  }
+  getContext() {
+    return this.storage.getStore() || {};
+  }
+  setContext(context) {
+    const current = this.getContext();
+    const merged = { ...current, ...context };
+    this.storage.enterWith(merged);
+  }
+  clearContext() {
+    this.storage.enterWith({});
+  }
+  mergeContext(context) {
+    const current = this.getContext();
+    return { ...current, ...context };
+  }
+}
+var contextManager = new ContextManager;
+
+// src/logger.ts
+class Logger {
+  config;
+  transports = [];
+  timers = new Map;
+  childContext = {};
+  constructor(config) {
+    this.config = config;
+    this.initializeTransports();
+    this.setupErrorHandlers();
+  }
+  initializeTransports() {
+    for (const transportConfig of this.config.transports) {
+      let transport;
+      switch (transportConfig.type) {
+        case "console":
+          transport = new ConsoleTransport(transportConfig);
+          break;
+        case "file":
+          transport = new FileTransport(transportConfig);
+          break;
+        case "http":
+          transport = new HTTPTransport(transportConfig);
+          break;
+        default:
+          console.warn(`Unknown transport type: ${transportConfig.type}`);
+          continue;
+      }
+      const format = transportConfig.format || this.config.format;
+      const formatter = createFormatter(format, {
+        colorize: this.config.colorize,
+        prettyPrint: this.config.prettyPrint,
+        includeTimestamp: this.config.timestamps
+      });
+      transport.setFormatter(formatter);
+      this.transports.push(transport);
+    }
+  }
+  setupErrorHandlers() {
+    if (this.config.handleExceptions) {
+      process.on("uncaughtException", (error) => {
+        this.error("Uncaught exception", {
+          type: "error",
+          error: {
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+          },
+          handled: false
+        });
+        if (this.config.exitOnError) {
+          this.close().then(() => process.exit(1));
+        }
+      });
+    }
+    if (this.config.handleRejections) {
+      process.on("unhandledRejection", (reason) => {
+        const error = reason instanceof Error ? reason : new Error(String(reason));
+        this.error("Unhandled rejection", {
+          type: "error",
+          error: {
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+          },
+          handled: false
+        });
+        if (this.config.exitOnError) {
+          this.close().then(() => process.exit(1));
+        }
+      });
+    }
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] <= LOG_LEVELS[this.config.level];
+  }
+  buildMeta(level, meta = {}) {
+    const asyncContext = contextManager.getContext();
+    const mergedMeta = {
+      timestamp: new Date().toISOString(),
+      level,
+      service: this.config.service,
+      hostname: this.config.hostname || getHostname(),
+      pid: getPid(),
+      version: this.config.version,
+      environment: this.config.environment,
+      ...this.config.defaultMeta,
+      ...asyncContext,
+      ...this.childContext,
+      ...meta
+    };
+    if (this.config.sanitize?.enabled) {
+      return sanitize(mergedMeta, this.config.sanitize.fields, this.config.sanitize.replacement);
+    }
+    return mergedMeta;
+  }
+  log(level, message, meta = {}) {
+    if (!this.shouldLog(level))
+      return;
+    const fullMeta = this.buildMeta(level, meta);
+    if (this.config.sampling?.enabled && !this.shouldSample(fullMeta)) {
+      return;
+    }
+    if (this.config.filters?.enabled && this.shouldFilter(fullMeta)) {
+      return;
+    }
+    for (const transport of this.transports) {
+      try {
+        transport.log(message, fullMeta);
+      } catch (error) {
+        console.error("Transport error:", error);
+      }
+    }
+  }
+  shouldSample(meta) {
+    if (!this.config.sampling?.enabled)
+      return true;
+    for (const rule of this.config.sampling.rules) {
+      if (rule.level && meta.level !== rule.level)
+        continue;
+      if (rule.service && meta.service !== rule.service)
+        continue;
+      if (rule.condition && !rule.condition(meta))
+        continue;
+      return Math.random() < rule.rate;
+    }
+    return true;
+  }
+  shouldFilter(meta) {
+    if (!this.config.filters?.enabled)
+      return false;
+    for (const rule of this.config.filters.rules) {
+      const value = this.getNestedValue(meta, rule.field);
+      if (value === undefined)
+        continue;
+      const matches = typeof rule.pattern === "string" ? String(value).includes(rule.pattern) : rule.pattern.test(String(value));
+      if (rule.type === "exclude" && matches) {
+        return true;
+      }
+      if (rule.type === "include" && !matches) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getNestedValue(obj, path2) {
+    return path2.split(".").reduce((current, key) => {
+      return current && typeof current === "object" ? current[key] : undefined;
+    }, obj);
+  }
+  fatal(message, meta) {
+    this.log("fatal", message, meta);
+  }
+  error(message, meta) {
+    this.log("error", message, meta);
+  }
+  warn(message, meta) {
+    this.log("warn", message, meta);
+  }
+  info(message, meta) {
+    this.log("info", message, meta);
+  }
+  debug(message, meta) {
+    this.log("debug", message, meta);
+  }
+  trace(message, meta) {
+    this.log("trace", message, meta);
+  }
+  audit(action, meta) {
+    this.info(`Audit: ${action}`, {
+      ...meta,
+      type: "audit"
+    });
+  }
+  security(event, meta) {
+    const level = meta.severity === "critical" || meta.severity === "high" ? "error" : "warn";
+    this.log(level, `Security: ${event}`, {
+      ...meta,
+      type: "security",
+      event
+    });
+  }
+  performance(operation, duration, meta) {
+    this.info(`Performance: ${operation}`, {
+      ...meta,
+      type: "performance",
+      operation,
+      duration: {
+        ms: duration,
+        human: formatDuration(duration)
+      }
+    });
+  }
+  metric(name, value, meta) {
+    this.info(`Metric: ${name}`, {
+      ...meta,
+      type: "metrics",
+      metrics: {
+        counters: { [name]: value }
+      }
+    });
+  }
+  child(context) {
+    const childLogger = new Logger(this.config);
+    childLogger.childContext = { ...this.childContext, ...context };
+    childLogger.transports = this.transports;
+    return childLogger;
+  }
+  setContext(context) {
+    contextManager.setContext(context);
+  }
+  clearContext() {
+    contextManager.clearContext();
+  }
+  startWorkflow(workflow) {
+    this.setContext({ workflow });
+    this.info("Workflow started", {
+      type: "workflow",
+      event: "started"
+    });
+  }
+  endWorkflow(success, meta) {
+    const event = success ? "completed" : "failed";
+    const logMeta = {
+      type: "workflow",
+      event,
+      ...meta
+    };
+    this.info(`Workflow ${event}`, logMeta);
+    this.clearContext();
+  }
+  startRequest(request) {
+    this.setContext({ request });
+    this.info("Request started", {
+      type: "api",
+      direction: "inbound"
+    });
+  }
+  endRequest(statusCode, duration) {
+    this.info("Request completed", {
+      type: "api",
+      direction: "inbound",
+      statusCode,
+      duration
+    });
+    this.clearContext();
+  }
+  profile(id) {
+    if (this.timers.has(id)) {
+      const start = this.timers.get(id);
+      const duration = Date.now() - start;
+      this.timers.delete(id);
+      this.performance(id, duration);
+    } else {
+      this.timers.set(id, Date.now());
+    }
+  }
+  startTimer() {
+    const start = Date.now();
+    return () => Date.now() - start;
+  }
+  async flush() {
+    await Promise.all(this.transports.map((t) => t.flush()));
+  }
+  async close() {
+    await Promise.all(this.transports.map((t) => t.close()));
+  }
+}
+
+// src/presets/backend.ts
+var import_node_path2 = __toESM(require("node:path"));
+function createBackendLogger(options = {}) {
+  const {
+    level = isDevelopment() ? "debug" : "info",
+    logDir = "./logs",
+    enableConsole = true,
+    enableFile = true,
+    version = "1.0.0",
+    defaultMeta = {}
+  } = options;
+  const config = {
+    service: "backend",
+    environment: "development",
+    version,
+    level,
+    format: isDevelopment() ? "pretty" : "json",
+    prettyPrint: isDevelopment(),
+    colorize: isDevelopment(),
+    timestamps: true,
+    transports: [],
+    handleExceptions: true,
+    handleRejections: true,
+    exitOnError: false,
+    defaultMeta,
+    contextStorage: "asynclocal",
+    sanitize: {
+      enabled: true,
+      fields: ["password", "token", "apiKey", "secret", "authorization", "cookie"]
+    }
+  };
+  if (enableConsole) {
+    config.transports.push({
+      type: "console",
+      enabled: true,
+      level,
+      format: isDevelopment() ? "pretty" : "json"
+    });
+  }
+  if (enableFile) {
+    config.transports.push({
+      type: "file",
+      enabled: true,
+      level,
+      format: "json",
+      file: {
+        path: import_node_path2.default.join(logDir, "backend.log"),
+        maxSize: "10m",
+        maxFiles: 10,
+        compress: true,
+        datePattern: "YYYY-MM-DD"
+      }
+    });
+    config.transports.push({
+      type: "file",
+      enabled: true,
+      level: "error",
+      format: "json",
+      file: {
+        path: import_node_path2.default.join(logDir, "backend-error.log"),
+        maxSize: "10m",
+        maxFiles: 10,
+        compress: true,
+        datePattern: "YYYY-MM-DD"
+      }
+    });
+    config.transports.push({
+      type: "file",
+      enabled: true,
+      level: "info",
+      format: "json",
+      file: {
+        path: import_node_path2.default.join(logDir, "backend-audit.log"),
+        maxSize: "10m",
+        maxFiles: 30,
+        compress: true,
+        datePattern: "YYYY-MM-DD"
+      }
+    });
+  }
+  return new Logger(config);
+}
+// src/presets/engine.ts
+var import_node_path3 = __toESM(require("node:path"));
+function createEngineLogger(options = {}) {
+  const {
+    level = isDevelopment() ? "debug" : "info",
+    logDir = "./logs",
+    enableConsole = true,
+    enableFile = true,
+    version = "1.0.0",
+    workerId,
+    defaultMeta = {}
+  } = options;
+  const config = {
+    service: "engine",
+    environment: "development",
+    version,
+    level,
+    format: isDevelopment() ? "pretty" : "json",
+    prettyPrint: isDevelopment(),
+    colorize: isDevelopment(),
+    timestamps: true,
+    transports: [],
+    handleExceptions: true,
+    handleRejections: true,
+    exitOnError: false,
+    defaultMeta: {
+      ...defaultMeta,
+      ...workerId && { workerId }
+    },
+    contextStorage: "asynclocal"
+  };
+  if (enableConsole) {
+    config.transports.push({
+      type: "console",
+      enabled: true,
+      level,
+      format: isDevelopment() ? "pretty" : "json"
+    });
+  }
+  if (enableFile) {
+    const workerSuffix = workerId ? `-${workerId}` : "";
+    config.transports.push({
+      type: "file",
+      enabled: true,
+      level,
+      format: "json",
+      file: {
+        path: import_node_path3.default.join(logDir, `engine${workerSuffix}.log`),
+        maxSize: "10m",
+        maxFiles: 10,
+        compress: true,
+        datePattern: "YYYY-MM-DD"
+      }
+    });
+    config.transports.push({
+      type: "file",
+      enabled: true,
+      level: "error",
+      format: "json",
+      file: {
+        path: import_node_path3.default.join(logDir, `engine${workerSuffix}-error.log`),
+        maxSize: "10m",
+        maxFiles: 10,
+        compress: true,
+        datePattern: "YYYY-MM-DD"
+      }
+    });
+    config.transports.push({
+      type: "file",
+      enabled: true,
+      level: "info",
+      format: "json",
+      file: {
+        path: import_node_path3.default.join(logDir, `engine${workerSuffix}-workflows.log`),
+        maxSize: "20m",
+        maxFiles: 20,
+        compress: true,
+        datePattern: "YYYY-MM-DD"
+      }
+    });
+    config.transports.push({
+      type: "file",
+      enabled: true,
+      level: "info",
+      format: "json",
+      file: {
+        path: import_node_path3.default.join(logDir, `engine${workerSuffix}-performance.log`),
+        maxSize: "10m",
+        maxFiles: 10,
+        compress: true,
+        datePattern: "YYYY-MM-DD"
+      }
+    });
+  }
+  return new Logger(config);
+}
+// src/presets/ui.ts
+function createUILogger(options = {}) {
+  const {
+    level = isDevelopment() ? "debug" : "warn",
+    enableConsole = true,
+    enableRemote = false,
+    remoteUrl,
+    version = "1.0.0",
+    defaultMeta = {}
+  } = options;
+  const config = {
+    service: "ui",
+    environment: "development",
+    version,
+    level,
+    format: isDevelopment() ? "pretty" : "compact",
+    prettyPrint: isDevelopment(),
+    colorize: isDevelopment(),
+    timestamps: true,
+    transports: [],
+    handleExceptions: true,
+    handleRejections: true,
+    exitOnError: false,
+    defaultMeta,
+    contextStorage: "asynclocal",
+    sanitize: {
+      enabled: true,
+      fields: ["password", "token", "apiKey", "secret", "authorization", "cookie", "creditCard"]
+    },
+    sampling: isDevelopment() ? undefined : {
+      enabled: true,
+      rules: [
+        {
+          level: "debug",
+          rate: 0.1
+        },
+        {
+          level: "trace",
+          rate: 0.05
+        }
+      ]
+    }
+  };
+  if (enableConsole) {
+    config.transports.push({
+      type: "console",
+      enabled: true,
+      level,
+      format: isDevelopment() ? "pretty" : "compact"
+    });
+  }
+  if (enableRemote && remoteUrl) {
+    config.transports.push({
+      type: "http",
+      enabled: true,
+      level: "warn",
+      format: "json",
+      http: {
+        url: remoteUrl,
+        method: "POST",
+        batchSize: 20,
+        flushInterval: 1e4,
+        retry: {
+          attempts: 3,
+          delay: 1000
+        }
+      }
+    });
+  }
+  return new Logger(config);
+}
+
+//# debugId=F1B76F8586B4D6C964756E2164756E21