@reventlessdev/reventless-aws 3.0.0-alpha.419 → 3.0.0-alpha.421

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

@@ -5,6 +5,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as DisplayName$Reventless from "@reventlessdev/reventless-spec/src/components/DisplayName.res.mjs";
 import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
 import * as StateTopicPublishMjs from "./StateTopicPublish.mjs";
+import * as RowChange$ReventlessCore from "@reventlessdev/reventless-core/src/RowChange.res.mjs";
 import * as QueryDbEntryPoint_Ops$ReventlessAws from "./QueryDbEntryPoint_Ops.res.mjs";
 import * as QueryDbStorage_Postgres_Runtime$ReventlessAws from "../QueryDb/QueryDbStorage_Postgres_Runtime.res.mjs";
 
@@ -70,17 +71,29 @@ function withDisplayName(base, stateSchema) {
   };
 }
 
+function withRowChange(base) {
+  return {
+    load: base.load,
+    loadStream: base.loadStream,
+    save: (id, state, saveMode, ttl) => base.save(id, RowChange$ReventlessCore.stamp(state), saveMode, ttl),
+    saveBatch: items => base.saveBatch(items.map(param => [
+      param[0],
+      RowChange$ReventlessCore.stamp(param[1]),
+      param[2]
+    ])),
+    count: base.count,
+    delete: base.delete,
+    deleteBatch: base.deleteBatch
+  };
+}
+
 function makeQueryDbOps(queryDbTableName, pgConnection, stateTopicName, indexes, subIdField) {
-  if (pgConnection !== undefined) {
-    return StateTopicPublishMjs.withLiveUpdates(QueryDbStorage_Postgres_Runtime$ReventlessAws.opsFor(pgConnection, queryDbTableName, indexes, subIdField), {
+  return withRowChange(pgConnection !== undefined ? StateTopicPublishMjs.withLiveUpdates(QueryDbStorage_Postgres_Runtime$ReventlessAws.opsFor(pgConnection, queryDbTableName, indexes, subIdField), {
       endpoint: process.env["APPSYNC_ENDPOINT"],
       region: process.env["AWS_REGION"],
       topicName: stateTopicName,
       subIdField: subIdField
-    });
-  } else {
-    return QueryDbEntryPoint_Ops$ReventlessAws.makeDynamoQueryDbOps(queryDbTableName);
-  }
+    }) : QueryDbEntryPoint_Ops$ReventlessAws.makeDynamoQueryDbOps(queryDbTableName));
 }
 
 export {
@@ -89,6 +102,7 @@ export {
   withLiveUpdates,
   withUnionMemberTypes,
   withDisplayName,
+  withRowChange,
   makeQueryDbOps,
 }
 /* DisplayName-Reventless Not a pure module */

package/src/adapter/ScheduledPublisher/ScheduledPublisher_EventBridgeScheduler_Runtime.res.mjs

@@ -60,7 +60,7 @@ function scheduleInput(roleArn, targetArn, setAt, schedule) {
 
 function failWithoutQueue(action) {
   let err = action + ` not possible: no Queue configured !`;
-  return Effect.runPromise(Effect.flatMap(EffectLogger$ReventlessCore.logError("ScheduledPublisher_EventBridgeScheduler_Runtime-ReventlessAws", undefined, err), () => Effect.sync(() => Stdlib_JsError.throwWithMessage(err))));
+  return Effect.runPromise(Effect.flatMap(EffectLogger$ReventlessCore.logError("ScheduledPublisher_EventBridgeScheduler_Runtime-ReventlessAws", undefined, undefined, err), () => Effect.sync(() => Stdlib_JsError.throwWithMessage(err))));
 }
 
 async function putSchedule(roleArn, targetArn, schedule) {

package/src/plugin/runtime/Util_PluginMessage_Runtime.res.mjs

@@ -9,7 +9,7 @@ import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src
 function sendMessage(channelId, messageBody) {
   return Effect$1.runPromise(Effect$1.catchAll(Effect$1.retry(Effect$1.map(Effect.tryPromise(SQS_Error$ReventlessAws.classify, () => SQS_Helpers$AwsSdk.sendMessage(channelId, messageBody, undefined, undefined, undefined)), () => {}), SQS_Error$ReventlessAws.retrySchedule), err => {
     let msg = SQS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_PluginMessage_Runtime-ReventlessAws", undefined, "Failed to send message to channel: " + msg), () => Effect$1.fail(err));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_PluginMessage_Runtime-ReventlessAws", undefined, undefined, "Failed to send message to channel: " + msg), () => Effect$1.fail(err));
   }));
 }
 

package/src/util/Util_CognitoGroupUser_Runtime.res.mjs

@@ -21,7 +21,7 @@ function addUserToGroup(region, userName, groupName, userPoolId) {
     return client.send(addUserToGroupCommand);
   }), () => {}), Cognito_Error$ReventlessAws.retrySchedule), err => {
     let msg = Cognito_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_CognitoGroupUser_Runtime-ReventlessAws", undefined, `addUserToGroup: ` + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_CognitoGroupUser_Runtime-ReventlessAws", undefined, undefined, `addUserToGroup: ` + msg), () => Effect$1.fail(msg));
   }));
 }
 
