@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/logger/LogFormatTest.res

@@ -0,0 +1,348 @@
+open JestGlobals
+open LogFormat
+
+S.enableJson()
+
+// Sink detection (Reventless.AnsiStyle) defaults a non-TTY stdout — Jest
+// included — to JSON, which no-ops `bold`/`fmtComp`. The human-format
+// assertions below expect ANSI, so force text mode for this file. The
+// "JSON sink" block flips to json and restores text in its own setup.
+@val external _processEnv: Dict.t<string> = "process.env"
+_processEnv->Dict.set("REVENTLESS_LOG_FORMAT", "text")
+Reventless.AnsiStyle.reload()
+
+describe("LogFormat", () => {
+  describe("commandJsonsToLogMessages", () => {
+    testSync(
+      "empty",
+      () => {
+        let arr: array<Message.commandJson> = []
+        expect(commandJsonsToLogMessages(arr))->toEqual([])
+      },
+    )
+    testSync(
+      "simple",
+      () => {
+        let commands: array<PluginSpec.command> = [Heartbeat("0.0.0")]
+        let meta: Message.meta = {
+          service: "testService",
+          time: "testTime",
+          ip: "testIp",
+          user: "testUser",
+          msgId: "testMsgId",
+          correlationId: "testCorrelationId",
+        }
+        let metaStr = meta->Message.encode(Message.metaSchema)->JSON.stringify
+        let arr: array<Message.commandJson> = commands->Array.mapWithIndex(
+          (command, idx) => {
+            {
+              Message.id: idx->Int.toString,
+              meta,
+              commandJson: command->Message.encode(PluginSpec.commandSchema),
+            }
+          },
+        )
+        let expected = `1/1: \x1b[1mHeartbeat\x1b[0m(0): {"command":{"TAG":"Heartbeat","_0":"0.0.0"},"meta":${metaStr},"id":"0"}`
+        expect(commandJsonsToLogMessages(arr))->toEqual([expected])
+      },
+    )
+    testSync(
+      "complex",
+      () => {
+        let commands: array<PluginSpec.command> = [
+          Heartbeat("0.0.0"),
+          Connect({
+            id: "id",
+            name: "testName",
+            version: "testVersion",
+            extensionPoints: [
+              {
+                name: "testExtensionPoint",
+                commandTopic: "testCommandTopic",
+                eventTopic: "testEventTopic",
+              },
+            ],
+            extensions: [
+              {
+                name: "testExtension",
+                extensionPointName: "testExtensionPoint",
+                dcbSources: [],
+              },
+            ],
+            eventCollector: "testEventCollector",
+            extensionProtocols: [],
+            apiSchemaFragment: None,
+            apiTarget: None,
+            uiFragments: None,
+            structure: None,
+            dcbEventLog: None,
+          }),
+        ]
+        let meta: Message.meta = {
+          service: "testService",
+          time: "testTime",
+          ip: "testIp",
+          user: "testUser",
+          msgId: "testMsgId",
+          correlationId: "testCorrelationId",
+        }
+        let metaStr = meta->Message.encode(Message.metaSchema)->JSON.stringify
+        let arr: array<Message.commandJson> = commands->Array.mapWithIndex(
+          (command, idx) => {
+            {
+              Message.id: idx->Int.toString,
+              meta,
+              commandJson: command->Message.encode(PluginSpec.commandSchema),
+            }
+          },
+        )
+        let expected1 = `1/2: \x1b[1mHeartbeat\x1b[0m(0): {"command":{"TAG":"Heartbeat","_0":"0.0.0"},"meta":${metaStr},"id":"0"}`
+        let expected2 = `2/2: \x1b[1mConnect\x1b[0m(1): {"command":{"TAG":"Connect","_0":{"id":"id","name":"testName","version":"testVersion","extensionPoints":[{"name":"testExtensionPoint","commandTopic":"testCommandTopic","eventTopic":"testEventTopic"}],"extensions":[{"name":"testExtension","extensionPointName":"testExtensionPoint","dcbSources":[]}],"eventCollector":"testEventCollector","extensionProtocols":[],"apiSchemaFragment":null,"apiTarget":null,"uiFragments":null,"structure":null,"dcbEventLog":null}},"meta":${metaStr},"id":"1"}`
+        expect(commandJsonsToLogMessages(arr))->toEqual([expected1, expected2])
+      },
+    )
+  })
+  describe("event'JsonToLogMessage", () => {
+    testSync(
+      "simple",
+      () => {
+        open PluginSpec
+        let event': Message.event'<string, event> = {
+          id: "testId",
+          meta: {
+            service: "testService",
+            time: "testTime",
+            ip: "testIp",
+            user: "testUser",
+            msgId: "testMsgId",
+            correlationId: "testCorrelationId",
+          },
+          event: VersionDetected("0.0.0"),
+        }
+        let eventJson' = event'->Message.encodeEvent'(S.string, eventSchema)
+        let msg = event'JsonToLogMessage(eventJson')
+
+        let expected = `\x1b[1mVersionDetected\x1b[0m(testId): {"event":{"TAG":"VersionDetected","_0":"0.0.0"},"meta":{"service":"testService","time":"testTime","ip":"testIp","user":"testUser","msgId":"testMsgId","correlationId":"testCorrelationId"},"id":"testId"}`
+
+        expect(msg)->toEqual(expected)
+      },
+    )
+  })
+})
+
+// ─── JSON sink (non-TTY collector: CloudWatch / Datadog / …) ─────────────────
+// Regression guard: in a JSON sink every emitted record must parse as JSON and
+// must NOT carry any ANSI escape (\x1b) anywhere. This fails the moment a new
+// helper inlines an ANSI code into a path that reaches Logger.emit.
+
+type consoleObj = {mutable log: string => unit}
+@val external _console: consoleObj = "console"
+
+let hasAnsi = (s: string): bool => s->String.includes("\x1b")
+
+// Run `fn` with console.log captured; restores the original even if `fn` throws.
+// Logger's JSON branch emits every level through Console.log, so this captures
+// all of it.
+let captureLogs = (fn: unit => unit): array<string> => {
+  let captured: array<string> = []
+  let original = _console.log
+  _console.log = s => captured->Array.push(s)
+  let result = try {
+    fn()
+    Ok()
+  } catch {
+  | e => Error(e)
+  }
+  _console.log = original
+  switch result {
+  | Ok() => captured
+  | Error(e) => throw(e)
+  }
+}
+
+let validLevels = ["DEBUG", "INFO", "WARN", "ERROR"]
+
+// True when a captured line is a clean JSON log record: parses as JSON, carries
+// no ANSI escape anywhere, has a string `message` and a known `level`.
+let isCleanRecord = (line: string): bool =>
+  !hasAnsi(line) &&
+  (try {
+    switch line->JSON.parseOrThrow->JSON.Decode.object {
+    | Some(obj) =>
+      let levelOk =
+        obj
+        ->Dict.get("level")
+        ->Option.flatMap(JSON.Decode.string)
+        ->Option.mapOr(false, l => validLevels->Array.includes(l))
+      let msgOk = obj->Dict.get("message")->Option.flatMap(JSON.Decode.string)->Option.isSome
+      levelOk && msgOk
+    | None => false
+    }
+  } catch {
+  | _ => false
+  })
+
+// Read a top-level string field off a captured JSON record (None if absent).
+let fieldOf = (line: string, key: string): option<string> =>
+  switch line->JSON.parseOrThrow->JSON.Decode.object {
+  | Some(obj) => obj->Dict.get(key)->Option.flatMap(JSON.Decode.string)
+  | None => None
+  }
+
+describe("JSON sink", () => {
+  // Flip to json for the whole block; restore text afterwards so a re-run of the
+  // file (or shared module state) keeps the human-format assertions valid.
+  beforeAll(() => {
+    _processEnv->Dict.set("REVENTLESS_LOG_FORMAT", "json")
+    Reventless.AnsiStyle.reload()
+  })
+  afterAll(() => {
+    _processEnv->Dict.set("REVENTLESS_LOG_FORMAT", "text")
+    Reventless.AnsiStyle.reload()
+  })
+
+  // Logger.t goes Debug+ regardless of LOG_LEVEL via an explicit min level.
+  let log = Logger.makeLogger(~minLevel=Debug)
+
+  testSync("Logger.info emits one clean JSON record with comp as a top-level field", () => {
+    let lines = captureLogs(() => log.info(~comp="Aggregate(Product)", "handling command"))
+    let line = lines->Array.length == 1 ? lines->Array.getUnsafe(0) : ""
+    let ok =
+      lines->Array.length == 1 &&
+      isCleanRecord(line) &&
+      // comp is promoted to a top-level key, message stays clean (no [Comp] prefix)
+      line->fieldOf("comp") == Some("Aggregate(Product)") &&
+      line->fieldOf("message") == Some("handling command")
+    expect(ok)->toBe(true)
+  })
+
+  testSync("Logger.info resolves plugin to a top-level field when the comp is registered", () => {
+    Logger.registerComponentPlugin(~componentName="Product", ~pluginName="Catalog")
+    let lines = captureLogs(() => log.info(~comp="Aggregate(Product)", "handling command"))
+    let line = lines->Array.length == 1 ? lines->Array.getUnsafe(0) : ""
+    expect(lines->Array.length == 1 && line->fieldOf("plugin") == Some("Catalog"))->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)
+  })
+
+  testSync("Logger.error with ~data emits one clean JSON record", () => {
+    let lines = captureLogs(() =>
+      log.error(
+        ~comp="Util_AppSync_Caller",
+        ~data=JSON.parseOrThrow(`{"errors":["boom"]}`),
+        "query errors",
+      )
+    )
+    expect(lines->Array.length == 1 && isCleanRecord(lines->Array.getUnsafe(0)))->toBe(true)
+  })
+
+  testSync("EffectLogger.logInfo emits clean JSON through install()", () => {
+    let lines = captureLogs(() =>
+      EffectLogger.logInfo(~comp="Aggregate(Product)", "replay done")->Effect.runSync
+    )
+    let allClean = lines->Array.filter(l => !isCleanRecord(l))->Array.length == 0
+    expect(lines->Array.length >= 1 && allClean)->toBe(true)
+  })
+
+  testSync("EffectLogger.logInfo carries ~comp + ~detail as structured fields (no \\x00)", () => {
+    let lines = captureLogs(() =>
+      EffectLogger.logInfo(
+        ~comp="Aggregate(Product)",
+        ~detail=JSON.parseOrThrow(`{"id":"p-1"}`),
+        "added",
+      )->Effect.runSync
+    )
+    let ok = lines->Array.some(line =>
+      switch line->JSON.parseOrThrow->JSON.Decode.object {
+      | Some(obj) =>
+        obj->Dict.get("comp")->Option.flatMap(JSON.Decode.string) == Some("Aggregate(Product)") &&
+        obj
+        ->Dict.get("detail")
+        ->Option.flatMap(JSON.Decode.object)
+        ->Option.flatMap(d => d->Dict.get("id"))
+        ->Option.flatMap(JSON.Decode.string) == Some("p-1")
+      | None => false
+      }
+    )
+    expect(ok)->toBe(true)
+  })
+
+  testSync("Effect.annotateLogs(correlationId) surfaces as a top-level field", () => {
+    let lines = captureLogs(() =>
+      EffectLogger.logInfo(~comp="Aggregate(Product)", "handling")
+      ->Effect.annotateLogs("correlationId", "c-123")
+      ->Effect.runSync
+    )
+    expect(lines->Array.some(line => line->fieldOf("correlationId") == Some("c-123")))->toBe(true)
+  })
+
+  testSync("Effect.annotateLogs(plugin) overrides registry resolution", () => {
+    // The component is NOT registered against any plugin; without an explicit
+    // ~plugin annotation, resolvePlugin would fall back through transformations
+    // and emit no plugin field. With the annotation, plugin wins.
+    let lines = captureLogs(() =>
+      EffectLogger.logInfo(~comp="Aggregate(Unregistered)", "handling")
+      ->Effect.annotateLogs("plugin", "Ordering")
+      ->Effect.runSync
+    )
+    expect(lines->Array.some(line => line->fieldOf("plugin") == Some("Ordering")))->toBe(true)
+  })
+
+  testSync("every JSON record carries an RFC 3339 time field", () => {
+    let lines = captureLogs(() => log.info(~comp="Platform", "tick"))
+    let ok = switch lines->Array.get(0)->Option.flatMap(l => l->fieldOf("time")) {
+    | Some(t) => t->String.includes("T") && t->String.endsWith("Z")
+    | None => false
+    }
+    expect(ok)->toBe(true)
+  })
+
+  testSync("service field is emitted when REVENTLESS_SERVICE is set", () => {
+    _processEnv->Dict.set("REVENTLESS_SERVICE", "TestService")
+    let lines = captureLogs(() => log.info(~comp="Platform", "tick"))
+    let got = lines->Array.get(0)->Option.flatMap(l => l->fieldOf("service"))
+    _processEnv->Dict.delete("REVENTLESS_SERVICE")
+    expect(got)->toEqual(Some("TestService"))
+  })
+
+  testSync("oversized detail is truncated to a preview stub", () => {
+    let big = String.repeat("x", 40000)
+    let detail = Dict.fromArray([("blob", JSON.Encode.string(big))])->JSON.Encode.object
+    // ~detail flows through emit (Logger.t's ~data goes into the message instead).
+    let direct = captureLogs(() => Logger.emit(~level=Info, ~comp="Platform", ~detail, "big"))
+    let ok = switch direct->Array.get(0)->Option.flatMap(l => l->JSON.parseOrThrow->JSON.Decode.object) {
+    | Some(obj) =>
+      switch obj->Dict.get("detail")->Option.flatMap(JSON.Decode.object) {
+      | Some(d) =>
+        d->Dict.get("truncated")->Option.flatMap(JSON.Decode.bool) == Some(true) &&
+          d->Dict.get("preview")->Option.flatMap(JSON.Decode.string)->Option.mapOr(false, p =>
+            p->String.length <= 512
+          )
+      | None => false
+      }
+    | None => false
+    }
+    expect(ok)->toBe(true)
+  })
+
+  testSync("LogFormat.cmdName carries no ANSI in a JSON sink", () => {
+    let meta: Message.meta = {
+      service: "testService",
+      time: "testTime",
+      ip: "testIp",
+      user: "testUser",
+      msgId: "testMsgId",
+      correlationId: "testCorrelationId",
+    }
+    let cmd: Message.commandJson = {
+      Message.id: "0",
+      meta,
+      commandJson: (Heartbeat("0.0.0"): PluginSpec.command)->Message.encode(PluginSpec.commandSchema),
+    }
+    let name = cmd->cmdName
+    expect(!hasAnsi(name) && name == "Heartbeat")->toBe(true)
+  })
+})

