autotel 2.26.3 → 3.0.3

package/dist/index.js

@@ -1,34 +1,34 @@
 export { createDrainPipeline } from './chunk-KFOHQK7X.js';
-export { getCurrentWorkflowContext, isInWorkflow, traceStep, traceWorkflow } from './chunk-YN7USLHW.js';
-export { attrs, autoRedactPII, dbClient, httpClient, httpServer, identify, mergeAttrs, mergeServiceResource, request, safeSetAttributes, setDevice, setError, setException, setSession, setUser, validateAttribute } from './chunk-ER43K7ES.js';
+export { getCurrentWorkflowContext, isInWorkflow, traceStep, traceWorkflow } from './chunk-K7HSRLP5.js';
+export { attrs, autoRedactPII, dbClient, httpClient, httpServer, identify, mergeAttrs, mergeServiceResource, request, safeSetAttributes, setDevice, setError, setException, setSession, setUser, validateAttribute } from './chunk-DDXIUZEG.js';
 export { httpRequestHeaderAttribute, httpResponseHeaderAttribute } from './chunk-7552UTQW.js';
 export { HTTPAttributes, ServiceAttributes, URLAttributes } from './chunk-4A53YIAX.js';
 export { parseError } from './chunk-J7VGRIAJ.js';
-export { traceConsumer, traceProducer } from './chunk-QC5MNKVF.js';
+export { traceConsumer, traceProducer } from './chunk-TFRZOUTV.js';
+import { emitCorrelatedEvent } from './chunk-KIL5CUN6.js';
 export { BusinessBaggage, createSafeBaggageSchema } from './chunk-4IFSYQVX.js';
 import { resetMetrics } from './chunk-7SAWIN74.js';
 export { Metric, getMetrics, resetMetrics } from './chunk-7SAWIN74.js';
 import './chunk-5ZN622AO.js';
 export { createCounter, createHistogram, createObservableGauge, createUpDownCounter, getMeter } from './chunk-TQ5UWA7S.js';
-export { traceDB, traceHTTP, traceLLM, traceMessaging } from './chunk-U54FTVFH.js';
-import { getEventQueue, resetEventQueue } from './chunk-HPUGKUMZ.js';
-export { ctx, getEventQueue, instrument, span, trace, track, withBaggage, withNewContext, withTracing } from './chunk-HPUGKUMZ.js';
-export { createDeterministicTraceId, enrichWithTraceContext, finalizeSpan, flattenMetadata, getActiveContext, getActiveSpan, getTraceContext, getTracer, isTracing, resolveTraceUrl, runWithSpan } from './chunk-B3ZHLLMP.js';
-import { resetEvents } from './chunk-BJ2XPN77.js';
-export { Event, getEvents, resetEvents } from './chunk-BJ2XPN77.js';
+export { traceDB, traceHTTP, traceLLM, traceMessaging } from './chunk-52PUSFC2.js';
+import { trace as trace$1 } from './chunk-PMRWMRXY.js';
+export { ctx, instrument, span, withBaggage, withNewContext, withTracing } from './chunk-PMRWMRXY.js';
+export { createDeterministicTraceId, enrichWithTraceContext, finalizeSpan, flattenMetadata, getActiveContext, getActiveSpan, getTraceContext, getTracer, isTracing, resolveTraceUrl, runWithSpan } from './chunk-DSMSIVTG.js';
+import { resetEvents } from './chunk-OM4OSBOP.js';
+export { Event, getEvents, resetEvents } from './chunk-OM4OSBOP.js';
 import './chunk-LITNXTTT.js';
 import './chunk-BZHG5IZ4.js';
