@reventlessdev/reventless-core 3.0.0-alpha.174 → 3.0.0-alpha.175

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.175 (2026-07-22)
+
+### Features
+
+* **aws:** give deployed resources a complete attribution tag schema ([f931a44](https://github.com/ReventlessDev/reventless-core/commit/f931a44ab311a4aff1cd73939b42e7e5221621c9))
+* **aws:** unify the deployed entry-point dispatch boundary; add latency fields ([ad7b3f6](https://github.com/ReventlessDev/reventless-core/commit/ad7b3f60e7b2b2213677732bbf13f486043075ef))
+* **core:** annotate event-collector logs with the element's comp ([eda413a](https://github.com/ReventlessDev/reventless-core/commit/eda413ab00eb8bb02b30e029af2d6221e3e9ba75)), closes [#1](https://github.com/ReventlessDev/reventless-core/issues/1)
+* **core:** attribute piece resources to the component that owns them ([2ddd91a](https://github.com/ReventlessDev/reventless-core/commit/2ddd91ae1a5394257dec4b9b6e5021d5aa6e7f63))
+* **core:** attribute shared substrate to the plugin that owns it ([a440d4f](https://github.com/ReventlessDev/reventless-core/commit/a440d4f827dfab9e2e9a763ffd9fc40240852e09))
+
+
 # 3.0.0-alpha.174 (2026-07-21)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.174",
+  "version": "3.0.0-alpha.175",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,17 +28,17 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.30",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.13",
     "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.14",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.13",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.29",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.17",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.14",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.17",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.102",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.103",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.28",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.79"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.80"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/ComponentType.res

@@ -2,6 +2,7 @@ type t =
   | Aggregate
   | Counter
   | Plugin
+  | Platform
   | CommandGenerator
   | CommandTopic
   | EventCollector
@@ -17,7 +18,10 @@ type t =
   | SideEffectHandler
   | Task
   | Vpc
-  | Core
+  | /** Vestigial: predates the platform/plugin split and names nothing the
+       framework builds. Do not reach for it — platform-level things are
+       `Platform`, and the built-in core PLUGIN is a `Plugin`. */
+  Core
   | Heartbeat
   | Cloner
   | DcbEventLog
@@ -32,6 +36,7 @@ let toString = componentType =>
   | Aggregate => "Aggregate"
   | Counter => "Counter"
   | Plugin => "Plugin"
+  | Platform => "Platform"
   | CommandGenerator => "CommandGenerator"
   | CommandTopic => "CommandTopic"
   | EventCollector => "EventCollector"
@@ -63,6 +68,7 @@ let ofString = str =>
   | "Aggregate" => Aggregate->Some
   | "Counter" => Counter->Some
   | "Plugin" => Plugin->Some
+  | "Platform" => Platform->Some
   | "CommandGenerator" => CommandGenerator->Some
   | "CommandTopic" => CommandTopic->Some
   | "EventCollector" => EventCollector->Some
@@ -95,6 +101,7 @@ let toName = componentType =>
   | Aggregate => "Aggr"
   | Counter => "Counter"
   | Plugin => "Plugin"
+  | Platform => "Platform"
   | CommandGenerator => "CmdGen"
   | CommandTopic => "CmdTopic"
   | EventCollector => "EventColl"

package/src/ComponentType.res.mjs

@@ -10,6 +10,8 @@ function toString(componentType) {
       return "Counter";
     case "Plugin" :
       return "Plugin";
+    case "Platform" :
+      return "Platform";
     case "CommandGenerator" :
       return "CommandGenerator";
     case "CommandTopic" :
@@ -97,6 +99,8 @@ function ofString(str) {
       return "InboundTranslationSlice";
     case "OutboundTranslationSlice" :
       return "OutboundTranslationSlice";
+    case "Platform" :
+      return "Platform";
     case "Plugin" :
       return "Plugin";
     case "QueryDB" :
@@ -130,6 +134,8 @@ function toName(componentType) {
       return "Counter";
     case "Plugin" :
       return "Plugin";
+    case "Platform" :
+      return "Platform";
     case "CommandGenerator" :
       return "CmdGen";
     case "CommandTopic" :

package/src/RequestContext.res

@@ -19,13 +19,24 @@
 // causal chain within one `correlationId`. `component` / `pluginName` identify the
 // component and plugin handling the invocation — mirror the `comp` / `plugin` log
 // fields so a consumer of this service sees the same attribution the logs carry.
-// All three are optional: absent in `.test()` and wherever the dispatch site has
+//
+// `timestamp` = when the triggering message was *sent* (ms since epoch), not when
+// this handler started: SQS `SentTimestamp`, a DynamoDB stream record's
+// `ApproximateCreationDateTime`, or dispatch time in-process. A handler computes
+// end-to-end latency from it without calling `Date.now()` itself, and the value
+// includes queue dwell — which a handler-local clock cannot see.
+// `retryCount` = delivery attempt, 1 on first delivery (SQS
+// `ApproximateReceiveCount`; always 1 where the transport has no redelivery).
+//
+// All optional fields are absent in `.test()` and wherever the dispatch site has
 // no value to supply.
 type t = {
   correlationId: string,
   causationId?: string,
   component?: string,
   pluginName?: string,
+  timestamp?: float,
+  retryCount?: int,
   identity: Reventless.Identity.t,
   claims: dict<string>,
 }
@@ -39,6 +50,8 @@ let make = (
   ~causationId=?,
   ~component=?,
   ~pluginName=?,
+  ~timestamp=?,
+  ~retryCount=?,
   ~identity=Reventless.Identity.anonymous,
   ~claims=Dict.make(),
 ): t => {
@@ -46,10 +59,37 @@ let make = (
   causationId: ?causationId,
   component: ?component,
   pluginName: ?pluginName,
+  timestamp: ?timestamp,
+  retryCount: ?retryCount,
   identity,
   claims,
 }
 
+// JS-facing constructor for the hand-written Lambda entry-point shells
+// (HandlerFactoryHelpers.mjs). `make`'s labelled arguments compile to *positional*
+// ones, so a JS caller breaks silently the moment an argument is inserted; this
+// takes a single options object whose field names survive compilation and stay
+// compiler-checked here. Every field is optional so a shell can supply only what
+// its transport actually carries.
+type options = {
+  correlationId?: string,
+  causationId?: string,
+  component?: string,
+  pluginName?: string,
+  timestamp?: float,
+  retryCount?: int,
+}
+
+let fromOptions = (o: options): t =>
+  make(
+    ~correlationId=o.correlationId->Option.getOr("unknown"),
+    ~causationId=?o.causationId,
+    ~component=?o.component,
+    ~pluginName=?o.pluginName,
+    ~timestamp=?o.timestamp,
+    ~retryCount=?o.retryCount,
+  )
+
 let getClaim = (ctx: t, key: string): option<string> =>
   ctx.claims->Dict.get(key)
 
@@ -61,10 +101,14 @@ let withClaim = (ctx: t, key: string, value: string): t => {
 
 let test = (
   ~correlationId="test-correlation-id",
+  ~timestamp=?,
+  ~retryCount=?,
   ~identity=Reventless.Identity.anonymous,
   ~claims=Dict.make(),
 ): t => {
   correlationId,
+  timestamp: ?timestamp,
+  retryCount: ?retryCount,
   identity,
   claims,
 }

package/src/RequestContext.res.mjs

@@ -1,11 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Context from "effect/Context";
 import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
 
 let tag = Context.GenericTag("reventless/RequestContext");
 
-function make(correlationId, causationId, component, pluginName, identityOpt, claimsOpt) {
+function make(correlationId, causationId, component, pluginName, timestamp, retryCount, identityOpt, claimsOpt) {
   let identity = identityOpt !== undefined ? identityOpt : Identity$Reventless.anonymous;
   let claims = claimsOpt !== undefined ? claimsOpt : ({});
   return {
@@ -13,11 +14,17 @@ function make(correlationId, causationId, component, pluginName, identityOpt, cl
     causationId: causationId,
     component: component,
     pluginName: pluginName,
+    timestamp: timestamp,
+    retryCount: retryCount,
     identity: identity,
     claims: claims
   };
 }
 
+function fromOptions(o) {
+  return make(Stdlib_Option.getOr(o.correlationId, "unknown"), o.causationId, o.component, o.pluginName, o.timestamp, o.retryCount, undefined, undefined);
+}
+
 function getClaim(ctx, key) {
   return ctx.claims[key];
 }
@@ -30,12 +37,14 @@ function withClaim(ctx, key, value) {
   return newrecord;
 }
 
-function test(correlationIdOpt, identityOpt, claimsOpt) {
+function test(correlationIdOpt, timestamp, retryCount, identityOpt, claimsOpt) {
   let correlationId = correlationIdOpt !== undefined ? correlationIdOpt : "test-correlation-id";
   let identity = identityOpt !== undefined ? identityOpt : Identity$Reventless.anonymous;
   let claims = claimsOpt !== undefined ? claimsOpt : ({});
   return {
     correlationId: correlationId,
+    timestamp: timestamp,
+    retryCount: retryCount,
     identity: identity,
     claims: claims
   };
@@ -44,6 +53,7 @@ function test(correlationIdOpt, identityOpt, claimsOpt) {
 export {
   tag,
   make,
+  fromOptions,
   getClaim,
   withClaim,
   test,

package/src/ResourceAttribution.res

@@ -0,0 +1,133 @@
+/***
+The vocabulary a deployed resource is attributed with: which model element owns
+it, in what role, at what level. Provider-agnostic on purpose — AWS renders these
+as namespaced `reventless:` tags, Kubernetes as `reventless.io` labels. Defining
+them once here is what keeps the two backends (and the monitoring registry) from
+drifting into private spellings of the same fact.
+
+The three facts are deliberately independent:
+
+- `ComponentType.t` — the *modelling* kind (Aggregate, StateViewSlice, …): what
+  the element IS in the domain model.
+- `Role.t` — the *deployment piece* (EventLog, QueryDb, Runtime, …): what job
+  this particular resource does for that element. One component owns several
+  pieces, so kind alone can't identify a resource.
+- `Scope.t` — the level the resource is attributed to: an individual component,
+  a plugin's shared substrate, or platform substrate.
+
+Note this is NOT the same axis as `Monitoring.unitKind`, which classifies an
+execution unit by what its *failure* means (CommandHandler / Projection /
+Reactor). A `Runtime` role can be any of those; both facts are worth carrying and
+neither derives from the other.
+*/
+
+/** The level a resource is attributed to. */
+module Scope = {
+  type t =
+    | /** owned by one model component */ Component
+    | /** shared substrate within a plugin (DcbEventLog, plugin DLQ, …) */ Plugin
+    | /** shared substrate across the platform (API, auth, hosting, …) */ Platform
+
+  let toString = scope =>
+    switch scope {
+    | Component => "component"
+    | Plugin => "plugin"
+    | Platform => "platform"
+    }
+}
+
+/**
+The deployment piece a resource implements. `Other(string)` is the escape hatch
+for support pieces and future roles (same pattern as `Monitoring.unitKind`).
+*/
+module Role = {
+  type t =
+    | CommandTopic
+    | EventTopic
+    | StateTopic
+    | EventLog
+    | DcbEventLog
+    | EventLogSubscription
+    | EventCollector
+    | QueryDb
+    | /** the execution unit that runs a component's handler */ Runtime
+    | /** queue/topic receiving messages that exhausted processing */ DeadLetter
+    | /** scheduled invocation (heartbeat, task scheduler) */ Scheduler
+    | /** log storage and log-derived metrics */ Logs
+    | /** execution identity and its policies */ Identity
+    | /** the GraphQL API surface and its resolvers */ Api
+    | /** identity provider / user pools */ Auth
+    | /** static-site hosting, CDN, certificates, DNS */ Hosting
+    | /** VPC and its network plumbing */ Network
+    | /** transport wiring between a source and a runtime */ EventSourceMapping
+    | /** bulk data movement (cloner, migrations) */ DataTransfer
+    | Other(string)
+
+  let toString = role =>
+    switch role {
+    | CommandTopic => "CommandTopic"
+    | EventTopic => "EventTopic"
+    | StateTopic => "StateTopic"
+    | EventLog => "EventLog"
+    | DcbEventLog => "DcbEventLog"
+    | EventLogSubscription => "EventLogSubscription"
+    | EventCollector => "EventCollector"
+    | QueryDb => "QueryDb"
+    | Runtime => "Runtime"
+    | DeadLetter => "DeadLetter"
+    | Scheduler => "Scheduler"
+    | Logs => "Logs"
+    | Identity => "Identity"
+    | Api => "Api"
+    | Auth => "Auth"
+    | Hosting => "Hosting"
+    | Network => "Network"
+    | EventSourceMapping => "EventSourceMapping"
+    | DataTransfer => "DataTransfer"
+    | Other(name) => name
+    }
+}
+
+/**
+The model component a provisioned resource belongs to.
+
+Piece builders (EventLog, QueryDb, CommandTopic, EventTopic, EventCollector) are
+shared building blocks applied as functors by many different component kinds — a
+QueryDb is instantiated by ReadModel, StateViewSlice, AutomationSlice, both
+translation slices and Counter. The adapter that provisions the physical resource
+sits at the bottom of that chain and would otherwise only know its own piece, so
+`kind` would collapse onto `role` and the owning component would be unrecoverable.
+The owning builder passes this record down instead.
+
+`name` is the owner's spec name (the component stem, `Products`), not the
+suffixed resource name (`ProductsQueryDb`).
+*/
+type owner = {kind: ComponentType.t, name: string}
+
+/**
+Ambient deploy-time context: which plugin (and platform) is currently being
+constructed. Adapters that create resources sit far below the builder that knows
+these names, and threading two strings through every adapter signature would be a
+large, purely mechanical churn — so the plugin builder publishes them here for
+the duration of its construct, exactly as it already does for
+`Logger.currentPluginName`.
+
+Safe because deploy-time resource construction is synchronous (the framework
+forbids creating resources inside `Pulumi.Output.apply`), so everything built
+between `enter` and `restore` genuinely belongs to that plugin. Outside any
+plugin construct both are `None` — which is the correct answer for
+platform-scope substrate.
+*/
+type context = {platform: option<string>, plugin: option<string>}
+
+let current: ref<context> = ref({platform: None, plugin: None})
+
+/** Publish the plugin being constructed; returns the previous context to restore. */
+let enter = (~platform: string, ~plugin: string) => {
+  let previous = current.contents
+  current := {platform: Some(platform), plugin: Some(plugin)}
+  previous
+}
+
+/** Restore the context captured by `enter`. */
+let restore = (previous: context) => current := previous

package/src/ResourceAttribution.res.mjs

@@ -0,0 +1,96 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function toString(scope) {
+  switch (scope) {
+    case "Component" :
+      return "component";
+    case "Plugin" :
+      return "plugin";
+    case "Platform" :
+      return "platform";
+  }
+}
+
+let Scope = {
+  toString: toString
+};
+
+function toString$1(role) {
+  if (typeof role === "object") {
+    return role._0;
+  }
+  switch (role) {
+    case "CommandTopic" :
+      return "CommandTopic";
+    case "EventTopic" :
+      return "EventTopic";
+    case "StateTopic" :
+      return "StateTopic";
+    case "EventLog" :
+      return "EventLog";
+    case "DcbEventLog" :
+      return "DcbEventLog";
+    case "EventLogSubscription" :
+      return "EventLogSubscription";
+    case "EventCollector" :
+      return "EventCollector";
+    case "QueryDb" :
+      return "QueryDb";
+    case "Runtime" :
+      return "Runtime";
+    case "DeadLetter" :
+      return "DeadLetter";
+    case "Scheduler" :
+      return "Scheduler";
+    case "Logs" :
+      return "Logs";
+    case "Identity" :
+      return "Identity";
+    case "Api" :
+      return "Api";
+    case "Auth" :
+      return "Auth";
+    case "Hosting" :
+      return "Hosting";
+    case "Network" :
+      return "Network";
+    case "EventSourceMapping" :
+      return "EventSourceMapping";
+    case "DataTransfer" :
+      return "DataTransfer";
+  }
+}
+
+let Role = {
+  toString: toString$1
+};
+
+let current = {
+  contents: {
+    platform: undefined,
+    plugin: undefined
+  }
+};
+
+function enter(platform, plugin) {
+  let previous = current.contents;
+  current.contents = {
+    platform: platform,
+    plugin: plugin
+  };
+  return previous;
+}
+
+function restore(previous) {
+  current.contents = previous;
+}
+
+export {
+  Scope,
+  Role,
+  current,
+  enter,
+  restore,
+}
+/* No side effect */

package/src/adapter/Runtime/AggregateRuntime_Builder_Common.res

@@ -26,20 +26,29 @@ module Make = (
   }
   type effectHandler = Runtime.effectHandler<RuntimeEnvironment.event, context, unit, string>
 
+  // Event collectors nested under this aggregate belong to their own element (a
+  // ReadModel, an EventMapper, …), so they carry the comp resolved at registration
+  // time rather than the hosting aggregate's.
+  type registeredHandler = {comp: string, handler: effectHandler}
+
   let runtimeSpecs: dict<runtimeSpec> = Dict.make()
   let commandGeneratorHandlers: dict<CommandGenerator.effectEventHandler<context>> = Dict.make()
   let commandTopicHandlers: dict<effectHandler> = Dict.make()
-  let eventCollectorHandlers: dict<array<effectHandler>> = Dict.make()
+  let eventCollectorHandlers: dict<array<registeredHandler>> = Dict.make()
 
   let aggregateHandler = aggregateName =>
     async (event: RuntimeEnvironment.event, context) => {
       let correlationId = event->RuntimeEnvironment.extractCorrelationId
       let causationId = event->RuntimeEnvironment.extractCausationId
+      let timestamp = event->RuntimeEnvironment.extractSentTimestamp
+      let retryCount = event->RuntimeEnvironment.extractRetryCount
       let comp = `AggregateRuntime(${aggregateName})`
       // Shared dispatch helper (Runtime.runEffect) annotates correlationId / comp /
       // causationId onto the invocation so the application handler's own log lines
-      // carry them without re-logging by hand.
-      let runEffect = effect => Runtime.runEffect(~correlationId?, ~causationId?, ~comp, effect)
+      // carry them without re-logging by hand, and carries the transport's send
+      // time / delivery attempt into RequestContext.
+      let runEffect = effect =>
+        Runtime.runEffect(~correlationId?, ~causationId?, ~comp, ~timestamp?, ~retryCount?, effect)
       switch event->CommandGenerator.metaInfo {
       | Some(info) =>
         switch commandGeneratorHandlers->Dict.get(info) {
@@ -71,7 +80,16 @@ module Make = (
                 `found ${count} EventCollector handler(s) for ${urn}`,
               )->Effect.runSync
               let _ = await handlers
-              ->Array.map(handler => runEffect(handler(event, context)))
+              ->Array.map(({comp, handler}) =>
+                Runtime.runEffect(
+                  ~correlationId?,
+                  ~causationId?,
+                  ~comp,
+                  ~timestamp?,
+                  ~retryCount?,
+                  handler(event, context),
+                )
+              )
               ->Promise.all
             | None =>
               let available =
@@ -237,11 +255,12 @@ module Make = (
             ~comp="AggregateRuntime",
             `forEventCollector ${eventCollectorName}: set handler for ${urns->Array.join(", ")}`,
           )
+          let comp = `EventCollector(${eventCollectorName})`
           urns->Array.map(urn => {
             let handlers = eventCollectorHandlers->Dict.get(urn)->Option.getOr([])
             eventCollectorHandlers->Dict.set(
               urn,
-              handlers->Array.concat([handler->RuntimeEnvironment.asEffectHandler]),
+              handlers->Array.concat([{comp, handler: handler->RuntimeEnvironment.asEffectHandler}]),
             )
           })
         })

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

@@ -21,8 +21,10 @@ function Make(RuntimeEnvironment) {
     let aggregateHandler = aggregateName => (async (event, context) => {
       let correlationId = RuntimeEnvironment.extractCorrelationId(event);
       let causationId = RuntimeEnvironment.extractCausationId(event);
+      let timestamp = RuntimeEnvironment.extractSentTimestamp(event);
+      let retryCount = RuntimeEnvironment.extractRetryCount(event);
       let comp = `AggregateRuntime(` + aggregateName + `)`;
-      let runEffect = effect => Runtime$ReventlessCore.runEffect(correlationId, causationId, comp, undefined, undefined, undefined, effect);
+      let runEffect = effect => Runtime$ReventlessCore.runEffect(correlationId, causationId, comp, undefined, timestamp, retryCount, undefined, undefined, effect);
       let info = CommandGenerator$ReventlessCore.metaInfo(event);
       if (info !== undefined) {
         let handler = commandGeneratorHandlers[info];
@@ -46,7 +48,7 @@ function Make(RuntimeEnvironment) {
         if (handlers !== undefined) {
           let count = handlers.length.toString();
           Effect.runSync(EffectLogger$ReventlessCore.logDebug(comp, undefined, `found ` + count + ` EventCollector handler(s) for ` + urn));
-          await Promise.all(handlers.map(handler => runEffect(handler(event, context))));
+          await Promise.all(handlers.map(param => Runtime$ReventlessCore.runEffect(correlationId, causationId, param.comp, undefined, timestamp, retryCount, undefined, undefined, param.handler(event, context))));
           return;
         }
         let available = Object.keys(commandTopicHandlers).concat(Object.keys(eventCollectorHandlers)).join(",");
@@ -155,9 +157,13 @@ function Make(RuntimeEnvironment) {
         let handler = param[1];
         let urns = param[0];
         log.debug("AggregateRuntime", undefined, `forEventCollector ` + eventCollectorName + `: set handler for ` + urns.join(", "));
+        let comp = `EventCollector(` + eventCollectorName + `)`;
         return urns.map(urn => {
           let handlers = Stdlib_Option.getOr(eventCollectorHandlers[urn], []);
-          eventCollectorHandlers[urn] = handlers.concat([RuntimeEnvironment.asEffectHandler(handler)]);
+          eventCollectorHandlers[urn] = handlers.concat([{
+              comp: comp,
+              handler: RuntimeEnvironment.asEffectHandler(handler)
+            }]);
         });
       });
     };

package/src/adapter/Runtime/AggregateRuntime_Builder_Micro.res

@@ -32,6 +32,8 @@ module Make = (
         ->Runtime.runEffectHandler(
           ~extractCorrelationId=RuntimeEnvironment.extractCorrelationId,
           ~extractCausationId=RuntimeEnvironment.extractCausationId,
+          ~extractSentTimestamp=RuntimeEnvironment.extractSentTimestamp,
+          ~extractRetryCount=RuntimeEnvironment.extractRetryCount,
           ~comp=name,
         )
       ),
@@ -60,6 +62,8 @@ module Make = (
         ->Runtime.runEffectHandler(
           ~extractCorrelationId=RuntimeEnvironment.extractCorrelationId,
           ~extractCausationId=RuntimeEnvironment.extractCausationId,
+          ~extractSentTimestamp=RuntimeEnvironment.extractSentTimestamp,
+          ~extractRetryCount=RuntimeEnvironment.extractRetryCount,
           ~comp=name,
         )
       ),
@@ -91,6 +95,8 @@ module Make = (
         ->Runtime.runEffectHandler(
           ~extractCorrelationId=RuntimeEnvironment.extractCorrelationId,
           ~extractCausationId=RuntimeEnvironment.extractCausationId,
+          ~extractSentTimestamp=RuntimeEnvironment.extractSentTimestamp,
+          ~extractRetryCount=RuntimeEnvironment.extractRetryCount,
           ~comp=name,
         )
       ),

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

@@ -14,7 +14,7 @@ function Make(RuntimeEnvironment) {
       let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
       let resource = Component$ReventlessCore.toPulumiResource(commandGenerator);
       let name = ComponentType$ReventlessCore.nameOpt(resource.__name, CommandGenerator$ReventlessCore.componentType);
-      return connect(RuntimeEnvironment.make(name, handler.apply(handler => Runtime$ReventlessCore.runEffectHandler(RuntimeEnvironment.extractCorrelationId, RuntimeEnvironment.extractCausationId, name, undefined, RuntimeEnvironment.asEffectHandler(handler))), memorySize, timeout, {
+      return connect(RuntimeEnvironment.make(name, handler.apply(handler => Runtime$ReventlessCore.runEffectHandler(RuntimeEnvironment.extractCorrelationId, RuntimeEnvironment.extractCausationId, RuntimeEnvironment.extractSentTimestamp, RuntimeEnvironment.extractRetryCount, name, undefined, RuntimeEnvironment.asEffectHandler(handler))), memorySize, timeout, {
         parent: resource
       }));
     };
@@ -23,7 +23,7 @@ function Make(RuntimeEnvironment) {
       let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
       let resource = Component$ReventlessCore.toPulumiResource(commandTopic);
       let name = ComponentType$ReventlessCore.nameOpt(resource.__name, CommandTopic$ReventlessCore.componentType);
-      return connect(RuntimeEnvironment.make(name, handler.apply(handler => Runtime$ReventlessCore.runEffectHandler(RuntimeEnvironment.extractCorrelationId, RuntimeEnvironment.extractCausationId, name, undefined, RuntimeEnvironment.asEffectHandler(handler))), memorySize, timeout, {
+      return connect(RuntimeEnvironment.make(name, handler.apply(handler => Runtime$ReventlessCore.runEffectHandler(RuntimeEnvironment.extractCorrelationId, RuntimeEnvironment.extractCausationId, RuntimeEnvironment.extractSentTimestamp, RuntimeEnvironment.extractRetryCount, name, undefined, RuntimeEnvironment.asEffectHandler(handler))), memorySize, timeout, {
         parent: resource
       }));
     };
@@ -36,7 +36,7 @@ function Make(RuntimeEnvironment) {
       let opts = {
         parent: opts_parent
       };
-      let runtime = RuntimeEnvironment.make(name, handler.apply(handler => Runtime$ReventlessCore.runEffectHandler(RuntimeEnvironment.extractCorrelationId, RuntimeEnvironment.extractCausationId, name, undefined, RuntimeEnvironment.asEffectHandler(handler))), memorySize, timeout, opts);
+      let runtime = RuntimeEnvironment.make(name, handler.apply(handler => Runtime$ReventlessCore.runEffectHandler(RuntimeEnvironment.extractCorrelationId, RuntimeEnvironment.extractCausationId, RuntimeEnvironment.extractSentTimestamp, RuntimeEnvironment.extractRetryCount, name, undefined, RuntimeEnvironment.asEffectHandler(handler))), memorySize, timeout, opts);
       EventCollectorChannel.connect(name, [{
           channel: eventCollector.channel,
           eventTopics: eventTopics,

package/src/adapter/Runtime/EventCollectorRuntime_Builder_PerEventCollector.res

@@ -22,6 +22,9 @@ module Make = (
   ) => {
     let resource = eventCollector->Component.toPulumiResource
     let name = resource.name->ComponentType.nameOpt(EventCollector.componentType)
+    // Same `comp` shape as the shared-runtime dispatchers, so a log filter reads the
+    // same whichever deployment strategy hosts the collector.
+    let comp = `EventCollector(${resource.name->Option.getOr("Unnamed")})`
     let opts = {Pulumi.ComponentResource.parent: resource}
     let runtime = RuntimeEnvironment.make(
       ~name,
@@ -31,7 +34,9 @@ module Make = (
         ->Runtime.runEffectHandler(
           ~extractCorrelationId=RuntimeEnvironment.extractCorrelationId,
           ~extractCausationId=RuntimeEnvironment.extractCausationId,
-          ~comp=name,
+          ~extractSentTimestamp=RuntimeEnvironment.extractSentTimestamp,
+          ~extractRetryCount=RuntimeEnvironment.extractRetryCount,
+          ~comp,
         )
       ),
       ~memorySize,