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

package/src/adapter/Runtime/ExtensionPointEntryPoint.mjs

@@ -3,48 +3,22 @@
 // wires ExtensionPoint_Callback.Make + CommandTopic_Callback.Make,
 // routes SQS events through handleQueueEvent.
 
-import * as Effect from "effect/Effect";
-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 extensionPointCallbackMake } from "@reventlessdev/reventless-core/src/components/ExtensionPoint/ExtensionPoint_Callback.res.mjs";
 import { Make as commandTopicCallbackMake } from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Callback.res.mjs";
 import { handleQueueEvent, publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
 
 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);
-}
-
-function extractCorrelationId(records) {
-  const first = records[0];
-  if (!first) return undefined;
-  const body = first.body;
-  if (!body) return undefined;
-  try {
-    const parsed = JSON.parse(body);
-    if (typeof parsed === "object" && parsed !== null) {
-      const meta = parsed.meta;
-      if (meta && typeof meta === "object" && typeof meta.correlationId === "string") {
-        return meta.correlationId;
-      }
-    }
-  } catch (_) {}
-  return undefined;
-}
-
 async function buildHandler() {
   const configStr = process.env["HANDLER_CONFIG"] || "{}";
   const config = JSON.parse(configStr);
@@ -84,18 +58,28 @@ async function buildHandler() {
   });
 
   const resolvedQueue = makeQueueRef(config.queueUrl);
-  return handleQueueEvent(resolvedQueue, commandTopicCallback.handleJsonCommands);
+  // Pair the handler with the extension point it serves so the invocation's log
+  // lines name the component, not just this Lambda.
+  return {
+    sqsHandler: handleQueueEvent(resolvedQueue, commandTopicCallback.handleJsonCommands),
+    comp: `ExtensionPoint(${patchedSpec.name})`,
+  };
 }
 
 const initPromise = buildHandler();
 
 export async function handler(event, context) {
-  _currentRequestId = context?.awsRequestId || "unknown";
-  const sqsHandler = await initPromise;
+  setRequestId(context?.awsRequestId);
+  const { sqsHandler, comp } = await initPromise;
   const records = event.Records || [];
-  const correlationId = extractCorrelationId(records);
 
   log.debug("processing " + records.length.toString() + " record(s)", { comp: "ExtensionPointRuntime" });
-  await runEffect(correlationId, sqsHandler(event, context));
+  await runEffect(sqsHandler(event, context), {
+    correlationId: extractMetaField(records, "correlationId"),
+    causationId: extractMetaField(records, "causationId"),
+    comp,
+    timestamp: extractSentTimestamp(records),
+    retryCount: extractRetryCount(records),
+  });
   return "";
 }

package/src/adapter/Runtime/ExtensionPointRuntime_Builder_PerExtensionPoint.res

