autotel-edge 3.16.0 → 3.16.2

package/dist/logger.js

@@ -1,7 +1,258 @@
 import { createContextKey, context, trace } from '@opentelemetry/api';
 
+// src/api/logger.ts
+
+// src/api/redact.ts
+var DEFAULT_CENSOR = "[Redacted]";
+function parsePath(path) {
+  if (typeof path !== "string" || path.length === 0) {
+    throw new Error(
+      `redact path must be a non-empty string, got: ${JSON.stringify(path)}`
+    );
+  }
+  if (path.includes("..")) {
+    throw new Error(
+      `redact path contains empty segment: ${JSON.stringify(path)}`
+    );
+  }
+  const openBracket = path.indexOf("[");
+  const closeBracket = path.indexOf("]");
+  if (openBracket !== -1 && closeBracket === -1 || closeBracket !== -1 && openBracket === -1) {
+    throw new Error(
+      `redact path has unclosed bracket: ${JSON.stringify(path)}`
+    );
+  }
+  if (openBracket !== -1 && closeBracket < openBracket) {
+    throw new Error(
+      `redact path has bracket close before open: ${JSON.stringify(path)}`
+    );
+  }
+  if (/\[\s*\]$/.test(path)) {
+    throw new Error(
+      `redact path has unclosed bracket: ${JSON.stringify(path)}`
+    );
+  }
+  if (/\][^.[\]]/.test(path) && !/\]\[/.test(path)) {
+    const afterClose = path.match(/\]([^.[\]]+)/);
+    if (afterClose) {
+      throw new Error(
+        `redact path has invalid characters after ']': ${JSON.stringify(path)}`
+      );
+    }
+  }
+  const segments = [];
+  const rx = /[^.[\]]+|\[(\d+|\*)\]/g;
+  let match;
+  let lastIndex = 0;
+  while ((match = rx.exec(path)) !== null) {
+    segments.push(match[1] ?? match[0]);
+    lastIndex = rx.lastIndex;
+  }
+  if (lastIndex < path.length) {
+    throw new Error(
+      `redact path has unexpected trailing content: ${JSON.stringify(path)}`
+    );
+  }
+  if (segments.length === 0) {
+    throw new Error(
+      `redact path produced no segments: ${JSON.stringify(path)}`
+    );
+  }
+  return segments;
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function deepClone(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((v) => deepClone(v));
+  if (!isPlainObject(value)) return value;
+  const result = {};
+  for (const key of Object.keys(value)) {
+    result[key] = deepClone(value[key]);
+  }
+  return result;
+}
+function buildPathTree(paths) {
+  const root = {};
+  for (const segments of paths) {
+    let node = root;
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      const isLast = i === segments.length - 1;
+      if (!node.children) node.children = {};
+      if (!node.children[seg]) node.children[seg] = {};
+      if (isLast) {
+        node.children[seg].redact = true;
+      }
+      node = node.children[seg];
+    }
+  }
+  return root;
+}
+function redactWithTree(obj, node, censor, remove, path = []) {
+  if (!node.children) return;
+  const applyCensor = (target, k, currentPath) => {
+    if (remove) {
+      delete target[k];
+    } else {
+      target[k] = typeof censor === "function" ? censor(target[k], currentPath) : censor;
+    }
+  };
+  for (const [key, childNode] of Object.entries(node.children)) {
+    if (key === "*") {
+      for (const k of Object.keys(obj)) {
+        const wildcardPath = [...path, k];
+        if (childNode.redact && !childNode.children) {
+          applyCensor(obj, k, wildcardPath);
+        } else if (childNode.redact && childNode.children) {
+          const child = obj[k];
+          if (child != null && typeof child === "object" && !Array.isArray(child)) {
+            redactWithTree(child, childNode, censor, remove, wildcardPath);
+          } else {
+            applyCensor(obj, k, wildcardPath);
+          }
+        } else if (childNode.children) {
+          const child = obj[k];
+          if (child != null && typeof child === "object") {
+            redactWithTree(child, childNode, censor, remove, wildcardPath);
+          }
+        }
+      }
+      continue;
+    }
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+    const val = obj[key];
+    const currentPath = [...path, key];
+    if (childNode.redact && !childNode.children) {
+      applyCensor(obj, key, currentPath);
+    } else if (childNode.redact && childNode.children) {
+      if (val != null && typeof val === "object") {
+        redactWithTree(val, childNode, censor, remove, currentPath);
+      }
+    } else if (childNode.children && val != null && typeof val === "object") {
+      redactWithTree(val, childNode, censor, remove, currentPath);
+    }
+  }
+}
+var SENSITIVE_KEY_PATHS = [
+  "password",
+  "passwd",
+  "pwd",
+  "secret",
+  "token",
+  "apiKey",
+  "api_key",
+  "auth",
+  "credential",
+  "privateKey",
+  "private_key",
+  "authorization"
+];
+var SENSITIVE_HEADER_PATHS = [
+  "req.headers.authorization",
+  "req.headers.cookie",
+  "headers.authorization",
+  "headers.cookie",
+  "request.headers.authorization",
+  "request.headers.cookie"
+];
+var REDACT_PRESETS = {
+  /**
+   * Default: covers the same sensitive-key names as the main autotel package's
+   * `sensitiveKey` pattern, plus common request header paths.
+   *
+   * Redacted keys: password, passwd, pwd, secret, token, apiKey, auth,
+   *                credential, privateKey, authorization
+   * Redacted headers: req.headers.authorization, req.headers.cookie, etc.
+   */
+  default: {
+    paths: [...SENSITIVE_KEY_PATHS, ...SENSITIVE_HEADER_PATHS]
+  },
+  /**
+   * Strict: everything in default, plus nested paths for bearer tokens,
+   * JWT fields, and API key fields at common depths.
+   */
+  strict: {
+    paths: [
+      ...SENSITIVE_KEY_PATHS,
+      ...SENSITIVE_HEADER_PATHS,
+      // Common nested auth shapes
+      "bearer",
+      "jwt",
+      "apiSecret",
+      "api_secret",
+      "accessToken",
+      "access_token",
+      "refreshToken",
+      "refresh_token",
+      "clientSecret",
+      "client_secret"
+    ]
+  },
+  /**
+   * PCI-DSS: credit card and payment-related fields.
+   */
+  "pci-dss": {
+    paths: [
+      "card",
+      "cardNumber",
+      "card_number",
+      "ccn",
+      "pan",
+      "cvv",
+      "cvc",
+      "expirationDate",
+      "expiration_date",
+      "exp",
+      "payment.card",
+      "payment.cardNumber",
+      "payment.cvv"
+    ]
+  }
+};
+function resolveConfig(config) {
+  if (typeof config === "string") {
+    const preset = REDACT_PRESETS[config];
+    if (!preset) {
+      throw new Error(
+        `Unknown redactor preset: "${config}". Available: ${Object.keys(REDACT_PRESETS).join(", ")}`
+      );
+    }
+    return preset;
+  }
+  return config;
+}
+function createRedactor(config) {
+  const { paths, censor = DEFAULT_CENSOR, remove = false } = resolveConfig(config);
+  if (paths.length === 0) {
+    return (obj) => obj;
+  }
+  const parsed = paths.map((p) => parsePath(p));
+  const tree = buildPathTree(parsed);
+  return function redactor(obj) {
+    if (obj == null || typeof obj !== "object") return obj;
+    const clone = deepClone(obj);
+    redactWithTree(clone, tree, censor, remove);
+    return clone;
+  };
+}
+
 // src/api/logger.ts
 var LOG_LEVEL_KEY = createContextKey("autotel-edge-log-level");
