@reventlessdev/reventless-aws 3.0.0-alpha.220 → 3.0.0-alpha.221

package/src/adapter/Runtime/AggregateRuntime_Builder_PerAggregate_Async.res.mjs

@@ -8,6 +8,7 @@ import * as Aggregate$ReventlessCore from "@reventlessdev/reventless-core/src/co
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
 import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/src/ComponentType.res.mjs";
+import * as Util_LogAttribution$ReventlessAws from "../../util/Util_LogAttribution.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 
@@ -138,11 +139,12 @@ function finish() {
       let name = ComponentType$ReventlessCore.name(spec.aggregateName, Aggregate$ReventlessCore.componentType);
       let specModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
       let behaviorModule = Stdlib_Option.getOr(JSON.stringify(info.behaviorModulePath), `""`);
+      let pluginFragment = Util_LogAttribution$ReventlessAws.pluginFragment(`AggregateRuntime(` + spec.aggregateName + `)`);
       let handlerConfigOutput = Pulumi.all([
         info.eventLogTableName,
         spec.queueUrl,
         spec.queueArn
-      ]).apply(param => `{"handlers":[{"specModule":` + specModule + `,"behaviorModule":` + behaviorModule + `,"eventLogTable":"` + param[0] + `","queueUrl":"` + param[1] + `","queueArn":"` + param[2] + `"}]}`);
+      ]).apply(param => `{"handlers":[{"specModule":` + specModule + `,"behaviorModule":` + behaviorModule + `,"eventLogTable":"` + param[0] + `","queueUrl":"` + param[1] + `","queueArn":"` + param[2] + `"` + pluginFragment + `}]}`);
       let envVars = {};
       envVars["HANDLER_CONFIG"] = handlerConfigOutput;
       envVars["DISPATCH_MODE"] = "async";
@@ -152,7 +154,7 @@ function finish() {
       packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg);
       packageDirs[behaviorPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(behaviorPkg);
       let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AggregateEntryPoint.mjs", packageDirs, undefined);
-      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(name, "CommandHandler", match.code, match.sourceCodeHash, envVars, spec.memorySize, spec.timeout, undefined, undefined, undefined, undefined, undefined, aggregateOpts);
+      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(name, "CommandHandler", "Aggregate", match.code, match.sourceCodeHash, envVars, spec.memorySize, spec.timeout, undefined, undefined, undefined, undefined, undefined, aggregateOpts);
       spec.connects.forEach(connect => connect(runtime));
       let channelSpecs = Stdlib_Option.mapOr(spec.eventCollectorChannelSpec, [], cs => [cs]);
       EventCollectorChannel_DynamoDbStream$ReventlessAws.connect(name, channelSpecs, runtime, aggregateOpts);

package/src/adapter/Runtime/AggregateRuntime_Builder_Single.res

@@ -250,6 +250,13 @@ let finish = () =>
             let behaviorModule =
               info.behaviorModulePath->JSON.stringifyAny->Option.getOr(`""`)
 
+// `plugin` cannot be resolved inside the Lambda — LogPrefix's registry is a
+            // deploy-time structure, and the Lambda-name fallback yields nothing for a
+            // shared or per-aggregate command handler. Resolve it here; the shell still
+            // derives `comp` itself from the spec name.
+            let pluginFragment = Util_LogAttribution.pluginFragment(
+              ~comp=`AggregateRuntime(${spec.aggregateName})`,
+            )
             let handlerJson =
               Pulumi.Output.all4((
                 info.eventLogTableName,
@@ -258,7 +265,7 @@ let finish = () =>
                 pgConnectionFragment,
               ))
               ->Pulumi.Output.apply(((table, queueUrl, queueArn, pgFragment)) =>
-                `{"specModule":${specModule},"behaviorModule":${behaviorModule},"eventLogTable":"${table}","queueUrl":"${queueUrl}","queueArn":"${queueArn}"${pgFragment}}`
+                `{"specModule":${specModule},"behaviorModule":${behaviorModule},"eventLogTable":"${table}","queueUrl":"${queueUrl}","queueArn":"${queueArn}"${pluginFragment}${pgFragment}}`
               )
             let _ = handlerOutputs->Array.push(handlerJson)
           | None =>
@@ -327,6 +334,7 @@ let finish = () =>
         let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
           ~name="AllAggregatesCmdHandler",
           ~unitKind=ReventlessCore.Monitoring.CommandHandler,
+          ~componentKind=ReventlessCore.ComponentType.Aggregate,
           ~code,
           ~sourceCodeHash,
           ~envVars,

package/src/adapter/Runtime/AggregateRuntime_Builder_Single.res.mjs

@@ -13,6 +13,7 @@ import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/sr
 import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
 import * as PgConnection$ReventlessAws from "../Postgres/PgConnection.res.mjs";
 import * as EventLogBackend$ReventlessAws from "../EventLog/EventLogBackend.res.mjs";
+import * as Util_LogAttribution$ReventlessAws from "../../util/Util_LogAttribution.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 import * as CommandTopicChannel_SQS_Sync$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Sync.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
@@ -174,12 +175,13 @@ function finish() {
         packageDirs[behaviorPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(behaviorPkg);
         let specModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
         let behaviorModule = Stdlib_Option.getOr(JSON.stringify(info.behaviorModulePath), `""`);
+        let pluginFragment = Util_LogAttribution$ReventlessAws.pluginFragment(`AggregateRuntime(` + spec.aggregateName + `)`);
         let handlerJson = Pulumi.all([
           info.eventLogTableName,
           spec.queueUrl,
           spec.queueArn,
           pgConnectionFragment
-        ]).apply(param => `{"specModule":` + specModule + `,"behaviorModule":` + behaviorModule + `,"eventLogTable":"` + param[0] + `","queueUrl":"` + param[1] + `","queueArn":"` + param[2] + `"` + param[3] + `}`);
+        ]).apply(param => `{"specModule":` + specModule + `,"behaviorModule":` + behaviorModule + `,"eventLogTable":"` + param[0] + `","queueUrl":"` + param[1] + `","queueArn":"` + param[2] + `"` + pluginFragment + param[3] + `}`);
         handlerOutputs.push(handlerJson);
       });
       let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
