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

package/src/components/ReadModel/ReadModel_Builder.res

@@ -58,7 +58,12 @@ module Make = (
     let timeout = ReventlessInfra.RuntimeHints.resolveTimeout(runtime, ~default=30)
 
     module SpecificQueryDb = QueryDb_Builder.Make(Spec, QueryDbStorage, QueryDbResolvers)
-    let queryDb = SpecificQueryDb.make(~api, ~apiRole, ~opts)
+    let queryDb = SpecificQueryDb.make(
+      ~api,
+      ~apiRole,
+      ~owner={kind: ComponentType.ReadModel, name: Spec.name},
+      ~opts,
+    )
 
     let toProjectionOperations: SpecificQueryDb.operations => projectionOperations = ({
       load,
@@ -114,7 +119,12 @@ module Make = (
       ->Component.operations
       ->Pulumi.Output.apply(operations => {
         let eventTopics = allEventTopics->EventTopic.filter(sourceNames)
-        let eventCollector = SpecificEventCollector.make(~name, ~eventTopics, ~opts)
+        let eventCollector = SpecificEventCollector.make(
+          ~name,
+          ~eventTopics,
+          ~owner={kind: ComponentType.ReadModel, name: Spec.name},
+          ~opts,
+        )
 
         module Callback = ReadModel_Callback.Make(
           Spec,

package/src/components/ReadModel/ReadModel_Builder.res.mjs

@@ -27,7 +27,10 @@ function Make(Spec) {
       let memorySize = RuntimeHints$ReventlessInfra.resolveMemory(runtime, 1024);
       let timeout = RuntimeHints$ReventlessInfra.resolveTimeout(runtime, 30);
       let SpecificQueryDb = QueryDb_Builder$ReventlessCore.Make(Spec)(QueryDbStorage)(QueryDbResolvers);
-      let queryDb = SpecificQueryDb.make(api, apiRole, undefined, opts);
+      let queryDb = SpecificQueryDb.make(api, apiRole, undefined, {
+        kind: "ReadModel",
+        name: Spec.name
+      }, opts);
       let toProjectionOperations = param => {
         let deleteBatch = param.deleteBatch;
         let $$delete = param.delete;
@@ -64,7 +67,10 @@ function Make(Spec) {
       let SpecificEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
       let eventCollector = Component$ReventlessCore.operations(queryDb).apply(operations => {
         let eventTopics = EventTopic$ReventlessCore.filter(allEventTopics, sourceNames);
-        let eventCollector = SpecificEventCollector.make(name, eventTopics, opts);
+        let eventCollector = SpecificEventCollector.make(name, eventTopics, {
+          kind: "ReadModel",
+          name: Spec.name
+        }, opts);
         let operations$1 = toProjectionOperations(operations);
         let Callback = ReadModel_Callback$ReventlessCore.Make(Spec)(Mappings)({
           ReadModelSpec: Spec,

package/src/components/SideEffectHandler/SideEffectHandler_Builder.res

@@ -27,7 +27,12 @@ module Make = (
       ->Belt.Set.String.fromArray
 
     let eventTopics = allEventTopics->EventTopic.filter(aggregateNames)
-    let eventCollector = SpecificEventCollector.make(~name, ~eventTopics, ~opts)
+    let eventCollector = SpecificEventCollector.make(
+      ~name,
+      ~eventTopics,
+      ~owner={kind: ComponentType.SideEffectHandler, name},
+      ~opts,
+    )
 
     module Callback = SideEffectHandler_Callback.Make({
       let sideEffects = sideEffects

package/src/components/SideEffectHandler/SideEffectHandler_Builder.res.mjs

@@ -24,7 +24,10 @@ function Make(RuntimeEnvironment) {
         };
         let aggregateNames = Belt_SetString.fromArray(sideEffects.map(SideEffect => SideEffect.Source.name));
         let eventTopics = EventTopic$ReventlessCore.filter(allEventTopics, aggregateNames);
-        let eventCollector = SpecificEventCollector.make(extra$1, eventTopics, opts);
+        let eventCollector = SpecificEventCollector.make(extra$1, eventTopics, {
+          kind: "SideEffectHandler",
+          name: extra$1
+        }, opts);
         let Callback = SideEffectHandler_Callback$ReventlessCore.Make({
           sideEffects: sideEffects,
           queryEngine: queryEngine

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -63,7 +63,12 @@ module Make = (
       let memorySize = ReventlessInfra.RuntimeHints.resolveMemory(runtime, ~default=1024)
       let timeout = ReventlessInfra.RuntimeHints.resolveTimeout(runtime, ~default=30)
 
-      let queryDb = SpecificQueryDb.make(~api=Api.api(), ~apiRole=Api.apiRole(), ~opts)
+      let queryDb = SpecificQueryDb.make(
+        ~api=Api.api(),
+        ~apiRole=Api.apiRole(),
+        ~owner={kind: ComponentType.StateViewSlice, name: Spec.name},
+        ~opts,
+      )
 
       let dcbEventTopicOutputs: EventTopic.outputs = (dcbEventLog->Component.outputs).eventTopic
       let allEventTopics = Dict.fromArray([(Spec.name, dcbEventTopicOutputs)])
@@ -74,7 +79,12 @@ module Make = (
         ->Pulumi.Output.apply(queryDbOps => {
           let projectionOps = toProjectionOps(queryDbOps)
 
-          let ec = SpecificEventCollector.make(~name=Spec.name, ~eventTopics=allEventTopics, ~opts)
+          let ec = SpecificEventCollector.make(
+            ~name=Spec.name,
+            ~eventTopics=allEventTopics,
+            ~owner={kind: ComponentType.StateViewSlice, name: Spec.name},
+            ~opts,
+          )
 
           let comp = `StateViewSlice(${Spec.name})`
 

package/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs

@@ -61,7 +61,10 @@ function Make(RuntimeEnvironment) {
         };
         let memorySize = RuntimeHints$ReventlessInfra.resolveMemory(runtime, 1024);
         let timeout = RuntimeHints$ReventlessInfra.resolveTimeout(runtime, 30);
-        let queryDb = SpecificQueryDb.make(Api.api(), Api.apiRole(), undefined, opts);
+        let queryDb = SpecificQueryDb.make(Api.api(), Api.apiRole(), undefined, {
+          kind: "StateViewSlice",
+          name: Spec.name
+        }, opts);
         let dcbEventTopicOutputs = Component$ReventlessCore.outputs(dcbEventLog).eventTopic;
         let allEventTopics = Object.fromEntries([[
             Spec.name,
@@ -69,7 +72,10 @@ function Make(RuntimeEnvironment) {
           ]]);
         let eventCollector = Component$ReventlessCore.operations(queryDb).apply(queryDbOps => {
           let projectionOps = toProjectionOps(queryDbOps);
-          let ec = SpecificEventCollector.make(Spec.name, allEventTopics, opts);
+          let ec = SpecificEventCollector.make(Spec.name, allEventTopics, {
+            kind: "StateViewSlice",
+            name: Spec.name
+          }, opts);
           let comp = `StateViewSlice(` + Spec.name + `)`;
           let jsonEventsHandler = stream => Effect.flatMap(Stream.runCollect(stream), events => {
             let total = events.length.toString();

package/src/plugin/component/Plugin_Builder.res

@@ -67,6 +67,11 @@ module Make = (
     let _prevPluginName = Logger.currentPluginName.contents
     Logger.currentPluginName := Some(name)
 
+    // Publish the owning plugin/platform for resource attribution, so adapters
+    // creating infrastructure below this point can tag it without every adapter
+    // signature having to carry the two names. Restored at the end of construct.
+    let _prevAttribution = ResourceAttribution.enter(~platform=Spec.platformName, ~plugin=name)
+
     // Register every component → plugin so runtime logs (fired after construct
     // returns) can resolve a comp like `StateChangeSlice(AddProduct)` to its
     // owning plugin via `Logger.componentPluginRegistry`. Also register the
@@ -975,6 +980,7 @@ module Make = (
       )
 
     Logger.currentPluginName := _prevPluginName
+    ResourceAttribution.restore(_prevAttribution)
   }
 
   let makeAutoUIManifest = (

package/src/plugin/component/Plugin_Builder.res.mjs

@@ -31,6 +31,7 @@ import * as AdapterDeploytime$ReventlessCore from "../../adapter/AdapterDeployti
 import * as ExtensionMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionMapping.res.mjs";
 import * as ExtensionPoint$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/ExtensionPoint.res.mjs";
 import * as Heartbeat_Builder$ReventlessCore from "../../components/Heartbeat/Heartbeat_Builder.res.mjs";
+import * as ResourceAttribution$ReventlessCore from "../../ResourceAttribution.res.mjs";
 import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
 import * as Plugin_SubscriptionSchema$ReventlessCore from "./Plugin_SubscriptionSchema.res.mjs";
 
@@ -121,6 +122,7 @@ function Make(Spec) {
       return Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(Plugin$ReventlessCore.componentType), name, (extra, extra$1) => {
         let _prevPluginName = Logger$ReventlessCore.currentPluginName.contents;
         Logger$ReventlessCore.currentPluginName.contents = extra$1;
+        let _prevAttribution = ResourceAttribution$ReventlessCore.enter(Spec.platformName, extra$1);
         Logger$ReventlessCore.registerComponentPlugin(extra$1, extra$1);
         aggregates.forEach(M => Logger$ReventlessCore.registerComponentPlugin(M.Spec.name, extra$1));
         readModels.forEach(R => Logger$ReventlessCore.registerComponentPlugin(R.Spec.name, extra$1));
@@ -626,6 +628,7 @@ function Make(Spec) {
         Component$ReventlessCore.setOutputs(extra, pluginOutputs);
         Plugin_Helpers$ReventlessCore.interopMetaOutput.contents = builderOutputs.apply(outputs => S.reverseConvertToJsonOrThrow(Plugin_Helpers$ReventlessCore.toInteropMeta(outputs), ExportMeta$ReventlessInterop.schema));
         Logger$ReventlessCore.currentPluginName.contents = _prevPluginName;
+        return ResourceAttribution$ReventlessCore.restore(_prevAttribution);
       }, opts);
     };
     return {

package/src/plugin/component/Plugin_Helpers.res

@@ -449,7 +449,7 @@ module MakeEventCollectorHelper = (
     EventCollectorChannel,
   )
   let make = (~name, ~eventTopics, ~opts) => {
-    let eventCollector = PluginEventCollector.make(~name, ~eventTopics, ~opts)
+    let eventCollector = PluginEventCollector.make(~name, ~eventTopics, ~owner={kind: ComponentType.Plugin, name}, ~opts)
     let eventCollectorOutputs = eventCollector->Component.outputs
     // pluginDefinition.eventCollector must identify the EC's inbound queue
     // ARN — admin's `manageSubscriptions` uses it as the subscription target

package/src/plugin/component/Plugin_Helpers.res.mjs

@@ -255,7 +255,10 @@ function MakeEventCollectorHelper(RuntimeEnvironment) {
   return EventCollectorChannel => (PluginRuntimeBuilder => {
     let PluginEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
     let make = (name, eventTopics, opts) => {
-      let eventCollector = PluginEventCollector.make(name, eventTopics, opts);
+      let eventCollector = PluginEventCollector.make(name, eventTopics, {
+        kind: "Plugin",
+        name: name
+      }, opts);
       let eventCollectorOutputs = Component$ReventlessCore.outputs(eventCollector);
       let resources = eventCollectorOutputs.resources;
       let r = resources[resources.length - 1 | 0];

package/tests/ResourceAttributionTest.res

@@ -0,0 +1,70 @@
+open JestGlobals
+
+// The attribution vocabulary is the shared contract between the AWS tag renderer
+// and the Kubernetes label renderer. These guard the wire spellings (which land
+// in deployed resource metadata and in downstream inventories) and the ambient
+// context's save/restore discipline, which is what keeps a plugin's resources
+// from being attributed to whichever plugin was constructed before it.
+
+module Attribution = ResourceAttribution
+
+describe("ResourceAttribution.Scope — wire spellings", () => {
+  testSync("scopes render lower-case", () => {
+    expect(
+      [Attribution.Scope.Component, Plugin, Platform]->Array.map(Attribution.Scope.toString),
+    )->toEqual(["component", "plugin", "platform"])
+  })
+})
+
+describe("ResourceAttribution.Role — wire spellings", () => {
+  testSync("piece roles render as their constructor name", () => {
+    expect(
+      [Attribution.Role.EventLog, QueryDb, Runtime, DeadLetter]->Array.map(
+        Attribution.Role.toString,
+      ),
+    )->toEqual(["EventLog", "QueryDb", "Runtime", "DeadLetter"])
+  })
+
+  testSync("Other carries the caller's name verbatim", () => {
+    expect(Attribution.Role.Other("ChangeFeed")->Attribution.Role.toString)->toBe("ChangeFeed")
+  })
+
+  testSync("platform-level things are Platform, not Core", () => {
+    // `Core` predates the platform/plugin split and names nothing the framework
+    // builds; it also reads as the built-in core PLUGIN, which is a different
+    // thing. Platform substrate is attributed to `Platform`, matching
+    // `reventless:platform` and `Scope.Platform`.
+    expect(ComponentType.Platform->ComponentType.toString)->toBe("Platform")
+    expect(ComponentType.ofString("Platform"))->toEqual(Some(ComponentType.Platform))
+  })
+
+  testSync("a role is NOT a component kind — Runtime has no ComponentType twin", () => {
+    // The whole point of splitting role from kind: `Runtime` is a deployment
+    // piece, not something the domain model can be. If this ever resolves, the
+    // two vocabularies have started to merge again.
+    expect(ComponentType.ofString("Runtime"))->toEqual(None)
+  })
+})
+
+describe("ResourceAttribution — ambient plugin context", () => {
+  testSync("outside any plugin construct, nothing is attributed", () => {
+    expect(Attribution.current.contents.plugin)->toEqual(None)
+    expect(Attribution.current.contents.platform)->toEqual(None)
+  })
+
+  testSync("enter publishes the plugin and platform under construction", () => {
+    let previous = Attribution.enter(~platform="online-shop", ~plugin="Ordering")
+    expect(Attribution.current.contents.plugin)->toEqual(Some("Ordering"))
+    expect(Attribution.current.contents.platform)->toEqual(Some("online-shop"))
+    Attribution.restore(previous)
+  })
+
+  testSync("restore unwinds to the previous context, so plugins don't leak", () => {
+    let outer = Attribution.enter(~platform="online-shop", ~plugin="Catalog")
+    let inner = Attribution.enter(~platform="online-shop", ~plugin="Ordering")
+    Attribution.restore(inner)
+    expect(Attribution.current.contents.plugin)->toEqual(Some("Catalog"))
+    Attribution.restore(outer)
+    expect(Attribution.current.contents.plugin)->toEqual(None)
+  })
+})

package/tests/aggregate/AggregateCacheTest.res

@@ -166,7 +166,7 @@ module TestOps = {
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
     // Never called — satisfies module type only
-    let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
+    let make = (~name as _: string, ~owner as _=?, ~opts as _=?): component => Obj.magic(0)
   }
   let eventLog: EventLog.operations = {
     append: mock.appendFn,

package/tests/aggregate/AggregateConflictTest.res

@@ -126,7 +126,7 @@ module TestOps = {
       writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
-    let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
+    let make = (~name as _: string, ~owner as _=?, ~opts as _=?): component => Obj.magic(0)
   }
   let eventLog: EventLog.operations = {
     append: mock.appendFn,

package/tests/aggregate/AggregateFixtures.res

@@ -142,7 +142,7 @@ module TestOps = {
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
     // Never called — satisfies module type only
-    let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
+    let make = (~name as _: string, ~owner as _=?, ~opts as _=?): component => Obj.magic(0)
   }
   let eventLog: EventLog.operations = {
     append: mock.appendFn,

package/tests/aggregate/AggregateSnapshotTest.res

@@ -188,7 +188,7 @@ module MakeOps = (B: {let name: string}) => {
       writeSnapshot: (string, EventLog.snapshot) => promise<result<unit, string>>,
     }
     type component = Component.t<OuterEventLog.t, OuterEventLog.outputs, operations>
-    let make = (~name as _: string, ~opts as _=?): component => Obj.magic(0)
+    let make = (~name as _: string, ~owner as _=?, ~opts as _=?): component => Obj.magic(0)
   }
   let eventLog: EventLog.operations = {
     append: mock.appendFn,

package/tests/eventlog/EventLogFixtures.res

@@ -84,7 +84,7 @@ module MockEventTopic: EventTopic.T
     publishJsonStream: ReventlessInfra.EventTopic.publishJsonStream,
   }
   type component = Component.t<EventTopic.t, EventTopic.outputs, operations>
-  let make = (~name as _, ~storageResources as _, ~opts as _=?): component => Obj.magic(0)
+  let make = (~name as _, ~storageResources as _, ~owner as _=?, ~opts as _=?): component => Obj.magic(0)
 }
 
 let mockEventTopicOps: MockEventTopic.operations = {

package/tests/logger/LogFormatTest.res

@@ -223,6 +223,49 @@ describe("JSON sink", () => {
     expect(lines->Array.length == 1 && line->fieldOf("plugin") == Some("Catalog"))->toBe(true)
   })
 
+  testSync("Logger.info resolves plugin from a kind-suffixed component name", () => {
+    // Event-collector comps carry the component *resource* name (`<Spec><Kind>`),
+    // while the registry holds the bare spec name — the prefix candidate bridges them.
+    Logger.registerComponentPlugin(~componentName="Products", ~pluginName="Catalog")
+    let lines = captureLogs(() =>
+      log.info(~comp="EventCollector(ProductsReadModel)", "projecting event")
+    )
+    let line = lines->Array.length == 1 ? lines->Array.getUnsafe(0) : ""
+    expect(lines->Array.length == 1 && line->fieldOf("plugin") == Some("Catalog"))->toBe(true)
+  })
+
+  testSync("Plugin resolution prefers the longest registered prefix", () => {
+    // `Order` (Ordering) must not win over `OrderLines` (Billing) for `OrderLinesReadModel`.
+    Logger.registerComponentPlugin(~componentName="Order", ~pluginName="Ordering")
+    Logger.registerComponentPlugin(~componentName="OrderLines", ~pluginName="Billing")
+    let lines = captureLogs(() =>
+      log.info(~comp="EventCollector(OrderLinesReadModel)", "projecting event")
+    )
+    let line = lines->Array.length == 1 ? lines->Array.getUnsafe(0) : ""
+    expect(lines->Array.length == 1 && line->fieldOf("plugin") == Some("Billing"))->toBe(true)
+  })
+
+  testSync("dispatch annotation carries comp onto a handler line that passes none", () => {
+    // What makes two collectors in one runtime process separable: the element's comp
+    // comes from the dispatch boundary, not from the application's own log call.
+    let lines = captureLogs(() =>
+      EffectLogger.logInfo("projected")
+      ->Runtime.annotateInvocation(
+        ~correlationId="cid-1",
+        ~causationId="parent-1",
+        ~comp="EventCollector(ProductsReadModel)",
+      )
+      ->Effect.runSync
+    )
+    let line = lines->Array.length >= 1 ? lines->Array.getUnsafe(0) : ""
+    let ok =
+      line->fieldOf("comp") == Some("EventCollector(ProductsReadModel)") &&
+      line->fieldOf("correlationId") == Some("cid-1") &&
+      line->fieldOf("causationId") == Some("parent-1") &&
+      line->fieldOf("message") == Some("projected")
+    expect(ok)->toBe(true)
+  })
+
   testSync("Logger.warn emits one clean JSON record", () => {
     let lines = captureLogs(() => log.warn(~comp="Platform", "heartbeat skipped"))
     expect(lines->Array.length == 1 && isCleanRecord(lines->Array.getUnsafe(0)))->toBe(true)