package/tests/logger/LogFormatTest.res.mjs

@@ -0,0 +1,309 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+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_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as AnsiStyle$Reventless from "@reventlessdev/reventless-spec/src/AnsiStyle.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Logger$ReventlessCore from "../../src/util/Logger.res.mjs";
+import * as Message$ReventlessCore from "../../src/Message.res.mjs";
+import * as LogFormat$ReventlessCore from "../../src/util/LogFormat.res.mjs";
+import * as PluginSpec$ReventlessCore from "../../src/plugin/lifecycle/PluginSpec.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../src/util/EffectLogger.res.mjs";
+
+S.enableJson();
+
+process.env["REVENTLESS_LOG_FORMAT"] = "text";
+
+AnsiStyle$Reventless.reload();
+
+globalThis.describe("LogFormat", () => {
+  globalThis.describe("commandJsonsToLogMessages", () => {
+    globalThis.test("empty", () => {
+      let arr = [];
+      globalThis.expect(LogFormat$ReventlessCore.commandJsonsToLogMessages(arr)).toEqual([]);
+    });
+    globalThis.test("simple", () => {
+      let commands = [{
+          TAG: "Heartbeat",
+          _0: "0.0.0"
+        }];
+      let meta = {
+        service: "testService",
+        time: "testTime",
+        ip: "testIp",
+        user: "testUser",
+        msgId: "testMsgId",
+        correlationId: "testCorrelationId"
+      };
+      let metaStr = JSON.stringify(Message$ReventlessCore.encode(meta, Message$ReventlessCore.metaSchema));
+      let arr = commands.map((command, idx) => ({
+        id: idx.toString(),
+        meta: meta,
+        commandJson: Message$ReventlessCore.encode(command, PluginSpec$ReventlessCore.commandSchema)
+      }));
+      let expected = `1/1: \x1b[1mHeartbeat\x1b[0m(0): {"command":{"TAG":"Heartbeat","_0":"0.0.0"},"meta":` + metaStr + `,"id":"0"}`;
+      globalThis.expect(LogFormat$ReventlessCore.commandJsonsToLogMessages(arr)).toEqual([expected]);
+    });
+    globalThis.test("complex", () => {
+      let commands = [
+        {
+          TAG: "Heartbeat",
+          _0: "0.0.0"
+        },
+        {
+          TAG: "Connect",
+          _0: {
+            id: "id",
+            name: "testName",
+            version: "testVersion",
+            extensionPoints: [{
+                name: "testExtensionPoint",
+                commandTopic: "testCommandTopic",
+                eventTopic: "testEventTopic"
+              }],
+            extensions: [{
+                name: "testExtension",
+                extensionPointName: "testExtensionPoint",
+                dcbSources: []
+              }],
+            eventCollector: "testEventCollector",
+            extensionProtocols: [],
+            apiSchemaFragment: undefined,
+            apiTarget: undefined,
+            uiFragments: undefined,
+            structure: undefined,
+            dcbEventLog: undefined
+          }
+        }
+      ];
+      let meta = {
+        service: "testService",
+        time: "testTime",
+        ip: "testIp",
+        user: "testUser",
+        msgId: "testMsgId",
+        correlationId: "testCorrelationId"
+      };
+      let metaStr = JSON.stringify(Message$ReventlessCore.encode(meta, Message$ReventlessCore.metaSchema));
+      let arr = commands.map((command, idx) => ({
+        id: idx.toString(),
+        meta: meta,
+        commandJson: Message$ReventlessCore.encode(command, PluginSpec$ReventlessCore.commandSchema)
+      }));
+      let expected1 = `1/2: \x1b[1mHeartbeat\x1b[0m(0): {"command":{"TAG":"Heartbeat","_0":"0.0.0"},"meta":` + metaStr + `,"id":"0"}`;
+      let expected2 = `2/2: \x1b[1mConnect\x1b[0m(1): {"command":{"TAG":"Connect","_0":{"id":"id","name":"testName","version":"testVersion","extensionPoints":[{"name":"testExtensionPoint","commandTopic":"testCommandTopic","eventTopic":"testEventTopic"}],"extensions":[{"name":"testExtension","extensionPointName":"testExtensionPoint","dcbSources":[]}],"eventCollector":"testEventCollector","extensionProtocols":[],"apiSchemaFragment":null,"apiTarget":null,"uiFragments":null,"structure":null,"dcbEventLog":null}},"meta":` + metaStr + `,"id":"1"}`;
+      globalThis.expect(LogFormat$ReventlessCore.commandJsonsToLogMessages(arr)).toEqual([
+        expected1,
+        expected2
+      ]);
+    });
+  });
+  globalThis.describe("event'JsonToLogMessage", () => {
+    globalThis.test("simple", () => {
+      let eventJson$p = Message$ReventlessCore.encodeEvent$p({
+        id: "testId",
+        meta: {
+          service: "testService",
+          time: "testTime",
+          ip: "testIp",
+          user: "testUser",
+          msgId: "testMsgId",
+          correlationId: "testCorrelationId"
+        },
+        event: {
+          TAG: "VersionDetected",
+          _0: "0.0.0"
+        }
+      }, S.string, PluginSpec$ReventlessCore.eventSchema);
+      let msg = LogFormat$ReventlessCore.event$pJsonToLogMessage(eventJson$p);
+      globalThis.expect(msg).toEqual(`\x1b[1mVersionDetected\x1b[0m(testId): {"event":{"TAG":"VersionDetected","_0":"0.0.0"},"meta":{"service":"testService","time":"testTime","ip":"testIp","user":"testUser","msgId":"testMsgId","correlationId":"testCorrelationId"},"id":"testId"}`);
+    });
+  });
+});
+
+function hasAnsi(s) {
+  return s.includes("\x1b");
+}
+
+function captureLogs(fn) {
+  let captured = [];
+  let original = console.log;
+  console.log = s => {
+    captured.push(s);
+  };
+  let result;
+  try {
+    fn();
+    result = {
+      TAG: "Ok",
+      _0: undefined
+    };
+  } catch (raw_e) {
+    let e = Primitive_exceptions.internalToException(raw_e);
+    result = {
+      TAG: "Error",
+      _0: e
+    };
+  }
+  console.log = original;
+  if (result.TAG === "Ok") {
+    return captured;
+  }
+  throw result._0;
+}
+
+let validLevels = [
+  "DEBUG",
+  "INFO",
+  "WARN",
+  "ERROR"
+];
+
+function isCleanRecord(line) {
+  if (line.includes("\x1b")) {
+    return false;
+  }
+  try {
+    let obj = Stdlib_JSON.Decode.object(JSON.parse(line));
+    if (obj === undefined) {
+      return false;
+    }
+    let levelOk = Stdlib_Option.mapOr(Stdlib_Option.flatMap(obj["level"], Stdlib_JSON.Decode.string), false, l => validLevels.includes(l));
+    let msgOk = Stdlib_Option.isSome(Stdlib_Option.flatMap(obj["message"], Stdlib_JSON.Decode.string));
+    if (levelOk) {
+      return msgOk;
+    } else {
+      return false;
+    }
+  } catch (exn) {
+    return false;
+  }
+}
+
+function fieldOf(line, key) {
+  let obj = Stdlib_JSON.Decode.object(JSON.parse(line));
+  if (obj !== undefined) {
+    return Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.string);
+  }
+}
+
+globalThis.describe("JSON sink", () => {
+  globalThis.beforeAll(() => {
+    process.env["REVENTLESS_LOG_FORMAT"] = "json";
+    AnsiStyle$Reventless.reload();
+  });
+  globalThis.afterAll(() => {
+    process.env["REVENTLESS_LOG_FORMAT"] = "text";
+    AnsiStyle$Reventless.reload();
+  });
+  let log = Logger$ReventlessCore.makeLogger("Debug");
+  globalThis.test("Logger.info emits one clean JSON record with comp as a top-level field", () => {
+    let lines = captureLogs(() => log.info("Aggregate(Product)", undefined, "handling command"));
+    let line = lines.length === 1 ? lines[0] : "";
+    let ok = lines.length === 1 && isCleanRecord(line) && Primitive_object.equal(fieldOf(line, "comp"), "Aggregate(Product)") && Primitive_object.equal(fieldOf(line, "message"), "handling command");
+    globalThis.expect(ok).toBe(true);
+  });
+  globalThis.test("Logger.info resolves plugin to a top-level field when the comp is registered", () => {
+    Logger$ReventlessCore.registerComponentPlugin("Product", "Catalog");
+    let lines = captureLogs(() => log.info("Aggregate(Product)", undefined, "handling command"));
+    let line = lines.length === 1 ? lines[0] : "";
+    globalThis.expect(lines.length === 1 && Primitive_object.equal(fieldOf(line, "plugin"), "Catalog")).toBe(true);
+  });
+  globalThis.test("Logger.warn emits one clean JSON record", () => {
+    let lines = captureLogs(() => log.warn("Platform", undefined, "heartbeat skipped"));
+    globalThis.expect(lines.length === 1 && isCleanRecord(lines[0])).toBe(true);
+  });
+  globalThis.test("Logger.error with ~data emits one clean JSON record", () => {
+    let lines = captureLogs(() => log.error("Util_AppSync_Caller", JSON.parse(`{"errors":["boom"]}`), "query errors"));
+    globalThis.expect(lines.length === 1 && isCleanRecord(lines[0])).toBe(true);
+  });
+  globalThis.test("EffectLogger.logInfo emits clean JSON through install()", () => {
+    let lines = captureLogs(() => Effect.runSync(EffectLogger$ReventlessCore.logInfo("Aggregate(Product)", undefined, "replay done")));
+    let allClean = lines.filter(l => !isCleanRecord(l)).length === 0;
+    globalThis.expect(lines.length >= 1 && allClean).toBe(true);
+  });
+  globalThis.test("EffectLogger.logInfo carries ~comp + ~detail as structured fields (no \\x00)", () => {
+    let lines = captureLogs(() => Effect.runSync(EffectLogger$ReventlessCore.logInfo("Aggregate(Product)", JSON.parse(`{"id":"p-1"}`), "added")));
+    let ok = lines.some(line => {
+      let obj = Stdlib_JSON.Decode.object(JSON.parse(line));
+      if (obj !== undefined && Primitive_object.equal(Stdlib_Option.flatMap(obj["comp"], Stdlib_JSON.Decode.string), "Aggregate(Product)")) {
+        return Primitive_object.equal(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(obj["detail"], Stdlib_JSON.Decode.object), d => d["id"]), Stdlib_JSON.Decode.string), "p-1");
+      } else {
+        return false;
+      }
+    });
+    globalThis.expect(ok).toBe(true);
+  });
+  globalThis.test("Effect.annotateLogs(correlationId) surfaces as a top-level field", () => {
+    let lines = captureLogs(() => Effect.runSync(Effect.annotateLogs(EffectLogger$ReventlessCore.logInfo("Aggregate(Product)", undefined, "handling"), "correlationId", "c-123")));
+    globalThis.expect(lines.some(line => Primitive_object.equal(fieldOf(line, "correlationId"), "c-123"))).toBe(true);
+  });
+  globalThis.test("Effect.annotateLogs(plugin) overrides registry resolution", () => {
+    let lines = captureLogs(() => Effect.runSync(Effect.annotateLogs(EffectLogger$ReventlessCore.logInfo("Aggregate(Unregistered)", undefined, "handling"), "plugin", "Ordering")));
+    globalThis.expect(lines.some(line => Primitive_object.equal(fieldOf(line, "plugin"), "Ordering"))).toBe(true);
+  });
+  globalThis.test("every JSON record carries an RFC 3339 time field", () => {
+    let lines = captureLogs(() => log.info("Platform", undefined, "tick"));
+    let t = Stdlib_Option.flatMap(lines[0], l => fieldOf(l, "time"));
+    let ok = t !== undefined ? t.includes("T") && t.endsWith("Z") : false;
+    globalThis.expect(ok).toBe(true);
+  });
+  globalThis.test("service field is emitted when REVENTLESS_SERVICE is set", () => {
+    process.env["REVENTLESS_SERVICE"] = "TestService";
+    let lines = captureLogs(() => log.info("Platform", undefined, "tick"));
+    let got = Stdlib_Option.flatMap(lines[0], l => fieldOf(l, "service"));
+    Stdlib_Dict.$$delete(process.env, "REVENTLESS_SERVICE");
+    globalThis.expect(got).toEqual("TestService");
+  });
+  globalThis.test("oversized detail is truncated to a preview stub", () => {
+    let big = "x".repeat(40000);
+    let detail = Object.fromEntries([[
+        "blob",
+        big
+      ]]);
+    let direct = captureLogs(() => Logger$ReventlessCore.emit("Info", "Platform", undefined, detail, undefined, "big"));
+    let obj = Stdlib_Option.flatMap(direct[0], l => Stdlib_JSON.Decode.object(JSON.parse(l)));
+    let ok;
+    if (obj !== undefined) {
+      let d = Stdlib_Option.flatMap(obj["detail"], Stdlib_JSON.Decode.object);
+      ok = d !== undefined ? Primitive_object.equal(Stdlib_Option.flatMap(d["truncated"], Stdlib_JSON.Decode.bool), true) && Stdlib_Option.mapOr(Stdlib_Option.flatMap(d["preview"], Stdlib_JSON.Decode.string), false, p => p.length <= 512) : false;
+    } else {
+      ok = false;
+    }
+    globalThis.expect(ok).toBe(true);
+  });
+  globalThis.test("LogFormat.cmdName carries no ANSI in a JSON sink", () => {
+    let cmd_meta = {
+      service: "testService",
+      time: "testTime",
+      ip: "testIp",
+      user: "testUser",
+      msgId: "testMsgId",
+      correlationId: "testCorrelationId"
+    };
+    let cmd_commandJson = Message$ReventlessCore.encode({
+      TAG: "Heartbeat",
+      _0: "0.0.0"
+    }, PluginSpec$ReventlessCore.commandSchema);
+    let cmd = {
+      id: "0",
+      meta: cmd_meta,
+      commandJson: cmd_commandJson
+    };
+    let name = LogFormat$ReventlessCore.cmdName(cmd);
+    globalThis.expect(!name.includes("\x1b") && name === "Heartbeat").toBe(true);
+  });
+});
+
+export {
+  hasAnsi,
+  captureLogs,
+  validLevels,
+  isCleanRecord,
+  fieldOf,
+}
+/*  Not a pure module */