autotel 2.26.3 → 3.0.0

package/src/index.ts

@@ -81,7 +81,6 @@ export type {
   InstrumentOptions,
 } from './functional';
 export {
-  trace,
   instrument,
   withTracing,
   span,
@@ -89,6 +88,9 @@ export {
   withBaggage,
   ctx,
 } from './functional';
+// `trace` is the hybrid: callable like autotel's `trace(fn)` AND carries the
+// full `@opentelemetry/api` TraceAPI surface (getActiveSpan, getTracer, etc).
+export { trace } from './trace-hybrid';
 
 // Operation context (for advanced usage)
 export type { OperationContext } from './operation-context';
@@ -333,19 +335,33 @@ export {
   type TLSAttrs,
 } from './attributes';
 
-// Re-export common OpenTelemetry types and utilities
-// This allows plugins and apps to use OTel without needing separate @opentelemetry/api installation
+// Re-export common OpenTelemetry types and utilities so plugins, apps, and
+// existing OTel code can `import { ... } from 'autotel'` without also taking
+// a separate `@opentelemetry/api` dependency.
 export type {
   Span,
   SpanContext,
+  SpanAttributes,
   Tracer,
+  TracerProvider,
   Context,
+  Attributes,
+  AttributeValue,
+  Link,
   Link as SpanLink,
+  TimeInput,
+  HrTime,
+  Baggage,
+  BaggageEntry,
+  Exception,
+  TraceFlags,
+  TraceState,
   TextMapSetter,
   TextMapGetter,
 } from '@opentelemetry/api';
 export { SpanKind, ROOT_CONTEXT } from '@opentelemetry/api';
-// Note: trace exported from functional.ts, context/propagation/SpanStatusCode already exported above
+// Note: trace, context, propagation, SpanStatusCode already exported above
+// (`trace` is the hybrid; `otelTrace` is the pure TraceAPI singleton).
 
 // Export typed baggage helper
 export { defineBaggageSchema } from './trace-context';

package/src/messaging.ts

@@ -50,6 +50,7 @@ import type {
 } from '@opentelemetry/api';
 import { trace } from './functional';
 import type { TraceContext } from './trace-context';
+import { emitCorrelatedEvent } from './correlated-events';
 import { createLinkFromHeaders, extractLinksFromBatch } from './sampling';
 
 // ============================================================================
@@ -1406,7 +1407,7 @@ function extendContextForConsumer(
           producerLink.context.spanId;
       }
 
-      baseCtx.addEvent('dlq_routed', eventAttrs);
+      emitCorrelatedEvent(baseCtx, 'dlq_routed', eventAttrs);
 
       // Call user's onDLQ callback if provided
       if (config.onDLQ) {
@@ -1447,7 +1448,7 @@ function extendContextForConsumer(
         }),
       };
 