@@ -39,7 +39,7 @@ function removeUserFromGroup(region, userName, groupName, userPoolId) {
     return client.send(removeUserFromGroupCommand);
   }), () => {}), Cognito_Error$ReventlessAws.retrySchedule), err => {
     let msg = Cognito_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_CognitoGroupUser_Runtime-ReventlessAws", undefined, `removeUserFromGroup: ` + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_CognitoGroupUser_Runtime-ReventlessAws", undefined, undefined, `removeUserFromGroup: ` + msg), () => Effect$1.fail(msg));
   }));
 }
 

package/src/util/Util_Cognito_Runtime.res.mjs

@@ -24,7 +24,7 @@ function signUp(region, userPoolId, userPoolClientId, userName, password) {
 }
 
 function signUpIfMissing(region, userPoolId, userPoolClientId, userName, password) {
-  return Effect$1.runPromise(Effect$1.catchAll(Effect$1.flatMap(Effect.tryPromise(Cognito_Error$ReventlessAws.classify, () => signUp(region, userPoolId, userPoolClientId, userName, password)), result => EffectLogger$ReventlessCore.logInfo("Util_Cognito_Runtime-ReventlessAws", undefined, `Created User ` + userName + ` ` + Stdlib_Option.getOr(result.UserSub, ""))), err => EffectLogger$ReventlessCore.logInfo("Util_Cognito_Runtime-ReventlessAws", undefined, Cognito_Error$ReventlessAws.message(err))));
+  return Effect$1.runPromise(Effect$1.catchAll(Effect$1.flatMap(Effect.tryPromise(Cognito_Error$ReventlessAws.classify, () => signUp(region, userPoolId, userPoolClientId, userName, password)), result => EffectLogger$ReventlessCore.logInfo("Util_Cognito_Runtime-ReventlessAws", undefined, undefined, `Created User ` + userName + ` ` + Stdlib_Option.getOr(result.UserSub, ""))), err => EffectLogger$ReventlessCore.logInfo("Util_Cognito_Runtime-ReventlessAws", undefined, undefined, Cognito_Error$ReventlessAws.message(err))));
 }
 
 export {

package/src/util/Util_DeadLetterHandler.res

@@ -0,0 +1,138 @@
+// The dead-letter function's handler. `Util_DeadLetterQueue` ships this module's compiled file
+// as the function's whole code, so it must compile to a file that imports nothing: it keeps
+// working when the layer or the handlers of a deploy are broken, which is when dead letters
+// arrive. So only the Stdlib's externals (which compile inline) and plain switches here: no
+// Stdlib function such as `Option.getOr`, which compiles to an import, and no `try`, whose
+// compiled form imports the runtime's exception helpers.
+//
+// It logs what arrived, then FAILS the invocation on purpose.
+//
+// Returning success would let SQS delete the message, which is what this handler used to do,
+// and it made a dead letter unobservable twice over: the queue's depth returned to 0, so a
+// depth alarm could never fire, and the function's `Errors` metric stayed at 0, so neither
+// could an error alarm. A plugin whose commands failed every 5 minutes for two days produced
+// 217 dead letters and no signal at all; it was found by a person noticing a stale UI.
+//
+// Failing instead keeps the message on the queue and keeps `Errors` non-zero while the
+// condition lasts. Both are conventional alarm subjects, and a monitoring backend attached
+// through the `DeadLetterSink` seam now has something to attach to.
+//
+// The transport retries by design too: a failed batch returns to the queue and is redelivered
+// until retention expires. A handler that fails forever, on a transport that retries forever,
+// is a loop, and it outlives its cause, because nothing about a fixed bug removes the message
+// that was stranded by it. So what the loop costs is a function of the line, not the count:
+// the first delivery here writes the record's ids, kind, size and attribute names (never its
+// body, which is a command or event and may be about a person), and every redelivery after it
+// writes a single identity line. A stranded message is ~150 KB over a fortnight rather than
+// ~17 MB, small enough that ending the loop early is an operator's job.
+
+// How many times a consuming queue delivers a message before it moves it here. Every redrive
+// policy in the framework takes it from here. SQS keeps a message's receive count when it
+// moves it, so a dead letter's first delivery here reports `maxReceiveCount + 1`; a message
+// sent here directly starts at 1.
+let maxReceiveCount = 5
+let firstDeliveryCount = maxReceiveCount + 1
+
+type record = {
+  messageId?: string,
+  body?: string,
+  attributes?: dict<string>,
+  messageAttributes?: dict<JSON.t>,
+  eventSourceARN?: string,
+}
+type event = {@as("Records") records?: array<record>}
+
+// The body parsed, or nothing when it is not JSON. A `try` would import the runtime, so the
+// parse is guarded in plain JS.
+let parseOrNull: string => Nullable.t<JSON.t> = %raw(`function (text) {
+  try { return JSON.parse(text) } catch (_) { return null }
+}`)
+
+// `Option.getOr` would import the Stdlib, so the default is given here.
+let orElse = (value: option<string>, fallback: string) =>
+  switch value {
+  | Some(v) => v
+  | None => fallback
+  }
+
+// The command's or event's tag, "sns" for an SNS envelope, else "unknown".
+let kindOf = (body: string): string =>
+  switch parseOrNull(body)->Nullable.toOption {
+  | Some(JSON.Object(d)) =>
+    let tagOf = key =>
+      switch d->Dict.get(key) {
+      | Some(JSON.Object(inner)) =>
+        switch inner->Dict.get("TAG") {
+        | Some(JSON.String(tag)) => Some(tag)
+        | _ => None
+        }
+      | _ => None
+      }
+    switch (tagOf("command"), tagOf("event"), d->Dict.get("Message")) {
+    | (Some(tag), _, _) | (None, Some(tag), _) => tag
+    | (None, None, Some(_)) => "sns"
+    | (None, None, None) => "unknown"
+    }
+  | _ => "unknown"
+  }
+
+let receiveCountOf = (attrs: dict<string>): int =>
+  switch attrs->Dict.get("ApproximateReceiveCount") {
+  | Some(text) =>
+    let n = Float.parseFloat(text)
+    Float.isNaN(n) ? 1 : Float.toInt(n)
+  | None => 1
+  }
+
+// The line a record writes: the full one on its first delivery here, the short one after.
+let lineOf = (record: record): string => {
+  let attrs = switch record.attributes {
+  | Some(a) => a
+  | None => Dict.make()
+  }
+  let receiveCount = receiveCountOf(attrs)
+  let body = record.body->orElse("")
+  let source = switch attrs->Dict.get("DeadLetterQueueSourceArn") {
+  | Some(arn) => arn
+  | None => record.eventSourceARN->orElse("unknown")
+  }
+  let identity =
+    "messageId=" ++
+    record.messageId->orElse("unknown") ++
+    " source=" ++
+    source ++
+    " receiveCount=" ++
+    Int.toString(receiveCount) ++
+    " bodyBytes=" ++
+    Int.toString(String.length(body))
+  if receiveCount <= firstDeliveryCount {
+    let attributeNames = switch record.messageAttributes {
+    | Some(m) => m->Dict.keysToArray
+    | None => []
+    }
+    "DEAD LETTER ITEM: " ++
+    identity ++
+    " kind=" ++
+    kindOf(body) ++
+    " attributes=" ++
+    attributeNames->Array.join(",")
+  } else {
+    "DEAD LETTER REDELIVERY: " ++ identity
+  }
+}
+
+let handler = async (event: event): unit => {
+  let records = switch event.records {
+  | Some(r) => r
+  | None => []
+  }
+  records->Array.forEach(record => Console.error(lineOf(record)))
+  JsError.throw(
+    JsError.make(
+      "Dead-lettered " ++
+      Int.toString(
+        Array.length(records),
+      ) ++ " message(s); see DEAD LETTER ITEM above. Failing so the messages are retained and Errors is non-zero.",
+    ),
+  )
+}

package/src/util/Util_DeadLetterHandler.res.mjs

@@ -0,0 +1,113 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let firstDeliveryCount = 6;
+
+let parseOrNull = (function (text) {
+  try { return JSON.parse(text) } catch (_) { return null }
+});
+
+function orElse(value, fallback) {
+  if (value !== undefined) {
+    return value;
+  } else {
+    return fallback;
+  }
+}
+
+function kindOf(body) {
+  let match = parseOrNull(body);
+  if (match == null) {
+    return "unknown";
+  }
+  if (typeof match !== "object" || match === null || Array.isArray(match)) {
+    return "unknown";
+  }
+  let tagOf = key => {
+    let match$1 = match[key];
+    if (match$1 === undefined) {
+      return;
+    }
+    if (typeof match$1 !== "object" || match$1 === null || Array.isArray(match$1)) {
+      return;
+    }
+    let match$2 = match$1["TAG"];
+    if (typeof match$2 === "string") {
+      return match$2;
+    }
+  };
+  let match$1 = tagOf("command");
+  let match$2 = tagOf("event");
+  let match$3 = match["Message"];
+  if (match$1 !== undefined) {
+    return match$1;
+  } else if (match$2 !== undefined) {
+    return match$2;
+  } else if (match$3 !== undefined) {
+    return "sns";
+  } else {
+    return "unknown";
+  }
+}
+
+function receiveCountOf(attrs) {
+  let text = attrs["ApproximateReceiveCount"];
+  if (text === undefined) {
+    return 1;
+  }
+  let n = parseFloat(text);
+  if (Number.isNaN(n)) {
+    return 1;
+  } else {
+    return n | 0;
+  }
+}
+
+function lineOf(record) {
+  let a = record.attributes;
+  let attrs = a !== undefined ? a : ({});
+  let receiveCount = receiveCountOf(attrs);
+  let value = record.body;
+  let body = value !== undefined ? value : "";
+  let arn = attrs["DeadLetterQueueSourceArn"];
+  let source;
+  if (arn !== undefined) {
+    source = arn;
+  } else {
+    let value$1 = record.eventSourceARN;
+    source = value$1 !== undefined ? value$1 : "unknown";
+  }
+  let value$2 = record.messageId;
+  let identity = "messageId=" + (
+    value$2 !== undefined ? value$2 : "unknown"
+  ) + " source=" + source + " receiveCount=" + receiveCount.toString() + " bodyBytes=" + body.length.toString();
+  if (receiveCount > firstDeliveryCount) {
+    return "DEAD LETTER REDELIVERY: " + identity;
+  }
+  let m = record.messageAttributes;
+  let attributeNames = m !== undefined ? Object.keys(m) : [];
+  return "DEAD LETTER ITEM: " + identity + " kind=" + kindOf(body) + " attributes=" + attributeNames.join(",");
+}
+
+async function handler(event) {
+  let r = event.Records;
+  let records = r !== undefined ? r : [];
+  records.forEach(record => {
+    console.error(lineOf(record));
+  });
+  throw new Error("Dead-lettered " + records.length.toString() + " message(s); see DEAD LETTER ITEM above. Failing so the messages are retained and Errors is non-zero.");
+}
+
+let maxReceiveCount = 5;
+
+export {
+  maxReceiveCount,
+  firstDeliveryCount,
+  parseOrNull,
+  orElse,
+  kindOf,
+  receiveCountOf,
+  lineOf,
+  handler,
+}
+/* No side effect */

package/src/util/Util_DeadLetterQueue.res

@@ -17,6 +17,10 @@ let queueTags = queueName =>
 // 4-day default can expire it over a long weekend before anyone reads it.
 let retentionSeconds = 14 * 24 * 60 * 60
 
+// How many times a consuming queue delivers a message before it moves it here; every redrive
+// policy in the framework takes it from here. Defined beside the handler, which needs it.
+let maxReceiveCount = Util_DeadLetterHandler.maxReceiveCount
+
 // A dead letter has no latency requirement, and the handler below fails on
 // purpose — so a message returns to the queue and is redelivered until retention
 // expires. At 180 s that is ~480 redeliveries per message per day, which outlives
@@ -67,59 +71,12 @@ let lambdaRole = IAM.Role.makeWithDefaultPolicy(
   ~opts,
 )
 
-// Logs what arrived, then FAILS the invocation on purpose.
-//
-// Returning success here would let SQS delete the message, which is what this
-// handler used to do — and it made a dead letter unobservable twice over: the
-// queue's depth returned to 0, so a depth alarm could never fire, and the
-// function's `Errors` metric stayed at 0, so neither could an error alarm. A
-// plugin whose commands failed every 5 minutes for two days produced 217 dead
-// letters and no signal at all; it was found by a person noticing a stale UI.
-//
-// Failing instead keeps the message on the queue and keeps `Errors` non-zero
-// while the condition lasts. Both are conventional alarm subjects, and a
-// monitoring backend attached through the `DeadLetterSink` seam below now has
-// something to attach to.
-//
-// What that reasoning did not account for is that the transport retries by
-// design too: a failed batch returns to the queue and is redelivered until
-// retention expires. A handler that fails forever, on a transport that retries
-// forever, is a loop — and it outlives its cause, because nothing about a fixed
-// bug removes the message that was stranded by it. Seven of them were still
-// cycling twelve hours after the fix that made them impossible.
-//
-// What the loop costs is now a function of the line, not the count: the first
-// delivery writes the record's ids, kind, size and attribute names — never its
-// body, which is a command or event and may be about a person — and every
-// redelivery after it costs a single identity line. A stranded
-// message is ~150 KB over a fortnight rather than ~17 MB, which is small enough
-// that ending the loop early is an operator's job rather than the topology's.
-let entryPointCode = `export const handler = async (event) => {
-  const records = event?.Records ?? [];
-  for (const record of records) {
-    const attrs = record?.attributes ?? {};
-    const receiveCount = Number(attrs.ApproximateReceiveCount ?? 1);
-    const identity =
-      "messageId=" + (record?.messageId ?? "unknown") +
-      " source=" + (attrs.DeadLetterQueueSourceArn ?? record?.eventSourceARN ?? "unknown") +
-      " receiveCount=" + receiveCount +
-      " bodyBytes=" + (record?.body?.length ?? 0);
-    if (receiveCount <= 1) {
-      // Ids, type and size, never the body: a dead letter is a command or event,
-      // and its payload may be about a person.
-      const body = (() => { try { return JSON.parse(record?.body ?? "null") } catch { return null } })();
-      const kind = body?.command?.TAG ?? body?.event?.TAG ?? (body?.Message ? "sns" : "unknown");
-      console.error("DEAD LETTER ITEM: " + identity + " kind=" + kind +
-        " attributes=" + JSON.stringify(Object.keys(record?.messageAttributes ?? {})));
-    } else {
-      console.error("DEAD LETTER REDELIVERY: " + identity);
-    }
-  }
-  throw new Error(
-    "Dead-lettered " + records.length +
-    " message(s); see DEAD LETTER ITEM above. Failing so the messages are retained and Errors is non-zero."
-  );
-};`
+// The function's whole code is `Util_DeadLetterHandler`'s compiled file, which imports
+// nothing (see there), shipped as `index.mjs`. It sits beside `Util_Bundle`'s compiled file,
+// so it resolves from there.
+let entryPointCode = NodeFs.readFileSync(
+  Util_Bundle.localRequire->NodeModule.requireResolve("./Util_DeadLetterHandler.res.mjs"),
+)
 
 let archiveContents: dict<Pulumi.Archive.assetOrArchive> = Dict.make()
 archiveContents->Dict.set(

package/src/util/Util_DeadLetterQueue.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Nodefs from "node:fs";
 import * as Aws from "@pulumi/aws";
 import * as IAM$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/IAM.res.mjs";
 import * as Pulumi from "@pulumi/pulumi";
@@ -11,6 +12,7 @@ import * as Monitoring$ReventlessCore from "@reventlessdev/reventless-core/src/a
 import * as Util_Bundle$ReventlessAws from "./Util_Bundle.res.mjs";
 import * as Util_Lambda$ReventlessAws from "./Util_Lambda.res.mjs";
 import * as Util_LambdaLogging$ReventlessAws from "./Util_LambdaLogging.res.mjs";
+import * as Util_DeadLetterHandler$ReventlessAws from "./Util_DeadLetterHandler.res.mjs";
 import * as Util_EventSourceMapping$ReventlessAws from "./Util_EventSourceMapping.res.mjs";
 
 let name = "DeadLetterQueue";
@@ -45,32 +47,7 @@ let opts = {
 
 let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name, Pulumi.output(AWS$ReventlessAws.Lambda.principal), AWS_Tags$ReventlessAws.make(name, "Plugin", "Identity", "Plugin", undefined, undefined, undefined, undefined), opts);
 
-let entryPointCode = `export const handler = async (event) => {
-  const records = event?.Records ?? [];
-  for (const record of records) {
-    const attrs = record?.attributes ?? {};
-    const receiveCount = Number(attrs.ApproximateReceiveCount ?? 1);
-    const identity =
-      "messageId=" + (record?.messageId ?? "unknown") +
-      " source=" + (attrs.DeadLetterQueueSourceArn ?? record?.eventSourceARN ?? "unknown") +
-      " receiveCount=" + receiveCount +
-      " bodyBytes=" + (record?.body?.length ?? 0);
-    if (receiveCount <= 1) {
-      // Ids, type and size, never the body: a dead letter is a command or event,
-      // and its payload may be about a person.
-      const body = (() => { try { return JSON.parse(record?.body ?? "null") } catch { return null } })();
-      const kind = body?.command?.TAG ?? body?.event?.TAG ?? (body?.Message ? "sns" : "unknown");
-      console.error("DEAD LETTER ITEM: " + identity + " kind=" + kind +
-        " attributes=" + JSON.stringify(Object.keys(record?.messageAttributes ?? {})));
-    } else {
-      console.error("DEAD LETTER REDELIVERY: " + identity);
-    }
-  }
-  throw new Error(
-    "Dead-lettered " + records.length +
-    " message(s); see DEAD LETTER ITEM above. Failing so the messages are retained and Errors is non-zero."
-  );
-};`;
+let entryPointCode = Nodefs.readFileSync(Util_Bundle$ReventlessAws.localRequire.resolve("./Util_DeadLetterHandler.res.mjs"), "utf8");
 
 let archiveContents = {};
 
@@ -185,6 +162,8 @@ Pulumi.all([
 
 let retentionSeconds = 1209600;
 
+let maxReceiveCount = Util_DeadLetterHandler$ReventlessAws.maxReceiveCount;
+
 let visibilityTimeoutSeconds = 900;
 
 export {
@@ -192,6 +171,7 @@ export {
   nameFifo,
   queueTags,
   retentionSeconds,
+  maxReceiveCount,
   visibilityTimeoutSeconds,
   queue,
   fifoQueue,

package/src/util/Util_DynamoDb_Runtime.res.mjs

@@ -46,7 +46,7 @@ function putWithRetries(table, id, item) {
         break;
     }
     let msg = err._0;
-    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, `putWithRetries: id=` + id + `: ` + msg), () => ({
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `putWithRetries: id=` + id + `: ` + msg), () => ({
       TAG: "Error",
       _0: `put id=` + id + ` failed: ` + msg
     }));
@@ -70,7 +70,7 @@ function putIfNotExistsWithRetries(idKey, sortKey, table, id, item) {
         break;
     }
     let msg = err._0;
-    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, `putIfNotExistsWithRetries: id=` + id + `: ` + msg), () => ({
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `putIfNotExistsWithRetries: id=` + id + `: ` + msg), () => ({
       TAG: "Error",
       _0: `putIfNotExists id=` + id + ` failed: ` + msg
     }));
@@ -87,7 +87,7 @@ function deleteWithRetries(sort, table, id) {
     _0: undefined
   })), DynamoDb_Error$ReventlessAws.retrySchedule), err => {
     let msg = DynamoDb_Error$ReventlessAws.message(err);
-    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, `delete: id=` + id + `: ` + msg), () => ({
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `delete: id=` + id + `: ` + msg), () => ({
       TAG: "Error",
       _0: `delete id=` + id + ` failed: ` + msg
     }));
@@ -199,7 +199,7 @@ function batchWriteWithRetries(batchWriteRequests) {
     }
     let unprocessedRequests = Stdlib_Option.getOrThrow(writeOutput.UnprocessedItems, undefined);
     let count = Object.keys(unprocessedRequests).length.toString();
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_DynamoDb_Runtime-ReventlessAws", undefined, `batchWriteWithRetries: retry ` + retry.toString() + `: ` + count + ` unprocessed items`), () => attempt(retry + 1 | 0, unprocessedRequests));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_DynamoDb_Runtime-ReventlessAws", undefined, undefined, `batchWriteWithRetries: retry ` + retry.toString() + `: ` + count + ` unprocessed items`), () => attempt(retry + 1 | 0, unprocessedRequests));
   }), err => {
     let msg = DynamoDb_Error$ReventlessAws.message(err);
     return Effect$1.succeed({

package/src/util/Util_Kinesis_Runtime.res.mjs

@@ -14,7 +14,7 @@ function putRecord(stream, data) {
     PartitionKey: ""
   }))), param => {}), Kinesis_Error$ReventlessAws.retrySchedule), err => {
     let msg = Kinesis_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_Kinesis_Runtime-ReventlessAws", undefined, `putRecord: ` + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_Kinesis_Runtime-ReventlessAws", undefined, undefined, `putRecord: ` + msg), () => Effect$1.fail(msg));
   }));
 }
 

