@reventlessdev/reventless-local 3.0.0-alpha.317 → 3.0.0-alpha.319

package/tests/adapter/LocalFeedTest.res

@@ -0,0 +1,314 @@
+// The feeds a watching tool reads: a listener that stops reading costs the
+// platform a bounded amount and is told what it missed; a filter line narrows
+// what it is sent; the log feed starts with the recent records.
+
+@@warning("-44")
+
+open JestGlobals
+
+module Logger = ReventlessCore.Logger
+
+let sleep = (ms: int): promise<unit> =>
+  Promise.make((resolve, _) => {
+    let _ = setTimeout(() => resolve(), ms)
+  })
+
+// Polls until `cond` holds, for at most `ms`.
+let until = async (~ms=2000, cond: unit => bool): bool => {
+  let waited = ref(0)
+  while !cond() && waited.contents < ms {
+    await sleep(5)
+    waited := waited.contents + 5
+  }
+  cond()
+}
+
+let bind = (feed: LocalFeed.t): promise<int> =>
+  Promise.make((resolve, _) => feed->LocalFeed.start(~setting=Ephemeral, ~onBound=resolve, ()))
+
+type client = {socket: NodeNet.socket, mutable received: string}
+
+let connect = (port: int): promise<client> =>
+  Promise.make((resolve, _) => {
+    let c = ref(None)
+    let socket = NodeNet.connect(port, "127.0.0.1", () =>
+      c.contents->Option.forEach(client => resolve(client))
+    )
+    socket->NodeNet.setEncoding("utf8")
+    socket->NodeNet.onSocketError(_ => ())
+    let client = {socket, received: ""}
+    socket->NodeNet.onSocketData(chunk => client.received = client.received ++ chunk)
+    c := Some(client)
+  })
+
+let lines = (c: client): array<string> => c.received->String.split("\n")->Array.filter(l => l != "")
+
+let skippedCounts = (c: client): array<int> =>
+  c
+  ->lines
+  ->Array.filterMap(l =>
+    switch l->JSON.parseOrThrow->JSON.Decode.object {
+    | Some(d) if d->Dict.get("kind") == Some(JSON.String("skipped")) =>
+      d->Dict.get("count")->Option.flatMap(JSON.Decode.float)->Option.map(Float.toInt)
+    | _ => None
+    | exception _ => None
+    }
+  )
+
+describe("LocalFeed: a listener that never reads", () => {
+  test(
+    "costs a bounded amount, and is told how many lines it missed when it reads again",
+    async () => {
+      let maxBytes = 64 * 1024
+      let feed = LocalFeed.make(
+        ~name="TestFeed",
+        ~honours=[],
+        ~maxLines=200,
+        ~maxBytes,
+        ~filterWaitMs=10,
+        (),
+      )
+      let port = await bind(feed)
+      let client = await connect(port)
+      expect(await until(() => feed->LocalFeed.hasReaders))->toBe(true)
+      client.socket->NodeNet.pause
+
+      // 20,000 lines of about 1 KB: twenty megabytes the listener does not read.
+      let pad = String.repeat("x", 1000)
+      let total = 20_000
+      let held = ref(0)
+      for i in 1 to total {
+        feed->LocalFeed.broadcast(`{"n":${i->Int.toString},"pad":"${pad}"}`)
+        held := Math.Int.max(held.contents, feed->LocalFeed.heldBytes)
+      }
+      // What the platform holds for it never exceeds the queue's bound plus what
+      // one socket buffers before it reports backpressure.
+      expect(feed->LocalFeed.queuedBytes <= maxBytes)->toBe(true)
+      expect(held.contents < maxBytes + 4 * 1024 * 1024)->toBe(true)
+
+      client.socket->NodeNet.resume
+      let last = `{"n":${total->Int.toString},`
+      expect(await until(~ms=5000, () => client.received->String.includes(last)))->toBe(true)
+      let skipped = skippedCounts(client)->Array.reduce(0, (a, b) => a + b)
+      expect(skipped > 0)->toBe(true)
+      // Every line is either received or counted as skipped.
+      let received = lines(client)->Array.filter(l => l->String.startsWith(`{"n":`))->Array.length
+      expect(received + skipped)->toBe(total)
+      NodeNet.destroySocket(client.socket)
+      await feed->LocalFeed.stopForTests
+    },
+  )
+})
+
+describe("LocalFeed: the filter line", () => {
+  testSync("is read leniently and ignores what it does not know", () => {
+    expect(
+      LocalFeed.parseFilter(`{"plugins":["Ordering"],"level":"WARN","eventTypes":["Placed"],"x":1}`),
+    )->toEqual(Some({LocalFeed.plugins: ["Ordering"], level: Warn, eventTypes: ["Placed"]}))
+    expect(LocalFeed.parseFilter("not json"))->toEqual(None)
+  })
+
+  testSync("narrows only by the fields the feed honours", () => {
+    let filter: LocalFeed.filter = {plugins: ["Ordering"], level: Warn}
+    let warnOrdering: LocalFeed.facets = {plugin: "Ordering", level: Warn}
+    let infoOrdering: LocalFeed.facets = {plugin: "Ordering", level: Info}
+    let catalog: LocalFeed.facets = {plugin: "Catalog", level: Error}
+    let logs: array<LocalFeed.filterField> = [Plugins, Level]
+    expect(LocalFeed.matches(~honours=logs, filter, warnOrdering))->toBe(true)
+    expect(LocalFeed.matches(~honours=logs, filter, infoOrdering))->toBe(false)
+    expect(LocalFeed.matches(~honours=logs, filter, catalog))->toBe(false)
+    // An event has no level; the tap ignores the field.
+    expect(LocalFeed.matches(~honours=[Plugins], filter, {plugin: "Ordering"}))->toBe(true)
+  })
+
+  test("narrows the event tap and the log feed alike", async () => {
+    LocalEventTap.resetForTests()
+    LocalLogFeed.resetForTests()
+    LocalLogFeed.install(~env=Dict.make())
+    // Logged before anyone connects: sent first, filtered, by the log feed.
+    Logger.emit(~level=Warn, ~comp="Projection", ~plugin="Ordering", "before connect")
+    Logger.emit(~level=Info, ~comp="Projection", ~plugin="Ordering", "before connect, quiet")
+
+    let tapPort = await Promise.make(
+      (resolve, _) => LocalEventTap.start(~env=Dict.make(), ~onBound=resolve, ()),
+    )
+    let logPort = await Promise.make(
+      (resolve, _) => LocalLogFeed.start(~env=Dict.make(), ~onBound=resolve, ()),
+    )
+    let tap = await connect(tapPort)
+    let logFeed = await connect(logPort)
+    let filterLine = `{"plugins":["Ordering"],"level":"warn","eventTypes":["Placed"],"correlationId":"c-1"}\n`
+    let _ = tap.socket->NodeNet.write(filterLine)
+    let _ = logFeed.socket->NodeNet.write(filterLine)
+    expect(await until(() => LocalEventTap.hasReaders() && LocalLogFeed.hasReaders()))->toBe(true)
+
+    let event = (~plugin, ~eventType, ~correlationId, name) =>
+      LocalEventTap.publish({
+        line: `@@RVLESS_EVT@@ {"name":"${name}"}`,
+        facets: {plugin, eventType, correlationId},
+      })
+    event(~plugin="Ordering", ~eventType="Placed", ~correlationId="c-1", "match")
+    event(~plugin="Catalog", ~eventType="Placed", ~correlationId="c-1", "other plugin")
+    event(~plugin="Ordering", ~eventType="Shipped", ~correlationId="c-1", "other type")
+    event(~plugin="Ordering", ~eventType="Placed", ~correlationId="c-2", "other flow")
+
+    let annotations = Dict.fromArray([("correlationId", "c-1")])
+    Logger.emit(~level=Error, ~comp="Projection", ~plugin="Ordering", ~annotations, "live match")
+    Logger.emit(~level=Info, ~comp="Projection", ~plugin="Ordering", ~annotations, "too quiet")
+    Logger.emit(~level=Error, ~comp="Projection", ~plugin="Catalog", ~annotations, "other plugin")
+
+    expect(await until(() => logFeed.received->String.includes("live match")))->toBe(true)
+    expect(await until(() => tap.received->String.includes("match")))->toBe(true)
+    await sleep(30)
+
+    expect(tap->lines)->toEqual([`@@RVLESS_EVT@@ {"name":"match"}`])
+    let messages =
+      logFeed
+      ->lines
+      ->Array.filterMap(
+        l =>
+          l
+          ->JSON.parseOrThrow
+          ->JSON.Decode.object
+          ->Option.flatMap(d => d->Dict.get("message"))
+          ->Option.flatMap(JSON.Decode.string),
+      )
+    // The backlog line has no correlation id, so the filter's flow leaves it out.
+    expect(messages)->toEqual(["live match"])
+
+    NodeNet.destroySocket(tap.socket)
+    NodeNet.destroySocket(logFeed.socket)
+    await LocalEventTap.stopForTests()
+    await LocalLogFeed.stopForTests()
+    LocalLogFeed.resetForTests()
+  })
+
+  test("a listener that sends no filter gets everything, the recent records first", async () => {
+    LocalLogFeed.resetForTests()
+    LocalLogFeed.install(~env=Dict.make())
+    Logger.emit(~level=Debug, ~comp="Projection", "earlier")
+    let logPort = await Promise.make(
+      (resolve, _) => LocalLogFeed.start(~env=Dict.make(), ~onBound=resolve, ()),
+    )
+    let client = await connect(logPort)
+    expect(await until(() => LocalLogFeed.hasReaders()))->toBe(true)
+    Logger.emit(~level=Debug, ~comp="Projection", "later")
+    expect(await until(() => client.received->String.includes("later")))->toBe(true)
+    let messages =
+      client
+      ->lines
+      ->Array.filterMap(
+        l =>
+          l
+          ->JSON.parseOrThrow
+          ->JSON.Decode.object
+          ->Option.flatMap(d => d->Dict.get("message"))
+          ->Option.flatMap(JSON.Decode.string),
+      )
+    // Only this test's own lines: the platform's may be logged too.
+    expect(messages->Array.filter(m => m == "earlier" || m == "later"))->toEqual([
+      "earlier",
+      "later",
+    ])
+    NodeNet.destroySocket(client.socket)
+    await LocalLogFeed.stopForTests()
+    LocalLogFeed.resetForTests()
+  })
+})
+
+type consoleObj = {mutable log: string => unit}
+@val external console: consoleObj = "console"
+
+describe("LocalLogFeed: the rings", () => {
+  afterEach(() => {
+    LocalLogFeed.resetForTests()
+    NodeProcess.env->Dict.set("REVENTLESS_LOG_FORMAT", "text")
+    Reventless.AnsiStyle.reload()
+  })
+
+  testSync("a record in the ring equals the JSON line's fields", () => {
+    LocalLogFeed.install(~env=Dict.make())
+    NodeProcess.env->Dict.set("REVENTLESS_LOG_FORMAT", "json")
+    Reventless.AnsiStyle.reload()
+    let printed = []
+    let original = console.log
+    console.log = s => printed->Array.push(s)
+    Logger.emit(
+      ~level=Warn,
+      ~comp="Aggregate(Order)",
+      ~plugin="Ordering",
+      ~annotations=Dict.fromArray([("correlationId", "c-9")]),
+      ~detail=Dict.fromArray([("orderId", JSON.Encode.string("o-1"))])->JSON.Encode.object,
+      "refused",
+    )
+    console.log = original
+    // Only this test's own line: the platform's may be logged too.
+    let entry =
+      LocalLogFeed.snapshot()->Array.find(e => e.record.message == "refused")->Option.getOrThrow
+    let line = printed->Array.find(l => l->String.includes(`"refused"`))->Option.getOrThrow
+    expect(entry.item.line)->toEqual(line)
+    expect(entry.record->Logger.recordToJson)->toEqual(line->JSON.parseOrThrow)
+  })
+
+  testSync("detail is redacted in the ring", () => {
+    LocalLogFeed.install(~env=Dict.make())
+    Logger.emit(
+      ~level=Info,
+      ~comp="Projection",
+      ~detail=Dict.fromArray([
+        ("name", Dict.fromArray([("$pii", JSON.Encode.string("Ada Secret"))])->JSON.Encode.object),
+      ])->JSON.Encode.object,
+      "joined",
+    )
+    let line = (LocalLogFeed.snapshot()->Array.getUnsafe(0)).item.line
+    expect(line->String.includes("joined"))->toBe(true)
+    expect(line->String.includes("Ada Secret"))->toBe(false)
+  })
+
+  testSync("the count bound holds, and warnings outlive it in their own ring", () => {
+    LocalLogFeed.install(
+      ~env=Dict.fromArray([(LocalLogFeed.ringEnvVar, "3"), (LocalLogFeed.problemRingEnvVar, "2")]),
+    )
+    Logger.emit(~level=Warn, ~comp="C", "warn 1")
+    Logger.emit(~level=Error, ~comp="C", "error 2")
+    Logger.emit(~level=Warn, ~comp="C", "warn 3")
+    for i in 1 to 5 {
+      Logger.emit(~level=Info, ~comp="C", `info ${i->Int.toString}`)
+    }
+    expect(LocalLogFeed.recent->LocalLogFeed.toArray->Array.map(e => e.record.message))->toEqual([
+      "info 3",
+      "info 4",
+      "info 5",
+    ])
+    expect(LocalLogFeed.snapshot()->Array.map(e => e.record.message))->toEqual([
+      "error 2",
+      "warn 3",
+      "info 3",
+      "info 4",
+      "info 5",
+    ])
+  })
+
+  testSync("the byte bound holds", () => {
+    LocalLogFeed.install(~env=Dict.fromArray([(LocalLogFeed.ringEnvVar, "1000,600")]))
+    for i in 1 to 50 {
+      Logger.emit(~level=Info, ~comp="C", `line ${i->Int.toString}`)
+    }
+    let kept = LocalLogFeed.recent->LocalLogFeed.toArray
+    expect(LocalLogFeed.recent->LocalLogFeed.ringBytes <= 600)->toBe(true)
+    expect(kept->Array.length > 0 && kept->Array.length < 50)->toBe(true)
+    expect((kept->Array.at(-1)->Option.getOrThrow).record.message)->toEqual("line 50")
+  })
+
+  testSync("recentRecords filters like the feed and keeps the most recent", () => {
+    LocalLogFeed.install(~env=Dict.make())
+    Logger.emit(~level=Warn, ~comp="A", ~plugin="Ordering", "w1")
+    Logger.emit(~level=Info, ~comp="A", ~plugin="Ordering", "i1")
+    Logger.emit(~level=Error, ~comp="B", ~plugin="Ordering", "e1")
+    Logger.emit(~level=Error, ~comp="A", ~plugin="Catalog", "e2")
+    let messages = (~filter, ~limit=?) =>
+      LocalLogFeed.recentRecords(~filter, ~limit?)->Array.map(r => r.message)
+    expect(messages(~filter={plugins: ["Ordering"], level: Warn}))->toEqual(["w1", "e1"])
+    expect(messages(~filter={components: ["A"]}, ~limit=2))->toEqual(["i1", "e2"])
+  })
+})