-      baseCtx.addEvent('dlq_replay', eventAttrs);
+      emitCorrelatedEvent(baseCtx, 'dlq_replay', eventAttrs);
     },
 
     recordRetry(attemptNumber: number, maxAttempts?: number): void {
@@ -1455,7 +1456,7 @@ function extendContextForConsumer(
       if (maxAttempts !== undefined) {
         baseCtx.setAttribute('messaging.retry.max_attempts', maxAttempts);
       }
-      baseCtx.addEvent('retry_attempt', {
+      emitCorrelatedEvent(baseCtx, 'retry_attempt', {
         'messaging.retry.count': attemptNumber,
         ...(maxAttempts !== undefined && {
           'messaging.retry.max_attempts': maxAttempts,
@@ -1585,7 +1586,7 @@ function extendContextForConsumer(
           event.partitions.map((p) => `${p.topic}:${p.partition}`).join(',');
       }
 
-      baseCtx.addEvent(`consumer_group_${event.type}`, eventAttrs);
+      emitCorrelatedEvent(baseCtx, `consumer_group_${event.type}`, eventAttrs);
 
       // Call user's onRebalance callback if provided
       if (config.consumerGroupTracking?.onRebalance) {
@@ -1627,7 +1628,7 @@ function extendContextForConsumer(
         );
       }
 
-      baseCtx.addEvent('consumer_group_heartbeat', {
+      emitCorrelatedEvent(baseCtx, 'consumer_group_heartbeat', {
         'messaging.consumer_group.heartbeat.healthy': healthy,
         'messaging.consumer_group.heartbeat.timestamp':
           groupState.lastHeartbeat,
@@ -1644,7 +1645,7 @@ function extendContextForConsumer(
       baseCtx.setAttribute(`${prefix}.end_offset`, lag.endOffset);
       baseCtx.setAttribute(`${prefix}.lag`, lag.lag);
 
-      baseCtx.addEvent('partition_lag_recorded', {
+      emitCorrelatedEvent(baseCtx, 'partition_lag_recorded', {
         'messaging.consumer_group.lag.topic': lag.topic,
         'messaging.consumer_group.lag.partition': lag.partition,
         'messaging.consumer_group.lag.current_offset': lag.currentOffset,
@@ -1899,7 +1900,7 @@ async function extractLagMetrics(
         ctx.setAttribute('messaging.kafka.consumer_lag', lag);
 
         // Add lag event
-        ctx.addEvent('consumer_lag_measured', {
+        emitCorrelatedEvent(ctx, 'consumer_lag_measured', {
           'messaging.kafka.consumer_lag': lag,
           'messaging.kafka.message.offset': currentOffset,
           'messaging.kafka.high_watermark': endOffset,
@@ -2119,7 +2120,7 @@ function extractAndProcessOrdering(
           }
 
           // Add event for each out-of-order message
-          ctx.addEvent('message_out_of_order', {
+          emitCorrelatedEvent(ctx, 'message_out_of_order', {
             'messaging.ordering.batch_index': i,
             'messaging.ordering.current_sequence': msgSequence,
             'messaging.ordering.expected_sequence': expectedSequence,
@@ -2155,7 +2156,7 @@ function extractAndProcessOrdering(
         duplicateCount++;
 
         // Add event for each duplicate
-        ctx.addEvent('message_duplicate', {
+        emitCorrelatedEvent(ctx, 'message_duplicate', {
           'messaging.ordering.batch_index': i,
           'messaging.message.id': msgId,
         });

package/src/request-logger.ts

@@ -4,6 +4,7 @@ import type { TraceContext } from './trace-context';
 import { createTraceContext } from './trace-context';
 import { recordStructuredError } from './structured-error';
 import { flattenToAttributes } from './flatten-attributes';
+import { emitCorrelatedEvent } from './correlated-events';
 
 const POST_EMIT_FORK_HINT =
   "For intentional background work tied to this request, use log.fork('label', fn) when available.";
@@ -101,9 +102,9 @@ export function getRequestLogger(
     fields?: Record<string, unknown>,
   ) => {
     const attrs = fields ? flattenToAttributes(fields) : undefined;
-    activeContext.addEvent(`log.${level}`, {
+    emitCorrelatedEvent(activeContext, `log.${level}`, {
       message,
-      ...attrs,
+      ...(attrs ?? {}),
     });
   };
 
@@ -191,7 +192,7 @@ export function getRequestLogger(
         context: mergedContext,
       };
 
-      activeContext.addEvent('log.emit.manual', {
+      emitCorrelatedEvent(activeContext, 'log.emit.manual', {
         ...flattened,
       });
 

package/src/structured-error.test.ts

@@ -1,10 +1,41 @@
 import { describe, expect, it, vi } from 'vitest';
+import type { Span, SpanContext } from '@opentelemetry/api';
 import {
   createStructuredError,
   getStructuredErrorAttributes,
   recordStructuredError,
 } from './structured-error';
-import type { TraceContext } from './trace-context';
+import { createTraceContext, type TraceContext } from './trace-context';
+
+function createFakeSpan(): {
+  span: Span;
+  recordException: ReturnType<typeof vi.fn>;
+  setStatus: ReturnType<typeof vi.fn>;
+  setAttributes: ReturnType<typeof vi.fn>;
+} {
+  const recordException = vi.fn();
+  const setStatus = vi.fn();
+  const setAttributes = vi.fn();
+  const spanContext: SpanContext = {
+    traceId: '0123456789abcdef0123456789abcdef',
+    spanId: '0123456789abcdef',
+    traceFlags: 1,
+  };
+  const span = {
+    spanContext: () => spanContext,
+    setAttribute: vi.fn(),
+    setAttributes,
+    setStatus,
+    recordException,
+    addEvent: vi.fn(),
+    addLink: vi.fn(),
+    addLinks: vi.fn(),
+    updateName: vi.fn(),
+    isRecording: () => true,
+    end: vi.fn(),
+  } as unknown as Span;
+  return { span, recordException, setStatus, setAttributes };
+}
 
 describe('structured-error helpers', () => {
   it('creates an error with structured diagnostic fields', () => {
@@ -104,3 +135,54 @@ describe('structured-error helpers', () => {
     );
   });
 });
+
+describe('ctx.recordError', () => {
+  it('records a structured error onto the underlying span', () => {
+    const { span, recordException, setStatus, setAttributes } =
+      createFakeSpan();
+    const ctx = createTraceContext(span);
+    const err = createStructuredError({
+      message: 'Order failed',
+      why: 'Inventory unavailable',
+      fix: 'Retry after restock',
+    });
+
+    ctx.recordError(err);
+
+    expect(recordException).toHaveBeenCalledWith(err);
+    expect(setStatus).toHaveBeenCalledWith({ code: 2, message: 'Order failed' });
+    expect(setAttributes).toHaveBeenCalledWith(
+      expect.objectContaining({
+        'error.message': 'Order failed',
+        'error.why': 'Inventory unavailable',
+        'error.fix': 'Retry after restock',
+      }),
+    );
+  });
+
+  it('coerces non-Error values to Error so it is safe in catch blocks', () => {
+    const { span, recordException, setStatus, setAttributes } =
+      createFakeSpan();
+    const ctx = createTraceContext(span);
+
+    ctx.recordError('boom');
+
+    expect(recordException).toHaveBeenCalledTimes(1);
+    const recorded = recordException.mock.calls[0][0];
+    expect(recorded).toBeInstanceOf(Error);
+    expect(recorded.message).toBe('boom');
+    expect(setStatus).toHaveBeenCalledWith({ code: 2, message: 'boom' });
+    expect(setAttributes).toHaveBeenCalled();
+  });
+});
+
+describe('ctx.track', () => {
+  it('exposes track on the trace context as the ergonomic replacement for ctx.addEvent', () => {
+    const { span } = createFakeSpan();
+    const ctx = createTraceContext(span);
+
+    expect(typeof ctx.track).toBe('function');
+    // Smoke test — should not throw without init() (track is a no-op when no queue is configured)
+    expect(() => ctx.track('test.event', { foo: 'bar' })).not.toThrow();
+  });
+});

package/src/structured-error.ts

@@ -138,10 +138,17 @@ export function getStructuredErrorAttributes(
 }
 
 export function recordStructuredError(
-  ctx: Pick<TraceContext, 'recordException' | 'setAttributes' | 'setStatus'>,
+  ctx: Pick<TraceContext, 'setAttributes' | 'setStatus'>,
   error: Error,
 ): void {
-  ctx.recordException(error);
+  const maybeRecordException = (
+    ctx as unknown as {
+      recordException?: (e: Error) => void;
+    }
+  ).recordException;
+  if (typeof maybeRecordException === 'function') {
+    maybeRecordException(error);
+  }
   ctx.setStatus({
     code: SpanStatusCode.ERROR,
     message: error.message,

package/src/trace-context.ts

@@ -8,10 +8,11 @@ import type {
   BaggageEntry,
   Context,
   Link,
-  TimeInput,
 } from '@opentelemetry/api';
 import { context, propagation } from '@opentelemetry/api';
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { recordStructuredError } from './structured-error';
+import { track } from './track';
 
 type AsyncLocalBox<T> = {
   value: T;
@@ -132,14 +133,6 @@ export interface SpanMethods {
   setAttributes(attrs: Record<string, AttributeValue>): void;
   /** Set the status of the span */
   setStatus(status: { code: SpanStatusCode; message?: string }): void;
-  /** Record an exception on the span */
-  recordException(exception: Error, time?: TimeInput): void;
-  /** Add an event to the span (for logging milestones/checkpoints) */
-  addEvent(
-    name: string,
-    attributesOrStartTime?: Record<string, AttributeValue> | TimeInput,
-    startTime?: TimeInput,
-  ): void;
   /** Add a link to another span */
   addLink(link: Link): void;
   /** Add multiple links to other spans */
@@ -148,6 +141,26 @@ export interface SpanMethods {
   updateName(name: string): void;
   /** Check if the span is recording */
   isRecording(): boolean;
+  /**
+   * Record an error on the span: sets ERROR status, structured `error.*`
+   * attributes (including `why`/`fix`/`link` from `createStructuredError`),
+   * and during the OTel Span Event API back-compat window also records the
+   * exception via the legacy span event API.
+   *
+   * Replaces the deprecated `recordException` (OTEP 4430). Accepts `unknown`
+   * so it can be called directly with the value caught from a `catch` block.
+   */
+  recordError(error: unknown): void;
+  /**
+   * Emit a tracked event correlated to this span. Equivalent to the standalone
+   * `track(event, data)` but reads naturally on `ctx`. Replaces the deprecated
+   * `ctx.addEvent` (OTEP 4430) — events become correlated logs rather than
+   * span events.
+   */
+  track<Events extends Record<string, unknown> = Record<string, unknown>>(
+    event: keyof Events & string,
+    data?: Events[keyof Events & string],
+  ): void;
 }
 
 /**
@@ -411,7 +424,13 @@ export function createTraceContext<
       : never,
   };
 
-  return {
+  // `recordException` and `addEvent` are intentionally bound at runtime but
+  // omitted from the `SpanMethods` type. They exist solely so existing call
+  // sites keep working through the OTel Span Event API deprecation window
+  // (see MIGRATION.md). New code MUST go through `recordStructuredError`,
+  // `emitCorrelatedEvent`, or the request logger. The cast below is what hides
+  // these compatibility-only fields from the public type.
+  const traceCtx = {
     traceId: spanContext.traceId,
     spanId: spanContext.spanId,
     correlationId: spanContext.traceId.slice(0, 16),
@@ -424,8 +443,17 @@ export function createTraceContext<
     addLinks: span.addLinks.bind(span),
     updateName: span.updateName.bind(span),
     isRecording: span.isRecording.bind(span),
+    recordError: (error: unknown) => {
+      const err = error instanceof Error ? error : new Error(String(error));
+      recordStructuredError(traceCtx, err);
+    },
+    track: (event: string, data?: Record<string, unknown>) => {
+      track(event, data);
+    },
     ...baggageHelpers,
-  };
+  } as unknown as TraceContext<TBaggage>;
+
+  return traceCtx;
 }
 
 /**

package/src/trace-helpers.ts

@@ -241,7 +241,7 @@ export function getTracer(name: string, version?: string): Tracer {
  * Get the currently active span
  *
  * Returns undefined if no span is currently active.
- * Useful for adding attributes or events to the current span.
+ * Useful for adding attributes to the current span.
  *
  * @returns Active span or undefined
  *
@@ -252,7 +252,7 @@ export function getTracer(name: string, version?: string): Tracer {
  * const span = getActiveSpan();
  * if (span) {
  *   span.setAttribute('user.id', userId);
- *   span.addEvent('User action', { action: 'click' });
+ *   span.setAttribute('user.action', 'click');
  * }
  * ```
  *

package/src/trace-hybrid.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { trace as otelTraceApi } from '@opentelemetry/api';
+import { trace } from './trace-hybrid';
+
+describe('hybrid trace', () => {
+  it('is callable like autotel trace', () => {
+    expect(typeof trace).toBe('function');
+
+    const wrapped = trace(async (x: number) => x * 2);
+    expect(typeof wrapped).toBe('function');
+  });
+
+  it('exposes the OTel TraceAPI surface', () => {
+    expect(typeof trace.getActiveSpan).toBe('function');
+    expect(typeof trace.getTracer).toBe('function');
+    expect(typeof trace.getTracerProvider).toBe('function');
+    expect(typeof trace.setSpan).toBe('function');
+    expect(typeof trace.getSpan).toBe('function');
+    expect(typeof trace.setSpanContext).toBe('function');
+    expect(typeof trace.getSpanContext).toBe('function');
+    expect(typeof trace.deleteSpan).toBe('function');
+    expect(typeof trace.wrapSpanContext).toBe('function');
+    expect(typeof trace.isSpanContextValid).toBe('function');
+    expect(typeof trace.disable).toBe('function');
+    expect(typeof trace.setGlobalTracerProvider).toBe('function');
+  });
+
+  it('forwards getActiveSpan / getTracerProvider to the OTel singleton', () => {
+    expect(trace.getActiveSpan()).toBe(otelTraceApi.getActiveSpan());
+    // Same TracerProvider singleton — guarantees getTracer goes through one
+    // place. (Tracer instances themselves may not be referentially identical
+    // because the proxy creates a new wrapper per call.)
+    expect(trace.getTracerProvider()).toBe(otelTraceApi.getTracerProvider());
+  });
+
+  it('preserves `this` for class methods (no unbound-this errors)', () => {
+    // setGlobalTracerProvider/getTracerProvider rely on `this._proxyTracerProvider`.
+    // Calling through the destructured reference must not throw.
+    const { getTracerProvider } = trace;
+    expect(() => getTracerProvider()).not.toThrow();
+  });
+});

package/src/trace-hybrid.ts

@@ -0,0 +1,37 @@
+/**
+ * Hybrid `trace` export: callable like autotel's `trace(fn)`, AND exposes the
+ * full `@opentelemetry/api` `TraceAPI` surface (`trace.getActiveSpan()`,
+ * `trace.getTracer()`, …) so existing OTel code "just works" when imported
+ * from `autotel`.
+ *
+ * Implementation: `Object.assign` mutates the autotel `trace` function to
+ * attach the OTel TraceAPI methods. Because every reference to `trace` across
+ * autotel resolves to the same function instance, this is a one-time, global
+ * augmentation.
+ */
+
+import { trace as otelTraceApi } from '@opentelemetry/api';
+import { trace as autotelTraceFn } from './functional';
+
+const otelMethods = {
+  // Class methods on TraceAPI — bind to the singleton.
+  setGlobalTracerProvider:
+    otelTraceApi.setGlobalTracerProvider.bind(otelTraceApi),
+  getTracerProvider: otelTraceApi.getTracerProvider.bind(otelTraceApi),
+  getTracer: otelTraceApi.getTracer.bind(otelTraceApi),
+  disable: otelTraceApi.disable.bind(otelTraceApi),
+  // Instance fields on TraceAPI — already standalone, copy by reference.
+  wrapSpanContext: otelTraceApi.wrapSpanContext,
+  isSpanContextValid: otelTraceApi.isSpanContextValid,
+  deleteSpan: otelTraceApi.deleteSpan,
+  getSpan: otelTraceApi.getSpan,
+  getActiveSpan: otelTraceApi.getActiveSpan,
+  getSpanContext: otelTraceApi.getSpanContext,
+  setSpan: otelTraceApi.setSpan,
+  setSpanContext: otelTraceApi.setSpanContext,
+};
+
+export const trace: typeof autotelTraceFn & typeof otelTraceApi = Object.assign(
+  autotelTraceFn,
+  otelMethods,
+) as typeof autotelTraceFn & typeof otelTraceApi;

package/src/webhook.ts

@@ -36,8 +36,10 @@
 
 import { SpanKind, trace as otelTrace } from '@opentelemetry/api';
 import type { SpanContext, Link } from '@opentelemetry/api';
+import { emitCorrelatedEvent } from './correlated-events';
 import { trace } from './functional';
-import type { TraceContext } from './trace-context';
+import type { AttributeValue, TraceContext } from './trace-context';
+import { recordStructuredError } from './structured-error';
 
 // ============================================================================
 // Types
@@ -426,10 +428,9 @@ export function createParkingLot(config: ParkingLotConfig): ParkingLot {
 
       await store.save(fullKey, storedContext);
 
-      // Add event to current span
       const activeSpan = otelTrace.getActiveSpan();
       if (activeSpan) {
-        activeSpan.addEvent('trace_context_parked', {
+        const parkAttrs: Record<string, AttributeValue> = {
           'parking_lot.correlation_key': correlationKey,
           'parking_lot.ttl_ms': defaultTTLMs,
           ...(metadata &&
@@ -439,7 +440,16 @@ export function createParkingLot(config: ParkingLotConfig): ParkingLot {
                 v,
               ]),
             )),
-        });
+        };
+        emitCorrelatedEvent(
+          {
+            setAttribute: (k, v) => activeSpan.setAttribute(k, v),
+            setAttributes: (a) => activeSpan.setAttributes(a),
+            addEvent: (n, a) => activeSpan.addEvent(n, a),
+          },
+          'trace_context_parked',
+          parkAttrs,
+        );
       }
 
       // Return the unprefixed key so callers can use the same key for retrieve()
@@ -520,8 +530,7 @@ export function createParkingLot(config: ParkingLotConfig): ParkingLot {
                 const link = parkingLot.createLink(parkedContext);
                 baseCtx.addLinks([link]);
 
-                // Add event
-                baseCtx.addEvent('parked_context_retrieved', {
+                emitCorrelatedEvent(baseCtx, 'parked_context_retrieved', {
                   'parking_lot.correlation_key': correlationKey,
                   'parking_lot.elapsed_ms': elapsedMs!,
                   'parking_lot.original_trace_id': parkedContext.traceId,
@@ -533,7 +542,7 @@ export function createParkingLot(config: ParkingLotConfig): ParkingLot {
                   const error = new Error(
                     `Required parked context not found for key: ${correlationKey}`,
                   );
-                  baseCtx.recordException(error);
+                  recordStructuredError(baseCtx, error);
                   throw error;
                 }
               }

package/src/workflow-distributed.ts

@@ -49,6 +49,7 @@
 
 import { context, propagation, SpanKind } from '@opentelemetry/api';
 import { createSafeBaggageSchema } from './business-baggage';
+import { emitCorrelatedEvent } from './correlated-events';
 import { trace } from './functional';
 import type { TraceContext } from './trace-context';
 
@@ -422,7 +423,7 @@ export function traceDistributedWorkflow<TArgs extends unknown[], TReturn>(
               baggageValues.stepIndex = stepIndex;
               WorkflowBaggage.set(baseCtx, baggageValues);
 
-              baseCtx.addEvent('workflow.step_progress', {
+              emitCorrelatedEvent(baseCtx, 'workflow.step_progress', {
                 'workflow.step.name': stepName,
                 'workflow.step.index': stepIndex,
               });
@@ -433,7 +434,7 @@ export function traceDistributedWorkflow<TArgs extends unknown[], TReturn>(
           config.onStart?.(workflowCtx);
 
           // Add start event
-          baseCtx.addEvent('workflow.started', {
+          emitCorrelatedEvent(baseCtx, 'workflow.started', {
             'workflow.id': workflowId,
             'workflow.name': config.name,
           });
@@ -446,7 +447,7 @@ export function traceDistributedWorkflow<TArgs extends unknown[], TReturn>(
             config.onComplete?.(workflowCtx, result);
 
             // Add completion event
-            baseCtx.addEvent('workflow.completed', {
+            emitCorrelatedEvent(baseCtx, 'workflow.completed', {
               'workflow.id': workflowId,
             });
 
@@ -456,7 +457,7 @@ export function traceDistributedWorkflow<TArgs extends unknown[], TReturn>(
             config.onError?.(workflowCtx, error as Error);
 
             // Add error event
-            baseCtx.addEvent('workflow.failed', {
+            emitCorrelatedEvent(baseCtx, 'workflow.failed', {
               'workflow.id': workflowId,
               'workflow.error': (error as Error).message,
             });
@@ -634,12 +635,16 @@ export function traceDistributedStep<TArgs extends unknown[], TReturn>(
             requiresCompensation(data?: Record<string, unknown>): void {
               compensationData = data;
               baseCtx.setAttribute('workflow.step.requires_compensation', true);
-              baseCtx.addEvent('workflow.step.compensation_registered', {
-                'workflow.step.name': config.name,
-                ...(data && {
-                  'workflow.step.compensation_data': JSON.stringify(data),
-                }),
-              });
+              emitCorrelatedEvent(
+                baseCtx,
+                'workflow.step.compensation_registered',
+                {
+                  'workflow.step.name': config.name,
+                  ...(data && {
+                    'workflow.step.compensation_data': JSON.stringify(data),
+                  }),
+                },
+              );
             },
           };
 
@@ -647,7 +652,7 @@ export function traceDistributedStep<TArgs extends unknown[], TReturn>(
           config.onStart?.(stepCtx);
 
           // Add start event
-          baseCtx.addEvent('workflow.step.started', {
+          emitCorrelatedEvent(baseCtx, 'workflow.step.started', {
             'workflow.step.name': config.name,
             ...(baggageValues && { 'workflow.id': baggageValues.workflowId }),
           });
@@ -660,7 +665,7 @@ export function traceDistributedStep<TArgs extends unknown[], TReturn>(
             config.onComplete?.(stepCtx, result);
 
             // Add completion event
-            baseCtx.addEvent('workflow.step.completed', {
+            emitCorrelatedEvent(baseCtx, 'workflow.step.completed', {
               'workflow.step.name': config.name,
             });
 
@@ -670,7 +675,7 @@ export function traceDistributedStep<TArgs extends unknown[], TReturn>(
             config.onError?.(stepCtx, error as Error);
 
             // Add error event with compensation info if registered
-            baseCtx.addEvent('workflow.step.failed', {
+            emitCorrelatedEvent(baseCtx, 'workflow.step.failed', {
               'workflow.step.name': config.name,
               'workflow.step.error': (error as Error).message,
               ...(compensationData && {