@tanngo11/log 0.3.0

package/dist/index.cjs

@@ -0,0 +1,677 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_SKIP_PATHS: () => DEFAULT_SKIP_PATHS,
+  LEVELS: () => LEVELS,
+  REDACT_PATTERNS: () => REDACT_PATTERNS,
+  addContext: () => addContext,
+  createFetch: () => createFetch,
+  createLogger: () => createLogger,
+  getContext: () => getContext,
+  installProcessHandlers: () => installProcessHandlers,
+  jobData: () => jobData,
+  logHttpRequest: () => logHttpRequest,
+  logShutdown: () => logShutdown,
+  logStartup: () => logStartup,
+  parseTraceparent: () => parseTraceparent,
+  patchConsole: () => patchConsole,
+  propagationHeaders: () => propagationHeaders,
+  recordError: () => recordError,
+  requestContextFields: () => requestContextFields,
+  resolveRequestId: () => resolveRequestId,
+  runJob: () => runJob,
+  serializeError: () => serializeError,
+  withContext: () => withContext
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/context.ts
+var import_node_async_hooks = require("async_hooks");
+
+// src/global.ts
+function globalSingleton(name, make) {
+  const key = /* @__PURE__ */ Symbol.for(`@tanngo11/log.${name}`);
+  const g = globalThis;
+  let value = g[key];
+  if (value === void 0) {
+    value = make();
+    g[key] = value;
+  }
+  return value;
+}
+
+// src/context.ts
+var als = globalSingleton("als", () => new import_node_async_hooks.AsyncLocalStorage());
+function runWithStore(fields, fn) {
+  const parent = als.getStore();
+  const store = { fields: { ...parent?.fields, ...fields }, parent };
+  return als.run(store, () => fn(store));
+}
+function withContext(fields, fn) {
+  return runWithStore(fields, () => fn());
+}
+function getContext() {
+  return als.getStore()?.fields ?? {};
+}
+function addContext(fields) {
+  for (let s = als.getStore(); s; s = s.parent) Object.assign(s.fields, fields);
+}
+function recordErrorIn(store, err) {
+  store.error = err;
+  for (let s = store.parent; s; s = s.parent) if (s.error === void 0) s.error = err;
+}
+function recordError(err) {
+  const store = als.getStore();
+  if (store) recordErrorIn(store, err);
+}
+
+// src/levels.ts
+var LEVELS = ["trace", "debug", "info", "warn", "error", "fatal"];
+var LEVEL_RANK = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60
+};
+var ALIASES = { warning: "warn", err: "error", critical: "fatal", panic: "fatal" };
+function parseLevel(value, fallback = "info") {
+  if (typeof value !== "string") return fallback;
+  const v = value.trim().toLowerCase();
+  if (LEVELS.includes(v)) return v;
+  return ALIASES[v] ?? fallback;
+}
+
+// src/redact.ts
+var DEFAULT_REDACT_KEYS = [
+  "password",
+  "passwd",
+  "pwd",
+  "passphrase",
+  "secret",
+  "client_secret",
+  "token",
+  "access_token",
+  "refresh_token",
+  "id_token",
+  "auth_token",
+  "api_key",
+  "apikey",
+  "access_key",
+  "secret_key",
+  "private_key",
+  "authorization",
+  "cookie",
+  "set_cookie",
+  "session_id",
+  "sessionid",
+  "credential",
+  "credentials",
+  "dsn",
+  "connection_string",
+  "conn_string",
+  "jwt",
+  "bearer"
+];
+var REDACT_PATTERNS = {
+  /** Vietnamese mobile numbers: 0912345678, +84912345678, 84912345678. */
+  phoneVN: /(?<![\d+])(?:\+?84|0)[35789]\d{8}(?!\d)/g,
+  /** Visa, Mastercard, Amex, Discover-like card numbers, with optional spaces or dashes. */
+  paymentCard: /(?<!\d)(?:4\d{3}|5[1-5]\d{2}|2[2-7]\d{2}|3[47]\d{2}|6(?:011|5\d{2}))(?:[ -]?\d{4}){2}[ -]?\d{1,4}(?!\d)/g,
+  /** IPv4 addresses. */
+  ipv4: /(?<![\d.])(?:\d{1,3}\.){3}\d{1,3}(?![\d.])/g
+};
+var SAFE_SUFFIXES = ["_count", "_type", "_length", "_expires_at", "_expires_in", "_ttl", "_at", "_ms", "_enabled"];
+var REDACTED = "[REDACTED]";
+function toSnakeCase(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/[^A-Za-z0-9_]+/g, "_").toLowerCase();
+}
+var URL_CREDENTIALS_RE = /([a-z][a-z0-9+.-]*:\/\/)[^\s/@:"']+:[^\s/@"']+@/gi;
+var BEARER_RE = /\bBearer\s+[A-Za-z0-9._~+/=-]+/gi;
+var JWT_RE = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
+var EMAIL_RE = /[A-Za-z0-9._%+-]+@([A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,})/g;
+function globalize(re) {
+  return re.flags.includes("g") ? new RegExp(re.source, re.flags) : new RegExp(re.source, `${re.flags}g`);
+}
+function createRedactor(opts = {}) {
+  const words = [...DEFAULT_REDACT_KEYS];
+  const keyPatterns = [];
+  for (const k of opts.keys ?? []) {
+    if (typeof k === "string") words.push(toSnakeCase(k));
+    else keyPatterns.push(new RegExp(k.source, k.flags.replace("g", "")));
+  }
+  const valuePatterns = (opts.values ?? []).map(globalize);
+  const isSensitive = (key) => {
+    const k = toSnakeCase(key);
+    if (keyPatterns.some((re) => re.test(k))) return true;
+    if (!words.includes(k) && SAFE_SUFFIXES.some((s) => k.endsWith(s))) return false;
+    return words.some((w) => k === w || k.startsWith(`${w}_`) || k.endsWith(`_${w}`) || k.includes(`_${w}_`));
+  };
+  const scrub = (s) => {
+    let out = s.replace(URL_CREDENTIALS_RE, `$1${REDACTED}@`).replace(BEARER_RE, `Bearer ${REDACTED}`).replace(JWT_RE, "[REDACTED_JWT]").replace(EMAIL_RE, "***@$1");
+    for (const re of valuePatterns) out = out.replace(re, REDACTED);
+    return out;
+  };
+  const json = (value) => {
+    if (typeof value === "string") return value;
+    try {
+      const text = JSON.stringify(value, (key, val) => {
+        if (key && val !== null && val !== void 0 && isSensitive(key)) return REDACTED;
+        if (typeof val === "bigint") return val.toString();
+        if (val instanceof Error) return { name: val.name, message: val.message };
+        return val;
+      });
+      return text ?? String(value);
+    } catch {
+      return String(value);
+    }
+  };
+  return { isSensitive, scrub, json };
+}
+var defaultRedactor = createRedactor();
+
+// src/error.ts
+var MAX_CAUSE_DEPTH = 5;
+function isErrorLike(v) {
+  if (v instanceof Error) return true;
+  return typeof v === "object" && v !== null && typeof v.message === "string" && ("stack" in v || "name" in v);
+}
+function errorType(e) {
+  if (e.name && e.name !== "Error") return e.name;
+  const ctor = e.constructor?.name;
+  return ctor && ctor !== "Object" ? ctor : "Error";
+}
+function serializeError(err) {
+  if (!isErrorLike(err)) {
+    if (typeof err === "string") return { err_type: "string", err_message: err };
+    return { err_type: typeof err, err_message: defaultRedactor.json(err) };
+  }
+  const e = err;
+  const out = { err_type: errorType(e), err_message: String(e.message ?? "") };
+  if (e.code !== void 0 && e.code !== null) out.err_code = String(e.code);
+  if (typeof e.stack === "string") out.err_stack = e.stack;
+  const causes = [];
+  let cause = e.cause;
+  while (cause !== void 0 && cause !== null && causes.length < MAX_CAUSE_DEPTH) {
+    if (isErrorLike(cause)) {
+      causes.push(`${errorType(cause)}: ${cause.message}`);
+      cause = cause.cause;
+    } else {
+      causes.push(defaultRedactor.json(cause));
+      cause = void 0;
+    }
+  }
+  if (causes.length > 0) out.err_cause = causes.join(" <- ");
+  return out;
+}
+var logged = globalSingleton("logged", () => /* @__PURE__ */ new WeakSet());
+function markLogged(err) {
+  if (typeof err === "object" && err !== null) logged.add(err);
+}
+
+// src/normalize.ts
+var HOOK_EXEMPT = /* @__PURE__ */ new Set(["level", "message", "event"]);
+var RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "project",
+  "service",
+  "vps",
+  "version",
+  "container_name",
+  "container_id",
+  "image",
+  "stream",
+  "_timestamp",
+  "label",
+  "host",
+  "source_type",
+  "msg",
+  "lvl",
+  "severity",
+  "level",
+  "message"
+]);
+var MAX_LINE_BYTES = 16e3;
+var MAX_MESSAGE = 500;
+var MAX_STACK = 4e3;
+var MAX_STRING = 1e3;
+var MAX_DEPTH = 3;
+var TRUNCATED = "\u2026[truncated]";
+var KEEP_ON_SHRINK = /* @__PURE__ */ new Set([
+  "level",
+  "message",
+  "event",
+  "request_id",
+  "trace_id",
+  "span_id",
+  "job_name",
+  "job_id",
+  "job_attempt",
+  "user_id",
+  "tenant_id",
+  "err_type",
+  "err_message",
+  "err_code"
+]);
+function stripUrl(url) {
+  const noQuery = url.split(/[?#]/, 1)[0] ?? "";
+  return noQuery.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@\s]*@/i, "$1");
+}
+function truncate(s, max) {
+  return s.length > max ? s.slice(0, max - TRUNCATED.length) + TRUNCATED : s;
+}
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function isUrlKey(key) {
+  return key === "http_path" || key === "http_url" || key.endsWith("_url");
+}
+function flattenInto(out, prefix, obj, depth, opts) {
+  for (const [rawKey, value] of Object.entries(obj)) {
+    const key = opts.snakeCase ? toSnakeCase(rawKey) : rawKey;
+    const full = prefix ? `${prefix}_${key}` : key;
+    if (value === void 0 || typeof value === "function" || typeof value === "symbol") continue;
+    if (value !== null && (opts.redactor.isSensitive(rawKey) || opts.redactor.isSensitive(full))) {
+      out[full] = REDACTED;
+      continue;
+    }
+    if (value === null || typeof value === "string" || typeof value === "boolean") {
+      out[full] = value;
+    } else if (typeof value === "number") {
+      out[full] = Number.isFinite(value) ? value : String(value);
+    } else if (typeof value === "bigint") {
+      out[full] = value.toString();
+    } else if (value instanceof Date) {
+      out[full] = Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
+    } else if (isErrorLike(value)) {
+      out[full] = `${value.name}: ${value.message}`;
+    } else if (isPlainObject(value) && depth < MAX_DEPTH - 1) {
+      flattenInto(out, full, value, depth + 1, opts);
+    } else {
+      out[full] = opts.redactor.json(value);
+    }
+  }
+}
+function finalize(key, value, opts) {
+  if (typeof value !== "string") return value;
+  const v = opts.redactor.scrub(isUrlKey(key) ? stripUrl(value) : value);
+  return truncate(v, key === "err_stack" ? MAX_STACK : MAX_STRING);
+}
+function buildRecord(level, message, sources, opts) {
+  const merged = {};
+  for (const source of sources) if (source) Object.assign(merged, source);
+  let err;
+  if (merged.err !== void 0 && merged.err !== null) {
+    err = merged.err;
+    delete merged.err;
+  } else if (isErrorLike(merged.error)) {
+    err = merged.error;
+    delete merged.error;
+  }
+  const flat = {};
+  flattenInto(flat, "", merged, 0, opts);
+  if (err !== void 0) Object.assign(flat, serializeError(err));
+  const text = typeof message === "string" ? message : opts.redactor.json(message);
+  const out = { level, message: truncate(opts.redactor.scrub(text), MAX_MESSAGE) };
+  for (const [k, v] of Object.entries(flat)) {
+    const key = RESERVED_KEYS.has(k) ? `app_${k}` : k;
+    let value = finalize(key, v, opts);
+    if (opts.hook && !HOOK_EXEMPT.has(key)) {
+      const replaced = opts.hook(key, value);
+      if (replaced === void 0) continue;
+      value = typeof replaced === "object" && replaced !== null ? opts.redactor.json(replaced) : replaced;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function byteLength(s) {
+  if (s.length * 3 <= MAX_LINE_BYTES) return s.length;
+  return new TextEncoder().encode(s).length;
+}
+function serializeRecord(record) {
+  const line = JSON.stringify(record);
+  if (byteLength(line) <= MAX_LINE_BYTES) return line;
+  const small = {};
+  for (const [k, v] of Object.entries(record)) {
+    if (KEEP_ON_SHRINK.has(k) || k.startsWith("http_")) small[k] = v;
+  }
+  small.log_truncated = true;
+  return JSON.stringify(small);
+}
+
+// src/pretty.ts
+function formatPretty(record) {
+  const { level, message, err_stack, ...rest } = record;
+  const time = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+  const extras = Object.entries(rest).map(([k, v]) => `${k}=${typeof v === "string" && /\s/.test(v) ? JSON.stringify(v) : String(v)}`).join(" ");
+  let line = `${time} ${String(level).toUpperCase().padEnd(5)} ${String(message)}${extras ? ` ${extras}` : ""}`;
+  if (typeof err_stack === "string") line += `
+${err_stack}`;
+  return line;
+}
+
+// src/logger.ts
+function env(name) {
+  return typeof process !== "undefined" ? process.env?.[name] : void 0;
+}
+var consoleLog = console.log.bind(console);
+function defaultWrite(line) {
+  if (typeof process !== "undefined" && typeof process.stdout?.write === "function") {
+    process.stdout.write(`${line}
+`);
+  } else {
+    consoleLog(line);
+  }
+}
+function createLogger(options = {}) {
+  const level = parseLevel(options.level ?? env("LOG_LEVEL"));
+  const format = options.format ?? (env("LOG_FORMAT") === "pretty" ? "pretty" : "json");
+  const write = options.write ?? defaultWrite;
+  const norm = {
+    snakeCase: options.snakeCase ?? true,
+    redactor: createRedactor({ keys: options.redactKeys, values: options.redactValues }),
+    hook: options.redact
+  };
+  const make = (bound) => {
+    const emit = (lvl, message, fields) => {
+      if (LEVEL_RANK[lvl] < LEVEL_RANK[level]) return;
+      let line;
+      try {
+        const record = buildRecord(lvl, message, [options.base, getContext(), bound, fields], norm);
+        line = format === "pretty" ? formatPretty(record) : serializeRecord(record);
+      } catch (e) {
+        line = JSON.stringify({
+          level: "error",
+          message: "log serialize failed",
+          event: "log.serialize_failed",
+          err_message: String(e?.message ?? e).slice(0, 1e3),
+          original_message: String(message).slice(0, 500)
+        });
+      }
+      try {
+        write(line);
+      } catch {
+      }
+    };
+    return {
+      level,
+      trace: (m, f) => emit("trace", m, f),
+      debug: (m, f) => emit("debug", m, f),
+      info: (m, f) => emit("info", m, f),
+      warn: (m, f) => emit("warn", m, f),
+      error: (m, f) => emit("error", m, f),
+      fatal: (m, f) => emit("fatal", m, f),
+      child: (fields) => make({ ...bound, ...fields }),
+      isLevelEnabled: (l) => LEVEL_RANK[l] >= LEVEL_RANK[level]
+    };
+  };
+  return make({});
+}
+
+// src/request-id.ts
+var REQUEST_ID_RE = /^[A-Za-z0-9._-]{1,64}$/;
+var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/;
+function newRequestId() {
+  return globalThis.crypto.randomUUID();
+}
+function first(header2) {
+  return Array.isArray(header2) ? header2[0] : header2 ?? void 0;
+}
+function resolveRequestId(header2) {
+  const value = first(header2);
+  return value && REQUEST_ID_RE.test(value) ? value : newRequestId();
+}
+function parseTraceparent(header2) {
+  const value = first(header2)?.trim().toLowerCase();
+  const m = value ? TRACEPARENT_RE.exec(value) : null;
+  if (!m) return void 0;
+  const [, version, traceId, spanId] = m;
+  if (version === "ff" || /^0+$/.test(traceId) || /^0+$/.test(spanId)) return void 0;
+  return { trace_id: traceId, span_id: spanId };
+}
+
+// src/http.ts
+function header(headers, name) {
+  if (typeof headers.get === "function") return headers.get(name) ?? void 0;
+  return headers[name];
+}
+function requestContextFields(headers) {
+  const out = {
+    request_id: resolveRequestId(header(headers, "x-request-id"))
+  };
+  const tp = parseTraceparent(header(headers, "traceparent"));
+  if (tp) Object.assign(out, tp);
+  return out;
+}
+function propagationHeaders() {
+  const ctx = getContext();
+  const out = {};
+  if (typeof ctx.request_id === "string") out["x-request-id"] = ctx.request_id;
+  if (typeof ctx.trace_id === "string" && typeof ctx.span_id === "string") {
+    out.traceparent = `00-${ctx.trace_id}-${ctx.span_id}-01`;
+  }
+  return out;
+}
+var DEFAULT_SKIP_PATHS = [
+  /^\/(health|healthz|ready|readyz|livez)\/?$/,
+  "/favicon.ico",
+  /^\/_next\/static\//
+];
+function shouldSkip(method, path, skipPaths = DEFAULT_SKIP_PATHS) {
+  if (method.toUpperCase() === "OPTIONS") return true;
+  const p = stripUrl(path);
+  return skipPaths.some((s) => typeof s === "string" ? p === s : s.test(p));
+}
+function logHttpRequest(log, info, opts = {}) {
+  if (shouldSkip(info.method, info.path, opts.skipPaths)) return;
+  const level = info.status >= 500 ? "error" : info.status >= 400 ? "warn" : "info";
+  const path = stripUrl(info.path);
+  const errFields = {};
+  if (info.err !== void 0 && info.err !== null) {
+    Object.assign(errFields, serializeError(info.err));
+    if (info.status < 500) delete errFields.err_stack;
+    markLogged(info.err);
+  }
+  const message = info.route ? `${info.method} ${info.route} ${info.status}` : `${info.method} ${info.status}`;
+  log[level](message, {
+    ...info.fields,
+    event: "http.request",
+    http_method: info.method,
+    http_route: info.route,
+    http_path: path,
+    http_status: info.status,
+    duration_ms: info.duration_ms === void 0 ? void 0 : Math.round(info.duration_ms),
+    ...errFields
+  });
+}
+
+// src/fetch.ts
+function describeRequest(input, init) {
+  const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+  const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+  return { method, url };
+}
+function createFetch(log, opts) {
+  const slowMs = opts.slowMs ?? 1e3;
+  const wrapped = async (input, init) => {
+    const base = opts.fetch ?? globalThis.fetch;
+    const { method, url } = describeRequest(input, init);
+    let requestInit = init;
+    if (opts.internal) {
+      const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+      for (const [k, v] of Object.entries(propagationHeaders())) if (!headers.has(k)) headers.set(k, v);
+      requestInit = { ...init, headers };
+    }
+    const fields = { event: "http.outbound", peer_service: opts.peer_service, http_method: method, http_url: url };
+    const start = performance.now();
+    try {
+      const res = await base(input, requestInit);
+      const duration_ms = Math.round(performance.now() - start);
+      if (res.status >= 500) {
+        log.warn("outbound request failed", { ...fields, http_status: res.status, duration_ms });
+      } else if (duration_ms >= slowMs) {
+        log.warn("outbound request slow", { ...fields, http_status: res.status, duration_ms });
+      }
+      return res;
+    } catch (err) {
+      log.warn("outbound request failed", { ...fields, duration_ms: Math.round(performance.now() - start), err });
+      throw err;
+    }
+  };
+  return wrapped;
+}
+
+// src/job.ts
+async function runJob(log, info, fn) {
+  const ctx = { ...info.fields, job_name: info.job_name };
+  if (info.job_id !== void 0) ctx.job_id = String(info.job_id);
+  if (info.job_attempt !== void 0) ctx.job_attempt = info.job_attempt;
+  if (info.request_id !== void 0) ctx.request_id = info.request_id;
+  return withContext(ctx, async () => {
+    const start = performance.now();
+    try {
+      const result = await fn();
+      log.info("job completed", { event: "job.completed", duration_ms: Math.round(performance.now() - start) });
+      return result;
+    } catch (err) {
+      const final = typeof info.final_attempt === "function" ? info.final_attempt(err) : info.final_attempt ?? true;
+      log[final ? "error" : "warn"]("job failed", {
+        event: "job.failed",
+        duration_ms: Math.round(performance.now() - start),
+        err
+      });
+      markLogged(err);
+      throw err;
+    }
+  });
+}
+function jobData(data) {
+  const requestId = getContext().request_id;
+  if (typeof requestId !== "string" || data.request_id !== void 0) return data;
+  return { ...data, request_id: requestId };
+}
+
+// src/console.ts
+var METHODS = { log: "info", info: "info", warn: "warn", error: "error", debug: "debug", trace: "debug" };
+function patchConsole(log) {
+  const target = console;
+  const saved = {};
+  let inside = false;
+  for (const method of Object.keys(METHODS)) {
+    const previous = target[method];
+    saved[method] = previous;
+    const level = METHODS[method];
+    target[method] = (...args) => {
+      if (inside) return previous.apply(console, args);
+      inside = true;
+      try {
+        let err;
+        const parts = [];
+        for (const arg of args) {
+          if (isErrorLike(arg)) {
+            err ??= arg;
+            parts.push(arg.message);
+          } else {
+            parts.push(typeof arg === "string" ? arg : defaultRedactor.json(arg));
+          }
+        }
+        log[level](parts.join(" "), { event: "console", console_method: method, err });
+      } finally {
+        inside = false;
+      }
+    };
+  }
+  return () => {
+    for (const method of Object.keys(saved)) target[method] = saved[method];
+  };
+}
+
+// src/process.ts
+function logStartup(log, fields = {}) {
+  log.info("app started", {
+    event: "app.started",
+    runtime_version: `node ${process.versions.node}`,
+    log_level: log.level,
+    ...fields
+  });
+}
+function logShutdown(log, fields = {}) {
+  log.info("app stopping", { event: "app.stopping", ...fields });
+}
+function crashHandlers(log, opts = {}) {
+  const exitOnCrash = opts.exitOnCrash ?? true;
+  const exitDelayMs = opts.exitDelayMs ?? 1e3;
+  const exit = opts.exit ?? ((code) => process.exit(code));
+  let exiting = false;
+  const crash = (source, err) => {
+    if (!exitOnCrash) {
+      log.error("unhandled error", { event: "app.unhandled_error", crash_source: source, err });
+      return;
+    }
+    log.fatal("app crashed", { event: "app.crashed", crash_source: source, err });
+    if (exiting) return;
+    exiting = true;
+    if (typeof process !== "undefined") process.exitCode = 1;
+    const timer = setTimeout(() => exit(1), exitDelayMs);
+    timer.unref?.();
+  };
+  return {
+    onUncaught: (err) => crash("uncaughtException", err),
+    onRejection: (reason) => crash("unhandledRejection", reason)
+  };
+}
+var state = globalSingleton("process", () => ({ installed: false }));
+function installProcessHandlers(log, opts = {}) {
+  if (state.installed || typeof process === "undefined" || typeof process.on !== "function") return;
+  state.installed = true;
+  const h = crashHandlers(log, opts);
+  process.on("uncaughtException", h.onUncaught);
+  process.on("unhandledRejection", h.onRejection);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SKIP_PATHS,
+  LEVELS,
+  REDACT_PATTERNS,
+  addContext,
+  createFetch,
+  createLogger,
+  getContext,
+  installProcessHandlers,
+  jobData,
+  logHttpRequest,
+  logShutdown,
+  logStartup,
+  parseTraceparent,
+  patchConsole,
+  propagationHeaders,
+  recordError,
+  requestContextFields,
+  resolveRequestId,
+  runJob,
+  serializeError,
+  withContext
+});
+//# sourceMappingURL=index.cjs.map