package/src/util/Util_SNS_Runtime.res.mjs

@@ -9,14 +9,14 @@ import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src
 function publish(topic, message) {
   return Effect$1.runPromise(Effect$1.catchAll(Effect$1.retry(Effect$1.map(Effect.tryPromise(SNS_Error$ReventlessAws.classify, () => SNS_Helpers$AwsSdk.publish(topic.arn, undefined, message)), param => {}), SNS_Error$ReventlessAws.retrySchedule), err => {
     let msg = SNS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SNS_Runtime-ReventlessAws", undefined, "publish: " + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SNS_Runtime-ReventlessAws", undefined, undefined, "publish: " + msg), () => Effect$1.fail(msg));
   }));
 }
 
 function publishFifo(topic, messageGroupId, message) {
   return Effect$1.runPromise(Effect$1.catchAll(Effect$1.retry(Effect$1.map(Effect.tryPromise(SNS_Error$ReventlessAws.classify, () => SNS_Helpers$AwsSdk.publish(topic.arn, messageGroupId, message)), param => {}), SNS_Error$ReventlessAws.retrySchedule), err => {
     let msg = SNS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SNS_Runtime-ReventlessAws", undefined, "publishFifo: " + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SNS_Runtime-ReventlessAws", undefined, undefined, "publishFifo: " + msg), () => Effect$1.fail(msg));
   }));
 }
 

