autotel 2.25.3 → 2.25.5

package/src/test-span-collector.ts

@@ -36,8 +36,11 @@ type SerializableValue =
 /**
  * Portable serialized span for embedding in test metadata.
  * `startTimeMs` is derived from OTel HrTime — epoch-based wall-clock ms in the current SDK.
+ *
+ * Defined as a `type` (not `interface`) so it is assignable to
+ * `Record<string, unknown>` in TypeScript 6+ strict mode.
  */
-export interface SerializedSpan {
+export type SerializedSpan = {
   spanId: string;
   parentSpanId?: string;
   name: string;
@@ -46,7 +49,7 @@ export interface SerializedSpan {
   status: 'ok' | 'error' | 'unset';
   statusMessage?: string;
   attributes?: Record<string, SerializableValue>;
-}
+};
 
 export class TestSpanCollector implements SpanExporter {
   private traces = new Map<string, ReadableSpan[]>();

package/src/trace-context.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from 'vitest';
+import { enterOrRun } from './trace-context';
+
+type Box<T> = { value: T };
+
+function createFakeStorage<T>(initialValue?: T) {
+  let currentStore =
+    initialValue === undefined ? undefined : { value: initialValue };
+  const runCalls: Array<Box<T>> = [];
+  const enterWithCalls: Array<Box<T>> = [];
+
+  const storage = {
+    getStore() {
+      return currentStore;
+    },
+    run(store: Box<T>, fn: () => void) {
+      runCalls.push(store);
+      const previousStore = currentStore;
+      currentStore = store;
+      try {
+        fn();
+      } finally {
+        currentStore = previousStore;
+      }
+    },
+    enterWith(store: Box<T>) {
+      enterWithCalls.push(store);
+      currentStore = store;
+    },
+  };
+
+  return {
+    enterWithCalls,
+    runCalls,
+    storage: storage as unknown as {
+      enterWith?: (store: Box<T>) => void;
+      getStore: () => Box<T> | undefined;
+      run: (store: Box<T>, fn: () => void) => void;
+    },
+  };
+}
+
+describe('enterOrRun', () => {
+  it('mutates the existing store when already inside a run scope', () => {
+    const { storage } = createFakeStorage('outer');
+
+    enterOrRun(storage as never, 'updated');
+
+    expect(storage.getStore()?.value).toBe('updated');
+  });
+
+  it('falls back to run() when enterWith throws', () => {
+    const { runCalls, storage } = createFakeStorage<string>();
+    storage.enterWith = () => {
+      throw new Error('enterWith not supported');
+    };
+
+    enterOrRun(storage as never, 'worker-value');
+
+    expect(runCalls).toHaveLength(1);
+    expect(runCalls[0]?.value).toBe('worker-value');
+  });
+
+  it('prefers enterWith() when no store exists and the runtime supports it', () => {
+    const { enterWithCalls, storage } = createFakeStorage<string>();
+
+    enterOrRun(storage as never, 'node-value');
+
+    expect(enterWithCalls).toHaveLength(1);
+    expect(enterWithCalls[0]?.value).toBe('node-value');
+    expect(storage.getStore()?.value).toBe('node-value');
+  });
+});

package/src/trace-context.ts

@@ -13,16 +13,20 @@ import type {
 import { context, propagation } from '@opentelemetry/api';
 import { AsyncLocalStorage } from 'node:async_hooks';
 
+type AsyncLocalBox<T> = {
+  value: T;
+};
+
 /**
  * AsyncLocalStorage for storing the active context with baggage
  * This allows setters to update the context and have it persist
  */
-const contextStorage = new AsyncLocalStorage<Context>();
+const contextStorage = new AsyncLocalStorage<AsyncLocalBox<Context>>();
 
 /**
  * Get the context storage instance (for initialization in functional.ts)
  */
-export function getContextStorage(): AsyncLocalStorage<Context> {
+export function getContextStorage(): AsyncLocalStorage<AsyncLocalBox<Context>> {
   return contextStorage;
 }
 
@@ -33,10 +37,38 @@ export function getContextStorage(): AsyncLocalStorage<Context> {
 export function getActiveContextWithBaggage(): Context {
   // Check stored context first (from setters), then fall back to active context
   // This ensures ctx.setBaggage() changes are visible to OpenTelemetry operations
-  const stored = contextStorage.getStore();
+  const stored = contextStorage.getStore()?.value;
   return stored ?? context.active();
 }
 
+/**
+ * Set a value in AsyncLocalStorage, preferring enterWith() when available
+ * (Node.js) and falling back to run() for environments that only support
+ * run() (e.g. Cloudflare Workers).
+ *
+ * On runtimes without enterWith() we mutate the existing run() scope when one
+ * exists. This is what allows baggage/correlation updates to remain visible
+ * for the rest of the traced callback in Workers.
+ */
+export function enterOrRun<T>(
+  storage: AsyncLocalStorage<AsyncLocalBox<T>>,
+  value: T,
+): void {
+  const existingStore = storage.getStore();
+  if (existingStore) {
+    existingStore.value = value;
+    return;
+  }
+
+  const boxedValue = { value };
+  try {
+    storage.enterWith(boxedValue);
+  } catch {
+    // Cloudflare Workers define enterWith but throw at runtime
+    storage.run(boxedValue, () => {});
+  }
+}
+
 /**
  * Try to keep OpenTelemetry's context manager in sync with baggage updates
  */
@@ -47,7 +79,7 @@ type ContextManagerLike = {
 
 function updateActiveContext(newContext: Context): void {
   // Update our storage first so any helper reads see the new context
-  contextStorage.enterWith(newContext);
+  enterOrRun(contextStorage, newContext);
 
   const contextWithManager = context as unknown as {
     _getContextManager?: () => ContextManagerLike;
@@ -240,10 +272,10 @@ export function createTraceContext<
   // Store the current active context in AsyncLocalStorage so baggage setters can update it
   // This ensures ctx.setBaggage() changes persist and are visible to OpenTelemetry operations
   // IMPORTANT: Only initialize if not already set (preserve baggage updates from parent spans)
-  const existingStored = contextStorage.getStore();
+  const existingStored = contextStorage.getStore()?.value;
   if (!existingStored) {
     const activeContext = context.active();
-    contextStorage.enterWith(activeContext);
+    enterOrRun(contextStorage, activeContext);
   }
 
   // Baggage helpers that always use the current active context
@@ -256,7 +288,7 @@ export function createTraceContext<
       const activeCtx = context.active();
       let baggage = propagation.getBaggage(activeCtx);
       if (!baggage) {
-        const storedContext = contextStorage.getStore();
+        const storedContext = contextStorage.getStore()?.value;
         if (storedContext) {
           baggage = propagation.getBaggage(storedContext);
         }
@@ -268,7 +300,7 @@ export function createTraceContext<
       // OpenTelemetry contexts are immutable, so we create a new context with updated baggage
       // Check active context first (may have baggage from withBaggage), then stored context
       const activeCtx = context.active();
-      const storedContext = contextStorage.getStore();
+      const storedContext = contextStorage.getStore()?.value;
       const currentContext = storedContext ?? activeCtx;
       const baggage =
         propagation.getBaggage(currentContext) ?? propagation.createBaggage();
@@ -283,7 +315,7 @@ export function createTraceContext<
     deleteBaggage(key: string): void {
       // Check active context first, then stored context
       const activeCtx = context.active();
-      const storedContext = contextStorage.getStore();
+      const storedContext = contextStorage.getStore()?.value;
       const currentContext = storedContext ?? activeCtx;
       const baggage = propagation.getBaggage(currentContext);
       if (baggage) {
@@ -299,7 +331,7 @@ export function createTraceContext<
       const activeCtx = context.active();
       let baggage = propagation.getBaggage(activeCtx);
       if (!baggage) {
-        const storedContext = contextStorage.getStore();
+        const storedContext = contextStorage.getStore()?.value;
         if (storedContext) {
           baggage = propagation.getBaggage(storedContext);
         }
@@ -324,7 +356,7 @@ export function createTraceContext<
       const activeCtx = context.active();
       let baggage = propagation.getBaggage(activeCtx);
       if (!baggage) {
-        const storedContext = contextStorage.getStore();
+        const storedContext = contextStorage.getStore()?.value;
         if (storedContext) {
           baggage = propagation.getBaggage(storedContext);
         }
@@ -356,7 +388,7 @@ export function createTraceContext<
     ) => {
       // Check active context first, then stored context
       const activeCtx = context.active();
-      const storedContext = contextStorage.getStore();
+      const storedContext = contextStorage.getStore()?.value;
       const currentContext = storedContext ?? activeCtx;
       let baggage =
         propagation.getBaggage(currentContext) ?? propagation.createBaggage();