@@ -71,6 +71,7 @@ let forCommandTopic = (
   let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
     ~name,
     ~unitKind=ReventlessCore.Monitoring.CommandHandler,
+    ~componentKind=ReventlessCore.ComponentType.ExtensionPoint,
     ~code,
     ~sourceCodeHash,
     ~envVars,

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

@@ -39,7 +39,7 @@ function forCommandTopic(param, connect, memorySizeOpt, timeoutOpt, specModuleUr
   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/ExtensionPointEntryPoint.mjs", packageDirs, undefined);
-  return connect(RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(name, "CommandHandler", match.code, match.sourceCodeHash, envVars, memorySize, timeout, undefined, undefined, undefined, undefined, undefined, opts));
+  return connect(RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(name, "CommandHandler", "ExtensionPoint", match.code, match.sourceCodeHash, envVars, memorySize, timeout, undefined, undefined, undefined, undefined, undefined, opts));
 }
 
 function finish() {

package/src/adapter/Runtime/HandlerFactoryHelpers.mjs

@@ -1,6 +1,11 @@
 // Shared runtime utilities for compiled Lambda entry points.
 
+import * as Effect from "effect/Effect";
 import { $$String as IdString } from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import {
+  tag as requestContextTag,
+  fromOptions as makeRequestContext,
+} from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { DynamoDBDocumentClient, ScanCommand } from "@aws-sdk/lib-dynamodb";
 
@@ -66,6 +71,127 @@ export const log = {
 // Lambdas). Export so shim runEffect wrappers can annotate Effect logs with it.
 export const pluginName = PLUGIN_NAME;
 
+// ─── Dispatch boundary for the entry-point shells ───────────────────────────
+// The deployed Lambda is an archive whose index.handler is one of the .mjs entry
+// points here — the AWS runtime builders take `~handler as _` and discard the
+// ReScript closure, so ReventlessCore.Runtime.annotateInvocation (the ReScript
+// dispatch boundary, used by reventless-local) never runs in a Lambda. This is
+// its counterpart: the single place where every deployed invocation gets its log
+// annotations and its RequestContext, so `comp` / `causationId` attribution is
+// the same on both platforms.
+//
+// Options object rather than positional arguments: the shells call this from
+// twelve sites and the field set grows, so a new field must not be able to
+// shift an existing one. Same reason RequestContext exposes `fromOptions` —
+// ReScript labelled arguments compile to positional ones.
+//
+// See docs/plans/entrypoint-dispatch-parity-and-latency-fields.md.
+
+// Set at handler entry via setRequestId; read on each dispatch to tag logs with
+// the Lambda request id.
+let _currentRequestId = "unknown";
+
+export function setRequestId(id) {
+  _currentRequestId = id || "unknown";
+}
+
+export function runEffect(effect, opts = {}) {
+  const { correlationId, causationId, comp, timestamp, retryCount, plugin } = opts;
+  const cid = correlationId || "unknown";
+  // `plugin` per dispatch (from HANDLER_CONFIG, resolved at deploy time) beats
+  // the Lambda-name-derived fallback: a shared Lambda (AllReadModels,
+  // AllAggregatesCmdHandler) hosts components from several plugins, so its name
+  // carries no single plugin identity.
+  const resolvedPlugin = plugin || pluginName;
+  let e = effect
+    // Promote correlationId/requestId/plugin/comp/causationId 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", cid))
+    .pipe(Effect.annotateLogs("requestId", _currentRequestId));
+  if (resolvedPlugin) e = e.pipe(Effect.annotateLogs("plugin", resolvedPlugin));
+  if (comp) e = e.pipe(Effect.annotateLogs("comp", comp));
+  if (causationId) e = e.pipe(Effect.annotateLogs("causationId", causationId));
+  // Only annotate a redelivery. A constant "1" on every line is noise, and its
+  // absence is what makes `filter retryCount > 1` a usable query.
+  if (retryCount > 1) e = e.pipe(Effect.annotateLogs("retryCount", String(retryCount)));
+  return e
+    .pipe(
+      Effect.provideService(
+        requestContextTag,
+        makeRequestContext({
+          correlationId: cid,
+          causationId,
+          component: comp,
+          pluginName: resolvedPlugin || undefined,
+          timestamp,
+          retryCount,
+        }),
+      ),
+    )
+    .pipe(Effect.runPromise);
+}
+
+// ─── Message-envelope + transport-attribute extraction ──────────────────────
+// Mirrors RuntimeEnvironment_Lambda.extractMetaField (ReScript side, same
+// position in the batch) so both dispatch boundaries read the same fields.
+
+// Read one envelope meta field (correlationId, causationId, …) off the first
+// record. Two transports, two shapes:
+//   SQS            — the envelope is a JSON `body` string with a nested `meta`.
+//   DynamoDB stream — the EventLog row stores meta keys *flat* as top-level
+//                     attributes (Message.composeMeta rebuilds `meta` from them),
+//                     so read NewImage.<field>.S.
+// Undefined when neither shape yields a string.
+export function extractMetaField(records, field) {
+  const first = (records || [])[0];
+  if (!first) return undefined;
+  if (typeof first.body === "string") {
+    let parsed;
+    try {
+      parsed = JSON.parse(first.body);
+    } catch (_) {
+      return undefined;
+    }
+    const value = parsed?.meta?.[field];
+    return typeof value === "string" ? value : undefined;
+  }
+  const attr = first.dynamodb?.NewImage?.[field];
+  return typeof attr?.S === "string" ? attr.S : undefined;
+}
+
+// Send time of the triggering message, ms since epoch. SQS stamps
+// `SentTimestamp` (ms, server-side clock — not the producer's); a DynamoDB
+// stream record carries `ApproximateCreationDateTime` in *seconds*. Undefined
+// when neither is present, so a handler can tell "no send time" from "zero
+// latency".
+export function extractSentTimestamp(records) {
+  const first = (records || [])[0];
+  if (!first) return undefined;
+  const sqsSent = first.attributes?.SentTimestamp;
+  if (sqsSent !== undefined) {
+    const ms = Number(sqsSent);
+    return Number.isFinite(ms) ? ms : undefined;
+  }
+  const streamCreated = first.dynamodb?.ApproximateCreationDateTime;
+  if (streamCreated !== undefined) {
+    const secs = Number(streamCreated);
+    return Number.isFinite(secs) ? secs * 1000 : undefined;
+  }
+  return undefined;
+}
+
+// Delivery attempt: 1 on first delivery. SQS counts redeliveries in
+// `ApproximateReceiveCount`; DynamoDB streams have no equivalent, so a stream
+// record reports 1.
+export function extractRetryCount(records) {
+  const first = (records || [])[0];
+  const raw = first?.attributes?.ApproximateReceiveCount;
+  if (raw === undefined) return 1;
+  const count = parseInt(raw, 10);
+  return Number.isFinite(count) && count > 0 ? count : 1;
+}
+
 // Patch a spec module's Id field to use IdString if undefined.
 // Workaround for `module Id = Id.String` not producing an ESM export.
 export const patchSpecId = (specModule) => ({ ...specModule, Id: specModule.Id || IdString });

package/src/adapter/Runtime/PluginExtensionPointEntryPoint.mjs

@@ -2,9 +2,17 @@
 // All imports are framework packages — no user modules needed.
 // Handles Heartbeat, Cloner, and other plugin-level extension point commands.
 
-import * as Effect from "effect/Effect";
-import { patchSpecId, makeQueueRef, scanByTableName, log, pluginName } from "./HandlerFactoryHelpers.mjs";
-import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import {
+  patchSpecId,
+  makeQueueRef,
+  scanByTableName,
+  log,
+  runEffect,
+  setRequestId,
+  extractMetaField,
+  extractSentTimestamp,
+  extractRetryCount,
+} from "./HandlerFactoryHelpers.mjs";
 import { sendMessage } from "@reventlessdev/reventless-aws/src/plugin/runtime/Util_PluginMessage_Runtime.res.mjs";
 import * as PluginExtensionPointSpec from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
 import { Make as pluginEPPluginMake } from "@reventlessdev/reventless-core/src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs";
@@ -13,39 +21,6 @@ import { Make as commandTopicCallbackMake } from "@reventlessdev/reventless-core
 import { handleQueueEvent, publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
 import { createSchedule as cwCreateSchedule, deleteSchedule as cwDeleteSchedule } from "@reventlessdev/reventless-aws/src/adapter/ScheduledPublisher/ScheduledPublisher_CloudWatchEvents_Runtime.res.mjs";
 
-// 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) return undefined;
-  try {
-    const parsed = JSON.parse(body);
-    if (typeof parsed === "object" && parsed !== null) {
-      const meta = parsed.meta;
-      if (meta && typeof meta === "object" && typeof meta.correlationId === "string") {
-        return meta.correlationId;
-      }
-    }
-  } catch (_) {}
-  return undefined;
-}
-
 function buildHandler() {
   const configStr = process.env["HANDLER_CONFIG"] || "{}";
   const config = JSON.parse(configStr);
@@ -121,17 +96,25 @@ function buildHandler() {
     commandsHandler: callback.handleIncomingCommands,
   });
 
-  return handleQueueEvent(makeQueueRef(config.queueUrl), commandTopicCallback.handleJsonCommands);
+  return {
+    sqsHandler: handleQueueEvent(makeQueueRef(config.queueUrl), commandTopicCallback.handleJsonCommands),
+    comp: `ExtensionPoint(${patchedSpec.name})`,
+  };
 }
 
-const sqsHandler = buildHandler();
+const { sqsHandler, comp } = buildHandler();
 
 export async function handler(event, context) {
-  _currentRequestId = context?.awsRequestId || "unknown";
+  setRequestId(context?.awsRequestId);
   const records = event.Records || [];
-  const correlationId = extractCorrelationId(records);
 
   log.debug("processing " + records.length.toString() + " record(s)", { comp: "PluginExtensionPointRuntime" });
-  await runEffect(correlationId, sqsHandler(event, context));
+  await runEffect(sqsHandler(event, context), {
+    correlationId: extractMetaField(records, "correlationId"),
+    causationId: extractMetaField(records, "causationId"),
+    comp,
+    timestamp: extractSentTimestamp(records),
+    retryCount: extractRetryCount(records),
+  });
   return "";
 }

package/src/adapter/Runtime/ReadModelEntryPoint.mjs

@@ -2,9 +2,15 @@
 // At cold start: reads HANDLER_CONFIG, dynamically imports Spec/Mappings modules,
 // wires ReadModel_Callback.Make, builds handler map keyed by source URN.
 
-import * as Effect from "effect/Effect";
-import { patchSpecId, log, pluginName } from "./HandlerFactoryHelpers.mjs";
-import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
+import {
+  patchSpecId,
+  log,
+  runEffect,
+  setRequestId,
+  extractMetaField,
+  extractSentTimestamp,
+  extractRetryCount,
+} from "./HandlerFactoryHelpers.mjs";
 import { Make as readModelCallbackMake } from "@reventlessdev/reventless-core/src/components/ReadModel/ReadModel_Callback.res.mjs";
 // Typed cold-start core — DynamoDB QueryDb ops, compiler-checked against the
 // framework signatures (see the module header and
@@ -48,22 +54,6 @@ function fixMappingsModule(mod) {
   return mod;
 }
 
-// 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 => {
@@ -130,13 +120,20 @@ async function buildAllHandlers() {
     const specModule = await dynamicImport(h.specModule);
     const mappingsModule = await dynamicImport(h.mappingsModule);
     const handler = buildReadModelHandler(specModule, mappingsModule, h.queryDbTableName, h.pgConnection, h.stateTopicName);
+    // `comp` / `plugin` are resolved at deploy time and baked into
+    // HANDLER_CONFIG (EventCollectorRuntime_Builder_Single) so the shell doesn't
+    // re-derive component identity from module paths, and so the string matches
+    // the ReScript dispatch boundary's `EventCollector(<Name>)` byte for byte.
+    // Kept next to the handler: this Lambda hosts every read model, so the comp
+    // is what separates their log lines.
+    const registered = { handler, comp: h.comp, plugin: h.plugin };
     // Multiple read models can share one source stream — e.g. every admin read
     // model (Plugins, PluginHistory, PlatformEventGraph, UIFragmentRegistry)
     // projects the Plugin aggregate's EventLog stream. Accumulate ALL handlers
     // per source ARN; a plain `handlers[urn] = handler` collapses them to one
     // (whichever async builder wins the Promise.all race), silently dropping the
     // rest — which leaves their QueryDbs empty.
-    (handlers[h.sourceUrn] ||= []).push(handler);
+    (handlers[h.sourceUrn] ||= []).push(registered);
   }));
 
   return handlers;
