autotel 4.3.0 → 5.0.0

package/dist/functional.d.ts

@@ -1,37 +1,8 @@
-import { n as TraceContext } from "./trace-context-Cijqoi6e.js";
-import { u as Sampler } from "./sampling-CR0Va1VB.js";
+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
-/**
- * Helper type to extract function signature from factory pattern
- * This helps TypeScript infer types correctly for factory functions
- */
-type ExtractFunctionSignature<T> = T extends ((ctx: TraceContext) => infer F) ? F extends ((...args: infer Args) => infer Return) ? (...args: Args) => Return : never : never;
-/**
- * Helper type to exclude functions that return functions from immediate execution overloads
- */
-type ExcludeFactoryReturn<T> = T extends ((ctx: TraceContext) => infer F) ? F extends ((...args: any[]) => any) ? never : T : T;
-/**
- * Mark a function as immediate-execution-with-ctx so `trace(name, fn)`
- * dispatch doesn't depend on the first parameter being named `ctx`.
- *
- * Necessary when the function will be bundled by a minifier (esbuild,
- * terser, etc.) that renames identifiers. The name-allowlist heuristic in
- * `looksLikeTraceFactory` cannot recover from that; the marker can.
- *
- * @example
- * ```ts
- * import { markAsImmediate, trace } from 'autotel';
- *
- * const inner = markAsImmediate(async (ctx) => {
- *   ctx.setAttribute('user.id', '123');
- *   return { ok: true };
- * });
- * const result = await trace('user.read', inner);
- * ```
- */
-declare function markAsImmediate<F>(fn: F): F;
+type WrappedFunction<TArgs extends unknown[], TReturn> = (...args: TArgs) => TReturn | Promise<TReturn>;
 /**
  * Common options for functional tracing
  */
@@ -95,12 +66,21 @@ interface TracingOptions<TArgs extends unknown[] = unknown[], TReturn = unknown>
    * @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, InstrumentableFunction> = Record<string, InstrumentableFunction>> extends TracingOptions {
-  /** Functions to instrument */
+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
@@ -117,10 +97,47 @@ interface InstrumentOptions<T extends Record<string, InstrumentableFunction> = R
    */
   skip?: (string | RegExp | ((key: string, fn: Function) => boolean))[];
 }