package/src/util/Util_SQS_Runtime.res.mjs

@@ -44,7 +44,7 @@ function send(queue, queueService, commandJson) {
     }
   }), () => {}), SQS_Error$ReventlessAws.sendRetrySchedule), err => {
     let msg = SQS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, "send: " + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, undefined, "send: " + msg), () => Effect$1.fail(msg));
   });
 }
 
@@ -69,7 +69,7 @@ function sendMessages(queue, queueService, commandJsons) {
       return failedIds.some(failedId => failedId === msgId);
     });
     if (retry < 5) {
-      return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_SQS_Runtime-ReventlessAws", undefined, `sendMessages: ` + failedIds.length.toString() + ` failed ids, retrying subset`), () => attempt(retry + 1 | 0, commandJsonsToRetry));
+      return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_SQS_Runtime-ReventlessAws", undefined, undefined, `sendMessages: ` + failedIds.length.toString() + ` failed ids, retrying subset`), () => attempt(retry + 1 | 0, commandJsonsToRetry));
     }
     let ids = failedIds.join(", ");
     return Effect$1.fail({
@@ -79,7 +79,7 @@ function sendMessages(queue, queueService, commandJsons) {
   });
   return Effect$1.catchAll(attempt(0, commandJsons), err => {
     let msg = SQS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, `sendMessages: ` + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, undefined, `sendMessages: ` + msg), () => Effect$1.fail(msg));
   });
 }
 
@@ -104,7 +104,7 @@ function deleteMessages(entries, queue) {
       ReceiptHandle: entry.ReceiptHandle
     }));
     if (retry < 5) {
-      return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_SQS_Runtime-ReventlessAws", undefined, `deleteMessages: ` + failedIds.length.toString() + ` failed ids, retrying subset`), () => attempt(retry + 1 | 0, entriesToRetry));
+      return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_SQS_Runtime-ReventlessAws", undefined, undefined, `deleteMessages: ` + failedIds.length.toString() + ` failed ids, retrying subset`), () => attempt(retry + 1 | 0, entriesToRetry));
     }
     let ids = failedIds.join(", ");
     return Effect$1.fail({
@@ -114,7 +114,7 @@ function deleteMessages(entries, queue) {
   });
   return Effect$1.catchAll(attempt(0, entries), err => {
     let msg = SQS_Error$ReventlessAws.message(err);
-    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, `deleteMessages: ` + msg), () => Effect$1.fail(msg));
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_SQS_Runtime-ReventlessAws", undefined, undefined, `deleteMessages: ` + msg), () => Effect$1.fail(msg));
   });
 }