@@ -145,7 +142,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);
@@ -154,11 +151,23 @@ 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: "ReadModelRuntime" });
+      const correlationId = extractMetaField(subRecords, "correlationId");
+      const causationId = extractMetaField(subRecords, "causationId");
+      const timestamp = extractSentTimestamp(subRecords);
+      const retryCount = extractRetryCount(subRecords);
       // Run every read model registered for this source stream (independent
-      // QueryDbs, so concurrent is safe).
+      // QueryDbs, so concurrent is safe). Each carries its own comp so the
+      // shared Lambda's log lines stay separable per read model.
       await Promise.all(
-        streamHandlers.map(streamHandler =>
-          runEffect(undefined, streamHandler({ Records: subRecords }, context))
+        streamHandlers.map(({ handler: streamHandler, comp, plugin }) =>
+          runEffect(streamHandler({ Records: subRecords }, context), {
+            correlationId,
+            causationId,
+            comp,
+            plugin,
+            timestamp,
+            retryCount,
+          })
         )
       );
     } else {

package/src/adapter/Runtime/RuntimeEnvironment_Lambda.res

@@ -33,7 +33,9 @@ let make: ReventlessCore.Runtime.environmentMaker<'event, context, 'result, part
     ~opts?,
   )
 
-  let tags = AWS.Tags.make(~name, ReventlessCore.CommandTopic.componentType)
+  // Legacy path (see above): no component kind reaches here because nothing calls
+  // it, so it is attributed to the Platform rather than to an invented domain kind.
+  let tags = AWS.Tags.make(~name, ~kind=ReventlessCore.ComponentType.Platform, ~role=Runtime, ~scope=Platform)
   let lambda =
     handler->Pulumi.Output.apply(handler =>
       Lambda.CallbackFunction.make(
@@ -70,6 +72,13 @@ let makeFromCodeAsset: (
       kind; `makeFromCodeAsset` announces the provisioned Lambda to the
       `Monitoring` registry (no-op unless an extension registered a backend). */
   ~unitKind: ReventlessCore.Monitoring.unitKind,
+  /** The modelling kind of the component this Lambda runs, for resource
+      attribution (`reventless:kind`). Distinct from `~unitKind`, which grades
+      the unit by what its failure means — `CommandHandler` covers aggregates,
+      state-change slices and extension points alike, so it cannot identify the
+      owning component. Shared Lambdas that host several components of one kind
+      (e.g. AllAggregates) pass that kind. */
+  ~componentKind: ReventlessCore.ComponentType.t,
   ~code: Pulumi.Archive.t,
   ~sourceCodeHash: string,
   ~envVars: dict<Pulumi.Input.t<string>>=?,
@@ -91,6 +100,7 @@ let makeFromCodeAsset: (
 ) => ReventlessCore.Runtime.environment<parts> = (
   ~name,
   ~unitKind,
+  ~componentKind,
   ~code,
   ~sourceCodeHash,
   ~envVars=Dict.make(),
@@ -107,9 +117,17 @@ let makeFromCodeAsset: (
   let opts =
     opts->Option.map(ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions)
 
+  // One attribution identity for every resource provisioned here: same owning
+  // component and kind throughout, distinct piece roles — the function itself,
+  // the execution identity it assumes, and its log group are three pieces of one
+  // component, and an inventory needs to roll all three up to it.
+  let tagsFor = (~resourceName, ~role) =>
+    AWS.Tags.make(~name=resourceName, ~kind=componentKind, ~role, ~component=name)
+
   let lambdaRole = IAM.Role.makeWithDefaultPolicy(
     ~name,
     ~servicePrincipal=AWS.Lambda.principal->Pulumi.Output.make,
+    ~tags=tagsFor(~resourceName=name, ~role=Identity),
     ~opts?,
   )
 
@@ -195,7 +213,7 @@ let makeFromCodeAsset: (
   variables->Dict.set("NODE_OPTIONS", Util_Bundle.esmLoaderNodeOptions->Pulumi.Input.make)
   variables->Dict.set("ESM_FALLBACK_DIRS", Util_Bundle.esmFallbackDirs->Pulumi.Input.make)
 
-  let tags = AWS.Tags.make(~name, ReventlessCore.CommandTopic.componentType)
+  let tags = tagsFor(~resourceName=name, ~role=Runtime)
   let lambda = Lambda.Function.make(
     ~name,
     ~args={
@@ -227,6 +245,7 @@ let makeFromCodeAsset: (
       ~args={
         name: `/aws/lambda/${name}`->Pulumi.Input.make,
         retentionInDays: days->Pulumi.Input.make,
+        tags: tagsFor(~resourceName=`${name}LogGroup`, ~role=Logs),
       },
       ~opts?,
     )
@@ -305,6 +324,37 @@ let extractMetaField = (event: event, field) =>
 let extractCorrelationId = (event: event) => event->extractMetaField("correlationId")
 let extractCausationId = (event: event) => event->extractMetaField("causationId")
 
+// SQS attributes ride on the record but are absent from the minimal record type
+// (see the commented-out `attributes` field in SQS_Queue.res). Read them the same
+// way `recordBody` reads `body`: as a typed getter over the untyped record.
+type recordAttributes = {
+  @as("SentTimestamp") sentTimestamp?: string,
+  @as("ApproximateReceiveCount") approximateReceiveCount?: string,
+}
+@get
+external recordAttributes: PulumiAws.Lambda.CallbackFunction.record => option<recordAttributes> =
+  "attributes"
+
+let firstRecordAttributes = (event: event) =>
+  event.records->Array.get(0)->Option.flatMap(recordAttributes)
+
+// Send time of the triggering message, ms since epoch. SQS stamps
+// `SentTimestamp` server-side (not the producer's clock). DynamoDB-stream
+// sources carry `ApproximateCreationDateTime` instead and are dispatched through
+// the entry-point shells, so None here rather than a fabricated value.
+let extractSentTimestamp = (event: event) =>
+  event
+  ->firstRecordAttributes
+  ->Option.flatMap(attrs => attrs.sentTimestamp)
+  ->Option.flatMap(Float.fromString)
+
+// Delivery attempt, 1 on first delivery.
+let extractRetryCount = (event: event) =>
+  event
+  ->firstRecordAttributes
+  ->Option.flatMap(attrs => attrs.approximateReceiveCount)
+  ->Option.flatMap(Int.fromString(_))
+
 external asEventHandler: 'a => ReventlessCore.Runtime.eventHandler<event, context, 'result> =
   "%identity"
 external asEffectHandler: 'a => ReventlessCore.Runtime.effectHandler<

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

@@ -1,8 +1,10 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Aws from "@pulumi/aws";
 import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Float from "@rescript/runtime/lib/es6/Stdlib_Float.js";
 import * as IAM$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/IAM.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
@@ -17,7 +19,6 @@ import * as Monitoring$ReventlessCore from "@reventlessdev/reventless-core/src/a
 import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
 import * as Util_Lambda$ReventlessAws from "../../util/Util_Lambda.res.mjs";
 import * as Util_Pulumi$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Pulumi.res.mjs";
-import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
 import * as Util_IAM_Role$ReventlessAws from "../../util/Util_IAM_Role.res.mjs";
 
 let additionalEnvVars = {};
@@ -28,8 +29,8 @@ function make(name, handler, memorySizeOpt, timeoutOpt, opts) {
   let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
   let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
   let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
-  let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name, Pulumi.output(AWS$ReventlessAws.Lambda.principal), opts$1);
-  let tags = AWS_Tags$ReventlessAws.make(name, CommandTopic$ReventlessCore.componentType);
+  let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name, Pulumi.output(AWS$ReventlessAws.Lambda.principal), undefined, opts$1);
+  let tags = AWS_Tags$ReventlessAws.make(name, "Platform", "Runtime", "Platform", undefined, undefined, undefined, undefined);
   let lambda = handler.apply(handler => new (Aws.lambda.CallbackFunction)(name, Lambda$PulumiAws.CallbackFunction.Args.make(handler, lambdaRole, undefined, undefined, undefined, memorySize, timeout, undefined, undefined, undefined, tags, undefined), opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined));
   return {
     parts: {
@@ -43,13 +44,14 @@ function make(name, handler, memorySizeOpt, timeoutOpt, opts) {
   };
 }
 
-function makeFromCodeAsset(name, unitKind, code, sourceCodeHash, envVarsOpt, memorySizeOpt, timeoutOpt, reservedConcurrency, ephemeralStorageMb, logRetentionDays, dcbMetricsOpt, vpcConfig, opts) {
+function makeFromCodeAsset(name, unitKind, componentKind, code, sourceCodeHash, envVarsOpt, memorySizeOpt, timeoutOpt, reservedConcurrency, ephemeralStorageMb, logRetentionDays, dcbMetricsOpt, vpcConfig, opts) {
   let envVars = envVarsOpt !== undefined ? envVarsOpt : ({});
   let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : Runtime$ReventlessCore.CommandHandlerDefaults.memorySize;
   let timeout = timeoutOpt !== undefined ? timeoutOpt : Runtime$ReventlessCore.CommandHandlerDefaults.timeout;
   let dcbMetrics = dcbMetricsOpt !== undefined ? dcbMetricsOpt : false;
   let opts$1 = Stdlib_Option.map(opts, Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions);
-  let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name, Pulumi.output(AWS$ReventlessAws.Lambda.principal), opts$1);
+  let tagsFor = (resourceName, role) => AWS_Tags$ReventlessAws.make(resourceName, componentKind, role, undefined, name, undefined, undefined, undefined);
+  let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name, Pulumi.output(AWS$ReventlessAws.Lambda.principal), tagsFor(name, "Identity"), opts$1);
   Stdlib_Option.forEach(vpcConfig, param => {
     new (Aws.iam.RolePolicy)(name + `VpcAccess`, {
       policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + `VpcAccessPolicy`, [{
@@ -95,7 +97,7 @@ function makeFromCodeAsset(name, unitKind, code, sourceCodeHash, envVarsOpt, mem
   });
   variables["NODE_OPTIONS"] = Util_Bundle$ReventlessAws.esmLoaderNodeOptions;
   variables["ESM_FALLBACK_DIRS"] = Util_Bundle$ReventlessAws.esmFallbackDirs;
-  let tags = AWS_Tags$ReventlessAws.make(name, CommandTopic$ReventlessCore.componentType);
+  let tags = tagsFor(name, "Runtime");
   let lambda = new (Aws.lambda.Function)(name, {
     handler: "index.handler",
     runtime: "nodejs22.x",
@@ -118,7 +120,8 @@ function makeFromCodeAsset(name, unitKind, code, sourceCodeHash, envVarsOpt, mem
   Stdlib_Option.forEach(logRetentionDays, days => {
     let logGroup = new (Aws.cloudwatch.LogGroup)(name + `LogGroup`, {
       name: `/aws/lambda/` + name,
-      retentionInDays: days
+      retentionInDays: days,
+      tags: tagsFor(name + `LogGroup`, "Logs")
     }, opts$1 !== undefined ? Primitive_option.valFromOption(opts$1) : undefined);
     if (dcbMetrics) {
       [
@@ -190,6 +193,18 @@ function extractCausationId(event) {
   return extractMetaField(event, "causationId");
 }
 
+function firstRecordAttributes(event) {
+  return Stdlib_Option.flatMap(event.Records[0], prim => prim.attributes);
+}
+
+function extractSentTimestamp(event) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(firstRecordAttributes(event), attrs => attrs.SentTimestamp), Stdlib_Float.fromString);
+}
+
+function extractRetryCount(event) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(firstRecordAttributes(event), attrs => attrs.ApproximateReceiveCount), __x => Stdlib_Int.fromString(__x, undefined));
+}
+
 export {
   additionalEnvVars,
   additionalIamPolicies,
@@ -199,5 +214,8 @@ export {
   extractMetaField,
   extractCorrelationId,
   extractCausationId,
+  firstRecordAttributes,
+  extractSentTimestamp,
+  extractRetryCount,
 }
 /* @pulumi/aws Not a pure module */