autotel 2.1.0

package/dist/trace-context-DRZdUvVY.d.cts

@@ -0,0 +1,181 @@
+import { SpanStatusCode, BaggageEntry } from '@opentelemetry/api';
+
+/**
+ * Trace context types and utilities
+ */
+
+/**
+ * Base trace context containing trace identifiers
+ */
+interface TraceContextBase {
+    traceId: string;
+    spanId: string;
+    correlationId: string;
+}
+/**
+ * Span methods available on trace context
+ */
+interface SpanMethods {
+    setAttribute(key: string, value: string | number | boolean): void;
+    setAttributes(attrs: Record<string, string | number | boolean>): void;
+    setStatus(status: {
+        code: SpanStatusCode;
+        message?: string;
+    }): void;
+    recordException(exception: Error): void;
+}
+/**
+ * Baggage methods available on trace context
+ *
+ * @template TBaggage - Optional type for typed baggage (defaults to undefined for untyped)
+ */
+interface BaggageMethods<TBaggage extends Record<string, unknown> | undefined = undefined> {
+    /**
+     * Get a baggage entry by key
+     * @param key - Baggage key
+     * @returns Baggage entry value or undefined
+     */
+    getBaggage(key: string): string | undefined;
+    /**
+     * Set a baggage entry
+     *
+     * Note: OpenTelemetry contexts are immutable. For proper scoping across async
+     * boundaries, use withBaggage() instead. This method updates baggage in the
+     * current context which may not propagate to all child operations.
+     *
+     * @param key - Baggage key
+     * @param value - Baggage value
+     * @returns The baggage value that was set (for chaining)
+     *
+     * @example Using withBaggage() (recommended)
+     * ```typescript
+     * await withBaggage({ baggage: { 'key': 'value' }, fn: async () => {
+     *   // Baggage is available here and in child spans
+     * });
+     * ```
+     */
+    setBaggage(key: string, value: string): string;
+    /**
+     * Delete a baggage entry
+     *
+     * Note: OpenTelemetry contexts are immutable. For proper scoping across async
+     * boundaries, use withBaggage() with only the entries you want instead.
+     *
+     * @param key - Baggage key
+     */
+    deleteBaggage(key: string): void;
+    /**
+     * Get all baggage entries
+     * @returns Map of all baggage entries
+     */
+    getAllBaggage(): Map<string, BaggageEntry>;
+    /**
+     * Get typed baggage (only available when TBaggage is defined)
+     * This is used internally by defineBaggageSchema()
+     *
+     * @internal
+     */
+    getTypedBaggage?: TBaggage extends Record<string, unknown> ? <T extends TBaggage>(namespace?: string) => Partial<T> | undefined : never;
+    /**
+     * Set typed baggage (only available when TBaggage is defined)
+     * This is used internally by defineBaggageSchema()
+     *
+     * @internal
+     */
+    setTypedBaggage?: TBaggage extends Record<string, unknown> ? <T extends TBaggage>(namespace: string | undefined, value: Partial<T>) => void : never;
+}
+/**
+ * Complete trace context that merges base context, span methods, and baggage methods
+ *
+ * This is the ctx parameter passed to factory functions in trace().
+ * It provides access to trace IDs, span manipulation methods, and baggage operations.
+ *
+ * @template TBaggage - Optional type for typed baggage support
+ *
+ * @example Untyped (default)
+ * ```typescript
+ * export const handler = trace((ctx) => async () => {
+ *   ctx.getBaggage('key'); // returns string | undefined
+ * });
+ * ```
+ *
+ * @example Typed baggage
+ * ```typescript
+ * type TenantBaggage = { tenantId: string; region?: string };
+ *
+ * export const handler = trace<TenantBaggage>((ctx) => async () => {
+ *   // Use typed schema helper for type-safe access
+ *   const schema = defineBaggageSchema<TenantBaggage>('tenant');
+ *   const tenant = schema.get(ctx); // Partial<TenantBaggage> | undefined
+ * });
+ * ```
+ */
+type TraceContext<TBaggage extends Record<string, unknown> | undefined = undefined> = TraceContextBase & SpanMethods & BaggageMethods<TBaggage>;
+/**
+ * Define a typed baggage schema for type-safe baggage operations
+ *
+ * This helper provides a type-safe API for working with baggage entries.
+ * The namespace parameter is optional and prefixes all keys to avoid collisions.
+ *
+ * @template T - The baggage schema type (all fields are treated as optional)
+ * @param namespace - Optional namespace to prefix baggage keys
+ *
+ * @example Basic usage
+ * ```typescript
+ * type TenantBaggage = { tenantId: string; region?: string };
+ * const tenantBaggage = defineBaggageSchema<TenantBaggage>('tenant');
+ *
+ * export const handler = trace<TenantBaggage>((ctx) => async () => {
+ *   // Get typed baggage
+ *   const tenant = tenantBaggage.get(ctx);
+ *   if (tenant?.tenantId) {
+ *     console.log('Tenant:', tenant.tenantId);
+ *   }
+ *
+ *   // Set typed baggage
+ *   tenantBaggage.set(ctx, { tenantId: 't1', region: 'us-east-1' });
+ * });
+ * ```
+ *
+ * @example With withBaggage helper
+ * ```typescript
+ * const tenantBaggage = defineBaggageSchema<TenantBaggage>('tenant');
+ *
+ * export const handler = trace<TenantBaggage>((ctx) => async () => {
+ *   return await tenantBaggage.with(ctx, { tenantId: 't1' }, async () => {
+ *     // Baggage is available here and in child spans
+ *     const tenant = tenantBaggage.get(ctx);
+ *   });
+ * });
+ * ```
+ */
+declare function defineBaggageSchema<T extends Record<string, unknown>>(namespace?: string): {
+    /**
+     * Get typed baggage from context
+     * @param ctx - Trace context
+     * @returns Partial baggage object or undefined if no baggage is set
+     */
+    get: (ctx: TraceContext<T>) => Partial<T> | undefined;
+    /**
+     * Set typed baggage in context
+     *
+     * Note: For proper scoping across async boundaries, use the `with` method instead
+     *
+     * @param ctx - Trace context
+     * @param value - Partial baggage object to set
+     */
+    set: (ctx: TraceContext<T>, value: Partial<T>) => void;
+    /**
+     * Run a function with typed baggage properly scoped
+     *
+     * This is the recommended way to set baggage as it ensures proper
+     * scoping across async boundaries.
+     *
+     * @param ctx - Trace context (can be omitted, will use active context)
+     * @param value - Partial baggage object to set
+     * @param fn - Function to execute with the baggage
+     */
+    with: <R>(ctxOrValue: TraceContext<T> | Partial<T>, valueOrFn: Partial<T> | (() => R | Promise<R>), maybeFn?: () => R | Promise<R>) => R | Promise<R>;
+};
+
+export { type TraceContext as T, defineBaggageSchema as d };