-export { getOperationContext, runInOperationContext } from './chunk-WD4RP6IV.js';
-export { CORRELATION_ID_BAGGAGE_KEY, generateCorrelationId, getCorrelationId, getOrCreateCorrelationId, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage } from './chunk-S4OFEXLA.js';
-import { createTraceContext } from './chunk-BBBWDIYQ.js';
-export { defineBaggageSchema } from './chunk-BBBWDIYQ.js';
-import { getLogger, getSdk, _closeEmbeddedDevtools } from './chunk-W35FVJBC.js';
-export { BaggageSpanProcessor, createStringRedactor, init, isLoggerLocked, lockLogger } from './chunk-W35FVJBC.js';
+export { getOperationContext, runInOperationContext } from './chunk-SEO6NAQT.js';
+import { getEventQueue, resetEventQueue, createTraceContext, flattenToAttributes, recordStructuredError } from './chunk-Z7VAOK5X.js';
+export { CORRELATION_ID_BAGGAGE_KEY, createStructuredError, defineBaggageSchema, flattenToAttributes, generateCorrelationId, getCorrelationId, getEventQueue, getOrCreateCorrelationId, getStructuredErrorAttributes, recordStructuredError, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage, structuredErrorToJSON, toAttributeValue, track } from './chunk-Z7VAOK5X.js';
+import { getLogger, getSdk, _closeEmbeddedDevtools } from './chunk-ZDPIWKWD.js';
+export { BaggageSpanProcessor, createStringRedactor, init, isLoggerLocked, lockLogger } from './chunk-ZDPIWKWD.js';
 import './chunk-3SDILILG.js';
 import './chunk-A4E5AQFK.js';
 export { FilteringSpanProcessor } from './chunk-WGWSHJ2N.js';
 export { NORMALIZER_PATTERNS, NORMALIZER_PRESETS, SpanNameNormalizingProcessor } from './chunk-GYR5K654.js';
-export { AttributeRedactingProcessor, REDACTOR_PATTERNS, REDACTOR_PRESETS, createAttributeRedactor, createRedactedSpan } from './chunk-TDNKIHKT.js';
+export { AttributeRedactingProcessor, REDACTOR_PATTERNS, REDACTOR_PRESETS, builtinPatterns, createAttributeRedactor, createRedactedSpan, normalizeAttributeRedactorConfig } from './chunk-JVWJDHDB.js';
 import './chunk-6UQRVUN3.js';
 export { formatDuration } from './chunk-3QXBFGKP.js';
 import './chunk-33WTKH7X.js';
@@ -37,11 +37,32 @@ import './chunk-55ER2KD5.js';
 import './chunk-J5QENANM.js';
 export { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider } from './chunk-HA2WBOGQ.js';
 import './chunk-DGUM43GV.js';
-import { AsyncLocalStorage } from 'async_hooks';
-import { SpanStatusCode, trace } from '@opentelemetry/api';
+import { trace } from '@opentelemetry/api';
 export { ROOT_CONTEXT, SpanKind, SpanStatusCode, context, trace as otelTrace, propagation } from '@opentelemetry/api';
+import { AsyncLocalStorage } from 'async_hooks';
 import { AggregationType } from '@opentelemetry/sdk-metrics';
 
+var otelMethods = {
+  // Class methods on TraceAPI — bind to the singleton.
+  setGlobalTracerProvider: trace.setGlobalTracerProvider.bind(trace),
+  getTracerProvider: trace.getTracerProvider.bind(trace),
+  getTracer: trace.getTracer.bind(trace),
+  disable: trace.disable.bind(trace),
+  // Instance fields on TraceAPI — already standalone, copy by reference.
+  wrapSpanContext: trace.wrapSpanContext,
+  isSpanContextValid: trace.isSpanContextValid,
+  deleteSpan: trace.deleteSpan,
+  getSpan: trace.getSpan,
+  getActiveSpan: trace.getActiveSpan,
+  getSpanContext: trace.getSpanContext,
+  setSpan: trace.setSpan,
+  setSpanContext: trace.setSpanContext
+};
+var trace2 = Object.assign(
+  trace$1,
+  otelMethods
+);
+
 // src/shutdown.ts
 async function flush(options) {
   const timeout = options?.timeout ?? 2e3;
@@ -172,159 +193,6 @@ function registerShutdownHooks() {
   }
 }
 registerShutdownHooks();
