autotel 6.3.0 → 6.4.0

package/dist/functional.d.ts

@@ -1,433 +1,3 @@
 import { n as TraceContext } from "./trace-context-IuyoPyNq.js";
-import { p as Sampler } from "./sampling-CP3e7-Yr.js";
-import { Span } from "@opentelemetry/api";
-//#region src/functional.d.ts
-type WrappedFunction<TArgs extends unknown[], TReturn> = (...args: TArgs) => TReturn | Promise<TReturn>;
-/**
- * Common options for functional tracing
- */
-interface TracingOptions<TArgs extends unknown[] = unknown[], TReturn = unknown> {
-  /**
-   * Span name (highest priority)
-   * If provided, this is used as the span name
-   */
-  name?: string;
-  /**
-   * Service name (used to compose final span name)
-   * If name not provided, span name becomes: ${serviceName}.${functionName}
-   */
-  serviceName?: string;
-  /**
-   * Sampling strategy
-   * @default AlwaysSampler
-   */
-  sampler?: Sampler;
-  /**
-   * Enable metrics collection (counter, histogram)
-   * @default false
-   */
-  withMetrics?: boolean;
-  /**
-   * Extract attributes from function arguments
-   */
-  attributesFromArgs?: (args: TArgs) => Record<string, unknown>;
-  /**
-   * Extract attributes from function result
-   */
-  attributesFromResult?: (result: TReturn) => Record<string, unknown>;
-  /**
-   * Capture the function arguments onto the span as `autotel.input`
-   * (JSON, truncated). One arg is captured directly; multiple are captured as
-   * an array. Off by default — opt in per call. Tools (visualizers, devtools)
-   * read this alongside `ai.toolCall.args` to show function I/O uniformly.
-   * Avoid on args with secrets/PII, or pair with a redacting processor.
-   */
-  captureInput?: boolean;
-  /**
-   * Capture the function return value onto the span as `autotel.output`
-   * (JSON, truncated). Off by default. Same caveats as {@link captureInput}.
-   */
-  captureOutput?: boolean;
-  /**
-   * Start a new root span instead of creating a child
-   * Useful for serverless entry points
-   * @default false
-   */
-  startNewRoot?: boolean;
-  /**
-   * Flush events queue when span ends
-   * Only flushes on root spans (to avoid excessive flushing)
-   * @default true
-   */
-  flushOnRootSpanEnd?: boolean;
-  /**
-   * Span kind for semantic convention compliance
-   * Used for messaging (PRODUCER/CONSUMER), HTTP (CLIENT/SERVER), etc.
-   * @default SpanKind.INTERNAL
-   */
-  spanKind?: import('@opentelemetry/api').SpanKind;
-  /**
-   * Classify a thrown value as a real error. Return `false` to treat the throw
-   * as expected control flow: the span is marked OK, no exception is recorded,
-   * and the value is rethrown untouched. Use this for framework control-flow
-   * signals that propagate via `throw` but are not failures — e.g. TanStack
-   * Router / Next.js `redirect()` and `notFound()`.
-   * @default every throw is treated as an error
-   */
-  isError?: (error: unknown) => boolean;
-}
-/**
- * Options for instrument() batch instrumentation
- */
-interface InstrumentOptions<T extends Record<string, AnyInstrumentable> = Record<string, AnyInstrumentable>> extends TracingOptions {
-  /** Object whose function properties should be instrumented */
-  functions: T;
-  /**
-   * Per-function configuration overrides
-   */
-  overrides?: Record<string, Partial<TracingOptions>>;
-  /**
-   * Functions to skip (won't be instrumented)
-   * Supports:
-   * - String keys: 'functionName'
-   * - RegExp: /^_internal/
-   * - Predicate: (key, fn) => boolean
-   *
-   * By default, functions starting with _ are skipped
-   */
-  skip?: (string | RegExp | ((key: string, fn: Function) => boolean))[];
-}
-/**
- * Options for instrumenting one function with an explicit stable key.
- */
-interface SingleInstrumentOptions<TFunction extends AnyInstrumentable = AnyInstrumentable> extends TracingOptions {
-  /** Stable function key used for span naming */
-  key: string;
-  /** Function to instrument */
-  fn: TFunction;
-}
-/**
- * Constraint alias for `instrument()` and friends. `never[]` parameters make
- * every concretely-typed function (e.g. `(name: string) => Promise<User>`)
- * satisfy the constraint under `strictFunctionTypes` without resorting to
- * `any`. Use ONLY in constraint positions — the concrete `T` is still
- * inferred from the actual argument, so call-site argument and return types
- * are fully preserved.
- */
-type AnyInstrumentable = ((...args: never[]) => unknown) & {
-  displayName?: string;
-  name?: string;
-};
-/**
- * Get the autotel {@link TraceContext} for the currently active span.
- *
- * This is the ambient accessor for the functional API: instead of threading a
- * `ctx` parameter through a factory, call this inside any traced function (or a
- * helper it calls) to reach `setAttribute`, `setUser`, `getBaggage`, and the
- * rest of the context surface. Returns `undefined` when no span is active.
- *
- * @example
- * ```typescript
- * const getUser = trace('getUser', async (id: string) => {
- *   getActiveTraceContext()?.setAttribute('user.id', id);
- *   return db.users.find(id);
- * });
- * ```
- *
- * @see getActiveSpan for the raw OpenTelemetry span
- * @see getRequestLogger which reads the active context when called with no args
- */
-declare function getActiveTraceContext<TBaggage extends Record<string, unknown> | undefined = undefined>(): TraceContext<TBaggage> | undefined;
-/**
- * Context object that lazily evaluates the active span on property access
- *
- * Access trace context directly without function call syntax.
- *
- * @example
- * ```typescript
- * import { trace, ctx } from 'autotel'
- *
- * export const createUser = trace(async (data) => {
- *   // Direct property access - no function call!
- *   if (ctx.traceId) {
- *     ctx.setAttribute('user.id', data.id)
- *     console.log('Trace:', ctx.traceId)
- *   }
- * })
- * ```
- */
-declare const ctx: TraceContext;
-/**
- * Approach 1: trace() - Zero-ceremony HOF
- *
- * Wrap a plain function with automatic tracing. The function receives its real
- * arguments; no context parameter is injected. Use
- * {@link getActiveTraceContext} inside the function, or use {@link withTracing}
- * for the explicit `(ctx) => (...args) => result` factory form.
- *
- * @example Auto-inferred name - Plain function
- * ```typescript
- * export const createUser = trace(async (data) => {
- *   return await db.users.create(data)
- * })
- * // → Traced as "createUser"
- * ```
- *
- * @example Ambient context access
- * ```typescript
- * export const createUser = trace(async (data) => {
- *   getActiveTraceContext()?.setAttribute('user.id', data.id)
- *   return await db.users.create(data)
- * })
- * ```
- *
- * @example Custom name - Plain function
- * ```typescript
- * export const createUser = trace('user.create', async (data) => {
- *   return await db.users.create(data)
- * })
- * // → Traced as "user.create"
- * ```
- *
- * @example Explicit factory context with withTracing()
- * ```typescript
- * export const createUser = withTracing({ name: 'user.create' })((ctx) => async (data) => {
- *   ctx.setAttribute('user.id', data.id)
- *   return await db.users.create(data)
- * })
- * ```
- *
- * @example Full options - Plain function
- * ```typescript
- * export const createUser = trace({
- *   name: 'user.create',
- *   sampler: new AdaptiveSampler(),
- *   withMetrics: true
- * }, async (data) => {
- *   return await db.users.create(data)
- * })
- * ```
- *
- */
-declare function trace<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-declare function trace<TArgs extends unknown[], TReturn>(name: string, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-declare function trace<TArgs extends unknown[], TReturn>(options: TracingOptions<TArgs, TReturn>, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-/**
- * Approach 2: withTracing() - Middleware-style composable wrapper
- *
- * Returns a HOF that wraps functions with tracing.
- * Perfect for composition and reusable configuration.
- *
- * @example Standard usage
- * ```typescript
- * export const createUser = withTracing({
- *   name: 'user.create'
- * })(ctx => async (data) => {
- *   ctx.setAttribute('user.id', data.id)
- *   return await db.users.create(data)
- * })
- * ```
- *
- * @example Composable
- * ```typescript
- * const tracer = withTracing({ serviceName: 'user' })
- *
- * export const createUser = tracer(ctx => async (data) => { })
- * export const updateUser = tracer(ctx => async (id, data) => { })
- * ```
- *
- * @example With other middleware
- * ```typescript
- * export const createUser = compose(
- *   withAuth({ role: 'admin' }),
- *   withTracing({ name: 'user.create' }),
- *   withRateLimit({ max: 100 })
- * )(ctx => async (data) => { })
- * ```
- */
-declare function withTracing<TCfgArgs extends unknown[] = unknown[], TCfgReturn = unknown>(options?: TracingOptions<TCfgArgs, TCfgReturn>): <TArgs extends TCfgArgs, TReturn extends TCfgReturn>(fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn | Promise<TReturn>) => WrappedFunction<TArgs, TReturn>;
-/**
- * Approach 3: instrument() - Batch auto-instrumentation
- *
- * Instrument an entire module/object at once.
- * Closest to @Instrumented decorator pattern.
- *
- * @example Basic usage
- * ```typescript
- * export default instrument({
- *   functions: {
- *     createUser: async (data) => { },
- *     updateUser: async (id, data) => { },
- *     deleteUser: async (id) => { }
- *   },
- *   serviceName: 'user',
- *   sampler: new AdaptiveSampler()
- * })
- * // → Traced as "user.createUser", "user.updateUser", "user.deleteUser"
- * ```
- *
- * @example Per-function overrides
- * ```typescript
- * export default instrument({
- *   functions: {
- *     createUser: async (data) => { },
- *     deleteUser: async (id) => { }
- *   },
- *   serviceName: 'user',
- *   overrides: {
- *     deleteUser: {
- *       sampler: new AlwaysSampler(),
- *       withMetrics: true
- *     }
- *   }
- * })
- * ```
- *
- * @example Skip functions
- * ```typescript
- * export default instrument({
- *   functions: {
- *     createUser: async (data) => { },
- *     _internal: async () => { }, // Auto-skipped (_-prefix)
- *     deleteUser: async (id) => { }
- *   },
- *   serviceName: 'user',
- *   skip: [/^test/, (key) => key.includes('debug')]
- * })
- * ```
- */
-declare function instrument<TFunction extends AnyInstrumentable>(options: SingleInstrumentOptions<TFunction>): TFunction;
-declare function instrument<T extends Record<string, AnyInstrumentable>>(options: InstrumentOptions<T>): T;
-/**
- * Options for span() function
- */
-interface SpanOptions {
-  /** Span name */
-  name: string;
-  /** Attributes to set on the span */
-  attributes?: Record<string, string | number | boolean>;
-  /** OpenTelemetry span kind */
-  spanKind?: import('@opentelemetry/api').SpanKind;
-}
-/**
- * Execute a function within a named span
- *
- * Useful for adding tracing to specific code blocks without wrapping
- * the entire function. Supports both synchronous and asynchronous functions.
- *
- * Mirrors `trace()`: pass a span name as the first argument for the common
- * case, or full `SpanOptions` when you need to attach attributes.
- *
- * @example
- * ```typescript
- * // Name shorthand
- * await span('payment.charge', async (span) => {
- *   await chargeCustomer(order);
- * })
- *
- * // Full options when attributes are needed
- * await span(
- *   { name: 'payment.charge', attributes: { amount: order.total } },
- *   async (span) => {
- *     await chargeCustomer(order);
- *   },
- * )
- *
- * // Sync
- * const total = span('calculateTotal', (span) => {
- *   return items.reduce((sum, item) => sum + item.price, 0);
- * })
- * ```
- */
-declare function span<T = unknown>(name: string, fn: (span: Span) => T): T;
-declare function span<T = unknown>(name: string, fn: (span: Span) => Promise<T>): Promise<T>;
-declare function span<T = unknown>(options: SpanOptions, fn: (span: Span) => T): T;
-declare function span<T = unknown>(options: SpanOptions, fn: (span: Span) => Promise<T>): Promise<T>;
-/**
- * Options for withNewContext() function
- */
-interface WithNewContextOptions<T = unknown> {
-  /** Function to execute in new root context */
-  fn: () => Promise<T>;
-}
-/**
- * Execute a function in a new root context (prevents span propagation)
- *
- * Useful when you want to start a completely new trace without
- * parent-child relationships.
- *
- * @example
- * ```typescript
- * async function handleWebhook(payload: WebhookPayload) {
- *   // This creates a new root trace, not connected to the HTTP request trace
- *   await withNewContext({
- *     fn: async () => {
- *       await span('webhook.process', async () => {
- *         await processWebhookPayload(payload)
- *       })
- *     }
- *   })
- * }
- * ```
- */
-declare function withNewContext<T = unknown>(options: WithNewContextOptions<T>): Promise<T>;
-/**
- * Options for withBaggage() function
- */
-interface WithBaggageOptions<T = unknown> {
-  /** Baggage entries to set (key-value pairs) */
-  baggage: Record<string, string>;
-  /** Function to execute with the updated baggage */
-  fn: () => T | Promise<T>;
-}
-/**
- * Execute a function with updated baggage entries
- *
- * Baggage is immutable in OpenTelemetry, so this helper creates a new context
- * with the specified baggage entries and runs the function within that context.
- * All child spans created within the function will inherit the baggage.
- *
- * @example Setting baggage for downstream services
- * ```typescript
- * import { withTracing, withBaggage } from 'autotel';
- *
- * export const createOrder = withTracing({ name: 'order.create' })((ctx) => async (order: Order) => {
- *   // Set baggage that will be propagated to downstream HTTP calls
- *   return await withBaggage({
- *     baggage: {
- *       'tenant.id': order.tenantId,
- *       'user.id': order.userId,
- *     },
- *     fn: async () => {
- *       // This HTTP call will include the baggage in headers
- *       await fetch('/api/charge', {
- *         method: 'POST',
- *         body: JSON.stringify(order),
- *       });
- *     },
- *   });
- * });
- * ```
- *
- * @example Using with existing baggage
- * ```typescript
- * export const processOrder = withTracing({ name: 'order.process' })((ctx) => async (order: Order) => {
- *   // Read existing baggage
- *   const tenantId = ctx.getBaggage('tenant.id');
- *
- *   // Add additional baggage entries
- *   return await withBaggage({
- *     baggage: {
- *       'order.id': order.id,
- *       'order.amount': String(order.amount),
- *     },
- *     fn: async () => {
- *       await charge(order);
- *     },
- *   });
- * });
- * ```
- */
-declare function withBaggage<T = unknown>(options: WithBaggageOptions<T>): T | Promise<T>;
-//#endregion
-export { InstrumentOptions, SingleInstrumentOptions, SpanOptions, type TraceContext, TracingOptions, WithBaggageOptions, WithNewContextOptions, ctx, getActiveTraceContext, instrument, span, trace, withBaggage, withNewContext, withTracing };
+import { a as getActiveTraceContext, c as trace, d as withTracing, f as InstrumentOptions, i as ctx, l as withBaggage, m as TracingOptions, n as WithBaggageOptions, o as instrument, p as SingleInstrumentOptions, r as WithNewContextOptions, s as span, t as SpanOptions, u as withNewContext } from "./functional-AT22vCw6.js";
+export { type InstrumentOptions, type SingleInstrumentOptions, SpanOptions, type TraceContext, type TracingOptions, WithBaggageOptions, WithNewContextOptions, ctx, getActiveTraceContext, instrument, span, trace, withBaggage, withNewContext, withTracing };

package/dist/functional.js

@@ -1,3 +1,3 @@
-import { a as trace, c as withTracing, i as span, n as getActiveTraceContext, o as withBaggage, r as instrument, s as withNewContext, t as ctx } from "./functional-DCBhFool.js";
+import { a as trace, c as withTracing, i as span, n as getActiveTraceContext, o as withBaggage, r as instrument, s as withNewContext, t as ctx } from "./functional-DbCVvGfT.js";
 
 export { ctx, getActiveTraceContext, instrument, span, trace, withBaggage, withNewContext, withTracing };

package/dist/http.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_config = require('./config.cjs');
-const require_init = require('./init-BneZ7WJ8.cjs');
+const require_init = require('./init-C5V4z7S5.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 
 //#region src/http.ts

package/dist/http.js

@@ -1,5 +1,5 @@
 import { getConfig } from "./config.js";
-import { D as getActiveContextWithBaggage } from "./init-Qn4gIW1i.js";
+import { D as getActiveContextWithBaggage } from "./init-C2fjPVkW.js";
 import { SpanStatusCode, context, propagation } from "@opentelemetry/api";
 
 //#region src/http.ts

package/dist/index.cjs

@@ -2,7 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_rolldown_runtime = require('./rolldown-runtime-C_NdSu1c.cjs');
 const require_tracer_provider = require('./tracer-provider.cjs');
 const require_sampling = require('./sampling.cjs');
-const require_init = require('./init-BneZ7WJ8.cjs');
+const require_init = require('./init-C5V4z7S5.cjs');
 const require_filtering_span_processor = require('./filtering-span-processor.cjs');
 const require_span_name_normalizer = require('./span-name-normalizer.cjs');
 const require_attribute_redacting_processor = require('./attribute-redacting-processor.cjs');
@@ -10,7 +10,7 @@ const require_canonical_log_line_processor = require('./canonical-log-line-proce
 const require_structured_error = require('./structured-error-CHg7DoIQ.cjs');
 const require_metric = require('./metric.cjs');
 const require_trace_helpers = require('./trace-helpers.cjs');
-const require_functional = require('./functional-TbnG2lu7.cjs');
+const require_functional = require('./functional-BEEhlVKD.cjs');
 const require_stable_hash = require('./stable-hash-CS9BxvVQ.cjs');
 const require_correlated_events = require('./correlated-events-kSwLo3mi.cjs');
 const require_parse_error = require('./parse-error.cjs');

package/dist/index.d.cts

@@ -4,12 +4,12 @@ import { n as TraceContext$1, r as defineBaggageSchema, t as AttributeValue$2 }
 import { BaggageError, BaggageFieldDefinition, BaggageFieldType, BusinessBaggage, BusinessBaggageValues, SafeBaggageOptions, SafeBaggageSchema, createSafeBaggageSchema } from "./business-baggage.cjs";
 import { CORRELATION_ID_BAGGAGE_KEY, generateCorrelationId, getCorrelationId, getOrCreateCorrelationId, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage } from "./correlation-id.cjs";
 import { _ as createLinkFromHeaders, a as AlwaysSampler, b as resolveSamplingPreset, f as RandomSampler, g as UserIdSampler, h as SamplingPreset, i as AdaptiveSampler, m as SamplingContext, n as AUTOTEL_SAMPLING_TAIL_EVALUATED, p as Sampler, r as AUTOTEL_SAMPLING_TAIL_KEEP, u as NeverSampler, v as extractLinksFromBatch, x as samplingPresets } from "./sampling-BR9fkSwx.cjs";
-import { InstrumentOptions, SingleInstrumentOptions, SpanOptions, WithBaggageOptions, WithNewContextOptions, ctx, getActiveTraceContext, instrument, span, trace as trace$2, withBaggage, withNewContext, withTracing } from "./functional.cjs";
+import { a as getActiveTraceContext, c as trace$2, d as withTracing, f as InstrumentOptions, i as ctx, l as withBaggage, n as WithBaggageOptions, o as instrument, p as SingleInstrumentOptions, r as WithNewContextOptions, s as span, t as SpanOptions, u as withNewContext } from "./functional-e6jw5zQj.cjs";
 import { DrainPipelineOptions, PipelineDrainFn, createDrainPipeline } from "./drain-pipeline.cjs";
 import { a as EventSubscriber, c as OutcomeStatus, i as EventSchemaMetadata, n as EventAttributes, o as EventTrackingOptions, s as FunnelStatus, t as AutotelEventContext } from "./event-subscriber-CWh8sTGh.cjs";
 import { Event, EventsOptions, getEvents, resetEvents } from "./event.cjs";
 import { n as FilteringSpanProcessorOptions, r as SpanFilterPredicate, t as FilteringSpanProcessor } from "./filtering-span-processor-BpDagWNa.cjs";
-import { a as AutotelConfig, c as StringRedactor, i as lockLogger, l as createStringRedactor, n as isInitialized, r as isLoggerLocked, s as ProcessHandlersConfig, t as init } from "./init-CfVWN4ND.cjs";
+import { a as AutotelConfig, c as StringRedactor, i as lockLogger, l as createStringRedactor, n as isInitialized, r as isLoggerLocked, s as ProcessHandlersConfig, t as init } from "./init-Cc7-vvzj.cjs";
 import { a as SpanNameNormalizerPreset, i as SpanNameNormalizerFn, n as NORMALIZER_PRESETS, o as SpanNameNormalizingProcessor, r as SpanNameNormalizerConfig, s as SpanNameNormalizingProcessorOptions, t as NORMALIZER_PATTERNS } from "./span-name-normalizer-CN1-8C76.cjs";
 import "./canonical-log-line-processor-B4WgG-VS.cjs";
 import { i as defineEvent, n as DefinedEvent, r as SchemaLike, t as DefineEventOptions } from "./define-event-CGG048HE.cjs";

package/dist/index.d.ts

@@ -4,12 +4,12 @@ import { n as TraceContext$1, r as defineBaggageSchema, t as AttributeValue$2 }
 import { BaggageError, BaggageFieldDefinition, BaggageFieldType, BusinessBaggage, BusinessBaggageValues, SafeBaggageOptions, SafeBaggageSchema, createSafeBaggageSchema } from "./business-baggage.js";
 import { CORRELATION_ID_BAGGAGE_KEY, generateCorrelationId, getCorrelationId, getOrCreateCorrelationId, runWithCorrelationId, setCorrelationId, setCorrelationIdInBaggage } from "./correlation-id.js";
 import { _ as createLinkFromHeaders, a as AlwaysSampler, b as resolveSamplingPreset, f as RandomSampler, g as UserIdSampler, h as SamplingPreset, i as AdaptiveSampler, m as SamplingContext, n as AUTOTEL_SAMPLING_TAIL_EVALUATED, p as Sampler, r as AUTOTEL_SAMPLING_TAIL_KEEP, u as NeverSampler, v as extractLinksFromBatch, x as samplingPresets } from "./sampling-CP3e7-Yr.js";
-import { InstrumentOptions, SingleInstrumentOptions, SpanOptions, WithBaggageOptions, WithNewContextOptions, ctx, getActiveTraceContext, instrument, span, trace as trace$2, withBaggage, withNewContext, withTracing } from "./functional.js";
+import { a as getActiveTraceContext, c as trace$2, d as withTracing, f as InstrumentOptions, i as ctx, l as withBaggage, n as WithBaggageOptions, o as instrument, p as SingleInstrumentOptions, r as WithNewContextOptions, s as span, t as SpanOptions, u as withNewContext } from "./functional-AT22vCw6.js";
 import { DrainPipelineOptions, PipelineDrainFn, createDrainPipeline } from "./drain-pipeline.js";
 import { a as EventSubscriber, c as OutcomeStatus, i as EventSchemaMetadata, n as EventAttributes, o as EventTrackingOptions, s as FunnelStatus, t as AutotelEventContext } from "./event-subscriber-CWh8sTGh.js";
 import { Event, EventsOptions, getEvents, resetEvents } from "./event.js";
 import { n as FilteringSpanProcessorOptions, r as SpanFilterPredicate, t as FilteringSpanProcessor } from "./filtering-span-processor-BpDagWNa.js";
-import { a as AutotelConfig, c as StringRedactor, i as lockLogger, l as createStringRedactor, n as isInitialized, r as isLoggerLocked, s as ProcessHandlersConfig, t as init } from "./init-C1i2_2zl.js";
+import { a as AutotelConfig, c as StringRedactor, i as lockLogger, l as createStringRedactor, n as isInitialized, r as isLoggerLocked, s as ProcessHandlersConfig, t as init } from "./init-CsODvlau.js";
 import { a as SpanNameNormalizerPreset, i as SpanNameNormalizerFn, n as NORMALIZER_PRESETS, o as SpanNameNormalizingProcessor, r as SpanNameNormalizerConfig, s as SpanNameNormalizingProcessorOptions, t as NORMALIZER_PATTERNS } from "./span-name-normalizer-CN1-8C76.js";
 import "./canonical-log-line-processor-CL_J7gb5.js";
 import { i as defineEvent, n as DefinedEvent, r as SchemaLike, t as DefineEventOptions } from "./define-event-B2z1SBe7.js";

package/dist/index.js

@@ -1,6 +1,6 @@
 import { getAutotelTracer, getAutotelTracerProvider, setAutotelTracerProvider } from "./tracer-provider.js";
 import { AUTOTEL_SAMPLING_TAIL_EVALUATED, AUTOTEL_SAMPLING_TAIL_KEEP, AdaptiveSampler, AlwaysSampler, NeverSampler, RandomSampler, UserIdSampler, createLinkFromHeaders, extractLinksFromBatch, resolveSamplingPreset, samplingPresets } from "./sampling.js";
-import { A as BaggageSpanProcessor, C as setCorrelationId, E as defineBaggageSchema, S as runWithCorrelationId, T as createTraceContext, _ as CORRELATION_ID_BAGGAGE_KEY, a as isInitialized, c as flush, d as getEvents, f as resetEvents, g as track, h as getEventQueue, i as init, k as createStringRedactor, l as shutdown, m as runInOperationContext, o as isLoggerLocked, p as getOperationContext, s as lockLogger, u as Event, v as generateCorrelationId, w as setCorrelationIdInBaggage, x as getOrCreateCorrelationId, y as getCorrelationId } from "./init-Qn4gIW1i.js";
+import { A as BaggageSpanProcessor, C as setCorrelationId, E as defineBaggageSchema, S as runWithCorrelationId, T as createTraceContext, _ as CORRELATION_ID_BAGGAGE_KEY, a as isInitialized, c as flush, d as getEvents, f as resetEvents, g as track, h as getEventQueue, i as init, k as createStringRedactor, l as shutdown, m as runInOperationContext, o as isLoggerLocked, p as getOperationContext, s as lockLogger, u as Event, v as generateCorrelationId, w as setCorrelationIdInBaggage, x as getOrCreateCorrelationId, y as getCorrelationId } from "./init-C2fjPVkW.js";
 import { FilteringSpanProcessor } from "./filtering-span-processor.js";
 import { NORMALIZER_PATTERNS, NORMALIZER_PRESETS, SpanNameNormalizingProcessor } from "./span-name-normalizer.js";
 import { AttributeRedactingProcessor, REDACTOR_PATTERNS, REDACTOR_PRESETS, builtinPatterns, createAttributeRedactor, createRedactedSpan, normalizeAttributeRedactorConfig } from "./attribute-redacting-processor.js";
@@ -8,7 +8,7 @@ import { n as formatDuration } from "./canonical-log-line-processor-mKABvGP0.js"
 import { a as flattenToAttributes, i as structuredErrorToJSON, n as getStructuredErrorAttributes, o as toAttributeValue, r as recordStructuredError, t as createStructuredError } from "./structured-error-9--cxBay.js";
 import { Metric, getMetrics, resetMetrics } from "./metric.js";
 import { createDeterministicTraceId, enrichWithTraceContext, finalizeSpan, flattenMetadata, getActiveContext, getActiveSpan, getTraceContext, getTracer, isTracing, resolveTraceUrl, runWithSpan } from "./trace-helpers.js";
-import { a as trace$2, c as withTracing, i as span, n as getActiveTraceContext, o as withBaggage, r as instrument, s as withNewContext, t as ctx } from "./functional-DCBhFool.js";
+import { a as trace$2, c as withTracing, i as span, n as getActiveTraceContext, o as withBaggage, r as instrument, s as withNewContext, t as ctx } from "./functional-DbCVvGfT.js";
 import { t as hashJson } from "./stable-hash-ChFBIhNt.js";
 import { t as emitCorrelatedEvent } from "./correlated-events-Bzh5y-UB.js";
 import { parseError } from "./parse-error.js";

package/dist/{init-Qn4gIW1i.js → init-C2fjPVkW.js}

@@ -4,6 +4,7 @@ import { AUTOTEL_SAMPLING_RATE, resolveSamplingPreset, samplingPresets } from ".
 import { n as safeRequire, t as requireModule } from "./node-require-vROmTeJ8.js";
 import { TailSamplingSpanProcessor } from "./tail-sampling-processor.js";
 import { FilteringSpanProcessor } from "./filtering-span-processor.js";
+import { PolicyLogRecordProcessor, policySpanFilter, setPolicies, watchPolicyFile } from "./policy.js";
 import { SpanNameNormalizingProcessor } from "./span-name-normalizer.js";
 import { AttributeRedactingProcessor, REDACTOR_PRESETS, normalizeAttributeRedactorConfig } from "./attribute-redacting-processor.js";
 import { t as PrettyConsoleExporter } from "./pretty-console-exporter-DqKl_q9z.js";
@@ -544,11 +545,15 @@ function getContextStorage() {
 	return contextStorage;
 }
 /**
-* Get the active context, checking our stored context first
-* This ensures baggage setters work with OpenTelemetry's propagation
+* Get the active OTel context with the latest stored baggage overlaid.
+* Span identity always comes from the active OTel scope.
 */
 function getActiveContextWithBaggage() {
-	return contextStorage.getStore()?.value ?? context.active();
+	const activeContext = context.active();
+	const stored = contextStorage.getStore()?.value;
+	if (!stored) return activeContext;
+	const storedBaggage = propagation.getBaggage(stored);
+	return storedBaggage ? propagation.setBaggage(activeContext, storedBaggage) : activeContext;
 }
 /**
 * Set a value in AsyncLocalStorage, preferring enterWith() when available
@@ -628,15 +633,13 @@ function createTraceContext(span) {
 			return baggage?.getEntry(key)?.value;
 		},
 		setBaggage(key, value) {
-			const activeCtx = context.active();
-			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const currentContext = getActiveContextWithBaggage();
 			const updated = (propagation.getBaggage(currentContext) ?? propagation.createBaggage()).setEntry(key, { value });
 			updateActiveContext(propagation.setBaggage(currentContext, updated));
 			return value;
 		},
 		deleteBaggage(key) {
-			const activeCtx = context.active();
-			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const currentContext = getActiveContextWithBaggage();
 			const baggage = propagation.getBaggage(currentContext);
 			if (baggage) {
 				const updated = baggage.removeEntry(key);
@@ -672,8 +675,7 @@ function createTraceContext(span) {
 			return Object.keys(result).length > 0 ? result : void 0;
 		}),
 		setTypedBaggage: ((namespace, value) => {
-			const activeCtx = context.active();
-			const currentContext = contextStorage.getStore()?.value ?? activeCtx;
+			const currentContext = getActiveContextWithBaggage();
 			let baggage = propagation.getBaggage(currentContext) ?? propagation.createBaggage();
 			const prefix = namespace ? `${namespace}.` : "";
 			for (const [key, val] of Object.entries(value)) if (val !== void 0) {
@@ -3177,6 +3179,12 @@ function init(cfg) {
 		for (const subscriber of mergedConfig.subscribers) if (acceptsStringRedactor(subscriber)) subscriber.setStringRedactor(_stringRedactor);
 	}
 	if (mergedConfig.spanNameNormalizer && spanProcessors.length > 0) spanProcessors = spanProcessors.map((processor) => new SpanNameNormalizingProcessor(processor, { normalizer: mergedConfig.spanNameNormalizer }));
+	if (mergedConfig.policies) {
+		if (typeof mergedConfig.policies === "string") watchPolicyFile(mergedConfig.policies);
+		else setPolicies(mergedConfig.policies);
+		const userSpanFilter = mergedConfig.spanFilter;
+		mergedConfig.spanFilter = userSpanFilter ? (span) => userSpanFilter(span) && policySpanFilter(span) : policySpanFilter;
+	}
 	if (mergedConfig.spanFilter && spanProcessors.length > 0) spanProcessors = spanProcessors.map((processor) => new FilteringSpanProcessor(processor, { filter: mergedConfig.spanFilter }));
 	const metricReaders = [];
 	if (configuredMetricReaders && configuredMetricReaders.length > 0) metricReaders.push(...configuredMetricReaders);
@@ -3215,6 +3223,7 @@ function init(cfg) {
 		logRecordProcessors.push(...posthogProcessors);
 		logger.info({}, "[autotel] PostHog OTLP logs configured");
 	}
+	if (mergedConfig.policies && logRecordProcessors) logRecordProcessors = logRecordProcessors.map((processor) => new PolicyLogRecordProcessor(processor));
 	let finalInstrumentations = mergedConfig.instrumentations ? [...mergedConfig.instrumentations] : [];
 	if (mergedConfig.autoInstrumentations !== void 0 && mergedConfig.autoInstrumentations !== false) {
 		if (isESMMode()) logger.info({}, "[autotel] ESM mode detected. For auto-instrumentation to work:\n  1. Install @opentelemetry/auto-instrumentations-node as a direct dependency\n  2. Import autotel/register FIRST in your instrumentation file\n  3. Use getNodeAutoInstrumentations() directly instead of autoInstrumentations\n  See: https://github.com/jagreehal/autotel#esm-setup");