@@ -201,7 +203,7 @@ function finish() {
           subnetIds: pgSelection.subnetIds,
           securityGroupIds: [sgId]
         })) : undefined;
-      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAggregatesCmdHandler", "CommandHandler", match.code, match.sourceCodeHash, envVars, memorySize, timeout, cfg.reservedConcurrency, cfg.ephemeralStorageMb, cfg.logRetentionDays, undefined, vpcConfig, opts);
+      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAggregatesCmdHandler", "CommandHandler", "Aggregate", match.code, match.sourceCodeHash, envVars, memorySize, timeout, cfg.reservedConcurrency, cfg.ephemeralStorageMb, cfg.logRetentionDays, undefined, vpcConfig, opts);
       if (pgSelection !== undefined) {
         pgSelection.connectionConfig.apply(cc => new (Aws.iam.RolePolicy)("AllAggregatesCmdHandler-pgSecret", {
           policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, "AllAggregatesCmdHandler-pgSecretPolicy", [{

package/src/adapter/Runtime/AggregateRuntime_Builder_Single_Async.res

@@ -231,6 +231,13 @@ let finish = () =>
             let behaviorModule =
               info.behaviorModulePath->JSON.stringifyAny->Option.getOr(`""`)
 
+// `plugin` cannot be resolved inside the Lambda — LogPrefix's registry is a
+            // deploy-time structure, and the Lambda-name fallback yields nothing for a
+            // shared or per-aggregate command handler. Resolve it here; the shell still
+            // derives `comp` itself from the spec name.
+            let pluginFragment = Util_LogAttribution.pluginFragment(
+              ~comp=`AggregateRuntime(${spec.aggregateName})`,
+            )
             let handlerJson =
               Pulumi.Output.all4((
                 info.eventLogTableName,
@@ -239,7 +246,7 @@ let finish = () =>
                 pgConnectionFragment,
               ))
               ->Pulumi.Output.apply(((table, queueUrl, queueArn, pgFragment)) =>
-                `{"specModule":${specModule},"behaviorModule":${behaviorModule},"eventLogTable":"${table}","queueUrl":"${queueUrl}","queueArn":"${queueArn}"${pgFragment}}`
+                `{"specModule":${specModule},"behaviorModule":${behaviorModule},"eventLogTable":"${table}","queueUrl":"${queueUrl}","queueArn":"${queueArn}"${pluginFragment}${pgFragment}}`
               )
             let _ = handlerOutputs->Array.push(handlerJson)
           | None =>
@@ -302,6 +309,7 @@ let finish = () =>
         let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
           ~name="AllAggregatesAsyncCmdHandler",
           ~unitKind=ReventlessCore.Monitoring.CommandHandler,
+          ~componentKind=ReventlessCore.ComponentType.Aggregate,
           ~code,
           ~sourceCodeHash,
           ~envVars,

package/src/adapter/Runtime/AggregateRuntime_Builder_Single_Async.res.mjs

@@ -13,6 +13,7 @@ import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/sr
 import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
 import * as PgConnection$ReventlessAws from "../Postgres/PgConnection.res.mjs";
 import * as EventLogBackend$ReventlessAws from "../EventLog/EventLogBackend.res.mjs";
+import * as Util_LogAttribution$ReventlessAws from "../../util/Util_LogAttribution.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 import * as CommandTopicChannel_SQS_Async$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Async.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
@@ -166,12 +167,13 @@ function finish() {
         packageDirs[behaviorPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(behaviorPkg);
         let specModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
         let behaviorModule = Stdlib_Option.getOr(JSON.stringify(info.behaviorModulePath), `""`);
+        let pluginFragment = Util_LogAttribution$ReventlessAws.pluginFragment(`AggregateRuntime(` + spec.aggregateName + `)`);
         let handlerJson = Pulumi.all([
           info.eventLogTableName,
           spec.queueUrl,
           spec.queueArn,
           pgConnectionFragment
-        ]).apply(param => `{"specModule":` + specModule + `,"behaviorModule":` + behaviorModule + `,"eventLogTable":"` + param[0] + `","queueUrl":"` + param[1] + `","queueArn":"` + param[2] + `"` + param[3] + `}`);
+        ]).apply(param => `{"specModule":` + specModule + `,"behaviorModule":` + behaviorModule + `,"eventLogTable":"` + param[0] + `","queueUrl":"` + param[1] + `","queueArn":"` + param[2] + `"` + pluginFragment + param[3] + `}`);
         handlerOutputs.push(handlerJson);
       });
       let handlerConfigOutput = Pulumi.all(handlerOutputs).apply(handlers => `{"handlers":[` + handlers.join(",") + `]}`);
@@ -190,7 +192,7 @@ function finish() {
           subnetIds: pgSelection.subnetIds,
           securityGroupIds: [sgId]
         })) : undefined;
-      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAggregatesAsyncCmdHandler", "CommandHandler", match.code, match.sourceCodeHash, envVars, memorySize, timeout, cfg.reservedConcurrency, cfg.ephemeralStorageMb, cfg.logRetentionDays, undefined, vpcConfig, opts);
+      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAggregatesAsyncCmdHandler", "CommandHandler", "Aggregate", match.code, match.sourceCodeHash, envVars, memorySize, timeout, cfg.reservedConcurrency, cfg.ephemeralStorageMb, cfg.logRetentionDays, undefined, vpcConfig, opts);
       if (pgSelection !== undefined) {
         pgSelection.connectionConfig.apply(cc => new (Aws.iam.RolePolicy)("AllAggregatesAsyncCmdHandler-pgSecret", {
           policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, "AllAggregatesAsyncCmdHandler-pgSecretPolicy", [{

package/src/adapter/Runtime/AutomationSliceEntryPoint.mjs

@@ -7,8 +7,16 @@ import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as Chunk from "effect/Chunk";
 import { parseJsonOrThrow } from "sury/src/S.res.mjs";
-import { makeTableRef, makeQueueRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
-import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import {
+  makeTableRef,
+  makeQueueRef,
+  log,
+  runEffect,
+  setRequestId,
+  extractMetaField,
+  extractSentTimestamp,
+  extractRetryCount,
+} from "./HandlerFactoryHelpers.mjs";
 import { save as qdbSave } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
 import { publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
 import { Make as automationSliceCallbackMake } from "@reventlessdev/reventless-core/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs";
@@ -17,21 +25,13 @@ import { Make as outboundTranslationSliceCallbackMake } from "@reventlessdev/rev
 
 const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
 
-// Set at handler entry; read by runEffect to tag logs with the Lambda request id.
-let _currentRequestId = "unknown";
-
-function runEffect(correlationId, effect) {
-  let e = effect
-    // Promote correlationId/requestId/plugin to top-level JSON log fields —
-    // decoded by EffectLogger.install() from Effect log annotations. Harmless
-    // no-op if the unified logger isn't installed.
-    .pipe(Effect.annotateLogs("correlationId", correlationId || "unknown"))
-    .pipe(Effect.annotateLogs("requestId", _currentRequestId));
-  if (pluginName) e = e.pipe(Effect.annotateLogs("plugin", pluginName));
-  return e
-    .pipe(Effect.provideService(requestContextTag, { correlationId: correlationId || "unknown" }))
-    .pipe(Effect.runPromise);
-}
+// Same comp the slice's own callback logs under (AutomationSlice_Callback /
+// OutboundTranslationSlice_Callback), so a filter catches both the framework's
+// lines and the application handler's.
+const sliceComp = (callbackType, sliceName) =>
+  callbackType === "outbound"
+    ? `OutboundTranslationSlice(${sliceName})`
+    : `AutomationSlice(${sliceName})`;
 
 function groupBySource(records) {
   const dict = {};
@@ -95,8 +95,12 @@ async function buildAllHandlers() {
     // Multiple slices can share one source stream (e.g. several automation
     // slices reacting to the same DcbEventLog). Accumulate all handlers per
     // source ARN; a plain assignment collapses them to one (Promise.all race),
-    // silently dropping the rest.
-    (handlers[h.sourceUrn] ||= []).push(handler);
+    // silently dropping the rest. Each keeps its own comp — that is what
+    // separates co-hosted slices in the log stream.
+    (handlers[h.sourceUrn] ||= []).push({
+      handler,
+      comp: sliceComp(h.callbackType, specModule.name),
+    });
   }));
   return handlers;
 }
@@ -104,7 +108,7 @@ async function buildAllHandlers() {
 const initPromise = buildAllHandlers();
 
 export async function handler(event, context) {
-  _currentRequestId = context?.awsRequestId || "unknown";
+  setRequestId(context?.awsRequestId);
   const handlers = await initPromise;
   const records = event.Records || [];
   const grouped = groupBySource(records);
@@ -113,8 +117,18 @@ export async function handler(event, context) {
     const streamHandlers = handlers[arn];
     if (streamHandlers !== undefined && streamHandlers.length > 0) {
       log.debug("found " + streamHandlers.length + " handler(s) for " + arn, { comp: "AutomationSliceRuntime" });
-      await Promise.all(streamHandlers.map(h =>
-        runEffect(undefined, h({ Records: subRecords }, context))
+      const correlationId = extractMetaField(subRecords, "correlationId");
+      const causationId = extractMetaField(subRecords, "causationId");
+      const timestamp = extractSentTimestamp(subRecords);
+      const retryCount = extractRetryCount(subRecords);
+      await Promise.all(streamHandlers.map(({ handler: h, comp }) =>
+        runEffect(h({ Records: subRecords }, context), {
+          correlationId,
+          causationId,
+          comp,
+          timestamp,
+          retryCount,
+        })
       ));
     } else {
       log.warn("no handler found: " + arn, { comp: "AutomationSliceRuntime" });

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res

@@ -166,6 +166,7 @@ let finish = () =>
         let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
           ~name="AllAutomationSlices",
           ~unitKind=ReventlessCore.Monitoring.Reactor,
+          ~componentKind=ReventlessCore.ComponentType.AutomationSlice,
           ~code,
           ~sourceCodeHash,
           ~envVars,

package/src/adapter/Runtime/AutomationSliceRuntime_Builder_Single.res.mjs

@@ -120,7 +120,7 @@ function finish() {
       let envVars = {};
       envVars["HANDLER_CONFIG"] = handlerConfigOutput;
       let match$1 = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AutomationSliceEntryPoint.mjs", packageDirs, undefined);
-      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAutomationSlices", "Reactor", match$1.code, match$1.sourceCodeHash, envVars, match[0], match[1], undefined, undefined, undefined, undefined, undefined, opts);
+      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllAutomationSlices", "Reactor", "AutomationSlice", match$1.code, match$1.sourceCodeHash, envVars, match[0], match[1], undefined, undefined, undefined, undefined, undefined, opts);
       let channelSpecs = storedSpecs.map(param => param.channelSpec);
       EventCollectorChannel_DynamoDbStream$ReventlessAws.connect("AllAutomationSlices", channelSpecs, runtime, opts);
     } else {

package/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs

@@ -6,8 +6,16 @@
 import * as Chunk from "effect/Chunk";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
-import { patchSpecId, makeQueueRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
-import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import {
+  patchSpecId,
+  makeQueueRef,
+  log,
+  runEffect,
+  setRequestId,
+  extractMetaField,
+  extractSentTimestamp,
+  extractRetryCount,
+} from "./HandlerFactoryHelpers.mjs";
 import { Make as dcbEventLogOperationsMake } from "@reventlessdev/reventless-core/src/components/DcbEventLog/DcbEventLog_Operations.res.mjs";
 import { makeCommandGenerator } from "./CommandGeneratorEntryPoint_Ops.res.mjs";
 import { commandOutcomeToJson, runInlineAndCollect } from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
@@ -39,39 +47,12 @@ function extractTypeName(json) {
   return undefined;
 }
 
-// Set at handler entry; read by runEffect to tag logs with the Lambda request id.
-let _currentRequestId = "unknown";
-
-function runEffect(correlationId, effect) {
-  let e = effect
-    // Promote correlationId/requestId/plugin to top-level JSON log fields —
-    // decoded by EffectLogger.install() from Effect log annotations. Harmless
-    // no-op if the unified logger isn't installed.
-    .pipe(Effect.annotateLogs("correlationId", correlationId || "unknown"))
-    .pipe(Effect.annotateLogs("requestId", _currentRequestId));
-  if (pluginName) e = e.pipe(Effect.annotateLogs("plugin", pluginName));
-  return e
-    .pipe(Effect.provideService(requestContextTag, { correlationId: correlationId || "unknown" }))
-    .pipe(Effect.runPromise);
-}
-
-function extractCorrelationId(records) {
-  const first = records[0];
-  if (!first) return undefined;
-  const body = first.body;
-  if (body == null) return undefined;
-  try {
-    const parsed = JSON.parse(body);
-    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
-      const meta = parsed.meta;
-      if (meta && typeof meta === "object" && !Array.isArray(meta)) {
-        const cid = meta.correlationId;
-        if (typeof cid === "string") return cid;
-      }
-    }
-  } catch (_) {}
-  return undefined;
-}
+// This Lambda hosts one plugin's StateChangeSlices behind a composite handler
+// that routes per command TAG *inside* the stream — so the dispatch boundary
+// names the runtime group, not the individual slice. `Kind(Name)` matches the
+// shape every other comp uses, and the plugin name resolves through
+// LogPrefix.
+const dcbComp = (plugin) => `DcbCommandTopicRuntime(${plugin})`;
 
 // Exported for tests: build the [sqsHandler, cmdGenHandler] pair from an
 // already-parsed `HANDLER_CONFIG` shape, with an injectable module loader.
@@ -204,7 +185,10 @@ export async function buildHandlersForConfig(config, opts = {}) {
     return generateCommand({ ...event, meta, identity });
   };
 
-  return [sqsHandler, cmdGenHandler];
+  // Third element is additive — existing callers (the integration tests) keep
+  // destructuring the first two. No deploy-time `plugin` fragment needed here:
+  // this Lambda serves exactly one plugin and HANDLER_CONFIG already names it.
+  return [sqsHandler, cmdGenHandler, dcbComp(config.pluginName), config.pluginName];
 }
 
 async function buildHandler() {
@@ -212,7 +196,7 @@ async function buildHandler() {
   // Importing this module without HANDLER_CONFIG (e.g. from a test that drives
   // `buildHandlersForConfig` directly) must not crash module evaluation.
   // Lambda always sets HANDLER_CONFIG; the production path is unchanged.
-  if (!configStr) return [null, null];
+  if (!configStr) return [null, null, undefined, undefined];
   const config = JSON.parse(configStr);
   return buildHandlersForConfig(config, { loadModule: dynamicImport });
 }
@@ -220,21 +204,34 @@ async function buildHandler() {
 const initPromise = buildHandler();
 
 export async function handler(event, context) {
-  _currentRequestId = context?.awsRequestId || "unknown";
-  const [sqsHandler, cmdGenHandler] = await initPromise;
+  setRequestId(context?.awsRequestId);
+  const [sqsHandler, cmdGenHandler, comp, plugin] = await initPromise;
 
   // Route 1: AppSync direct invocation — payload carries the CommandGenerator.payload
   // shape (`{command, arguments, meta, identity?}`).
   if (event.command != null && event.arguments != null) {
     log.debug("AppSync direct invocation (" + DISPATCH_MODE + ")", { comp: "DcbCommandTopicRuntime" });
-    const outcome = await runEffect(undefined, cmdGenHandler(event));
+    // Direct invoke: the envelope is on `event.meta`, and there is no send time
+    // or receive count on this path.
+    const outcome = await runEffect(cmdGenHandler(event), {
+      correlationId: event.meta?.correlationId,
+      causationId: event.meta?.causationId,
+      comp,
+      plugin,
+    });
     return commandOutcomeToJson(outcome);
   }
 
   // Route 2: SQS CommandTopic events
   const records = event.Records || [];
-  const correlationId = extractCorrelationId(records);
   log.debug("processing " + records.length.toString() + " record(s)", { comp: "DcbCommandTopicRuntime" });
-  await runEffect(correlationId, sqsHandler(event, context));
+  await runEffect(sqsHandler(event, context), {
+    correlationId: extractMetaField(records, "correlationId"),
+    causationId: extractMetaField(records, "causationId"),
+    comp,
+    plugin,
+    timestamp: extractSentTimestamp(records),
+    retryCount: extractRetryCount(records),
+  });
   return "";
 }

package/src/adapter/Runtime/EventCollectorRuntime_Builder_PerEventCollector.res

@@ -67,11 +67,16 @@ let forEventCollector: ReventlessCore.Runtime.forEventCollector<
       let mappingsModule =
         info.mappingsModulePath->JSON.stringifyAny->Option.getOr(`""`)
 
+      // Same deploy-time log attribution as the shared-runtime builder: the
+      // entry point annotates every invocation with these, and the `comp` string
+      // must match the ReScript dispatch boundary's `EventCollector(<name>)`.
+      let attribution = Util_LogAttribution.fragments(~comp=`EventCollector(${eventCollectorName})`)
+
       let handlerConfigOutput =
         Pulumi.Output.all2((info.queryDbTableName, sourceUrns))
         ->Pulumi.Output.apply(((tableName, urns)) => {
           let sourceUrn = urns->Array.getUnsafe(0)
-          `{"handlers":[{"specModule":${specModule},"mappingsModule":${mappingsModule},"queryDbTableName":"${tableName}","sourceUrn":"${sourceUrn}"}]}`
+          `{"handlers":[{"specModule":${specModule},"mappingsModule":${mappingsModule},"queryDbTableName":"${tableName}","sourceUrn":"${sourceUrn}"${attribution}}]}`
         })
 
       let envVars: dict<Pulumi.Input.t<string>> = Dict.make()
@@ -93,6 +98,7 @@ let forEventCollector: ReventlessCore.Runtime.forEventCollector<
       let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
         ~name,
         ~unitKind=ReventlessCore.Monitoring.EventCollector,
+        ~componentKind=ReventlessCore.ComponentType.EventCollector,
         ~code,
         ~sourceCodeHash,
         ~envVars,

package/src/adapter/Runtime/EventCollectorRuntime_Builder_PerEventCollector.res.mjs

@@ -8,6 +8,7 @@ import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/co
 import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
 import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/src/ComponentType.res.mjs";
 import * as EventCollector$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventCollector/EventCollector.res.mjs";
+import * as Util_LogAttribution$ReventlessAws from "../../util/Util_LogAttribution.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 
@@ -46,12 +47,13 @@ function forEventCollector(param, eventTopics, resources, memorySizeOpt, timeout
   };
   let specModule = Stdlib_Option.getOr(JSON.stringify(info.specModulePath), `""`);
   let mappingsModule = Stdlib_Option.getOr(JSON.stringify(info.mappingsModulePath), `""`);
+  let attribution = Util_LogAttribution$ReventlessAws.fragments(`EventCollector(` + eventCollectorName + `)`);
   let handlerConfigOutput = Pulumi.all([
     info.queryDbTableName,
     sourceUrns
   ]).apply(param => {
     let sourceUrn = param[1][0];
-    return `{"handlers":[{"specModule":` + specModule + `,"mappingsModule":` + mappingsModule + `,"queryDbTableName":"` + param[0] + `","sourceUrn":"` + sourceUrn + `"}]}`;
+    return `{"handlers":[{"specModule":` + specModule + `,"mappingsModule":` + mappingsModule + `,"queryDbTableName":"` + param[0] + `","sourceUrn":"` + sourceUrn + `"` + attribution + `}]}`;
   });
   let envVars = {};
   envVars["HANDLER_CONFIG"] = handlerConfigOutput;
@@ -61,7 +63,7 @@ function forEventCollector(param, eventTopics, resources, memorySizeOpt, timeout
   packageDirs[specPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(specPkg);
   packageDirs[mappingsPkg] = Util_Bundle$ReventlessAws.resolvePackageRoot(mappingsPkg);
   let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/ReadModelEntryPoint.mjs", packageDirs, undefined);
-  let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(name, "EventCollector", match.code, match.sourceCodeHash, envVars, memorySize, timeout, undefined, undefined, undefined, undefined, undefined, opts);
+  let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(name, "EventCollector", "EventCollector", match.code, match.sourceCodeHash, envVars, memorySize, timeout, undefined, undefined, undefined, undefined, undefined, opts);
   EventCollectorChannel_DynamoDbStream$ReventlessAws.connect(name, [{
       channel: channel,
       eventTopics: eventTopics,

package/src/adapter/Runtime/EventCollectorRuntime_Builder_Single.res

@@ -44,6 +44,13 @@ let registerReadModel = (
 
 type storedSpec = {
   componentName: string,
+  /** The event collector's own resource name (`CustomersReadModel`), as opposed
+      to `componentName` (its parent read model, `Customers`). Source of the
+      `comp` baked into HANDLER_CONFIG — the deployed entry point annotates logs
+      with it, so it must match the ReScript dispatch boundary's
+      `EventCollector(<name>)` exactly (see
+      docs/plans/entrypoint-dispatch-parity-and-latency-fields.md). */
+  eventCollectorName: string,
   parentResource: Pulumi.Resource.t,
   sourceUrns: Pulumi.Output.t<array<string>>,
   channelSpec: ReventlessCore.EventCollector_Adapter.channelSpec<
@@ -93,6 +100,7 @@ let forEventCollector: ReventlessCore.Runtime.forEventCollector<
     storedSpecs
     ->Array.push({
       componentName: parentName,
+      eventCollectorName,
       parentResource,
       sourceUrns,
       channelSpec: {channel, eventTopics, resources},
@@ -210,6 +218,15 @@ let finish = () =>
                     `,"stateTopicName":${topic->JSON.Encode.string->JSON.stringify}`
                   }
                 : ""
+            // Log attribution baked at deploy time: this Lambda hosts every read
+            // model, so the shell needs a per-handler `comp` to keep their log
+            // lines separable, and a per-handler `plugin` because the shared
+            // Lambda's own name carries no single plugin identity. Both are
+            // resolved here — the registry LogPrefix consults is a deploy-time
+            // structure, empty inside the Lambda.
+            let attribution = Util_LogAttribution.fragments(
+              ~comp=`EventCollector(${spec.eventCollectorName})`,
+            )
             let handlerJson =
               Pulumi.Output.all4((
                 info.queryDbTableName,
@@ -221,7 +238,7 @@ let finish = () =>
                 // No stream resource (Postgres-backed source) → dispatch on the
                 // feed queue's ARN instead of a stream URN.
                 let sourceUrn = urns->Array.get(0)->Option.getOr(feedArn)
-                `{"specModule":${specModule},"mappingsModule":${mappingsModule},"queryDbTableName":"${tableName}","sourceUrn":"${sourceUrn}"${pgFragment}${stateTopicFragment}}`
+                `{"specModule":${specModule},"mappingsModule":${mappingsModule},"queryDbTableName":"${tableName}","sourceUrn":"${sourceUrn}"${attribution}${pgFragment}${stateTopicFragment}}`
               })
             let _ = handlerOutputs->Array.push(handlerJson)
           | None =>
@@ -284,6 +301,7 @@ let finish = () =>
         let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
           ~name="AllReadModels",
           ~unitKind=ReventlessCore.Monitoring.EventCollector,
+          ~componentKind=ReventlessCore.ComponentType.EventCollector,
           ~code,
           ~sourceCodeHash,
           ~envVars,

package/src/adapter/Runtime/EventCollectorRuntime_Builder_Single.res.mjs

@@ -17,6 +17,7 @@ import * as QueryDbBackend$ReventlessAws from "../QueryDb/QueryDbBackend.res.mjs
 import * as EventLogBackend$ReventlessAws from "../EventLog/EventLogBackend.res.mjs";
 import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
 import * as PgProjectionFeed$ReventlessAws from "../Postgres/PgProjectionFeed.res.mjs";
+import * as Util_LogAttribution$ReventlessAws from "../../util/Util_LogAttribution.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 import * as EventCollectorChannel_DynamoDbStream$ReventlessAws from "../EventCollector/EventCollectorChannel_DynamoDbStream.res.mjs";
 
@@ -65,6 +66,7 @@ function forEventCollector(param, eventTopics, resources, memorySizeOpt, timeout
   let sourceUrns = Pulumi.all(Component$ReventlessCore.outputs(eventCollector).resources.map(param => param.urn));
   storedSpecs.push({
     componentName: parentName,
+    eventCollectorName: eventCollectorName,
     parentResource: parentResource,
     sourceUrns: sourceUrns,
     channelSpec: {
@@ -128,6 +130,7 @@ function finish() {
         } else {
           stateTopicFragment = "";
         }
+        let attribution = Util_LogAttribution$ReventlessAws.fragments(`EventCollector(` + spec.eventCollectorName + `)`);
         let handlerJson = Pulumi.all([
           info.queryDbTableName,
           spec.sourceUrns,
@@ -135,7 +138,7 @@ function finish() {
           handlerPgFragment
         ]).apply(param => {
           let sourceUrn = Stdlib_Option.getOr(param[1][0], param[2]);
-          return `{"specModule":` + specModule + `,"mappingsModule":` + mappingsModule + `,"queryDbTableName":"` + param[0] + `","sourceUrn":"` + sourceUrn + `"` + param[3] + stateTopicFragment + `}`;
+          return `{"specModule":` + specModule + `,"mappingsModule":` + mappingsModule + `,"queryDbTableName":"` + param[0] + `","sourceUrn":"` + sourceUrn + `"` + attribution + param[3] + stateTopicFragment + `}`;
         });
         handlerOutputs.push(handlerJson);
       });
@@ -158,7 +161,7 @@ function finish() {
           subnetIds: qdbSelection.subnetIds,
           securityGroupIds: [sgId]
         })) : undefined;
-      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllReadModels", "EventCollector", match$1.code, match$1.sourceCodeHash, envVars, match[0], match[1], undefined, undefined, undefined, undefined, vpcConfig, opts);
+      let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset("AllReadModels", "EventCollector", "EventCollector", match$1.code, match$1.sourceCodeHash, envVars, match[0], match[1], undefined, undefined, undefined, undefined, vpcConfig, opts);
       if (qdbSelection !== undefined && anyPgBacked) {
         qdbSelection.connectionConfig.apply(cc => new (Aws.iam.RolePolicy)("AllReadModels-pgSecret", {
           policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, "AllReadModels-pgSecretPolicy", [{

package/src/adapter/Runtime/EventMapperEntryPoint.mjs

@@ -2,10 +2,17 @@
 // At cold start: reads HANDLER_CONFIG, dynamically imports Target Spec and Mappings,
 // wires EventMapper_Callback.MakeCounterHandler + MakeEventCollectorHandler.
 
-import * as Effect from "effect/Effect";
 import { $$String as IdString } from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
-import { patchSpecId, makeQueueRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
-import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import {
+  patchSpecId,
+  makeQueueRef,
+  log,
+  runEffect,
+  setRequestId,
+  extractMetaField,
+  extractSentTimestamp,
+  extractRetryCount,
+} from "./HandlerFactoryHelpers.mjs";
 import { MakeCounterHandler, MakeEventCollectorHandler } from "@reventlessdev/reventless-core/src/components/EventMapper/EventMapper_Callback.res.mjs";
 import { publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
 import { handleStreamEvent } from "@reventlessdev/reventless-aws/src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream_Runtime.res.mjs";
@@ -26,22 +33,6 @@ function patchMappingsSourceIds(mappingsModule) {
   };
 }
 
-// Set at handler entry; read by runEffect to tag logs with the Lambda request id.
-let _currentRequestId = "unknown";
-
-function runEffect(correlationId, effect) {
-  let e = effect
-    // Promote correlationId/requestId/plugin to top-level JSON log fields —
-    // decoded by EffectLogger.install() from Effect log annotations. Harmless
-    // no-op if the unified logger isn't installed.
-    .pipe(Effect.annotateLogs("correlationId", correlationId || "unknown"))
-    .pipe(Effect.annotateLogs("requestId", _currentRequestId));
-  if (pluginName) e = e.pipe(Effect.annotateLogs("plugin", pluginName));
-  return e
-    .pipe(Effect.provideService(requestContextTag, { correlationId: correlationId || "unknown" }))
-    .pipe(Effect.runPromise);
-}
-
 function groupBySource(records) {
   const dict = {};
   records.forEach(record => {
@@ -77,20 +68,31 @@ async function buildHandler() {
     commonEventsHandler: counterHandler.commonEventsHandler,
   });
 
-  return (event, context) => handleStreamEvent(eventCollectorHandler.handleJsonEvents, event, context);
+  return {
+    streamHandler: (event, context) =>
+      handleStreamEvent(eventCollectorHandler.handleJsonEvents, event, context),
+    // The mapper is named after the target it maps into.
+    comp: `EventMapper(${patchedTarget.name})`,
+  };
 }
 
 const initPromise = buildHandler();
 
 export async function handler(event, context) {
-  _currentRequestId = context?.awsRequestId || "unknown";
-  const streamHandler = await initPromise;
+  setRequestId(context?.awsRequestId);
+  const { streamHandler, comp } = await initPromise;
   const records = event.Records || [];
   const grouped = groupBySource(records);
 
   await Promise.all(Object.entries(grouped).map(async ([arn, subRecords]) => {
     log.debug("processing " + arn, { comp: "EventMapperRuntime" });
-    await runEffect(undefined, streamHandler({ Records: subRecords }, context));
+    await runEffect(streamHandler({ Records: subRecords }, context), {
+      correlationId: extractMetaField(subRecords, "correlationId"),
+      causationId: extractMetaField(subRecords, "causationId"),
+      comp,
+      timestamp: extractSentTimestamp(subRecords),
+      retryCount: extractRetryCount(subRecords),
+    });
   }));
 
   return "";