-
-// src/flatten-attributes.ts
-function toAttributeValue(value) {
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    if (value.every((v) => typeof v === "string") || value.every((v) => typeof v === "number") || value.every((v) => typeof v === "boolean")) {
-      return value;
-    }
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return "<serialization-failed>";
-    }
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (value instanceof Error) {
-    return value.message;
-  }
-  return void 0;
-}
-function flattenToAttributes(fields, prefix = "") {
-  const out = {};
-  const seen = /* @__PURE__ */ new WeakSet();
-  function flatten(obj, currentPrefix) {
-    for (const [key, value] of Object.entries(obj)) {
-      if (value == null) continue;
-      const nextKey = currentPrefix ? `${currentPrefix}.${key}` : key;
-      const attr = toAttributeValue(value);
-      if (attr !== void 0) {
-        out[nextKey] = attr;
-        continue;
-      }
-      if (typeof value === "object" && value.constructor === Object) {
-        if (seen.has(value)) {
-          out[nextKey] = "<circular-reference>";
-          continue;
-        }
-        seen.add(value);
-        flatten(value, nextKey);
-        continue;
-      }
-      try {
-        out[nextKey] = JSON.stringify(value);
-      } catch {
-        out[nextKey] = "<serialization-failed>";
-      }
-    }
-  }
-  flatten(fields, prefix);
-  return out;
-}
-
-// src/structured-error.ts
-var internalKey = /* @__PURE__ */ Symbol.for("autotel.error.internal");
-function createStructuredError(input) {
-  const error = new Error(input.message, {
-    cause: input.cause
-  });
-  error.name = input.name ?? "StructuredError";
-  if (input.why !== void 0) error.why = input.why;
-  if (input.fix !== void 0) error.fix = input.fix;
-  if (input.link !== void 0) error.link = input.link;
-  if (input.code !== void 0) error.code = input.code;
-  if (input.status !== void 0) error.status = input.status;
-  if (input.details !== void 0) error.details = input.details;
-  if (input.internal !== void 0) {
-    Object.defineProperty(error, internalKey, {
-      value: input.internal,
-      enumerable: false,
-      writable: false,
-      configurable: true
-    });
-  }
-  Object.defineProperty(error, "internal", {
-    get() {
-      return this[internalKey];
-    },
-    enumerable: false,
-    configurable: true
-  });
-  error.toString = () => {
-    const lines = [`${error.name}: ${error.message}`];
-    if (error.why) lines.push(`  Why: ${error.why}`);
-    if (error.fix) lines.push(`  Fix: ${error.fix}`);
-    if (error.link) lines.push(`  Link: ${error.link}`);
-    if (error.code !== void 0) lines.push(`  Code: ${error.code}`);
-    if (error.status !== void 0) lines.push(`  Status: ${error.status}`);
-    if (error.cause) {
-      const cause = error.cause;
-      lines.push(`  Caused by: ${cause.name}: ${cause.message}`);
-    }
-    return lines.join("\n");
-  };
-  return error;
-}
-function structuredErrorToJSON(error) {
-  const result = {
-    name: error.name,
-    message: error.message
-  };
-  if (error.status !== void 0) result.status = error.status;
-  if (error.why || error.fix || error.link) {
-    result.data = {
-      ...error.why && { why: error.why },
-      ...error.fix && { fix: error.fix },
-      ...error.link && { link: error.link }
-    };
-  }
-  if (error.code !== void 0) result.code = error.code;
-  if (error.details) result.details = error.details;
-  if (error.cause instanceof Error) {
-    result.cause = { name: error.cause.name, message: error.cause.message };
-  }
-  return result;
-}
-function getStructuredErrorAttributes(error) {
-  const structured = error;
-  const attributes = {
-    "error.type": error.name || "Error",
-    "error.message": error.message
-  };
-  if (error.stack) attributes["error.stack"] = error.stack;
-  if (structured.why) attributes["error.why"] = structured.why;
-  if (structured.fix) attributes["error.fix"] = structured.fix;
-  if (structured.link) attributes["error.link"] = structured.link;
-  if (structured.code !== void 0) {
-    attributes["error.code"] = typeof structured.code === "string" ? structured.code : String(structured.code);
-  }
-  if (structured.status !== void 0) {
-    attributes["error.status"] = structured.status;
-  }
-  if (structured.details) {
-    Object.assign(
-      attributes,
-      flattenToAttributes(structured.details, "error.details")
-    );
-  }
-  return attributes;
-}
-function recordStructuredError(ctx2, error) {
-  ctx2.recordException(error);
-  ctx2.setStatus({
-    code: SpanStatusCode.ERROR,
-    message: error.message
-  });
-  ctx2.setAttributes(getStructuredErrorAttributes(error));
-}
-
-// src/request-logger.ts
 var POST_EMIT_FORK_HINT = "For intentional background work tied to this request, use log.fork('label', fn) when available.";
 function warnPostEmit(method, detail) {
   console.warn(
@@ -371,9 +239,9 @@ function getRequestLogger(ctx2, options) {
   let lastSnapshot = null;
   const addLogEvent = (level, message, fields) => {
     const attrs2 = fields ? flattenToAttributes(fields) : void 0;
-    activeContext.addEvent(`log.${level}`, {
+    emitCorrelatedEvent(activeContext, `log.${level}`, {
       message,
-      ...attrs2
+      ...attrs2 ?? {}
     });
   };
   const sealCheck = (method, keys) => {
@@ -446,7 +314,7 @@ function getRequestLogger(ctx2, options) {
         correlationId: activeContext.correlationId,
         context: mergedContext
       };
-      activeContext.addEvent("log.emit.manual", {
+      emitCorrelatedEvent(activeContext, "log.emit.manual", {
         ...flattened
       });
       if (options?.onEmit) {
@@ -458,7 +326,7 @@ function getRequestLogger(ctx2, options) {
       lastSnapshot = snapshot;
       return snapshot;
     },
-    fork(label, fn) {
+    fork(label, fn, forkOptions) {
       const parentRequestId = activeContext.correlationId;
       if (typeof parentRequestId !== "string" || parentRequestId.length === 0) {
         throw new Error(
@@ -466,6 +334,7 @@ function getRequestLogger(ctx2, options) {
         );
       }
       const tracer = trace.getTracer("autotel.request-logger");
+      const lifecycle = forkOptions?.lifecycle;
       void tracer.startActiveSpan(`request.fork:${label}`, (childSpan) => {
         const childContext = {
           ...createTraceContext(childSpan),
@@ -477,6 +346,7 @@ function getRequestLogger(ctx2, options) {
             operation: label,
             _parentCorrelationId: parentRequestId
           });
+          lifecycle?.onChildEnter?.(childLog);
           void Promise.resolve().then(() => fn()).then(() => {
             childLog.emitNow();
           }).catch((err) => {
@@ -484,6 +354,14 @@ function getRequestLogger(ctx2, options) {
             childLog.error(error);
             childLog.emitNow();
           }).finally(() => {
+            try {
+              lifecycle?.onChildExit?.(childLog);
+            } catch (hookError) {
+              console.warn(
+                "[autotel] fork onChildExit hook threw:",
+                hookError
+              );
+            }
             childSpan.end();
           });
         });
@@ -491,6 +369,119 @@ function getRequestLogger(ctx2, options) {
     }
   };
 }
+
+// src/drain-toolkit.ts
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_RETRIES = 2;
+function delay(ms) {
+  return new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    t.unref?.();
+  });
+}
+async function postWithRetry(options) {
+  const { name, request: request2, timeoutMs, retries } = options;
+  const attempts = Math.max(1, retries);
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    timeout.unref?.();
+    try {
+      const response = await fetch(request2.url, {
+        method: "POST",
+        headers: request2.headers,
+        body: request2.body,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(
+          `[autotel/${name}] HTTP ${response.status} draining ${request2.url}`
+        );
+      }
+      return;
+    } catch (error) {
+      lastError = error;
+      if (attempt < attempts) {
+        await delay(100 * attempt);
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  throw lastError;
+}
+function defineDrain(options) {
+  return async (ctx2) => {
+    const contexts = Array.isArray(ctx2) ? ctx2 : [ctx2];
+    if (contexts.length === 0) return;
+    const config = await options.resolve();
+    if (!config) return;
+    const payloads = options.transform ? options.transform(contexts) : contexts;
+    if (payloads.length === 0) return;
+    try {
+      await options.send(payloads, config);
+    } catch (error) {
+      console.error(`[autotel/${options.name}] drain failed:`, error);
+    }
+  };
+}
+function defineHttpDrain(options) {
+  return defineDrain({
+    name: options.name,
+    resolve: options.resolve,
+    transform: options.transform,
+    send: async (payloads, config) => {
+      const request2 = options.encode(payloads, config);
+      if (!request2) return;
+      const timeoutMs = options.resolveTimeoutMs?.(config) ?? options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+      const retries = options.resolveRetries?.(config) ?? options.retries ?? DEFAULT_RETRIES;
+      await postWithRetry({
+        name: options.name,
+        request: request2,
+        timeoutMs,
+        retries
+      });
+    }
+  });
+}
+
+// src/enricher-toolkit.ts
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeInto2(target, source) {
+  for (const key in source) {
+    const sourceVal = source[key];
+    if (sourceVal === void 0) continue;
+    const targetVal = target[key];
+    if (isPlainObject(sourceVal) && isPlainObject(targetVal)) {
+      mergeInto2(targetVal, sourceVal);
+    } else {
+      target[key] = sourceVal;
+    }
+  }
+}
+function defineEnricher(def, options = {}) {
+  return (ctx2) => {
+    let computed;
+    try {
+      computed = def.compute(ctx2);
+    } catch (error) {
+      console.error(`[autotel/${def.name}] enrich failed:`, error);
+      return;
+    }
+    if (!computed) return;
+    if (options.overwrite || !isPlainObject(ctx2.event[def.field])) {
+      ctx2.event[def.field] = computed;
+      return;
+    }
+    mergeInto2(
+      ctx2.event[def.field],
+      computed
+    );
+  };
+}
 var GEN_AI_DURATION_BUCKETS_SECONDS = Object.freeze(
   [0.01, 0.05, 0.1, 0.25, 0.5, 1, 2, 5, 10, 20, 30, 60, 120, 300]
 );
@@ -548,19 +539,27 @@ function genAiMetricViews(extra = []) {
 
 // src/gen-ai-events.ts
 function recordPromptSent(ctx2, event = {}) {
-  ctx2.addEvent("gen_ai.prompt.sent", buildPromptSentAttrs(event));
+  emitCorrelatedEvent(ctx2, "gen_ai.prompt.sent", buildPromptSentAttrs(event));
 }
 function recordResponseReceived(ctx2, event = {}) {
-  ctx2.addEvent("gen_ai.response.received", buildResponseAttrs(event));
+  emitCorrelatedEvent(
+    ctx2,
+    "gen_ai.response.received",
+    buildResponseAttrs(event)
+  );
 }
 function recordRetry(ctx2, event) {
-  ctx2.addEvent("gen_ai.retry", buildRetryAttrs(event));
+  emitCorrelatedEvent(ctx2, "gen_ai.retry", buildRetryAttrs(event));
 }
 function recordToolCall(ctx2, event) {
-  ctx2.addEvent("gen_ai.tool.call", buildToolCallAttrs(event));
+  emitCorrelatedEvent(ctx2, "gen_ai.tool.call", buildToolCallAttrs(event));
 }
 function recordStreamFirstToken(ctx2, event = {}) {
-  ctx2.addEvent("gen_ai.stream.first_token", buildStreamFirstTokenAttrs(event));
+  emitCorrelatedEvent(
+    ctx2,
+    "gen_ai.stream.first_token",
+    buildStreamFirstTokenAttrs(event)
+  );
 }
 function buildPromptSentAttrs(event) {
   const attrs2 = {};
@@ -607,6 +606,6 @@ function buildStreamFirstTokenAttrs(event) {
   return attrs2;
 }
 
-export { GEN_AI_COST_USD_BUCKETS, GEN_AI_DURATION_BUCKETS_SECONDS, GEN_AI_TOKEN_USAGE_BUCKETS, createStructuredError, flattenToAttributes, flush, genAiMetricViews, getRequestLogger, getStructuredErrorAttributes, llmHistogramAdvice, recordPromptSent, recordResponseReceived, recordRetry, recordStreamFirstToken, recordStructuredError, recordToolCall, runWithRequestContext, shutdown, structuredErrorToJSON, toAttributeValue };
+export { GEN_AI_COST_USD_BUCKETS, GEN_AI_DURATION_BUCKETS_SECONDS, GEN_AI_TOKEN_USAGE_BUCKETS, defineDrain, defineEnricher, defineHttpDrain, flush, genAiMetricViews, getRequestLogger, llmHistogramAdvice, recordPromptSent, recordResponseReceived, recordRetry, recordStreamFirstToken, recordToolCall, runWithRequestContext, shutdown, trace2 as trace };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map