+var PINO_LEVELS = {
+  values: {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60,
+    silent: Infinity
+  }};
+var LOGGER_VERSION = "autotel-edge";
 function getActiveLogLevel() {
   return context.active().getValue(LOG_LEVEL_KEY);
 }
@@ -20,62 +271,552 @@ function getTraceContext() {
     // First 16 chars for grouping
   };
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function toErrorAttrs(error) {
+  if (error instanceof Error) {
+    return {
+      error: {
+        message: error.message,
+        type: error.name,
+        stack: error.stack
+      }
+    };
+  }
+  return { error: { message: String(error), type: "Error" } };
+}
+function formatMessage(template, args) {
+  if (args.length === 0) return template;
+  let argIndex = 0;
+  const formatted = template.replaceAll(/%[sdjifoO%]/g, (token) => {
+    if (token === "%%") return "%";
+    if (argIndex >= args.length) return token;
+    const value = args[argIndex++];
+    switch (token) {
+      case "%d":
+      case "%i":
+      case "%f": {
+        return String(Number(value));
+      }
+      case "%j": {
+        try {
+          return JSON.stringify(value);
+        } catch {
+          return "[Circular]";
+        }
+      }
+      case "%s": {
+        return String(value);
+      }
+      case "%o":
+      case "%O": {
+        try {
+          return JSON.stringify(value);
+        } catch {
+          return String(value);
+        }
+      }
+      default: {
+        return token;
+      }
+    }
+  });
+  return formatted;
+}
+var ANSI_RESET = "\x1B[0m";
+var ANSI_DIM = "\x1B[2m";
+var ANSI_BOLD = "\x1B[1m";
+var ANSI_COLORS = {
+  fatal: "\x1B[41m\x1B[37m",
+  // white on red bg
+  error: "\x1B[31m",
+  // red
+  warn: "\x1B[33m",
+  // yellow
+  info: "\x1B[36m",
+  // cyan
+  debug: "\x1B[34m",
+  // blue
+  trace: "\x1B[90m"
+  // gray
+};
+var LEVEL_SYMBOLS = {
+  fatal: "\u2717",
+  error: "\u2717",
+  warn: "\u26A0",
+  info: "\u25CF",
+  debug: "\u25E6",
+  trace: "\u2026"
+};
+function formatPrettyTimestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const h = String(d.getHours()).padStart(2, "0");
+  const m = String(d.getMinutes()).padStart(2, "0");
+  const s = String(d.getSeconds()).padStart(2, "0");
+  const ms = String(d.getMilliseconds()).padStart(3, "0");
+  return `${h}:${m}:${s}.${ms}`;
+}
+function formatPrettyAttrs(attrs) {
+  const keys = Object.keys(attrs);
+  if (keys.length === 0) return "";
+  return "\n" + JSON.stringify(attrs, null, 2).split("\n").map((line) => `    ${line}`).join("\n");
+}
+function safeStringify(obj, depthLimit, edgeLimit) {
+  const ancestors = [];
+  return JSON.stringify(obj, function replacer(_key, value) {
+    if (typeof value === "object" && value !== null) {
+      while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+        ancestors.pop();
+      }
+      if (ancestors.includes(value)) return "[Circular]";
+      if (ancestors.length >= depthLimit) return "[Object]";
+      ancestors.push(value);
+      if (!Array.isArray(value)) {
+        const keys = Object.keys(value);
+        if (keys.length > edgeLimit) {
+          const truncated = {};
+          for (let i = 0; i < edgeLimit; i++) {
+            truncated[keys[i]] = value[keys[i]];
+          }
+          truncated["..."] = `[${keys.length - edgeLimit} more properties]`;
+          return truncated;
+        }
+      }
+    }
+    return value;
+  });
+}
+function parseLogArgs(args) {
+  const [first, ...rest] = args;
+  if (typeof first === "string") {
+    return {
+      msg: formatMessage(first, rest),
+      attrs: void 0
+    };
+  }
+  if (first instanceof Error) {
+    return {
+      msg: typeof rest[0] === "string" ? formatMessage(rest[0], rest.slice(1)) : first.message,
+      attrs: toErrorAttrs(first)
+    };
+  }
+  if (isRecord(first)) {
+    return {
+      msg: typeof rest[0] === "string" ? formatMessage(rest[0], rest.slice(1)) : "",
+      attrs: first
+    };
+  }
+  return {
+    msg: String(first ?? ""),
+    attrs: void 0
+  };
+}
 function createEdgeLogger(service, options) {
-  const defaultLevel = options?.level || "info";
+  const customLevels = {
+    ...options?.customLevels
+  };
+  const availableLevels = options?.useOnlyCustomLevels ? { ...customLevels, silent: Infinity } : { ...PINO_LEVELS.values, ...customLevels };
+  const defaultLevel = options?.level ?? (options?.useOnlyCustomLevels ? Object.keys(customLevels)[0] : "info") ?? "info";
+  let currentLevel = defaultLevel;
   const pretty = options?.pretty || false;
-  const levelPriority = {
-    none: -1,
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3
+  const currentBindings = { ...options?.bindings };
+  const resolvedRedact = Array.isArray(options?.redact) ? { paths: options.redact } : options?.redact;
+  const redactor = resolvedRedact ? createRedactor(resolvedRedact) : null;
+  const msgPrefix = options?.msgPrefix;
+  const levelValues = availableLevels;
+  const levelListeners = [];
+  const onChildCallback = options?.onChild ?? (() => {
+  });
+  const listeners = /* @__PURE__ */ new Map();
+  let maxListeners = 10;
+  const messageKey = options?.messageKey ?? "msg";
+  const errorKey = options?.errorKey ?? "err";
+  const nestedKey = options?.nestedKey;
+  const serializers = { ...options?.serializers };
+  const bindingsFormatter = options?.formatters?.bindings;
+  const levelFormatter = options?.formatters?.level;
+  const logFormatter = options?.formatters?.log;
+  const mixin = options?.mixin;
+  const levelComparison = options?.levelComparison;
+  const mixinMergeStrategy = options?.mixinMergeStrategy ?? ((mergeObject, mixinObject) => ({ ...mergeObject, ...mixinObject }));
+  let enabled = options?.enabled ?? true;
+  const loggerName = options?.name;
+  const base = options?.base;
+  const timestamp = options?.timestamp ?? true;
+  const safe = options?.safe ?? true;
+  const crlf = options?.crlf ?? false;
+  const depthLimit = options?.depthLimit ?? 5;
+  const edgeLimitOpt = options?.edgeLimit ?? 100;
+  const hooks = options?.hooks;
+  const writeFn = options?.write;
+  const transmit = options?.transmit;
+  const bindingsChain = options?._bindingsChain ?? [];
+  const compareLevels = (current, expected, comparison) => {
+    if (typeof comparison === "function") return comparison(current, expected);
+    if (comparison === "DESC") return current <= expected;
+    return current >= expected;
+  };
+  const addListener = (event, listener, prepend = false) => {
+    const activeListeners = listeners.get(event) ?? [];
+    if (prepend) {
+      activeListeners.unshift(listener);
+    } else {
+      activeListeners.push(listener);
+    }
+    listeners.set(event, activeListeners);
+    if (event === "level-change") {
+      levelListeners.length = 0;
+      levelListeners.push(
+        ...listeners.get(event) ?? []
+      );
+    }
+  };
+  const notifyLevelChange = (nextLevel, previousLevel, instance) => {
+    const nextValue = levelValues[nextLevel] ?? Infinity;
+    const previousValue = levelValues[previousLevel] ?? Infinity;
+    const snapshot = [...levelListeners];
+    for (const listener of snapshot) {
+      listener(nextLevel, nextValue, previousLevel, previousValue, instance);
+    }
+  };
+  const removeEventListener = (event, listener) => {
+    const activeListeners = listeners.get(event);
+    if (!activeListeners) {
+      return;
+    }
+    const index = activeListeners.indexOf(listener);
+    if (index !== -1) {
+      activeListeners.splice(index, 1);
+    }
+    if (activeListeners.length === 0) {
+      listeners.delete(event);
+    } else {
+      listeners.set(event, activeListeners);
+    }
+    if (event === "level-change") {
+      levelListeners.length = 0;
+      levelListeners.push(
+        ...listeners.get(event) ?? []
+      );
+    }
   };
   const shouldLog = (level) => {
-    const activeLevel = getActiveLogLevel() ?? defaultLevel;
-    if (activeLevel === "none") return false;
-    return levelPriority[level] >= levelPriority[activeLevel];
+    if (!enabled) return false;
+    const activeLevel = getActiveLogLevel() ?? currentLevel;
+    if (activeLevel === "silent") return false;
+    const currentValue = levelValues[activeLevel];
+    const expectedValue = levelValues[level];
+    if (currentValue === void 0 || expectedValue === void 0) return false;
+    return compareLevels(
+      expectedValue,
+      currentValue,
+      levelComparison
+    );
+  };
+  const stringify = (obj) => {
+    if (safe) {
+      return safeStringify(obj, depthLimit, edgeLimitOpt);
+    }
+    return JSON.stringify(obj);
+  };
+  const getTimestamp = () => {
+    if (timestamp === false) return void 0;
+    if (typeof timestamp === "function") return timestamp();
+    return (/* @__PURE__ */ new Date()).toISOString();
   };
-  const log = (level, msg, attrs) => {
+  const writeOutput = (level, logObject) => {
+    if (writeFn) {
+      if (typeof writeFn === "function") {
+        writeFn(logObject);
+      } else if (typeof writeFn === "object" && writeFn[level]) {
+        writeFn[level](logObject);
+      } else {
+        console.log(stringify(logObject));
+      }
+    } else if (pretty) {
+      return;
+    } else {
+      const json = stringify(logObject);
+      console.log(crlf ? json + "\r\n" : json);
+    }
+  };
+  const applySerializers = (obj) => {
+    if (Object.keys(serializers).length === 0) return obj;
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        key,
+        key in serializers ? serializers[key](value) : value
+      ])
+    );
+  };
+  const emitTransmit = (level, rawArgs) => {
+    if (!transmit) return;
+    if (transmit.level) {
+      const transmitValue = levelValues[transmit.level];
+      const logValue = levelValues[level];
+      if (transmitValue !== void 0 && logValue !== void 0 && logValue < transmitValue) {
+        return;
+      }
+    }
+    const processedMessages = rawArgs.map((m) => {
+      if (typeof m !== "object" || m === null) return m;
+      const serialized = applySerializers(m);
+      return redactor ? redactor(serialized) : serialized;
+    });
+    const processedBindings = bindingsChain.map((b) => {
+      const serialized = applySerializers({ ...b });
+      return redactor ? redactor(serialized) : serialized;
+    });
+    const logEvent = {
+      ts: Date.now(),
+      messages: processedMessages,
+      bindings: processedBindings,
+      level: { label: level, value: levelValues[level] }
+    };
+    transmit.send(level, logEvent);
+  };
+  const log = (level, msg, attrs, rawArgs) => {
     if (!shouldLog(level)) return;
     const ctx = getTraceContext();
+    const message = msgPrefix ? `${msgPrefix}${msg}` : msg;
+    const baseBindings = bindingsFormatter ? bindingsFormatter({ ...currentBindings }) : { ...currentBindings };
+    const serializedAttrs = attrs ? Object.fromEntries(
+      Object.entries(attrs).map(([key, value]) => [
+        key,
+        key in serializers ? serializers[key](value) : value
+      ])
+    ) : void 0;
+    const mergeObject = nestedKey ? { [nestedKey]: serializedAttrs ?? {} } : serializedAttrs ?? {};
+    const mixinObject = mixin?.(mergeObject, levelValues[level], logger) ?? {};
+    const mergedLogObject = mixinMergeStrategy(mergeObject, mixinObject);
+    const formattedLogObject = logFormatter ? logFormatter(mergedLogObject) : mergedLogObject;
+    const formattedLevel = levelFormatter ? levelFormatter(level, levelValues[level]) : {
+      level: logger.useLevelLabels ? level : levelValues[level]
+    };
+    const ts = getTimestamp();
     const logEntry = {
-      level,
+      ...formattedLevel,
+      ...loggerName === void 0 ? {} : { name: loggerName },
       service,
-      msg,
-      ...attrs,
+      ...message === "" ? {} : { [messageKey]: message },
+      ...base === null || base === void 0 ? {} : base,
+      ...baseBindings,
+      ...formattedLogObject,
       ...ctx,
       // Auto-inject traceId, spanId, correlationId
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      ...ts === void 0 ? {} : { timestamp: ts }
     };
-    if (pretty) {
-      const traceInfo = ctx ? ` [${ctx.traceId.slice(0, 8)}.../${ctx.spanId.slice(0, 8)}...]` : "";
+    if (serializedAttrs && !nestedKey && errorKey !== "error" && "error" in logEntry) {
+      logEntry[errorKey] = logEntry.error;
+      delete logEntry.error;
+    }
+    if (pretty && !writeFn) {
+      const color = ANSI_COLORS[level] ?? ANSI_COLORS.info;
+      const symbol = LEVEL_SYMBOLS[level] ?? "\u25CF";
+      const time = formatPrettyTimestamp();
+      const traceInfo = ctx ? ` ${ANSI_DIM}[${ctx.traceId.slice(0, 8)}/${ctx.spanId.slice(0, 8)}]${ANSI_RESET}` : "";
+      const prettyAttrs = {
+        ...baseBindings,
+        ...formattedLogObject
+      };
+      const safeAttrs = redactor ? redactor(prettyAttrs) : prettyAttrs;
+      const attrsStr = formatPrettyAttrs(safeAttrs);
       console.log(
-        `[${level.toUpperCase()}]${traceInfo} ${service}: ${msg}`,
-        attrs || ""
+        `${ANSI_DIM}${time}${ANSI_RESET} ${color}${ANSI_BOLD}${symbol} ${level.toUpperCase()}${ANSI_RESET}${traceInfo} ${ANSI_DIM}(${service})${ANSI_RESET} ${message}${attrsStr}`
       );
     } else {
-      console.log(JSON.stringify(logEntry));
+      const safeEntry = redactor ? redactor(logEntry) : logEntry;
+      writeOutput(level, safeEntry);
     }
+    emitTransmit(level, rawArgs ?? []);
   };
-  return {
-    info: (msg, attrs) => log("info", msg, attrs),
-    error: (msg, error, attrs) => {
-      const errorAttrs = error instanceof Error ? {
-        error: error.message,
-        stack: error.stack,
-        name: error.name,
-        ...attrs
-      } : { error: String(error), ...attrs };
-      log("error", msg, errorAttrs);
+  const makeLogMethod = (levelName) => {
+    return ((...args) => {
+      if (hooks?.logMethod) {
+        const method = ((...methodArgs) => {
+          const { msg: msg2, attrs: attrs2 } = parseLogArgs(methodArgs);
+          log(levelName, msg2, attrs2, methodArgs);
+        });
+        hooks.logMethod.call(logger, args, method, levelValues[levelName]);
+        return;
+      }
+      const { msg, attrs } = parseLogArgs(args);
+      log(levelName, msg, attrs, args);
+    });
+  };
+  const logger = {
+    version: LOGGER_VERSION,
+    get name() {
+      return loggerName;
+    },
+    levels: {
+      values: levelValues,
+      labels: Object.fromEntries(
+        Object.entries(levelValues).map(([label, value]) => [value, label])
+      )
+    },
+    useLevelLabels: options?.useLevelLabels ?? false,
+    customLevels: { ...customLevels },
+    useOnlyCustomLevels: options?.useOnlyCustomLevels ?? false,
+    get level() {
+      return currentLevel;
+    },
+    set level(level) {
+      const previousLevel = currentLevel;
+      currentLevel = level;
+      notifyLevelChange(level, previousLevel, logger);
+    },
+    get levelVal() {
+      return levelValues[currentLevel] ?? Infinity;
+    },
+    get msgPrefix() {
+      return msgPrefix;
+    },
+    onChild: onChildCallback,
+    get enabled() {
+      return enabled;
+    },
+    set enabled(value) {
+      enabled = value;
+    },
+    info: makeLogMethod("info"),
+    error: makeLogMethod("error"),
+    warn: makeLogMethod("warn"),
+    debug: makeLogMethod("debug"),
+    trace: makeLogMethod("trace"),
+    fatal: makeLogMethod("fatal"),
+    silent: (() => {
+    }),
+    child: (bindings, childOptions) => {
+      const childLogger = createEdgeLogger(service, {
+        level: childOptions?.level ?? currentLevel,
+        pretty,
+        bindings: { ...currentBindings, ...bindings },
+        redact: childOptions?.redact ?? options?.redact,
+        msgPrefix: childOptions?.msgPrefix === void 0 ? msgPrefix : `${msgPrefix ?? ""}${childOptions.msgPrefix}`,
+        useLevelLabels: logger.useLevelLabels,
+        onChild: onChildCallback,
+        enabled,
+        messageKey,
+        errorKey,
+        nestedKey,
+        serializers: { ...serializers, ...childOptions?.serializers },
+        formatters: {
+          level: childOptions?.formatters?.level ?? levelFormatter,
+          bindings: childOptions?.formatters?.bindings ?? bindingsFormatter,
+          log: childOptions?.formatters?.log ?? logFormatter
+        },
+        mixin,
+        mixinMergeStrategy,
+        customLevels,
+        useOnlyCustomLevels: options?.useOnlyCustomLevels,
+        levelComparison: options?.levelComparison,
+        name: loggerName,
+        base,
+        timestamp,
+        safe,
+        crlf,
+        depthLimit,
+        edgeLimit: edgeLimitOpt,
+        hooks,
+        write: writeFn,
+        transmit,
+        _bindingsChain: [...bindingsChain, bindings]
+      });
+      onChildCallback(childLogger);
+      return childLogger;
+    },
+    isLevelEnabled: (level) => shouldLog(level),
+    bindings: () => ({ ...currentBindings }),
+    setBindings: (bindings) => {
+      for (const [key, value] of Object.entries(bindings)) {
+        if (!(key in currentBindings)) {
+          currentBindings[key] = value;
+        }
+      }
+    },
+    flush: (cb) => {
+      cb?.();
     },
-    warn: (msg, attrs) => log("warn", msg, attrs),
-    debug: (msg, attrs) => log("debug", msg, attrs)
+    emit: (event, ...args) => {
+      const activeListeners = listeners.get(event);
+      if (!activeListeners || activeListeners.length === 0) {
+        return false;
+      }
+      const snapshot = [...activeListeners];
+      for (const listener of snapshot) {
+        listener(...args);
+      }
+      return true;
+    },
+    eventNames: () => [...listeners.keys()],
+    getMaxListeners: () => maxListeners,
+    listenerCount: (event) => listeners.get(event)?.length ?? 0,
+    listeners: (event) => [...listeners.get(event) ?? []],
+    on: (event, listener) => {
+      addListener(event, listener);
+      return logger;
+    },
+    addListener: (event, listener) => {
+      addListener(event, listener);
+      return logger;
+    },
+    once: (event, listener) => {
+      const wrapped = (...args) => {
+        removeEventListener(event, wrapped);
+        listener(...args);
+      };
+      addListener(event, wrapped);
+      return logger;
+    },
+    prependListener: (event, listener) => {
+      addListener(event, listener, true);
+      return logger;
+    },
+    prependOnceListener: (event, listener) => {
+      const wrapped = (...args) => {
+        removeEventListener(event, wrapped);
+        listener(...args);
+      };
+      addListener(event, wrapped, true);
+      return logger;
+    },
+    rawListeners: (event) => [...listeners.get(event) ?? []],
+    off: (event, listener) => {
+      removeEventListener(event, listener);
+      return logger;
+    },
+    removeAllListeners: (event) => {
+      if (event === void 0) {
+        listeners.clear();
+        levelListeners.length = 0;
+        return logger;
+      }
+      listeners.delete(event);
+      if (event === "level-change") {
+        levelListeners.length = 0;
+      }
+      return logger;
+    },
+    removeListener: (event, listener) => {
+      removeEventListener(event, listener);
+      return logger;
+    },
+    setMaxListeners: (n) => {
+      maxListeners = n;
+      return logger;
+    }
   };
+  for (const levelName of Object.keys(customLevels)) {
+    logger[levelName] = makeLogMethod(levelName);
+  }
+  return logger;
 }
 function getEdgeTraceContext() {
   return getTraceContext();
 }
 
-export { createEdgeLogger, getActiveLogLevel, getEdgeTraceContext, runWithLogLevel };
+export { REDACT_PRESETS, createEdgeLogger, createRedactor, getActiveLogLevel, getEdgeTraceContext, runWithLogLevel };
 //# sourceMappingURL=logger.js.map
 //# sourceMappingURL=logger.js.map