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

package/CHANGELOG.md

@@ -3,6 +3,33 @@
 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.176 (2026-07-22)
+
+* refactor!: retire the stale "core" vocabulary for platform things ([34e7480](https://github.com/ReventlessDev/reventless-core/commit/34e7480992bd58906a250b0a1ce6ff2c5ba45260))
+
+### BREAKING CHANGES
+
+* the built-in extension point is renamed Core.Plugin ->
+Platform.Plugin. This replaces the CorePluginExtPointCmdTopic SQS queue
+with PlatformPluginExtPointCmdTopic (a replacement, not an update) and
+breaks every already-deployed plugin's connection until redeployed.
+Wipe the alpha stack and redeploy fresh rather than migrating.
+
+Build clean; 1349 tests green (interop 50, core 518, local 501, aws 280).
+
+
+
+# 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.176",
   "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-hash-object": "1.2.0-alpha.13",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.30",
     "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.14",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.9",
+    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.13",
     "@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-interop": "3.0.0-alpha.28",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.79"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.104",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.29",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.80",
+    "@reventlessdev/rescript-uuid": "1.1.0-alpha.17"
   },
   "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,6 @@ type t =
   | SideEffectHandler
   | Task
   | Vpc
-  | Core
   | Heartbeat
   | Cloner
   | DcbEventLog
@@ -32,6 +32,7 @@ let toString = componentType =>
   | Aggregate => "Aggregate"
   | Counter => "Counter"
   | Plugin => "Plugin"
+  | Platform => "Platform"
   | CommandGenerator => "CommandGenerator"
   | CommandTopic => "CommandTopic"
   | EventCollector => "EventCollector"
@@ -47,7 +48,6 @@ let toString = componentType =>
   | SideEffectHandler => "SideEffectHandler"
   | Task => "Task"
   | Vpc => "Vpc"
-  | Core => "Core"
   | Heartbeat => "Heartbeat"
   | Cloner => "Cloner"
   | DcbEventLog => "DcbEventLog"
@@ -63,6 +63,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
@@ -78,7 +79,6 @@ let ofString = str =>
   | "SideEffectHandler" => SideEffectHandler->Some
   | "Task" => Task->Some
   | "Vpc" => Vpc->Some
-  | "Core" => Core->Some
   | "Heartbeat" => Heartbeat->Some
   | "Cloner" => Cloner->Some
   | "DcbEventLog" => DcbEventLog->Some
@@ -95,6 +95,7 @@ let toName = componentType =>
   | Aggregate => "Aggr"
   | Counter => "Counter"
   | Plugin => "Plugin"
+  | Platform => "Platform"
   | CommandGenerator => "CmdGen"
   | CommandTopic => "CmdTopic"
   | EventCollector => "EventColl"
@@ -110,7 +111,6 @@ let toName = componentType =>
   | SideEffectHandler => "SideEffectHandler"
   | Task => "Task"
   | Vpc => "Vpc"
-  | Core => "Core"
   | Heartbeat => "Heartbeat"
   | Cloner => "Cloner"
   | DcbEventLog => "DcbEventLog"

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" :
@@ -40,8 +42,6 @@ function toString(componentType) {
       return "Task";
     case "Vpc" :
       return "Vpc";
-    case "Core" :
-      return "Core";
     case "Heartbeat" :
       return "Heartbeat";
     case "Cloner" :
@@ -73,8 +73,6 @@ function ofString(str) {
       return "CommandGenerator";
     case "CommandTopic" :
       return "CommandTopic";
-    case "Core" :
-      return "Core";
     case "Counter" :
       return "Counter";
     case "DcbEventLog" :
@@ -97,6 +95,8 @@ function ofString(str) {
       return "InboundTranslationSlice";
     case "OutboundTranslationSlice" :
       return "OutboundTranslationSlice";
+    case "Platform" :
+      return "Platform";
     case "Plugin" :
       return "Plugin";
     case "QueryDB" :
@@ -130,6 +130,8 @@ function toName(componentType) {
       return "Counter";
     case "Plugin" :
       return "Plugin";
+    case "Platform" :
+      return "Platform";
     case "CommandGenerator" :
       return "CmdGen";
     case "CommandTopic" :
@@ -160,8 +162,6 @@ function toName(componentType) {
       return "Task";
     case "Vpc" :
       return "Vpc";
-    case "Core" :
-      return "Core";
     case "Heartbeat" :
       return "Heartbeat";
     case "Cloner" :

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,
         )
       ),