-type InstrumentableFunction<TArgs extends unknown[] = unknown[], TReturn = unknown> = ((...args: TArgs) => TReturn | Promise<TReturn>) & {
+/**
+ * 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
  *
@@ -139,16 +156,14 @@ type InstrumentableFunction<TArgs extends unknown[] = unknown[], TReturn = unkno
  * })
  * ```
  */
-declare const ctx: {};
+declare const ctx: TraceContext;
 /**
  * Approach 1: trace() - Zero-ceremony HOF
  *
- * Wrap a single function with automatic tracing.
- * The function receives a context object as the first parameter.
- *
- * Supports two patterns:
- * 1. **Factory pattern** - Returns a traced function: `trace(ctx => (...args) => result)`
- * 2. **Immediate execution** - Executes immediately with tracing: `trace(ctx => result)`
+ * 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
@@ -158,25 +173,12 @@ declare const ctx: {};
  * // → Traced as "createUser"
  * ```
  *
- * @example Auto-inferred name - Factory pattern (with ctx access)
+ * @example Ambient context access
  * ```typescript
- * export const createUser = trace(ctx => async (data) => {
- *   ctx.setAttribute('user.id', data.id)
+ * export const createUser = trace(async (data) => {
+ *   getActiveTraceContext()?.setAttribute('user.id', data.id)
  *   return await db.users.create(data)
  * })
- * // → Traced as "createUser", returns wrapped function
- * ```
- *
- * @example Immediate execution - Execute once with tracing
- * ```typescript
- * // Wraps an existing function and executes immediately
- * function timed<T>(fn: () => Promise<T>): Promise<T> {
- *   return trace(async (ctx) => {
- *     ctx.setAttribute('operation', 'timed')
- *     return await fn()
- *   })
- * }
- * // → Executes immediately, returns result directly
  * ```
  *
  * @example Custom name - Plain function
@@ -187,22 +189,12 @@ declare const ctx: {};
  * // → Traced as "user.create"
  * ```
  *
- * @example Custom name - Factory pattern
+ * @example Explicit factory context with withTracing()
  * ```typescript
- * export const createUser = trace('user.create', ctx => async (data) => {
+ * export const createUser = withTracing({ name: 'user.create' })((ctx) => async (data) => {
  *   ctx.setAttribute('user.id', data.id)
  *   return await db.users.create(data)
  * })
- * // → Traced as "user.create"
- * ```
- *
- * @example Custom name - Immediate execution
- * ```typescript
- * const result = trace('fetch.user', async (ctx) => {
- *   ctx.setAttribute('userId', '123')
- *   return await fetchUser('123')
- * })
- * // → Executes immediately with span name "fetch.user"
  * ```
  *
  * @example Full options - Plain function
@@ -216,56 +208,10 @@ declare const ctx: {};
  * })
  * ```
  *
- * @example Full options - Factory pattern
- * ```typescript
- * export const createUser = trace({
- *   name: 'user.create',
- *   sampler: new AdaptiveSampler(),
- *   withMetrics: true
- * }, ctx => async (data) => {
- *   ctx.setAttribute('user.id', data.id)
- *   return await db.users.create(data)
- * })
- * ```
  */
-declare function trace<TBaggage extends Record<string, unknown> | undefined = undefined, TReturn = unknown>(fn: (ctx: TraceContext<TBaggage>) => TReturn): TReturn;
-declare function trace<TBaggage extends Record<string, unknown> | undefined = undefined>(fnFactory: (ctx: TraceContext<TBaggage>) => () => unknown): () => unknown;
-declare function trace<TBaggage extends Record<string, unknown> | undefined = undefined, TArgs extends unknown[] = unknown[], TReturn = unknown>(fnFactory: (ctx: TraceContext<TBaggage>) => (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-declare function trace<TReturn = unknown>(fnFactory: (ctx: TraceContext) => () => TReturn): () => TReturn;
-declare function trace<TFactory extends (ctx: TraceContext) => (...args: unknown[]) => unknown>(fnFactory: TFactory): ExtractFunctionSignature<TFactory>;
-declare function trace<TArgs extends unknown[], TReturn = unknown>(fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-declare function trace<TReturn = unknown>(fn: () => TReturn): () => TReturn;
-declare function trace<TArgs extends unknown[], TReturn = unknown>(fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-declare function trace<TReturn = unknown>(name: string, fn: ExcludeFactoryReturn<(ctx: TraceContext) => TReturn>): TReturn;
-declare function trace<TReturn = unknown>(name: string, fnFactory: (ctx: TraceContext) => () => TReturn): () => TReturn;
-declare function trace<TArgs extends unknown[], TReturn>(name: string, fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-declare function trace<TFactory extends (ctx: TraceContext) => (...args: unknown[]) => unknown>(name: string, fnFactory: TFactory): ExtractFunctionSignature<TFactory>;
-declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(name: string, fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(name: string, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-declare function trace<TReturn = unknown>(options: TracingOptions<[], TReturn>, fn: (ctx: TraceContext) => TReturn): TReturn;
-declare function trace<TReturn = unknown>(options: TracingOptions<[], TReturn>, fnFactory: (ctx: TraceContext) => () => TReturn): () => TReturn;
-declare function trace<TArgs extends unknown[], TReturn>(options: TracingOptions<TArgs, TReturn>, fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(options: TracingOptions<TArgs, TReturn>, fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(options: TracingOptions<TArgs, TReturn>, fn: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
-declare function trace<TReturn = unknown>(fn: (ctx: TraceContext) => Promise<TReturn>): Promise<TReturn>;
-declare function trace(fnFactory: (ctx: TraceContext) => () => Promise<unknown>): () => Promise<unknown>;
-declare function trace<TArgs extends unknown[], TReturn>(fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
-declare function trace<TReturn = unknown>(fnFactory: (ctx: TraceContext) => () => Promise<TReturn>): () => Promise<TReturn>;
-declare function trace<TFactory extends (ctx: TraceContext) => (...args: unknown[]) => Promise<unknown>>(fnFactory: TFactory): ExtractFunctionSignature<TFactory>;
-declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
-declare function trace<TReturn = unknown>(fn: () => Promise<TReturn>): () => Promise<TReturn>;
-declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(fn: (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
-declare function trace<TReturn = unknown>(name: string, fn: ExcludeFactoryReturn<(ctx: TraceContext) => Promise<TReturn>>): Promise<TReturn>;
-declare function trace<TReturn = unknown>(name: string, fnFactory: (ctx: TraceContext) => () => Promise<TReturn>): () => Promise<TReturn>;
-declare function trace<TArgs extends unknown[], TReturn>(name: string, fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
-declare function trace<TFactory extends (ctx: TraceContext) => (...args: unknown[]) => Promise<unknown>>(name: string, fnFactory: TFactory): ExtractFunctionSignature<TFactory>;
-declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(name: string, fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
-declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(name: string, fn: (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
-declare function trace<TReturn = unknown>(options: TracingOptions<[], TReturn>, fn: (ctx: TraceContext) => Promise<TReturn>): Promise<TReturn>;
-declare function trace<TReturn = unknown>(options: TracingOptions<[], TReturn>, fnFactory: (ctx: TraceContext) => () => Promise<TReturn>): () => Promise<TReturn>;
-declare function trace<TArgs extends unknown[], TReturn>(options: TracingOptions<TArgs, TReturn>, fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
-declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(options: TracingOptions<TArgs, TReturn>, fnFactory: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
-declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(options: TracingOptions<TArgs, TReturn>, fn: (...args: TArgs) => Promise<TReturn>): (...args: TArgs) => Promise<TReturn>;
+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
  *
@@ -284,10 +230,10 @@ declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(o
  *
  * @example Composable
  * ```typescript
- * const trace = withTracing({ serviceName: 'user' })
+ * const tracer = withTracing({ serviceName: 'user' })
  *
- * export const createUser = trace(ctx => async (data) => { })
- * export const updateUser = trace(ctx => async (id, data) => { })
+ * export const createUser = tracer(ctx => async (data) => { })
+ * export const updateUser = tracer(ctx => async (id, data) => { })
  * ```
  *
  * @example With other middleware
@@ -299,7 +245,7 @@ declare function trace<TArgs extends unknown[] = unknown[], TReturn = unknown>(o
  * )(ctx => async (data) => { })
  * ```
  */
-declare function withTracing<TArgs extends unknown[] = unknown[], TReturn = unknown>(options?: TracingOptions<TArgs, TReturn>): (fnFactory: (ctx: TraceContext) => (...args: TArgs) => TReturn | Promise<TReturn>) => (...args: TArgs) => TReturn | Promise<TReturn>;
+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
  *
@@ -350,7 +296,8 @@ declare function withTracing<TArgs extends unknown[] = unknown[], TReturn = unkn
  * })
  * ```
  */
-declare function instrument<T extends Record<string, InstrumentableFunction>>(options: InstrumentOptions<T>): T;
+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
  */
@@ -359,6 +306,8 @@ interface SpanOptions {
   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
@@ -413,9 +362,9 @@ interface WithNewContextOptions<T = unknown> {
  *   // This creates a new root trace, not connected to the HTTP request trace
  *   await withNewContext({
  *     fn: async () => {
- *       await trace(ctx => async () => {
+ *       await span('webhook.process', async () => {
  *         await processWebhookPayload(payload)
- *       })()
+ *       })
  *     }
  *   })
  * }
@@ -440,9 +389,9 @@ interface WithBaggageOptions<T = unknown> {
  *
  * @example Setting baggage for downstream services
  * ```typescript
- * import { trace, withBaggage } from 'autotel';
+ * import { withTracing, withBaggage } from 'autotel';
  *
- * export const createOrder = trace((ctx) => async (order: Order) => {
+ * 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: {
@@ -462,7 +411,7 @@ interface WithBaggageOptions<T = unknown> {
  *
  * @example Using with existing baggage
  * ```typescript
- * export const processOrder = trace((ctx) => async (order: Order) => {
+ * export const processOrder = withTracing({ name: 'order.process' })((ctx) => async (order: Order) => {
  *   // Read existing baggage
  *   const tenantId = ctx.getBaggage('tenant.id');
  *
@@ -481,5 +430,5 @@ interface WithBaggageOptions<T = unknown> {
  */
 declare function withBaggage<T = unknown>(options: WithBaggageOptions<T>): T | Promise<T>;
 //#endregion
-export { InstrumentOptions, SpanOptions, type TraceContext, TracingOptions, WithBaggageOptions, WithNewContextOptions, ctx, instrument, markAsImmediate, span, trace, withBaggage, withNewContext, withTracing };
+export { InstrumentOptions, SingleInstrumentOptions, SpanOptions, type TraceContext, TracingOptions, WithBaggageOptions, WithNewContextOptions, ctx, getActiveTraceContext, instrument, span, trace, withBaggage, withNewContext, withTracing };
 //# sourceMappingURL=functional.d.ts.map

package/dist/functional.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functional.d.ts","names":[],"sources":["../src/functional.ts"],"mappings":"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"}
+{"version":3,"file":"functional.d.ts","names":[],"sources":["../src/functional.ts"],"mappings":";;;;KAgGK,gBAAgB,yBAAyB,eACzC,MAAM,UACN,UAAU,QAAQ;;;;UA+DN,eACf,qCACA;;;;;EAMA;;;;;EAMA;;;;;EAMA,UAAU;;;;;EAMV;;;;EAKA,sBAAsB,MAAM,UAAU;;;;EAKtC,wBAAwB,QAAQ,YAAY;;;;;;;;EAS5C;;;;;EAMA;;;;;;EAOA;;;;;;EAOA;;;;;;EAOA,wCAAwC;;;;;;;;;EAUxC,WAAW;;;;;UAMI,kBACf,UAAU,eAAe,qBAAqB,eAE5C,4BAEM;;EAER,WAAW;;;;EAIX,YAAY,eAAe,QAAQ;;;;;;;;;;EAYnC,iBAAiB,WAAW,aAAa,IAAI;;;;;UAM9B,wBACf,kBAAkB,oBAAoB,2BAC9B;;EAER;;EAEA,IAAI;;;;;;;;;;KAyMD,yBAAyB;EAC5B;EACA;;;;;;;;;;;;;;;;;;;;;iBAqJc,sBACd,iBAAiB,oDACd,aAAa;;;;;;;;;;;;;;;;;;;cAsBL,KAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyXA,MAAM,yBAAyB,SAC7C,QAAQ,MAAM,UAAU,cACnB,MAAM,UAAU;iBAEP,MAAM,yBAAyB,SAC7C,cACA,QAAQ,MAAM,UAAU,cACnB,MAAM,UAAU;iBAEP,MAAM,yBAAyB,SAC7C,SAAS,eAAe,OAAO,UAC/B,QAAQ,MAAM,UAAU,cACnB,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkEP,YACd,wCACA,sBACA,UAAS,eAAe,UAAU,eAC1B,cAAc,UAAU,gBAAgB,YAC9C,YACE,KAAK,qBACE,MAAM,UAAU,UAAU,QAAQ,aAC1C,gBAAgB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsDZ,WAAW,kBAAkB,mBAC3C,SAAS,wBAAwB,aAChC;iBACa,WAAW,UAAU,eAAe,oBAClD,SAAS,kBAAkB,KAC1B;;;;UAuFc;;EAEf;;EAEA,aAAa;;EAEb,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoC1B,KAAK,aAAa,cAAc,KAAK,MAAM,SAAS,IAAI;iBACxD,KAAK,aACnB,cACA,KAAK,MAAM,SAAS,QAAQ,KAC3B,QAAQ;iBACK,KAAK,aACnB,SAAS,aACT,KAAK,MAAM,SAAS,IACnB;iBACa,KAAK,aACnB,SAAS,aACT,KAAK,MAAM,SAAS,QAAQ,KAC3B,QAAQ;;;;UAmGM,sBAAsB;;EAErC,UAAU,QAAQ;;;;;;;;;;;;;;;;;;;;;;iBAuBE,eAAe,aACnC,SAAS,sBAAsB,KAC9B,QAAQ;;;;UA0BM,mBAAmB;;EAElC,SAAS;;EAET,UAAU,IAAI,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDR,YAAY,aAC1B,SAAS,mBAAmB,KAC3B,IAAI,QAAQ"}

package/dist/functional.js

@@ -1,3 +1,3 @@
-import { a as trace, c as withTracing, i as span, n as instrument, o as withBaggage, r as markAsImmediate, s as withNewContext, t as ctx } from "./functional-dAYhXQPA.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-Bit6noRu.js";
 
-export { ctx, instrument, markAsImmediate, span, trace, withBaggage, withNewContext, withTracing };
+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_track = require('./track-eovhCJ-I.cjs');
+const require_track = require('./track-BI6dmZ2X.cjs');
 let _opentelemetry_api = require("@opentelemetry/api");
 
 //#region src/http.ts
@@ -231,9 +231,9 @@ function extractStatusCode(result) {
 *
 * @example With baggage
 * ```typescript
-* import { trace, withBaggage, injectTraceContext } from 'autotel'
+* import { trace, withTracing, withBaggage, injectTraceContext } from 'autotel'
 *
-* export const createOrder = trace((ctx) => async (order: Order) => {
+* export const createOrder = withTracing({})((ctx) => async (order: Order) => {
 *   return await withBaggage({
 *     baggage: { 'tenant.id': order.tenantId },
 *     fn: async () => {
@@ -261,7 +261,7 @@ function injectTraceContext(headers = {}) {
 *
 * @example
 * ```typescript
-* import { extractTraceContext, trace } from 'autotel'
+* import { extractTraceContext, trace, withTracing } from 'autotel'
 * import { context } from 'autotel'
 *
 * // In Express middleware
@@ -275,7 +275,7 @@ function injectTraceContext(headers = {}) {
 *
 * @example In a traced function
 * ```typescript
-* export const handleWebhook = trace((ctx) => async (req: Request) => {
+* export const handleWebhook = withTracing({})((ctx) => async (req: Request) => {
 *   const extractedContext = extractTraceContext(req.headers);
 *   return await context.with(extractedContext, async () => {
 *     // Now ctx.getBaggage() will return baggage from the incoming request

package/dist/http.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"http.cjs","names":["getConfig","SpanStatusCode","getActiveContextWithBaggage","propagation","context"],"sources":["../src/http.ts"],"sourcesContent":["/**\n * HTTP Instrumentation Helpers\n *\n * Optional import: Not included in main bundle\n * Import from: 'autotel/http'\n *\n * Provides decorators and utilities for HTTP client instrumentation.\n * Works with fetch, axios, and other HTTP clients.\n *\n * @example\n * ```typescript\n * import { HttpInstrumented } from 'autotel/http'\n *\n * @HttpInstrumented()\n * class ApiClient {\n *   async getUser(id: string) {\n *     return fetch(`/api/users/${id}`)\n *   }\n * }\n * ```\n */\n\nimport { SpanStatusCode, context, propagation } from '@opentelemetry/api';\nimport { getConfig } from './config';\nimport { getActiveContextWithBaggage } from './trace-context';\n\nexport interface HttpInstrumentedOptions {\n  /** Service name for HTTP calls (default: 'http-client') */\n  serviceName?: string;\n  /** Extract URL from method arguments (default: first arg) */\n  urlExtractor?: (args: unknown[]) => string | undefined;\n  /** Extract HTTP method from method name or args */\n  methodExtractor?: (methodName: string, args: unknown[]) => string;\n  /** Add custom attributes to spans */\n  attributesFromArgs?: (args: unknown[]) => Record<string, string | number>;\n  /** Slow request threshold in milliseconds (adds warning attribute) - default: 3000ms */\n  slowRequestThresholdMs?: number;\n}\n\n/**\n * Decorator for auto-instrumenting HTTP client methods\n *\n * @example Basic usage\n * ```typescript\n * @HttpInstrumented()\n * class ApiClient {\n *   async fetchUser(userId: string) {\n *     const res = await fetch(`https://api.example.com/users/${userId}`)\n *     return res.json()\n *   }\n *\n *   async createOrder(order: Order) {\n *     const res = await fetch('https://api.example.com/orders', {\n *       method: 'POST',\n *       body: JSON.stringify(order)\n *     })\n *     return res.json()\n *   }\n * }\n * ```\n *\n * @example Advanced usage with custom extractors\n * ```typescript\n * @HttpInstrumented({\n *   serviceName: 'payment-gateway',\n *   urlExtractor: (args) => {\n *     const config = args[0] as RequestConfig\n *     return config.url\n *   },\n *   attributesFromArgs: (args) => ({\n *     'http.request_id': args[0]?.requestId,\n *     'http.retry_count': args[0]?.retryCount || 0\n *   })\n * })\n * class PaymentClient {\n *   async charge(config: RequestConfig) {\n *     return axios(config)\n *   }\n * }\n * ```\n */\nexport function HttpInstrumented(options: HttpInstrumentedOptions = {}) {\n  const serviceName = options.serviceName || 'http-client';\n  const slowRequestThresholdMs = options.slowRequestThresholdMs ?? 3000;\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-object-type\n  return function <T extends { new (...args: any[]): {} }>(\n    target: T,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _context: ClassDecoratorContext,\n  ) {\n    return class extends target {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      constructor(...args: any[]) {\n        super(...args);\n\n        const proto = target.prototype;\n        const methodNames = Object.getOwnPropertyNames(proto).filter(\n          (name) =>\n            name !== 'constructor' &&\n            typeof proto[name] === 'function' &&\n            !name.startsWith('_'),\n        );\n\n        for (const methodName of methodNames) {\n          const originalMethod = proto[methodName];\n\n          if (\n            originalMethod.constructor.name === 'AsyncFunction' ||\n            originalMethod.toString().startsWith('async ')\n          ) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            const wrappedMethod = async (...args: any[]) => {\n              const config = getConfig();\n              const tracer = config.tracer;\n\n              const url = options.urlExtractor\n                ? options.urlExtractor(args)\n                : (args[0] as string | undefined);\n\n              const method = options.methodExtractor\n                ? options.methodExtractor(methodName, args)\n                : inferHttpMethod(methodName);\n\n              const spanName = url\n                ? `HTTP ${method} ${extractPath(url)}`\n                : `HTTP ${method}`;\n\n              return tracer.startActiveSpan(spanName, async (span) => {\n                const startTime = performance.now();\n\n                try {\n                  span.setAttributes({\n                    'http.method': method,\n                    'http.url': url || 'unknown',\n                    'service.name': serviceName,\n                    'operation.name': `${serviceName}.${methodName}`,\n                  });\n\n                  if (url) {\n                    const urlObj = parseUrl(url);\n                    span.setAttributes({\n                      'http.scheme': urlObj.protocol,\n                      'http.host': urlObj.host,\n                      'http.target': urlObj.path,\n                    });\n                  }\n\n                  if (options.attributesFromArgs) {\n                    span.setAttributes(options.attributesFromArgs(args));\n                  }\n\n                  const result = await originalMethod.apply(this, args);\n\n                  const duration = performance.now() - startTime;\n\n                  // Extract status code from response\n                  const statusCode = extractStatusCode(result);\n                  if (statusCode) {\n                    span.setAttribute('http.status_code', statusCode);\n\n                    if (statusCode >= 400) {\n                      span.setStatus({\n                        code: SpanStatusCode.ERROR,\n                        message: `HTTP ${statusCode}`,\n                      });\n                    } else {\n                      span.setStatus({ code: SpanStatusCode.OK });\n                    }\n                  } else {\n                    span.setStatus({ code: SpanStatusCode.OK });\n                  }\n\n                  span.setAttributes({\n                    'http.duration_ms': duration,\n                  });\n\n                  // Mark slow requests for investigation\n                  if (duration > slowRequestThresholdMs) {\n                    span.setAttribute('http.slow_request', true);\n                    span.setAttribute(\n                      'http.slow_request_threshold_ms',\n                      slowRequestThresholdMs,\n                    );\n                  }\n\n                  return result;\n                } catch (error) {\n                  const duration = performance.now() - startTime;\n\n                  span.setStatus({\n                    code: SpanStatusCode.ERROR,\n                    message:\n                      error instanceof Error ? error.message : 'Unknown error',\n                  });\n\n                  span.setAttributes({\n                    'http.duration_ms': duration,\n                    'error.type':\n                      error instanceof Error\n                        ? error.constructor.name\n                        : 'Unknown',\n                    'error.message':\n                      error instanceof Error ? error.message : 'Unknown error',\n                  });\n\n                  throw error;\n                } finally {\n                  span.end();\n                }\n              });\n            };\n\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            (this as any)[methodName] = wrappedMethod;\n          }\n        }\n      }\n    };\n  };\n}\n\n/**\n * Helper: Trace a single HTTP request\n *\n * @example\n * ```typescript\n * import { traceHttpRequest } from 'autotel/http'\n *\n * const data = await traceHttpRequest(\n *   'GET /api/users',\n *   () => fetch('https://api.example.com/users')\n * )\n * ```\n */\nexport async function traceHttpRequest<T>(\n  spanName: string,\n  fn: () => Promise<T>,\n  attributes?: Record<string, string | number>,\n): Promise<T> {\n  const config = getConfig();\n  const tracer = config.tracer;\n\n  return tracer.startActiveSpan(spanName, async (span) => {\n    try {\n      if (attributes) {\n        span.setAttributes(attributes);\n      }\n\n      const result = await fn();\n      span.setStatus({ code: SpanStatusCode.OK });\n      return result;\n    } catch (error) {\n      span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: error instanceof Error ? error.message : 'Unknown error',\n      });\n      throw error;\n    } finally {\n      span.end();\n    }\n  });\n}\n\n// Helper functions\n\nfunction inferHttpMethod(methodName: string): string {\n  const lower = methodName.toLowerCase();\n  if (\n    lower.includes('get') ||\n    lower.includes('fetch') ||\n    lower.includes('list')\n  )\n    return 'GET';\n  if (lower.includes('post') || lower.includes('create')) return 'POST';\n  if (lower.includes('put') || lower.includes('update')) return 'PUT';\n  if (lower.includes('delete') || lower.includes('remove')) return 'DELETE';\n  if (lower.includes('patch')) return 'PATCH';\n  return 'GET'; // Default\n}\n\nfunction extractPath(url: string): string {\n  try {\n    const urlObj = new URL(url);\n    return urlObj.pathname;\n  } catch {\n    // Relative URL or invalid\n    return url.split('?')[0] || url;\n  }\n}\n\nfunction parseUrl(url: string): {\n  protocol: string;\n  host: string;\n  path: string;\n} {\n  try {\n    const urlObj = new URL(url);\n    return {\n      protocol: urlObj.protocol.replace(':', ''),\n      host: urlObj.host,\n      path: urlObj.pathname + urlObj.search,\n    };\n  } catch {\n    return {\n      protocol: 'http',\n      host: 'unknown',\n      path: url,\n    };\n  }\n}\n\nfunction extractStatusCode(result: unknown): number | undefined {\n  if (result && typeof result === 'object') {\n    // Check for Response.status (fetch API)\n    if ('status' in result && typeof result.status === 'number') {\n      return result.status;\n    }\n    // Check for statusCode (axios, node http)\n    if ('statusCode' in result && typeof result.statusCode === 'number') {\n      return result.statusCode;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Inject trace context into HTTP headers (for distributed tracing)\n *\n * This includes W3C Trace Context (traceparent, tracestate) and W3C Baggage headers.\n * Uses OpenTelemetry's propagation system for full compatibility.\n *\n * @example\n * ```typescript\n * import { injectTraceContext } from 'autotel/http'\n *\n * const headers = injectTraceContext({\n *   'Content-Type': 'application/json'\n * })\n *\n * fetch('/api/users', { headers })\n * ```\n *\n * @example With baggage\n * ```typescript\n * import { trace, withBaggage, injectTraceContext } from 'autotel'\n *\n * export const createOrder = trace((ctx) => async (order: Order) => {\n *   return await withBaggage({\n *     baggage: { 'tenant.id': order.tenantId },\n *     fn: async () => {\n *       const headers = injectTraceContext();\n *       // Headers now include 'baggage' header with tenant.id\n *       await fetch('/api/charge', { headers });\n *     },\n *   });\n * });\n * ```\n */\nexport function injectTraceContext(\n  headers: Record<string, string> = {},\n): Record<string, string> {\n  // Use getActiveContextWithBaggage to check stored context (from baggage setters)\n  // This ensures ctx.setBaggage() changes are included in injected headers\n  const currentContext = getActiveContextWithBaggage();\n\n  // Use OpenTelemetry's propagation.inject for full W3C support\n  // This includes traceparent, tracestate, and baggage headers\n  propagation.inject(currentContext, headers);\n\n  return headers;\n}\n\n/**\n * Extract trace context from HTTP headers (for distributed tracing)\n *\n * This extracts W3C Trace Context (traceparent, tracestate) and W3C Baggage headers.\n * Uses OpenTelemetry's propagation system for full compatibility.\n *\n * Returns a context that can be used with context.with() to run code\n * with the extracted trace context and baggage.\n *\n * @example\n * ```typescript\n * import { extractTraceContext, trace } from 'autotel'\n * import { context } from 'autotel'\n *\n * // In Express middleware\n * app.use((req, res, next) => {\n *   const extractedContext = extractTraceContext(req.headers);\n *   context.with(extractedContext, () => {\n *     next();\n *   });\n * });\n * ```\n *\n * @example In a traced function\n * ```typescript\n * export const handleWebhook = trace((ctx) => async (req: Request) => {\n *   const extractedContext = extractTraceContext(req.headers);\n *   return await context.with(extractedContext, async () => {\n *     // Now ctx.getBaggage() will return baggage from the incoming request\n *     const tenantId = ctx.getBaggage('tenant.id');\n *     await processWebhook(req.body);\n *   });\n * });\n * ```\n */\nexport function extractTraceContext(\n  headers: Record<string, string | string[] | undefined>,\n): ReturnType<typeof context.active> {\n  const carrier: Record<string, string> = {};\n\n  // Convert headers to flat string format expected by propagation\n  for (const [key, value] of Object.entries(headers)) {\n    if (value !== undefined) {\n      carrier[key] = Array.isArray(value) ? (value[0] ?? '') : value;\n    }\n  }\n\n  // Extract context using OpenTelemetry's propagation system\n  // Returns a Context that can be used with context.with()\n  return propagation.extract(context.active(), carrier);\n}\n"],"mappings":"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"}
+{"version":3,"file":"http.cjs","names":["getConfig","SpanStatusCode","getActiveContextWithBaggage","propagation","context"],"sources":["../src/http.ts"],"sourcesContent":["/**\n * HTTP Instrumentation Helpers\n *\n * Optional import: Not included in main bundle\n * Import from: 'autotel/http'\n *\n * Provides decorators and utilities for HTTP client instrumentation.\n * Works with fetch, axios, and other HTTP clients.\n *\n * @example\n * ```typescript\n * import { HttpInstrumented } from 'autotel/http'\n *\n * @HttpInstrumented()\n * class ApiClient {\n *   async getUser(id: string) {\n *     return fetch(`/api/users/${id}`)\n *   }\n * }\n * ```\n */\n\nimport { SpanStatusCode, context, propagation } from '@opentelemetry/api';\nimport { getConfig } from './config';\nimport { getActiveContextWithBaggage } from './trace-context';\n\nexport interface HttpInstrumentedOptions {\n  /** Service name for HTTP calls (default: 'http-client') */\n  serviceName?: string;\n  /** Extract URL from method arguments (default: first arg) */\n  urlExtractor?: (args: unknown[]) => string | undefined;\n  /** Extract HTTP method from method name or args */\n  methodExtractor?: (methodName: string, args: unknown[]) => string;\n  /** Add custom attributes to spans */\n  attributesFromArgs?: (args: unknown[]) => Record<string, string | number>;\n  /** Slow request threshold in milliseconds (adds warning attribute) - default: 3000ms */\n  slowRequestThresholdMs?: number;\n}\n\n/**\n * Decorator for auto-instrumenting HTTP client methods\n *\n * @example Basic usage\n * ```typescript\n * @HttpInstrumented()\n * class ApiClient {\n *   async fetchUser(userId: string) {\n *     const res = await fetch(`https://api.example.com/users/${userId}`)\n *     return res.json()\n *   }\n *\n *   async createOrder(order: Order) {\n *     const res = await fetch('https://api.example.com/orders', {\n *       method: 'POST',\n *       body: JSON.stringify(order)\n *     })\n *     return res.json()\n *   }\n * }\n * ```\n *\n * @example Advanced usage with custom extractors\n * ```typescript\n * @HttpInstrumented({\n *   serviceName: 'payment-gateway',\n *   urlExtractor: (args) => {\n *     const config = args[0] as RequestConfig\n *     return config.url\n *   },\n *   attributesFromArgs: (args) => ({\n *     'http.request_id': args[0]?.requestId,\n *     'http.retry_count': args[0]?.retryCount || 0\n *   })\n * })\n * class PaymentClient {\n *   async charge(config: RequestConfig) {\n *     return axios(config)\n *   }\n * }\n * ```\n */\nexport function HttpInstrumented(options: HttpInstrumentedOptions = {}) {\n  const serviceName = options.serviceName || 'http-client';\n  const slowRequestThresholdMs = options.slowRequestThresholdMs ?? 3000;\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-object-type\n  return function <T extends { new (...args: any[]): {} }>(\n    target: T,\n    _context: ClassDecoratorContext,\n  ) {\n    return class extends target {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      constructor(...args: any[]) {\n        super(...args);\n\n        const proto = target.prototype;\n        const methodNames = Object.getOwnPropertyNames(proto).filter(\n          (name) =>\n            name !== 'constructor' &&\n            typeof proto[name] === 'function' &&\n            !name.startsWith('_'),\n        );\n\n        for (const methodName of methodNames) {\n          const originalMethod = proto[methodName];\n\n          if (\n            originalMethod.constructor.name === 'AsyncFunction' ||\n            originalMethod.toString().startsWith('async ')\n          ) {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            const wrappedMethod = async (...args: any[]) => {\n              const config = getConfig();\n              const tracer = config.tracer;\n\n              const url = options.urlExtractor\n                ? options.urlExtractor(args)\n                : (args[0] as string | undefined);\n\n              const method = options.methodExtractor\n                ? options.methodExtractor(methodName, args)\n                : inferHttpMethod(methodName);\n\n              const spanName = url\n                ? `HTTP ${method} ${extractPath(url)}`\n                : `HTTP ${method}`;\n\n              return tracer.startActiveSpan(spanName, async (span) => {\n                const startTime = performance.now();\n\n                try {\n                  span.setAttributes({\n                    'http.method': method,\n                    'http.url': url || 'unknown',\n                    'service.name': serviceName,\n                    'operation.name': `${serviceName}.${methodName}`,\n                  });\n\n                  if (url) {\n                    const urlObj = parseUrl(url);\n                    span.setAttributes({\n                      'http.scheme': urlObj.protocol,\n                      'http.host': urlObj.host,\n                      'http.target': urlObj.path,\n                    });\n                  }\n\n                  if (options.attributesFromArgs) {\n                    span.setAttributes(options.attributesFromArgs(args));\n                  }\n\n                  const result = await originalMethod.apply(this, args);\n\n                  const duration = performance.now() - startTime;\n\n                  // Extract status code from response\n                  const statusCode = extractStatusCode(result);\n                  if (statusCode) {\n                    span.setAttribute('http.status_code', statusCode);\n\n                    if (statusCode >= 400) {\n                      span.setStatus({\n                        code: SpanStatusCode.ERROR,\n                        message: `HTTP ${statusCode}`,\n                      });\n                    } else {\n                      span.setStatus({ code: SpanStatusCode.OK });\n                    }\n                  } else {\n                    span.setStatus({ code: SpanStatusCode.OK });\n                  }\n\n                  span.setAttributes({\n                    'http.duration_ms': duration,\n                  });\n\n                  // Mark slow requests for investigation\n                  if (duration > slowRequestThresholdMs) {\n                    span.setAttribute('http.slow_request', true);\n                    span.setAttribute(\n                      'http.slow_request_threshold_ms',\n                      slowRequestThresholdMs,\n                    );\n                  }\n\n                  return result;\n                } catch (error) {\n                  const duration = performance.now() - startTime;\n\n                  span.setStatus({\n                    code: SpanStatusCode.ERROR,\n                    message:\n                      error instanceof Error ? error.message : 'Unknown error',\n                  });\n\n                  span.setAttributes({\n                    'http.duration_ms': duration,\n                    'error.type':\n                      error instanceof Error\n                        ? error.constructor.name\n                        : 'Unknown',\n                    'error.message':\n                      error instanceof Error ? error.message : 'Unknown error',\n                  });\n\n                  throw error;\n                } finally {\n                  span.end();\n                }\n              });\n            };\n\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            (this as any)[methodName] = wrappedMethod;\n          }\n        }\n      }\n    };\n  };\n}\n\n/**\n * Helper: Trace a single HTTP request\n *\n * @example\n * ```typescript\n * import { traceHttpRequest } from 'autotel/http'\n *\n * const data = await traceHttpRequest(\n *   'GET /api/users',\n *   () => fetch('https://api.example.com/users')\n * )\n * ```\n */\nexport async function traceHttpRequest<T>(\n  spanName: string,\n  fn: () => Promise<T>,\n  attributes?: Record<string, string | number>,\n): Promise<T> {\n  const config = getConfig();\n  const tracer = config.tracer;\n\n  return tracer.startActiveSpan(spanName, async (span) => {\n    try {\n      if (attributes) {\n        span.setAttributes(attributes);\n      }\n\n      const result = await fn();\n      span.setStatus({ code: SpanStatusCode.OK });\n      return result;\n    } catch (error) {\n      span.setStatus({\n        code: SpanStatusCode.ERROR,\n        message: error instanceof Error ? error.message : 'Unknown error',\n      });\n      throw error;\n    } finally {\n      span.end();\n    }\n  });\n}\n\n// Helper functions\n\nfunction inferHttpMethod(methodName: string): string {\n  const lower = methodName.toLowerCase();\n  if (\n    lower.includes('get') ||\n    lower.includes('fetch') ||\n    lower.includes('list')\n  )\n    return 'GET';\n  if (lower.includes('post') || lower.includes('create')) return 'POST';\n  if (lower.includes('put') || lower.includes('update')) return 'PUT';\n  if (lower.includes('delete') || lower.includes('remove')) return 'DELETE';\n  if (lower.includes('patch')) return 'PATCH';\n  return 'GET'; // Default\n}\n\nfunction extractPath(url: string): string {\n  try {\n    const urlObj = new URL(url);\n    return urlObj.pathname;\n  } catch {\n    // Relative URL or invalid\n    return url.split('?')[0] || url;\n  }\n}\n\nfunction parseUrl(url: string): {\n  protocol: string;\n  host: string;\n  path: string;\n} {\n  try {\n    const urlObj = new URL(url);\n    return {\n      protocol: urlObj.protocol.replace(':', ''),\n      host: urlObj.host,\n      path: urlObj.pathname + urlObj.search,\n    };\n  } catch {\n    return {\n      protocol: 'http',\n      host: 'unknown',\n      path: url,\n    };\n  }\n}\n\nfunction extractStatusCode(result: unknown): number | undefined {\n  if (result && typeof result === 'object') {\n    // Check for Response.status (fetch API)\n    if ('status' in result && typeof result.status === 'number') {\n      return result.status;\n    }\n    // Check for statusCode (axios, node http)\n    if ('statusCode' in result && typeof result.statusCode === 'number') {\n      return result.statusCode;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Inject trace context into HTTP headers (for distributed tracing)\n *\n * This includes W3C Trace Context (traceparent, tracestate) and W3C Baggage headers.\n * Uses OpenTelemetry's propagation system for full compatibility.\n *\n * @example\n * ```typescript\n * import { injectTraceContext } from 'autotel/http'\n *\n * const headers = injectTraceContext({\n *   'Content-Type': 'application/json'\n * })\n *\n * fetch('/api/users', { headers })\n * ```\n *\n * @example With baggage\n * ```typescript\n * import { trace, withTracing, withBaggage, injectTraceContext } from 'autotel'\n *\n * export const createOrder = withTracing({})((ctx) => async (order: Order) => {\n *   return await withBaggage({\n *     baggage: { 'tenant.id': order.tenantId },\n *     fn: async () => {\n *       const headers = injectTraceContext();\n *       // Headers now include 'baggage' header with tenant.id\n *       await fetch('/api/charge', { headers });\n *     },\n *   });\n * });\n * ```\n */\nexport function injectTraceContext(\n  headers: Record<string, string> = {},\n): Record<string, string> {\n  // Use getActiveContextWithBaggage to check stored context (from baggage setters)\n  // This ensures ctx.setBaggage() changes are included in injected headers\n  const currentContext = getActiveContextWithBaggage();\n\n  // Use OpenTelemetry's propagation.inject for full W3C support\n  // This includes traceparent, tracestate, and baggage headers\n  propagation.inject(currentContext, headers);\n\n  return headers;\n}\n\n/**\n * Extract trace context from HTTP headers (for distributed tracing)\n *\n * This extracts W3C Trace Context (traceparent, tracestate) and W3C Baggage headers.\n * Uses OpenTelemetry's propagation system for full compatibility.\n *\n * Returns a context that can be used with context.with() to run code\n * with the extracted trace context and baggage.\n *\n * @example\n * ```typescript\n * import { extractTraceContext, trace, withTracing } from 'autotel'\n * import { context } from 'autotel'\n *\n * // In Express middleware\n * app.use((req, res, next) => {\n *   const extractedContext = extractTraceContext(req.headers);\n *   context.with(extractedContext, () => {\n *     next();\n *   });\n * });\n * ```\n *\n * @example In a traced function\n * ```typescript\n * export const handleWebhook = withTracing({})((ctx) => async (req: Request) => {\n *   const extractedContext = extractTraceContext(req.headers);\n *   return await context.with(extractedContext, async () => {\n *     // Now ctx.getBaggage() will return baggage from the incoming request\n *     const tenantId = ctx.getBaggage('tenant.id');\n *     await processWebhook(req.body);\n *   });\n * });\n * ```\n */\nexport function extractTraceContext(\n  headers: Record<string, string | string[] | undefined>,\n): ReturnType<typeof context.active> {\n  const carrier: Record<string, string> = {};\n\n  // Convert headers to flat string format expected by propagation\n  for (const [key, value] of Object.entries(headers)) {\n    if (value !== undefined) {\n      carrier[key] = Array.isArray(value) ? (value[0] ?? '') : value;\n    }\n  }\n\n  // Extract context using OpenTelemetry's propagation system\n  // Returns a Context that can be used with context.with()\n  return propagation.extract(context.active(), carrier);\n}\n"],"mappings":"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"}

package/dist/http.d.cts

@@ -1,5 +1,4 @@
 import { context } from "@opentelemetry/api";
-
 //#region src/http.d.ts
 interface HttpInstrumentedOptions {
   /** Service name for HTTP calls (default: 'http-client') */
@@ -93,9 +92,9 @@ declare function traceHttpRequest<T>(spanName: string, fn: () => Promise<T>, att
  *
  * @example With baggage
  * ```typescript
- * import { trace, withBaggage, injectTraceContext } from 'autotel'
+ * import { trace, withTracing, withBaggage, injectTraceContext } from 'autotel'
  *
- * export const createOrder = trace((ctx) => async (order: Order) => {
+ * export const createOrder = withTracing({})((ctx) => async (order: Order) => {
  *   return await withBaggage({
  *     baggage: { 'tenant.id': order.tenantId },
  *     fn: async () => {
@@ -119,7 +118,7 @@ declare function injectTraceContext(headers?: Record<string, string>): Record<st
  *
  * @example
  * ```typescript
- * import { extractTraceContext, trace } from 'autotel'
+ * import { extractTraceContext, trace, withTracing } from 'autotel'
  * import { context } from 'autotel'
  *
  * // In Express middleware
@@ -133,7 +132,7 @@ declare function injectTraceContext(headers?: Record<string, string>): Record<st
  *
  * @example In a traced function
  * ```typescript
- * export const handleWebhook = trace((ctx) => async (req: Request) => {
+ * export const handleWebhook = withTracing({})((ctx) => async (req: Request) => {
  *   const extractedContext = extractTraceContext(req.headers);
  *   return await context.with(extractedContext, async () => {
  *     // Now ctx.getBaggage() will return baggage from the incoming request

package/dist/http.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"http.d.cts","names":[],"sources":["../src/http.ts"],"mappings":";;;UA0BiB,uBAAA;EA6DL;EA3DV,WAAA;;EAEA,YAAA,IAAgB,IAAA;;EAEhB,eAAA,IAAmB,UAAA,UAAoB,IAAA;EAiDR;EA/C/B,kBAAA,IAAsB,IAAA,gBAAoB,MAAM;EAoDX;EAlDrC,sBAAA;AAAA;;;;;;;AAuMF;;;;;;;;;;;;;;;;;;;;AAIY;AAwHZ;;;;;;;;AAES;AA+CT;;;;;;iBAvUgB,gBAAA,CAAiB,OAAA,GAAS,uBAAA;EAAA,QAKH,IAAA;AAAA,GACnC,MAAA,EAAQ,CAAA,EAER,QAAA,EAAU,qBAAA;EAAA;;;;;AAiUqB;;;;;;;;;;iBA/Kb,gBAAA,IACpB,QAAA,UACA,EAAA,QAAU,OAAA,CAAQ,CAAA,GAClB,UAAA,GAAa,MAAA,4BACZ,OAAA,CAAQ,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwHK,kBAAA,CACd,OAAA,GAAS,MAAA,mBACR,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+CO,mBAAA,CACd,OAAA,EAAS,MAAA,0CACR,UAAA,QAAkB,OAAA,CAAQ,MAAA"}
+{"version":3,"file":"http.d.cts","names":[],"sources":["../src/http.ts"],"mappings":";;UA0BiB;;EAEf;;EAEA,gBAAgB;;EAEhB,mBAAmB,oBAAoB;;EAEvC,sBAAsB,oBAAoB;;EAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6Cc,iBAAiB,UAAS,2BAKvB;UAAoB;GACnC,QAAQ,GACR,UAAU;UAIa;IA+H1B;;;;;;;;;;;;;;iBAeqB,iBAAiB,GACrC,kBACA,UAAU,QAAQ,IAClB,aAAa,kCACZ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwHK,mBACd,UAAS,yBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+Ca,oBACd,SAAS,gDACR,kBAAkB,QAAQ"}

package/dist/http.d.ts

@@ -1,5 +1,4 @@
 import { context } from "@opentelemetry/api";
-
 //#region src/http.d.ts
 interface HttpInstrumentedOptions {
   /** Service name for HTTP calls (default: 'http-client') */
@@ -93,9 +92,9 @@ declare function traceHttpRequest<T>(spanName: string, fn: () => Promise<T>, att
  *
  * @example With baggage
  * ```typescript
- * import { trace, withBaggage, injectTraceContext } from 'autotel'
+ * import { trace, withTracing, withBaggage, injectTraceContext } from 'autotel'
  *
- * export const createOrder = trace((ctx) => async (order: Order) => {
+ * export const createOrder = withTracing({})((ctx) => async (order: Order) => {
  *   return await withBaggage({
  *     baggage: { 'tenant.id': order.tenantId },
  *     fn: async () => {
@@ -119,7 +118,7 @@ declare function injectTraceContext(headers?: Record<string, string>): Record<st
  *
  * @example
  * ```typescript
- * import { extractTraceContext, trace } from 'autotel'
+ * import { extractTraceContext, trace, withTracing } from 'autotel'
  * import { context } from 'autotel'
  *
  * // In Express middleware
@@ -133,7 +132,7 @@ declare function injectTraceContext(headers?: Record<string, string>): Record<st
  *
  * @example In a traced function
  * ```typescript
- * export const handleWebhook = trace((ctx) => async (req: Request) => {
+ * export const handleWebhook = withTracing({})((ctx) => async (req: Request) => {
  *   const extractedContext = extractTraceContext(req.headers);
  *   return await context.with(extractedContext, async () => {
  *     // Now ctx.getBaggage() will return baggage from the incoming request

package/dist/http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http.d.ts","names":[],"sources":["../src/http.ts"],"mappings":";;;UA0BiB,uBAAA;EA6DL;EA3DV,WAAA;;EAEA,YAAA,IAAgB,IAAA;;EAEhB,eAAA,IAAmB,UAAA,UAAoB,IAAA;EAiDR;EA/C/B,kBAAA,IAAsB,IAAA,gBAAoB,MAAM;EAoDX;EAlDrC,sBAAA;AAAA;;;;;;;AAuMF;;;;;;;;;;;;;;;;;;;;AAIY;AAwHZ;;;;;;;;AAES;AA+CT;;;;;;iBAvUgB,gBAAA,CAAiB,OAAA,GAAS,uBAAA;EAAA,QAKH,IAAA;AAAA,GACnC,MAAA,EAAQ,CAAA,EAER,QAAA,EAAU,qBAAA;EAAA;;;;;AAiUqB;;;;;;;;;;iBA/Kb,gBAAA,IACpB,QAAA,UACA,EAAA,QAAU,OAAA,CAAQ,CAAA,GAClB,UAAA,GAAa,MAAA,4BACZ,OAAA,CAAQ,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwHK,kBAAA,CACd,OAAA,GAAS,MAAA,mBACR,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+CO,mBAAA,CACd,OAAA,EAAS,MAAA,0CACR,UAAA,QAAkB,OAAA,CAAQ,MAAA"}
+{"version":3,"file":"http.d.ts","names":[],"sources":["../src/http.ts"],"mappings":";;UA0BiB;;EAEf;;EAEA,gBAAgB;;EAEhB,mBAAmB,oBAAoB;;EAEvC,sBAAsB,oBAAoB;;EAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6Cc,iBAAiB,UAAS,2BAKvB;UAAoB;GACnC,QAAQ,GACR,UAAU;UAIa;IA+H1B;;;;;;;;;;;;;;iBAeqB,iBAAiB,GACrC,kBACA,UAAU,QAAQ,IAClB,aAAa,kCACZ,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwHK,mBACd,UAAS,yBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+Ca,oBACd,SAAS,gDACR,kBAAkB,QAAQ"}

package/dist/http.js

@@ -1,5 +1,5 @@
 import { getConfig } from "./config.js";
-import { g as getActiveContextWithBaggage } from "./track-D7O7oIZa.js";
+import { h as getActiveContextWithBaggage } from "./track-BBcxEJEC.js";
 import { SpanStatusCode, context, propagation } from "@opentelemetry/api";
 
 //#region src/http.ts
@@ -230,9 +230,9 @@ function extractStatusCode(result) {
 *
 * @example With baggage
 * ```typescript
-* import { trace, withBaggage, injectTraceContext } from 'autotel'
+* import { trace, withTracing, withBaggage, injectTraceContext } from 'autotel'
 *
-* export const createOrder = trace((ctx) => async (order: Order) => {
+* export const createOrder = withTracing({})((ctx) => async (order: Order) => {
 *   return await withBaggage({
 *     baggage: { 'tenant.id': order.tenantId },
 *     fn: async () => {
@@ -260,7 +260,7 @@ function injectTraceContext(headers = {}) {
 *
 * @example
 * ```typescript
-* import { extractTraceContext, trace } from 'autotel'
+* import { extractTraceContext, trace, withTracing } from 'autotel'
 * import { context } from 'autotel'
 *
 * // In Express middleware
@@ -274,7 +274,7 @@ function injectTraceContext(headers = {}) {
 *
 * @example In a traced function
 * ```typescript
-* export const handleWebhook = trace((ctx) => async (req: Request) => {
+* export const handleWebhook = withTracing({})((ctx) => async (req: Request) => {
 *   const extractedContext = extractTraceContext(req.headers);
 *   return await context.with(extractedContext, async () => {
 *     // Now ctx.getBaggage() will return baggage from the incoming request