package/tests/adapter/LocalFeedTest.res.mjs

@@ -0,0 +1,329 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodenet from "node:net";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+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 Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as LocalFeed$ReventlessLocal from "../../src/adapter/LocalFeed.res.mjs";
+import * as LocalLogFeed$ReventlessLocal from "../../src/adapter/LocalLogFeed.res.mjs";
+import * as LocalEventTap$ReventlessLocal from "../../src/adapter/LocalEventTap.res.mjs";
+
+function sleep(ms) {
+  return new Promise((resolve, param) => {
+    setTimeout(() => resolve(), ms);
+  });
+}
+
+async function until(msOpt, cond) {
+  let ms = msOpt !== undefined ? msOpt : 2000;
+  let waited = 0;
+  while (!cond() && waited < ms) {
+    await sleep(5);
+    waited = waited + 5 | 0;
+  };
+  return cond();
+}
+
+function bind(feed) {
+  return new Promise((resolve, param) => LocalFeed$ReventlessLocal.start(feed, "Ephemeral", resolve, undefined));
+}
+
+function connect(port) {
+  return new Promise((resolve, param) => {
+    let c = {
+      contents: undefined
+    };
+    let socket = Nodenet.createConnection(port, "127.0.0.1", () => Stdlib_Option.forEach(c.contents, client => resolve(client)));
+    socket.setEncoding("utf8");
+    socket.on("error", param => {});
+    let client = {
+      socket: socket,
+      received: ""
+    };
+    socket.on("data", chunk => {
+      client.received = client.received + chunk;
+    });
+    c.contents = client;
+  });
+}
+
+function lines(c) {
+  return c.received.split("\n").filter(l => l !== "");
+}
+
+function skippedCounts(c) {
+  return Stdlib_Array.filterMap(lines(c), l => {
+    let d;
+    try {
+      d = Stdlib_JSON.Decode.object(JSON.parse(l));
+    } catch (exn) {
+      return;
+    }
+    if (d !== undefined && Primitive_object.equal(d["kind"], "skipped")) {
+      return Stdlib_Option.map(Stdlib_Option.flatMap(d["count"], Stdlib_JSON.Decode.float), prim => prim | 0);
+    }
+  });
+}
+
+globalThis.describe("LocalFeed: a listener that never reads", () => {
+  globalThis.test("costs a bounded amount, and is told how many lines it missed when it reads again", async () => {
+    let feed = LocalFeed$ReventlessLocal.make("TestFeed", [], undefined, 200, 65536, 10, undefined);
+    let port = await bind(feed);
+    let client = await connect(port);
+    globalThis.expect(await until(undefined, () => LocalFeed$ReventlessLocal.hasReaders(feed))).toBe(true);
+    client.socket.pause();
+    let pad = "x".repeat(1000);
+    let held = 0;
+    for (let i = 1; i <= 20000; ++i) {
+      LocalFeed$ReventlessLocal.broadcast(feed, `{"n":` + i.toString() + `,"pad":"` + pad + `"}`);
+      held = Math.max(held, LocalFeed$ReventlessLocal.heldBytes(feed));
+    }
+    globalThis.expect(LocalFeed$ReventlessLocal.queuedBytes(feed) <= 65536).toBe(true);
+    globalThis.expect(held < 4259840).toBe(true);
+    client.socket.resume();
+    let last = `{"n":` + (20000).toString() + `,`;
+    globalThis.expect(await until(5000, () => client.received.includes(last))).toBe(true);
+    let skipped = Stdlib_Array.reduce(skippedCounts(client), 0, (a, b) => a + b | 0);
+    globalThis.expect(skipped > 0).toBe(true);
+    let received = lines(client).filter(l => l.startsWith(`{"n":`)).length;
+    globalThis.expect(received + skipped | 0).toBe(20000);
+    client.socket.destroy();
+    return await LocalFeed$ReventlessLocal.stopForTests(feed);
+  });
+});
+
+globalThis.describe("LocalFeed: the filter line", () => {
+  globalThis.test("is read leniently and ignores what it does not know", () => {
+    globalThis.expect(LocalFeed$ReventlessLocal.parseFilter(`{"plugins":["Ordering"],"level":"WARN","eventTypes":["Placed"],"x":1}`)).toEqual({
+      plugins: ["Ordering"],
+      level: "Warn",
+      eventTypes: ["Placed"]
+    });
+    globalThis.expect(LocalFeed$ReventlessLocal.parseFilter("not json")).toEqual(undefined);
+  });
+  globalThis.test("narrows only by the fields the feed honours", () => {
+    let filter_plugins = ["Ordering"];
+    let filter_level = "Warn";
+    let filter = {
+      plugins: filter_plugins,
+      level: filter_level
+    };
+    let logs = [
+      "Plugins",
+      "Level"
+    ];
+    globalThis.expect(LocalFeed$ReventlessLocal.matches(logs, filter, {
+      plugin: "Ordering",
+      level: "Warn"
+    })).toBe(true);
+    globalThis.expect(LocalFeed$ReventlessLocal.matches(logs, filter, {
+      plugin: "Ordering",
+      level: "Info"
+    })).toBe(false);
+    globalThis.expect(LocalFeed$ReventlessLocal.matches(logs, filter, {
+      plugin: "Catalog",
+      level: "Error"
+    })).toBe(false);
+    globalThis.expect(LocalFeed$ReventlessLocal.matches(["Plugins"], filter, {
+      plugin: "Ordering"
+    })).toBe(true);
+  });
+  globalThis.test("narrows the event tap and the log feed alike", async () => {
+    LocalEventTap$ReventlessLocal.resetForTests();
+    LocalLogFeed$ReventlessLocal.resetForTests();
+    LocalLogFeed$ReventlessLocal.install({});
+    Logger$ReventlessCore.emit("Warn", "Projection", "Ordering", undefined, undefined, "before connect");
+    Logger$ReventlessCore.emit("Info", "Projection", "Ordering", undefined, undefined, "before connect, quiet");
+    let tapPort = await new Promise((resolve, param) => LocalEventTap$ReventlessLocal.start({}, resolve, undefined));
+    let logPort = await new Promise((resolve, param) => LocalLogFeed$ReventlessLocal.start({}, resolve, undefined));
+    let tap = await connect(tapPort);
+    let logFeed = await connect(logPort);
+    let filterLine = `{"plugins":["Ordering"],"level":"warn","eventTypes":["Placed"],"correlationId":"c-1"}\n`;
+    tap.socket.write(filterLine);
+    logFeed.socket.write(filterLine);
+    globalThis.expect(await until(undefined, () => {
+      if (LocalEventTap$ReventlessLocal.hasReaders()) {
+        return LocalLogFeed$ReventlessLocal.hasReaders();
+      } else {
+        return false;
+      }
+    })).toBe(true);
+    let event = (plugin, eventType, correlationId, name) => LocalEventTap$ReventlessLocal.publish({
+      line: `@@RVLESS_EVT@@ {"name":"` + name + `"}`,
+      facets: {
+        plugin: plugin,
+        eventType: eventType,
+        correlationId: correlationId
+      }
+    });
+    event("Ordering", "Placed", "c-1", "match");
+    event("Catalog", "Placed", "c-1", "other plugin");
+    event("Ordering", "Shipped", "c-1", "other type");
+    event("Ordering", "Placed", "c-2", "other flow");
+    let annotations = Object.fromEntries([[
+        "correlationId",
+        "c-1"
+      ]]);
+    Logger$ReventlessCore.emit("Error", "Projection", "Ordering", undefined, annotations, "live match");
+    Logger$ReventlessCore.emit("Info", "Projection", "Ordering", undefined, annotations, "too quiet");
+    Logger$ReventlessCore.emit("Error", "Projection", "Catalog", undefined, annotations, "other plugin");
+    globalThis.expect(await until(undefined, () => logFeed.received.includes("live match"))).toBe(true);
+    globalThis.expect(await until(undefined, () => tap.received.includes("match"))).toBe(true);
+    await sleep(30);
+    globalThis.expect(lines(tap)).toEqual([`@@RVLESS_EVT@@ {"name":"match"}`]);
+    let messages = Stdlib_Array.filterMap(lines(logFeed), l => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(l)), d => d["message"]), Stdlib_JSON.Decode.string));
+    globalThis.expect(messages).toEqual(["live match"]);
+    tap.socket.destroy();
+    logFeed.socket.destroy();
+    await LocalEventTap$ReventlessLocal.stopForTests();
+    await LocalLogFeed$ReventlessLocal.stopForTests();
+    return LocalLogFeed$ReventlessLocal.resetForTests();
+  });
+  globalThis.test("a listener that sends no filter gets everything, the recent records first", async () => {
+    LocalLogFeed$ReventlessLocal.resetForTests();
+    LocalLogFeed$ReventlessLocal.install({});
+    Logger$ReventlessCore.emit("Debug", "Projection", undefined, undefined, undefined, "earlier");
+    let logPort = await new Promise((resolve, param) => LocalLogFeed$ReventlessLocal.start({}, resolve, undefined));
+    let client = await connect(logPort);
+    globalThis.expect(await until(undefined, () => LocalLogFeed$ReventlessLocal.hasReaders())).toBe(true);
+    Logger$ReventlessCore.emit("Debug", "Projection", undefined, undefined, undefined, "later");
+    globalThis.expect(await until(undefined, () => client.received.includes("later"))).toBe(true);
+    let messages = Stdlib_Array.filterMap(lines(client), l => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(l)), d => d["message"]), Stdlib_JSON.Decode.string));
+    globalThis.expect(messages.filter(m => {
+      if (m === "earlier") {
+        return true;
+      } else {
+        return m === "later";
+      }
+    })).toEqual([
+      "earlier",
+      "later"
+    ]);
+    client.socket.destroy();
+    await LocalLogFeed$ReventlessLocal.stopForTests();
+    return LocalLogFeed$ReventlessLocal.resetForTests();
+  });
+});
+
+globalThis.describe("LocalLogFeed: the rings", () => {
+  globalThis.afterEach(() => {
+    LocalLogFeed$ReventlessLocal.resetForTests();
+    process.env["REVENTLESS_LOG_FORMAT"] = "text";
+    AnsiStyle$Reventless.reload();
+  });
+  globalThis.test("a record in the ring equals the JSON line's fields", () => {
+    LocalLogFeed$ReventlessLocal.install({});
+    process.env["REVENTLESS_LOG_FORMAT"] = "json";
+    AnsiStyle$Reventless.reload();
+    let printed = [];
+    let original = console.log;
+    console.log = s => {
+      printed.push(s);
+    };
+    Logger$ReventlessCore.emit("Warn", "Aggregate(Order)", "Ordering", Object.fromEntries([[
+        "orderId",
+        "o-1"
+      ]]), Object.fromEntries([[
+        "correlationId",
+        "c-9"
+      ]]), "refused");
+    console.log = original;
+    let entry = Stdlib_Option.getOrThrow(LocalLogFeed$ReventlessLocal.snapshot().find(e => e.record.message === "refused"), undefined);
+    let line = Stdlib_Option.getOrThrow(printed.find(l => l.includes(`"refused"`)), undefined);
+    globalThis.expect(entry.item.line).toEqual(line);
+    globalThis.expect(Logger$ReventlessCore.recordToJson(entry.record)).toEqual(JSON.parse(line));
+  });
+  globalThis.test("detail is redacted in the ring", () => {
+    LocalLogFeed$ReventlessLocal.install({});
+    Logger$ReventlessCore.emit("Info", "Projection", undefined, Object.fromEntries([[
+        "name",
+        Object.fromEntries([[
+            "$pii",
+            "Ada Secret"
+          ]])
+      ]]), undefined, "joined");
+    let line = LocalLogFeed$ReventlessLocal.snapshot()[0].item.line;
+    globalThis.expect(line.includes("joined")).toBe(true);
+    globalThis.expect(line.includes("Ada Secret")).toBe(false);
+  });
+  globalThis.test("the count bound holds, and warnings outlive it in their own ring", () => {
+    LocalLogFeed$ReventlessLocal.install(Object.fromEntries([
+      [
+        LocalLogFeed$ReventlessLocal.ringEnvVar,
+        "3"
+      ],
+      [
+        LocalLogFeed$ReventlessLocal.problemRingEnvVar,
+        "2"
+      ]
+    ]));
+    Logger$ReventlessCore.emit("Warn", "C", undefined, undefined, undefined, "warn 1");
+    Logger$ReventlessCore.emit("Error", "C", undefined, undefined, undefined, "error 2");
+    Logger$ReventlessCore.emit("Warn", "C", undefined, undefined, undefined, "warn 3");
+    for (let i = 1; i <= 5; ++i) {
+      Logger$ReventlessCore.emit("Info", "C", undefined, undefined, undefined, `info ` + i.toString());
+    }
+    globalThis.expect(LocalLogFeed$ReventlessLocal.toArray(LocalLogFeed$ReventlessLocal.recent).map(e => e.record.message)).toEqual([
+      "info 3",
+      "info 4",
+      "info 5"
+    ]);
+    globalThis.expect(LocalLogFeed$ReventlessLocal.snapshot().map(e => e.record.message)).toEqual([
+      "error 2",
+      "warn 3",
+      "info 3",
+      "info 4",
+      "info 5"
+    ]);
+  });
+  globalThis.test("the byte bound holds", () => {
+    LocalLogFeed$ReventlessLocal.install(Object.fromEntries([[
+        LocalLogFeed$ReventlessLocal.ringEnvVar,
+        "1000,600"
+      ]]));
+    for (let i = 1; i <= 50; ++i) {
+      Logger$ReventlessCore.emit("Info", "C", undefined, undefined, undefined, `line ` + i.toString());
+    }
+    let kept = LocalLogFeed$ReventlessLocal.toArray(LocalLogFeed$ReventlessLocal.recent);
+    globalThis.expect(LocalLogFeed$ReventlessLocal.ringBytes(LocalLogFeed$ReventlessLocal.recent) <= 600).toBe(true);
+    globalThis.expect(kept.length !== 0 && kept.length < 50).toBe(true);
+    globalThis.expect(Stdlib_Option.getOrThrow(kept.at(-1), undefined).record.message).toEqual("line 50");
+  });
+  globalThis.test("recentRecords filters like the feed and keeps the most recent", () => {
+    LocalLogFeed$ReventlessLocal.install({});
+    Logger$ReventlessCore.emit("Warn", "A", "Ordering", undefined, undefined, "w1");
+    Logger$ReventlessCore.emit("Info", "A", "Ordering", undefined, undefined, "i1");
+    Logger$ReventlessCore.emit("Error", "B", "Ordering", undefined, undefined, "e1");
+    Logger$ReventlessCore.emit("Error", "A", "Catalog", undefined, undefined, "e2");
+    let messages = (filter, limit) => LocalLogFeed$ReventlessLocal.recentRecords(filter, limit).map(r => r.message);
+    globalThis.expect(messages({
+      plugins: ["Ordering"],
+      level: "Warn"
+    }, undefined)).toEqual([
+      "w1",
+      "e1"
+    ]);
+    globalThis.expect(messages({
+      components: ["A"]
+    }, 2)).toEqual([
+      "i1",
+      "e2"
+    ]);
+  });
+});
+
+let Logger;
+
+export {
+  Logger,
+  sleep,
+  until,
+  bind,
+  connect,
+  lines,
+  skippedCounts,
+}
+/*  Not a pure module */