package/dist/trace-context-DRZdUvVY.d.ts

@@ -0,0 +1,181 @@
+import { SpanStatusCode, BaggageEntry } from '@opentelemetry/api';
+
+/**
+ * Trace context types and utilities
+ */
+
+/**
+ * Base trace context containing trace identifiers
+ */
+interface TraceContextBase {
+    traceId: string;
+    spanId: string;
+    correlationId: string;
+}
+/**
+ * Span methods available on trace context
+ */
+interface SpanMethods {
+    setAttribute(key: string, value: string | number | boolean): void;
+    setAttributes(attrs: Record<string, string | number | boolean>): void;
+    setStatus(status: {
+        code: SpanStatusCode;
+        message?: string;
+    }): void;
+    recordException(exception: Error): void;
+}
+/**
+ * Baggage methods available on trace context
+ *
+ * @template TBaggage - Optional type for typed baggage (defaults to undefined for untyped)
+ */
+interface BaggageMethods<TBaggage extends Record<string, unknown> | undefined = undefined> {
+    /**
+     * Get a baggage entry by key
+     * @param key - Baggage key
+     * @returns Baggage entry value or undefined
+     */
+    getBaggage(key: string): string | undefined;
+    /**
+     * Set a baggage entry
+     *
+     * Note: OpenTelemetry contexts are immutable. For proper scoping across async
+     * boundaries, use withBaggage() instead. This method updates baggage in the
+     * current context which may not propagate to all child operations.
+     *
+     * @param key - Baggage key
+     * @param value - Baggage value
+     * @returns The baggage value that was set (for chaining)
+     *
+     * @example Using withBaggage() (recommended)
+     * ```typescript
+     * await withBaggage({ baggage: { 'key': 'value' }, fn: async () => {
+     *   // Baggage is available here and in child spans
+     * });
+     * ```
+     */
+    setBaggage(key: string, value: string): string;
+    /**
+     * Delete a baggage entry
+     *
+     * Note: OpenTelemetry contexts are immutable. For proper scoping across async
+     * boundaries, use withBaggage() with only the entries you want instead.
+     *
+     * @param key - Baggage key
+     */
+    deleteBaggage(key: string): void;
+    /**
+     * Get all baggage entries
+     * @returns Map of all baggage entries
+     */
+    getAllBaggage(): Map<string, BaggageEntry>;
+    /**
+     * Get typed baggage (only available when TBaggage is defined)
+     * This is used internally by defineBaggageSchema()
+     *
+     * @internal
+     */
+    getTypedBaggage?: TBaggage extends Record<string, unknown> ? <T extends TBaggage>(namespace?: string) => Partial<T> | undefined : never;
+    /**
+     * Set typed baggage (only available when TBaggage is defined)
+     * This is used internally by defineBaggageSchema()
+     *
+     * @internal
+     */
+    setTypedBaggage?: TBaggage extends Record<string, unknown> ? <T extends TBaggage>(namespace: string | undefined, value: Partial<T>) => void : never;
+}
+/**
+ * Complete trace context that merges base context, span methods, and baggage methods
+ *
+ * This is the ctx parameter passed to factory functions in trace().
+ * It provides access to trace IDs, span manipulation methods, and baggage operations.
+ *
+ * @template TBaggage - Optional type for typed baggage support
+ *
+ * @example Untyped (default)
+ * ```typescript
+ * export const handler = trace((ctx) => async () => {
+ *   ctx.getBaggage('key'); // returns string | undefined
+ * });
+ * ```
+ *
+ * @example Typed baggage
+ * ```typescript
+ * type TenantBaggage = { tenantId: string; region?: string };
+ *
+ * export const handler = trace<TenantBaggage>((ctx) => async () => {
+ *   // Use typed schema helper for type-safe access
+ *   const schema = defineBaggageSchema<TenantBaggage>('tenant');
+ *   const tenant = schema.get(ctx); // Partial<TenantBaggage> | undefined
+ * });
+ * ```
+ */
+type TraceContext<TBaggage extends Record<string, unknown> | undefined = undefined> = TraceContextBase & SpanMethods & BaggageMethods<TBaggage>;
+/**
+ * Define a typed baggage schema for type-safe baggage operations
+ *
+ * This helper provides a type-safe API for working with baggage entries.
+ * The namespace parameter is optional and prefixes all keys to avoid collisions.
+ *
+ * @template T - The baggage schema type (all fields are treated as optional)
+ * @param namespace - Optional namespace to prefix baggage keys
+ *
+ * @example Basic usage
+ * ```typescript
+ * type TenantBaggage = { tenantId: string; region?: string };
+ * const tenantBaggage = defineBaggageSchema<TenantBaggage>('tenant');
+ *
+ * export const handler = trace<TenantBaggage>((ctx) => async () => {
+ *   // Get typed baggage
+ *   const tenant = tenantBaggage.get(ctx);
+ *   if (tenant?.tenantId) {
+ *     console.log('Tenant:', tenant.tenantId);
+ *   }
+ *
+ *   // Set typed baggage
+ *   tenantBaggage.set(ctx, { tenantId: 't1', region: 'us-east-1' });
+ * });
+ * ```
+ *
+ * @example With withBaggage helper
+ * ```typescript
+ * const tenantBaggage = defineBaggageSchema<TenantBaggage>('tenant');
+ *
+ * export const handler = trace<TenantBaggage>((ctx) => async () => {
+ *   return await tenantBaggage.with(ctx, { tenantId: 't1' }, async () => {
+ *     // Baggage is available here and in child spans
+ *     const tenant = tenantBaggage.get(ctx);
+ *   });
+ * });
+ * ```
+ */
+declare function defineBaggageSchema<T extends Record<string, unknown>>(namespace?: string): {
+    /**
+     * Get typed baggage from context
+     * @param ctx - Trace context
+     * @returns Partial baggage object or undefined if no baggage is set
+     */
+    get: (ctx: TraceContext<T>) => Partial<T> | undefined;
+    /**
+     * Set typed baggage in context
+     *
+     * Note: For proper scoping across async boundaries, use the `with` method instead
+     *
+     * @param ctx - Trace context
+     * @param value - Partial baggage object to set
+     */
+    set: (ctx: TraceContext<T>, value: Partial<T>) => void;
+    /**
+     * Run a function with typed baggage properly scoped
+     *
+     * This is the recommended way to set baggage as it ensures proper
+     * scoping across async boundaries.
+     *
+     * @param ctx - Trace context (can be omitted, will use active context)
+     * @param value - Partial baggage object to set
+     * @param fn - Function to execute with the baggage
+     */
+    with: <R>(ctxOrValue: TraceContext<T> | Partial<T>, valueOrFn: Partial<T> | (() => R | Promise<R>), maybeFn?: () => R | Promise<R>) => R | Promise<R>;
+};
+
+export { type TraceContext as T, defineBaggageSchema as d };

