@kronos-ts/messaging 0.5.1 → 0.6.0

package/src/correlation-data.ts

@@ -92,6 +92,68 @@ export function simpleCorrelationDataProvider(...metadataKeys: string[]): Correl
   }
 }
 
+// ---------------------------------------------------------------------------
+// Extract phase (shared by the handler interceptor and the event processors)
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute correlation data from the given providers for `message` and merge it
+ * into the active UnitOfWork's correlation-data resource (`CORRELATION_DATA_KEY`).
+ *
+ * This is the reusable "extract" step. It is run:
+ * - by {@link correlationDataHandlerInterceptor} for command/query handlers, and
+ * - by the event processors per-event before invoking event handlers, so an
+ *   automation's outgoing commands/events inherit the triggering event's
+ *   lineage.
+ *
+ * Each provider is called with the message. Exceptions are caught and logged
+ * (they don't break message processing). Results merge over any existing
+ * correlation data, so values contributed earlier (e.g. via
+ * {@link contributeCorrelationData}) are preserved unless a provider overrides
+ * the same key.
+ *
+ * Must be called inside an active UnitOfWork.
+ */
+export function applyCorrelationData(
+  message: Message,
+  providers: ReadonlyArray<CorrelationDataProvider>,
+): void {
+  const correlationData: Record<string, string> = {}
+
+  for (const provider of providers) {
+    try {
+      Object.assign(correlationData, provider.correlationDataFor(message))
+    } catch (err) {
+      console.warn(
+        "Encountered exception creating correlation data from provider:",
+        err,
+      )
+    }
+  }
+
+  const existing = getActiveCorrelationData() ?? {}
+  setResource(CORRELATION_DATA_KEY, { ...existing, ...correlationData })
+}
+
+/**
+ * Contribute additional correlation data to the active UnitOfWork, merged over
+ * whatever is already present under `CORRELATION_DATA_KEY`. The merged set is
+ * applied to every message dispatched/appended from this UnitOfWork by the
+ * correlation-data dispatch interceptor and the event appender.
+ *
+ * Use this from a handler enhancer or handler to seed extra lineage keys that
+ * the built-in providers don't cover — for example an OpenTelemetry
+ * `traceparent` so the trace context rides along on outgoing messages. This is
+ * the supported alternative to mutating the object returned by
+ * {@link getActiveCorrelationData}.
+ *
+ * Throws `NoActiveUnitOfWork` when called outside an active UnitOfWork.
+ */
+export function contributeCorrelationData(partial: Record<string, string>): void {
+  const existing = getActiveCorrelationData() ?? {}
+  setResource(CORRELATION_DATA_KEY, { ...existing, ...partial })
+}
+
 // ---------------------------------------------------------------------------
 // Interceptor factory
 // ---------------------------------------------------------------------------
@@ -100,38 +162,18 @@ export function simpleCorrelationDataProvider(...metadataKeys: string[]): Correl
  * Creates a handler interceptor that extracts correlation data from the
  * incoming message and stores it in the ProcessingContext.
  *
- * This is the "extract" phase of the dual-interceptor pattern.
- *
- * Each provider is called with the message. Exceptions are caught and
- * logged (they don't break message processing). Results are merged —
- * later providers override earlier ones on key conflicts.
- *
- * The correlation data is stored as a ProcessingContext resource under
- * `CORRELATION_DATA_KEY`, where the dispatch interceptor reads it.
+ * This is the "extract" phase of the dual-interceptor pattern, delegating to
+ * {@link applyCorrelationData}. The correlation data is stored as a
+ * ProcessingContext resource under `CORRELATION_DATA_KEY`, where the dispatch
+ * interceptor reads it.
  */
 export function correlationDataHandlerInterceptor(
   providers: ReadonlyArray<CorrelationDataProvider>,
 ): HandlerInterceptor {
   return (message, next) => {
-    const correlationData: Record<string, string> = {}
-
-    for (const provider of providers) {
-      try {
-        const data = provider.correlationDataFor(message)
-        Object.assign(correlationData, data)
-      } catch (err) {
-        console.warn(
-          "Encountered exception creating correlation data from provider:",
-          err,
-        )
-      }
-    }
-
-    // Store in ALS-backed processing state.
     // CTX-01 / Plan 03-03: HandlerInterceptor no longer threads ProcessingContext;
     // resource writes go directly through the module-level ALS accessor.
-    setResource(CORRELATION_DATA_KEY, correlationData)
-
+    applyCorrelationData(message, providers)
     return next()
   }
 }

package/src/event-gateway.ts

@@ -28,6 +28,7 @@ export function createEventGateway(eventSink: EventSink): EventGateway {
     async publish(descriptor, payload, metadata = {}) {
       const tags = descriptor.tags ? descriptor.tags(payload) : []
       const event: EventMessage = {
+        kind: "event",
         identifier: generateIdentifier(),
         name: descriptor.name,
         version: descriptor.version,

package/src/gateway.ts

@@ -86,6 +86,7 @@ export function createCommandGateway(bus: CommandBus): CommandGateway {
     async send(descriptor, payload, metadata) {
       const resolvedMetadata = metadata ?? emptyMetadata()
       return bus.dispatch({
+        kind: "command",
         identifier: generateIdentifier(),
         name: descriptor.name,
         payload,
@@ -114,6 +115,7 @@ export function createQueryGateway(
       // bus.query, which handles its own UoW.
       return unitOfWorkRunner(resolvedMetadata, () =>
         bus.query({
+          kind: "query",
           identifier: generateIdentifier(),
           name: descriptor.name,
           payload,
@@ -125,6 +127,7 @@ export function createQueryGateway(
 
     subscriptionQuery(descriptor, payload, metadata) {
       return bus.subscriptionQuery({
+        kind: "query",
         identifier: generateIdentifier(),
         name: descriptor.name,
         payload,

package/src/handler-enhancer.ts

@@ -1,10 +1,12 @@
+import type { MessageKind } from "./message.js"
+
 /**
  * Metadata about a handler being enhanced. Allows enhancers to
  * selectively wrap based on handler type, message name, etc.
  */
 export interface HandlerMetadata {
   /** The type of message this handler processes. */
-  readonly messageType: "command" | "event" | "query"
+  readonly messageType: MessageKind
   /** The qualified name of the message (e.g., "university.courses.CreateCourse"). */
   readonly messageName: string
   /** The name of the handler group or module (e.g., "course-commands"). */

package/src/index.ts

@@ -109,6 +109,8 @@ export {
   type CorrelationDataProvider,
   CORRELATION_DATA_KEY,
   getActiveCorrelationData,
+  applyCorrelationData,
+  contributeCorrelationData,
   messageOriginProvider,
   simpleCorrelationDataProvider,
   correlationDataHandlerInterceptor,

package/src/message.ts

@@ -1,10 +1,26 @@
 import type { QualifiedName, Metadata } from "@kronos-ts/common"
 
+/**
+ * Discriminates a message by its dispatch category.
+ *
+ * TypeScript erases interfaces at runtime, so `CommandMessage`, `EventMessage`,
+ * and `QueryMessage` — which are otherwise shape-identical — cannot be told
+ * apart with `instanceof` the way Axon Framework's nominal interfaces can.
+ * This field is the structural-typing equivalent of that `instanceof` check:
+ * it lets a reusable handler interceptor branch on message category without
+ * being pinned to a single bus.
+ */
+export type MessageKind = "command" | "event" | "query"
+
 /**
  * A message carrying a payload and metadata, identified by a unique ID
  * and routed by its qualified name.
+ *
+ * `kind` is derived at construction/reconstruction time, never persisted —
+ * each bus and event-store reconstruction site sets it from context.
  */
 export interface Message<P = unknown> {
+  readonly kind: MessageKind
   readonly identifier: string
   readonly name: QualifiedName
   readonly payload: P
@@ -15,7 +31,9 @@ export interface Message<P = unknown> {
 /**
  * A command message — dispatched to exactly one handler, may return a result.
  */
-export interface CommandMessage<P = unknown> extends Message<P> {}
+export interface CommandMessage<P = unknown> extends Message<P> {
+  readonly kind: "command"
+}
 
 /**
  * A command result message — the response from handling a command.
@@ -31,6 +49,7 @@ export interface CommandResultMessage<R = unknown> {
  * An event message — published to all interested handlers.
  */
 export interface EventMessage<P = unknown> extends Message<P> {
+  readonly kind: "event"
   readonly version: string
   readonly tags: ReadonlyArray<{ readonly key: string; readonly value: string }>
 }
@@ -43,4 +62,6 @@ export interface SequencedEventMessage<P = unknown> extends EventMessage<P> {
 /**
  * A query message — dispatched to handler(s) that can answer it.
  */
-export interface QueryMessage<P = unknown> extends Message<P> {}
+export interface QueryMessage<P = unknown> extends Message<P> {
+  readonly kind: "query"
+}

package/src/send.ts

@@ -35,6 +35,7 @@ export const send: CommandDispatchFunction = async (descriptor, payload) => {
   const bus = state.resources.get(COMMAND_BUS_KEY.symbol) as CommandBus | undefined
   if (!bus) throw new Error("No command bus configured")
   return bus.dispatch({
+    kind: "command",
     identifier: generateIdentifier(),
     name: descriptor.name,
     payload,

package/src/span-factory.ts

@@ -12,6 +12,16 @@ export interface Span {
   end(): void
   /** Record an error on the span and end it. */
   recordException(error: Error): void
+  /**
+   * Run `fn` with this span set as the active trace context, returning `fn`'s
+   * result. Spans created — and trace context read (`propagateContext` /
+   * `currentTraceContext`) — inside `fn` are parented to this span. When `fn`
+   * is async the span stays active across its awaits.
+   *
+   * Optional: callers must fall back to invoking `fn` directly when a Span
+   * implementation doesn't provide it.
+   */
+  runActive?<T>(fn: () => T): T
 }
 
 /**
@@ -37,10 +47,22 @@ export interface SpanFactory {
 
   /**
    * Create a span for handling a message (consumer side).
-   * Extracts trace context from the parent message's metadata.
+   * Extracts trace context from the parent message's metadata and continues
+   * that trace (the new span is a child in the same trace).
    */
   createHandlerSpan(operationName: string, parentMessage: Message): Span
 
+  /**
+   * Like {@link createHandlerSpan}, but starts a NEW trace linked to the parent
+   * message's trace context instead of continuing it. Use for asynchronously
+   * handled messages (e.g. streaming/tracking event processors) where joining a
+   * possibly long-finished originating trace would be misleading — the link
+   * preserves correlation without false nesting.
+   *
+   * Optional: callers fall back to {@link createHandlerSpan} when absent.
+   */
+  createLinkedHandlerSpan?(operationName: string, parentMessage: Message): Span
+
   /**
    * Create a span for dispatching a message (producer side).
    * Links to the parent message's trace context.
@@ -56,6 +78,17 @@ export interface SpanFactory {
    */
   propagateContext<M extends Message>(message: M): M
 
+  /**
+   * Returns the currently active trace context as propagation headers (e.g. the
+   * W3C `traceparent`), or an empty object when no span is active. Used to store
+   * the handler's trace context on the UnitOfWork (via `contributeCorrelationData`)
+   * so it rides along on appended and dispatched messages — including those
+   * published at commit time, after the handler span has ended.
+   *
+   * Optional: callers treat absence as "no trace context".
+   */
+  currentTraceContext?(): Record<string, string>
+
   /** Register a custom span attribute provider. */
   registerSpanAttributeProvider(provider: SpanAttributesProvider): void
 }
@@ -68,14 +101,17 @@ export function noOpSpanFactory(): SpanFactory {
     start() { return this },
     end() {},
     recordException() {},
+    runActive<T>(fn: () => T): T { return fn() },
   }
 
   return {
     createRootTrace() { return noOpSpan },
     createHandlerSpan() { return noOpSpan },
+    createLinkedHandlerSpan() { return noOpSpan },
     createDispatchSpan() { return noOpSpan },
     createInternalSpan() { return noOpSpan },
     propagateContext<M extends Message>(message: M) { return message },
+    currentTraceContext() { return {} },
     registerSpanAttributeProvider() {},
   }
 }

package/src/streaming-event-processor.ts

@@ -25,6 +25,7 @@ import {
   advanceToken,
 } from "./tracking-token.js"
 import { REPLAY_STATE_KEY } from "./replay-token.js"
+import { applyCorrelationData, type CorrelationDataProvider } from "./correlation-data.js"
 import { setResource, onPrepareCommit } from "./processing-state.js"
 import type { CommandBus } from "./command-bus.js"
 import type { QueryBus } from "./query-bus.js"
@@ -84,6 +85,12 @@ export interface StreamingEventProcessorOptions {
   queryBus?: QueryBus
   /** Event scheduler injected into ALS at handler-invocation entry (read by schedule()). */
   eventScheduler?: EventScheduler
+  /**
+   * Correlation data providers run against each event before its handlers are
+   * invoked, so commands/events dispatched from an event handler inherit the
+   * triggering event's correlationId/causationId.
+   */
+  correlationDataProviders?: ReadonlyArray<CorrelationDataProvider>
   /** Optional per-event callback fired inside the UoW before handler invocation (e.g. monitoring). */
   onEventDelivery?: () => void
   unitOfWorkRunner?: UoWRunner
@@ -127,6 +134,7 @@ export function createStreamingEventProcessor(
     commandBus,
     queryBus,
     eventScheduler,
+    correlationDataProviders,
     onEventDelivery,
     unitOfWorkRunner = runInNewUoW,
     tokenStore,
@@ -330,6 +338,11 @@ export function createStreamingEventProcessor(
     if (commandBus !== undefined) setResource(COMMAND_BUS_KEY, commandBus)
     if (queryBus !== undefined) setResource(QUERY_BUS_KEY, queryBus)
     if (eventScheduler !== undefined) setResource(EVENT_SCHEDULER_KEY, eventScheduler)
+    // Seed correlation data from the triggering event so an automation's
+    // outgoing commands/events inherit its lineage.
+    if (correlationDataProviders && correlationDataProviders.length > 0) {
+      applyCorrelationData(event, correlationDataProviders)
+    }
     // Optional per-event callback (e.g. monitoring hooks registered inside the UoW).
     if (onEventDelivery) onEventDelivery()
 

package/src/subscribing-event-processor.ts

@@ -10,6 +10,7 @@ import type { SubscribableEventSource } from "./event-bus.js"
 import type { CommandBus } from "./command-bus.js"
 import type { QueryBus } from "./query-bus.js"
 import type { HandlerEnhancerDefinition } from "./handler-enhancer.js"
+import { applyCorrelationData, type CorrelationDataProvider } from "./correlation-data.js"
 import { setResource } from "./processing-state.js"
 import { STATE_MANAGER_KEY, EVENT_SCHEDULER_KEY } from "@kronos-ts/eventsourcing"
 import type { EventScheduler } from "./event-scheduler.js"
@@ -56,6 +57,13 @@ export interface SubscribingEventProcessorOptions {
   queryBus?: QueryBus
   /** Event scheduler injected into ALS at handler-invocation entry (read by schedule()). */
   eventScheduler?: EventScheduler
+  /**
+   * Correlation data providers run against each event before its handlers are
+   * invoked. Their output is seeded into the UoW so commands/events dispatched
+   * from an event handler inherit the triggering event's
+   * correlationId/causationId. Empty/undefined → no seeding.
+   */
+  correlationDataProviders?: ReadonlyArray<CorrelationDataProvider>
   /** Optional per-event callback fired inside the UoW before handler invocation (e.g. monitoring). */
   onEventDelivery?: () => void
   unitOfWorkRunner?: UoWRunner
@@ -87,6 +95,7 @@ export function createSubscribingEventProcessor(
     commandBus,
     queryBus,
     eventScheduler,
+    correlationDataProviders,
     onEventDelivery,
     unitOfWorkRunner = runInNewUoW,
     errorHandler = loggingErrorHandler(name),
@@ -141,6 +150,11 @@ export function createSubscribingEventProcessor(
     if (commandBus !== undefined) setResource(COMMAND_BUS_KEY, commandBus)
     if (queryBus !== undefined) setResource(QUERY_BUS_KEY, queryBus)
     if (eventScheduler !== undefined) setResource(EVENT_SCHEDULER_KEY, eventScheduler)
+    // Seed correlation data from the triggering event so an automation's
+    // outgoing commands/events inherit its lineage.
+    if (correlationDataProviders && correlationDataProviders.length > 0) {
+      applyCorrelationData(event, correlationDataProviders)
+    }
     // Optional per-event callback (e.g. monitoring hooks registered inside the UoW).
     if (onEventDelivery) onEventDelivery()
 

package/src/tracing-command-bus.ts

@@ -1,18 +1,26 @@
 import type { CommandBus } from "./command-bus.js"
 import type { CommandMessage } from "./message.js"
-import type { SpanFactory } from "./span-factory.js"
+import type { SpanFactory, Span } from "./span-factory.js"
+
+/** Run `fn` with `span` active, falling back to a plain call when the span lacks runActive. */
+function runActive<R>(span: Span, fn: () => R): R {
+  return span.runActive ? span.runActive(fn) : fn()
+}
 
 /**
- * A {@link CommandBus} decorator that wraps dispatch and handler invocations
- * with tracing spans.
+ * A {@link CommandBus} decorator that traces command dispatch (the producer
+ * side).
  *
  * Dispatch creates a "dispatch" span and propagates trace context into the
- * message metadata. Subscribe wraps each handler with a "handle" span.
- *
+ * message metadata, so the handler links back to it across the bus boundary.
+ * The handler ("handle") span is created by {@link tracingHandlerEnhancerDefinition},
+ * the single authority for handler-side spans across command/query/event
+ * handlers — so this decorator does not wrap subscribe, avoiding a duplicate
+ * command handle span.
  *
  * @param delegate  The underlying command bus to decorate.
  * @param spanFactory  The span factory for creating tracing spans.
- * @returns A decorated command bus with tracing instrumentation.
+ * @returns A decorated command bus with dispatch tracing.
  */
 export function createTracingCommandBus(
   delegate: CommandBus,
@@ -22,8 +30,12 @@ export function createTracingCommandBus(
     async dispatch(message: CommandMessage): Promise<unknown> {
       const span = spanFactory.createDispatchSpan(`dispatch(${String(message.name)})`, message).start()
       try {
-        const propagated = spanFactory.propagateContext(message)
-        const result = await delegate.dispatch(propagated)
+        // Propagate inside the active dispatch span so the outgoing message
+        // carries this span's trace context and the handler links to it.
+        const result = await runActive(span, () => {
+          const propagated = spanFactory.propagateContext(message)
+          return delegate.dispatch(propagated)
+        })
         span.end()
         return result
       } catch (err) {
@@ -36,17 +48,9 @@ export function createTracingCommandBus(
       commandName: string,
       handler: (message: CommandMessage) => Promise<unknown>,
     ): void {
-      delegate.subscribe(commandName, async (msg: CommandMessage) => {
-        const span = spanFactory.createHandlerSpan(`handle(${commandName})`, msg).start()
-        try {
-          const result = await handler(msg)
-          span.end()
-          return result
-        } catch (err) {
-          span.recordException(err instanceof Error ? err : new Error(String(err)))
-          throw err
-        }
-      })
+      // Handler-side spans are owned by tracingHandlerEnhancerDefinition; pass
+      // the handler through untouched so commands get exactly one handle span.
+      delegate.subscribe(commandName, handler)
     },
   }
 }

package/src/tracing-handler-enhancer.ts

@@ -1,12 +1,20 @@
 import type { HandlerEnhancerDefinition, HandlerMetadata } from "./handler-enhancer.js"
-import type { SpanFactory } from "./span-factory.js"
+import type { SpanFactory, Span } from "./span-factory.js"
+import type { Message } from "./message.js"
+import { contributeCorrelationData } from "./correlation-data.js"
 
 /**
  * Handler enhancer that wraps message handler invocations with tracing spans.
  *
- * Creates an internal span per handler invocation, recording the handler
- * name and message type as context. Errors are recorded on the span.
+ * The span is created from the message being handled (extracting any trace
+ * context from its metadata) so the handler re-parents onto the dispatcher's
+ * trace across the message boundary. Event handlers start a new trace linked to
+ * the triggering event; command/query handlers continue the current trace.
  *
+ * The handler runs inside the span's active context, and the active trace
+ * context is captured onto the UnitOfWork (via contributeCorrelationData) so
+ * appended and dispatched messages carry it — including events published at
+ * commit time, after the span has ended.
  */
 export function tracingHandlerEnhancerDefinition(
   spanFactory: SpanFactory,
@@ -19,9 +27,27 @@ export function tracingHandlerEnhancerDefinition(
       const spanName = `${metadata.handlerGroup}.${metadata.messageName}`
 
       return (async (...args: any[]) => {
-        const span = spanFactory.createInternalSpan(spanName).start()
+        const message = args[0]
+        const span = createSpan(spanFactory, spanName, message, metadata).start()
+        const runActive: <R>(fn: () => R) => R = span.runActive
+          ? span.runActive.bind(span)
+          : (fn) => fn()
+
         try {
-          const result = await handler(...args)
+          const result = await runActive(() => {
+            // Store the active trace context on the UnitOfWork so outgoing and
+            // appended messages carry it. Best-effort: tracing must never break
+            // handling, and there may be no active UnitOfWork.
+            try {
+              const traceContext = spanFactory.currentTraceContext?.()
+              if (traceContext && Object.keys(traceContext).length > 0) {
+                contributeCorrelationData(traceContext)
+              }
+            } catch {
+              // no active UnitOfWork or no tracing context — skip
+            }
+            return handler(...args)
+          })
           span.end()
           return result
         } catch (error) {
@@ -32,3 +58,28 @@ export function tracingHandlerEnhancerDefinition(
     },
   }
 }
+
+function isMessage(value: unknown): value is Message {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "metadata" in value &&
+    "identifier" in value
+  )
+}
+
+function createSpan(
+  spanFactory: SpanFactory,
+  spanName: string,
+  message: unknown,
+  metadata: HandlerMetadata,
+): Span {
+  if (!isMessage(message)) {
+    // No message to re-parent from (defensive — wired handlers always receive one).
+    return spanFactory.createInternalSpan(spanName)
+  }
+  if (metadata.messageType === "event" && spanFactory.createLinkedHandlerSpan) {
+    return spanFactory.createLinkedHandlerSpan(spanName, message)
+  }
+  return spanFactory.createHandlerSpan(spanName, message)
+}

package/src/tracking-event-processor.ts

@@ -22,6 +22,7 @@ import {
   advanceToken,
 } from "./tracking-token.js"
 import { REPLAY_STATE_KEY } from "./replay-token.js"
+import { applyCorrelationData, type CorrelationDataProvider } from "./correlation-data.js"
 import { setResource, onPrepareCommit } from "./processing-state.js"
 import type { HandlerEnhancerDefinition } from "./handler-enhancer.js"
 import type { CommandBus } from "./command-bus.js"
@@ -76,6 +77,12 @@ export interface TrackingEventProcessorOptions {
   queryBus?: QueryBus
   /** Event scheduler injected into ALS at handler-invocation entry (read by schedule()). */
   eventScheduler?: EventScheduler
+  /**
+   * Correlation data providers run against each event before its handlers are
+   * invoked, so commands/events dispatched from an event handler inherit the
+   * triggering event's correlationId/causationId.
+   */
+  correlationDataProviders?: ReadonlyArray<CorrelationDataProvider>
   /** Optional per-event callback fired inside the UoW before handler invocation (e.g. monitoring). */
   onEventDelivery?: () => void
   unitOfWorkRunner?: UoWRunner
@@ -151,6 +158,7 @@ export function createTrackingEventProcessor(
     commandBus,
     queryBus,
     eventScheduler,
+    correlationDataProviders,
     onEventDelivery,
     unitOfWorkRunner = runInNewUoW,
     tokenStore,
@@ -341,6 +349,11 @@ export function createTrackingEventProcessor(
     if (commandBus !== undefined) setResource(COMMAND_BUS_KEY, commandBus)
     if (queryBus !== undefined) setResource(QUERY_BUS_KEY, queryBus)
     if (eventScheduler !== undefined) setResource(EVENT_SCHEDULER_KEY, eventScheduler)
+    // Seed correlation data from the triggering event so an automation's
+    // outgoing commands/events inherit its lineage.
+    if (correlationDataProviders && correlationDataProviders.length > 0) {
+      applyCorrelationData(event, correlationDataProviders)
+    }
     // Optional per-event callback (e.g. monitoring hooks registered inside the UoW).
     if (onEventDelivery) onEventDelivery()
 
@@ -375,6 +388,9 @@ export function createTrackingEventProcessor(
     if (commandBus !== undefined) setResource(COMMAND_BUS_KEY, commandBus)
     if (queryBus !== undefined) setResource(QUERY_BUS_KEY, queryBus)
     if (eventScheduler !== undefined) setResource(EVENT_SCHEDULER_KEY, eventScheduler)
+    if (correlationDataProviders && correlationDataProviders.length > 0) {
+      applyCorrelationData(event, correlationDataProviders)
+    }
 
     const position =
       typeof letter.diagnostics.position === "number" ? BigInt(letter.diagnostics.position) : 0n