package/dist/trace-helpers.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+var chunkTRI4V5BF_cjs = require('./chunk-TRI4V5BF.cjs');
+require('./chunk-NHCNRQD3.cjs');
+require('./chunk-G7VZBCD6.cjs');
+
+
+
+Object.defineProperty(exports, "createDeterministicTraceId", {
+  enumerable: true,
+  get: function () { return chunkTRI4V5BF_cjs.createDeterministicTraceId; }
+});
+Object.defineProperty(exports, "enrichWithTraceContext", {
+  enumerable: true,
+  get: function () { return chunkTRI4V5BF_cjs.enrichWithTraceContext; }
+});
+Object.defineProperty(exports, "finalizeSpan", {
+  enumerable: true,
+  get: function () { return chunkTRI4V5BF_cjs.finalizeSpan; }
+});
+Object.defineProperty(exports, "flattenMetadata", {
+  enumerable: true,
+  get: function () { return chunkTRI4V5BF_cjs.flattenMetadata; }
+});
+Object.defineProperty(exports, "getActiveContext", {
+  enumerable: true,
+  get: function () { return chunkTRI4V5BF_cjs.getActiveContext; }
+});
+Object.defineProperty(exports, "getActiveSpan", {
+  enumerable: true,
+  get: function () { return chunkTRI4V5BF_cjs.getActiveSpan; }
+});
+Object.defineProperty(exports, "getTraceContext", {
+  enumerable: true,
+  get: function () { return chunkTRI4V5BF_cjs.getTraceContext; }
+});
+Object.defineProperty(exports, "getTracer", {
+  enumerable: true,
+  get: function () { return chunkTRI4V5BF_cjs.getTracer; }
+});
+Object.defineProperty(exports, "isTracing", {
+  enumerable: true,
+  get: function () { return chunkTRI4V5BF_cjs.isTracing; }
+});
+Object.defineProperty(exports, "runWithSpan", {
+  enumerable: true,
+  get: function () { return chunkTRI4V5BF_cjs.runWithSpan; }
+});
+Object.defineProperty(exports, "setSpanName", {
+  enumerable: true,
+  get: function () { return chunkTRI4V5BF_cjs.setSpanName; }
+});
+//# sourceMappingURL=trace-helpers.cjs.map
+//# sourceMappingURL=trace-helpers.cjs.map

package/dist/trace-helpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"trace-helpers.cjs"}