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

package/src/adapter/LocalEventLogRead.res.mjs

@@ -0,0 +1,507 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pervasives from "@rescript/runtime/lib/es6/Pervasives.js";
+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_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Float from "@rescript/runtime/lib/es6/Stdlib_Float.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 Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+
+function metaOfFlat(flat) {
+  return Object.fromEntries(Stdlib_Array.filterMap(Message$ReventlessCore.metaKeys, k => Stdlib_Option.map(flat[k], v => [
+    k,
+    v
+  ])));
+}
+
+function storedOfFlat(log, position, entityId, payload) {
+  let flat = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(payload), {});
+  let str = k => Stdlib_Option.flatMap(flat[k], Stdlib_JSON.Decode.string);
+  let meta = metaOfFlat(flat);
+  let t = str("recordedAt");
+  return {
+    log: log,
+    position: position,
+    eventType: Stdlib_Option.getOr(str("event"), "unknown"),
+    entityId: entityId,
+    tags: [],
+    payload: Stdlib_Option.getOr(flat["data"], null),
+    meta: meta,
+    recordedAt: t !== undefined ? t : Stdlib_Option.getOr(str("time"), "")
+  };
+}
+
+function numberOf(v) {
+  if (v === undefined) {
+    return 0;
+  }
+  switch (typeof v) {
+    case "string" :
+      return Stdlib_Option.getOr(Stdlib_Float.fromString(v), 0);
+    case "number" :
+      return v;
+    default:
+      return 0;
+  }
+}
+
+let readers = {};
+
+let pluginOfLog = {};
+
+function register(log, kind, readBack) {
+  readers[log] = {
+    kind: kind,
+    readBack: readBack
+  };
+}
+
+function notePlugin(log, plugin) {
+  pluginOfLog[log] = plugin;
+}
+
+function pluginOf(log) {
+  return pluginOfLog[log];
+}
+
+function logs() {
+  return Object.keys(readers).toSorted(Primitive_string.compare);
+}
+
+function positionToString(p) {
+  return p.toString();
+}
+
+let notes = new Map();
+
+function note(log, msgId, position) {
+  notes.set(msgId, [
+    log,
+    position
+  ]);
+  if (notes.size <= 10000) {
+    return;
+  }
+  let match = notes.keys().next();
+  if (match.done) {
+    return;
+  }
+  let oldest = match.value;
+  if (oldest !== undefined) {
+    notes.delete(oldest);
+    return;
+  }
+}
+
+function take(msgId) {
+  let found = notes.get(msgId);
+  if (found !== undefined) {
+    notes.delete(msgId);
+    return found;
+  }
+}
+
+function resetForTests() {
+  Object.keys(readers).forEach(k => Stdlib_Dict.$$delete(readers, k));
+  Object.keys(pluginOfLog).forEach(k => Stdlib_Dict.$$delete(pluginOfLog, k));
+  notes.clear();
+}
+
+function recordToJson(r) {
+  return Object.fromEntries([
+    [
+      "log",
+      r.log
+    ],
+    [
+      "position",
+      r.position
+    ],
+    [
+      "eventType",
+      r.eventType
+    ],
+    [
+      "tags",
+      r.tags.map(t => Object.fromEntries([
+        [
+          "key",
+          t.key
+        ],
+        [
+          "value",
+          t.value
+        ]
+      ]))
+    ],
+    [
+      "payload",
+      r.payload
+    ],
+    [
+      "meta",
+      r.meta
+    ],
+    [
+      "recordedAt",
+      r.recordedAt
+    ]
+  ].concat(Stdlib_Option.mapOr(r.plugin, [], p => [[
+      "plugin",
+      p
+    ]])).concat(Stdlib_Option.mapOr(r.entityId, [], e => [[
+      "entityId",
+      e
+    ]])));
+}
+
+function filterOfJson(json) {
+  let d = Stdlib_Option.getOr(Stdlib_Option.flatMap(json, Stdlib_JSON.Decode.object), {});
+  let s = k => Stdlib_Option.flatMap(d[k], Stdlib_JSON.Decode.string);
+  let a = k => Stdlib_Option.map(Stdlib_Option.flatMap(d[k], Stdlib_JSON.Decode.array), items => Stdlib_Array.filterMap(items, Stdlib_JSON.Decode.string));
+  return {
+    plugins: a("plugins"),
+    logs: a("logs"),
+    eventTypes: a("eventTypes"),
+    entityId: s("entityId"),
+    tagKey: s("tagKey"),
+    tagValue: s("tagValue"),
+    msgId: s("msgId"),
+    correlationId: s("correlationId"),
+    causationId: s("causationId"),
+    user: s("user"),
+    timeFrom: s("timeFrom"),
+    timeTo: s("timeTo")
+  };
+}
+
+function metaString(meta, key) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(meta), d => d[key]), Stdlib_JSON.Decode.string);
+}
+
+function selectsLog(f, log, plugin) {
+  if (Stdlib_Option.mapOr(f.logs, true, logs => logs.includes(log))) {
+    return Stdlib_Option.mapOr(f.plugins, true, plugins => Stdlib_Option.mapOr(plugin, false, p => plugins.includes(p)));
+  } else {
+    return false;
+  }
+}
+
+function matches(f, r) {
+  let equalsMeta = (wanted, key) => Stdlib_Option.mapOr(wanted, true, w => Primitive_object.equal(metaString(r.meta, key), w));
+  let match = f.tagKey;
+  let match$1 = f.tagValue;
+  let tagMatch = match !== undefined ? (
+      match$1 !== undefined ? r.tags.some(t => {
+          if (t.key === match) {
+            return t.value === match$1;
+          } else {
+            return false;
+          }
+        }) : r.tags.some(t => t.key === match)
+    ) : (
+      match$1 !== undefined ? r.tags.some(t => t.value === match$1) : true
+    );
+  let id = f.entityId;
+  let entityMatch = id !== undefined ? Primitive_object.equal(r.entityId, id) || r.tags.some(t => t.value === id) : true;
+  if (tagMatch && entityMatch && Stdlib_Option.mapOr(f.eventTypes, true, types => types.includes(r.eventType)) && equalsMeta(f.msgId, "msgId") && equalsMeta(f.correlationId, "correlationId") && equalsMeta(f.causationId, "causationId") && equalsMeta(f.user, "user") && Stdlib_Option.mapOr(f.timeFrom, true, from => r.recordedAt >= from)) {
+    return Stdlib_Option.mapOr(f.timeTo, true, to_ => r.recordedAt <= to_);
+  } else {
+    return false;
+  }
+}
+
+function toBase64Url(s) {
+  return btoa(s).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+
+function fromBase64Url(s) {
+  let b = s.replaceAll("-", "+").replaceAll("_", "/");
+  return atob(b + "=".repeat((4 - b.length % 4 | 0) % 4));
+}
+
+function encodeCursor(states) {
+  return toBase64Url(JSON.stringify(Object.fromEntries(states.map(param => {
+    let state = param[1];
+    let tmp;
+    if (typeof state !== "object") {
+      tmp = "done";
+    } else {
+      let p = state._0;
+      tmp = p.TAG === "Below" ? Object.fromEntries([[
+            "below",
+            p._0
+          ]]) : Object.fromEntries([[
+            "atMost",
+            p._0
+          ]]);
+    }
+    return [
+      param[0],
+      tmp
+    ];
+  }))));
+}
+
+function decodeCursor(cursor) {
+  let d;
+  try {
+    d = Stdlib_JSON.Decode.object(JSON.parse(fromBase64Url(cursor)));
+  } catch (exn) {
+    return;
+  }
+  if (d === undefined) {
+    return;
+  }
+  let out = {};
+  Object.entries(d).forEach(param => {
+    let v = param[1];
+    let log = param[0];
+    if (v === null || Array.isArray(v)) {
+      return;
+    }
+    switch (typeof v) {
+      case "string" :
+        if (v !== "done") {
+          return;
+        }
+        out[log] = "Done";
+        return;
+      case "object" :
+        let match = Stdlib_Option.flatMap(v["below"], Stdlib_JSON.Decode.float);
+        let match$1 = Stdlib_Option.flatMap(v["atMost"], Stdlib_JSON.Decode.float);
+        if (match !== undefined) {
+          out[log] = {
+            TAG: "Until",
+            _0: {
+              TAG: "Below",
+              _0: match
+            }
+          };
+          return;
+        } else if (match$1 !== undefined) {
+          out[log] = {
+            TAG: "Until",
+            _0: {
+              TAG: "AtMost",
+              _0: match$1
+            }
+          };
+          return;
+        } else {
+          return;
+        }
+      default:
+        return;
+    }
+  });
+  return out;
+}
+
+function toRecord(s, r) {
+  return {
+    plugin: s.plugin,
+    log: r.log,
+    position: r.position.toString(),
+    eventType: r.eventType,
+    entityId: r.entityId,
+    tags: r.tags,
+    payload: r.payload,
+    meta: r.meta,
+    recordedAt: r.recordedAt
+  };
+}
+
+function newerFirst(param, param$1) {
+  let b = param$1[1];
+  let sb = param$1[0];
+  let a = param[1];
+  let sa = param[0];
+  if (a.recordedAt !== b.recordedAt) {
+    if (a.recordedAt > b.recordedAt) {
+      return -1;
+    } else {
+      return 1;
+    }
+  }
+  let pa = Stdlib_Option.getOr(sa.plugin, "");
+  let pb = Stdlib_Option.getOr(sb.plugin, "");
+  if (pa !== pb) {
+    return Primitive_string.compare(pa, pb);
+  } else if (sa.log !== sb.log) {
+    return Primitive_string.compare(sa.log, sb.log);
+  } else {
+    return b.position - a.position;
+  }
+}
+
+async function read(filter, first, after) {
+  let pageSize = Math.min(Math.max(Stdlib_Option.getOr(first, 50), 0), 1000);
+  let incoming = Stdlib_Option.flatMap(after, decodeCursor);
+  let sources = Stdlib_Array.filterMap(logs(), log => {
+    let plugin = pluginOfLog[log];
+    let match = readers[log];
+    let match$1 = selectsLog(filter, log, plugin);
+    if (match === undefined) {
+      return;
+    }
+    if (!match$1) {
+      return;
+    }
+    let start = incoming !== undefined ? Stdlib_Option.getOr(incoming[log], "Done") : ({
+        TAG: "Until",
+        _0: {
+          TAG: "AtMost",
+          _0: Pervasives.infinity
+        }
+      });
+    if (typeof start !== "object") {
+      return;
+    } else {
+      return {
+        log: log,
+        plugin: plugin,
+        reader: match,
+        scan: Stdlib_Option.isSome(incoming) ? start._0 : undefined,
+        fetched: false,
+        exhausted: false,
+        buffer: [],
+        state: Stdlib_Option.isSome(incoming) ? start : "Done"
+      };
+    }
+  });
+  let batch = Math.max(pageSize + 1 | 0, 50);
+  let fetch = async s => {
+    let rows = await s.reader.readBack(s.scan, batch, filter.correlationId);
+    if (!s.fetched) {
+      s.fetched = true;
+      if (Stdlib_Option.isNone(incoming)) {
+        let newest = rows[0];
+        s.state = newest !== undefined ? ({
+            TAG: "Until",
+            _0: {
+              TAG: "AtMost",
+              _0: newest.position
+            }
+          }) : "Done";
+      }
+    }
+    let oldest = rows.at(-1);
+    if (oldest !== undefined) {
+      s.scan = {
+        TAG: "Below",
+        _0: oldest.position
+      };
+    }
+    if (rows.length < batch) {
+      s.exhausted = true;
+    }
+    s.buffer = s.buffer.concat(rows.filter(r => matches(filter, r)));
+  };
+  let headOf = async s => {
+    let head = s.buffer[0];
+    if (head !== undefined) {
+      return head;
+    } else if (s.exhausted) {
+      return;
+    } else {
+      await fetch(s);
+      return await headOf(s);
+    }
+  };
+  let newest = async () => {
+    let heads = [];
+    for (let i = 0, i_finish = sources.length; i < i_finish; ++i) {
+      let s = sources[i];
+      let r = await headOf(s);
+      if (r !== undefined) {
+        heads.push([
+          s,
+          r
+        ]);
+      }
+    }
+    return heads.toSorted(newerFirst)[0];
+  };
+  let stateNow = () => sources.map(s => [
+    s.log,
+    s.state
+  ]);
+  let edges = [];
+  let stop = false;
+  while (!stop && edges.length < pageSize) {
+    let match = await newest();
+    if (match !== undefined) {
+      let r = match[1];
+      let s = match[0];
+      s.buffer = s.buffer.slice(1, s.buffer.length);
+      s.state = s.exhausted && s.buffer.length === 0 ? "Done" : ({
+          TAG: "Until",
+          _0: {
+            TAG: "Below",
+            _0: r.position
+          }
+        });
+      edges.push([
+        toRecord(s, r),
+        encodeCursor(stateNow())
+      ]);
+    } else {
+      stop = true;
+    }
+  };
+  let hasNextPage = Stdlib_Option.isSome(await newest());
+  sources.forEach(s => {
+    if (s.exhausted && s.buffer.length === 0) {
+      s.state = "Done";
+      return;
+    }
+  });
+  return {
+    edges: edges,
+    hasNextPage: hasNextPage,
+    endCursor: edges.length !== 0 || Stdlib_Option.isSome(incoming) ? encodeCursor(stateNow()) : undefined
+  };
+}
+
+let maxNotes = 10000;
+
+let defaultPageSize = 50;
+
+let maxPageSize = 1000;
+
+export {
+  metaOfFlat,
+  storedOfFlat,
+  numberOf,
+  readers,
+  pluginOfLog,
+  register,
+  notePlugin,
+  pluginOf,
+  logs,
+  positionToString,
+  maxNotes,
+  notes,
+  note,
+  take,
+  resetForTests,
+  recordToJson,
+  filterOfJson,
+  metaString,
+  selectsLog,
+  matches,
+  toBase64Url,
+  fromBase64Url,
+  encodeCursor,
+  decodeCursor,
+  defaultPageSize,
+  maxPageSize,
+  toRecord,
+  newerFirst,
+  read,
+}
+/* notes Not a pure module */

package/src/adapter/LocalEventTap.res

@@ -7,12 +7,13 @@
 // what let it stop being configured. The noisy half (a line per event on stdout)
 // stays opt-in. `REVENTLESS_EVENT_TAP=off` disables the socket too.
 // See docs/plans/done/one-local-platform-one-store.md.
-
-let log = ReventlessCore.Logger.fromEnv()
+//
+// The socket is a `LocalFeed`: each reader has a bounded queue and may send a
+// filter line on connect. See docs/plans/the-local-platform-serves-what-is-watched.md.
 
 let envVar = "REVENTLESS_EVENT_TAP"
 
-type setting =
+type setting = LocalFeed.setting =
   | Off
   | Ephemeral
   | Fixed(int)
@@ -25,16 +26,7 @@ let envValue = (~env: dict<string>): option<string> =>
     A port only when the value IS one in the unprivileged range: the runner has
     passed `ndjson` since the tap existed, and someone writing `=1` means "on", not
     port 1. Everything else — unset included — takes the ephemeral default. */
-let settingFromEnv = (~env=NodeProcess.env): setting =>
-  switch envValue(~env) {
-  | Some("off") | Some("false") | Some("none") => Off
-  | Some(v) =>
-    switch Int.fromString(v) {
-    | Some(p) if p >= 1024 && p <= 65535 => Fixed(p)
-    | _ => Ephemeral
-    }
-  | None => Ephemeral
-  }
+let settingFromEnv = (~env=NodeProcess.env): setting => LocalFeed.settingOf(envValue(~env))
 
 /** Whether to ALSO write each line to stdout. Opt-in and unchanged: this is the
     half with a visible cost, and it exists for the child whose stdout the runner
@@ -45,33 +37,26 @@ let stdoutEnabled = (~env=NodeProcess.env): bool =>
   | Some(_) => true
   }
 
-let connections: ref<array<NodeNet.socket>> = ref([])
-let server: ref<option<NodeNet.server>> = ref(None)
-let listeningPort: ref<option<int>> = ref(None)
+/** The feed the socket serves. A filter line narrows it by plugin, event type and
+    correlation id; the other filter fields are about log lines and are ignored
+    here. */
+let feed = LocalFeed.make(~name="EventTap", ~honours=[Plugins, EventTypes, CorrelationId], ())
 
 /** The port the socket is actually bound to, known only once `listen` calls back —
     which is why {!start} takes `~onBound` rather than the caller reading this
     straight after. `None` until then, and if the bind fails. */
-let port = () => listeningPort.contents
+let port = () => feed->LocalFeed.port
 
 /** Whether anyone is reading, so the hot path can skip building a line nobody
     wants. */
-let hasReaders = () => connections.contents->Array.length > 0
+let hasReaders = () => feed->LocalFeed.hasReaders
 
-let drop = (socket: NodeNet.socket) =>
-  connections := connections.contents->Array.filter(s => s !== socket)
+/** Sends a line with what a filter can ask about it. */
+let publish = (item: LocalFeed.item): unit => feed->LocalFeed.publish(item)
 
 /** Guarded per socket: a write to a closed peer throws, and one dead reader must
     not cost the others their events or the platform its run. */
-let broadcast = (line: string): unit =>
-  if hasReaders() {
-    connections.contents->Array.forEach(socket =>
-      switch socket->NodeNet.write(line ++ "\n") {
-      | _ => ()
-      | exception _ => drop(socket)
-      }
-    )
-  }
+let broadcast = (line: string): unit => feed->LocalFeed.broadcast(line)
 
 /** Binds the tap socket and reports the port it got.
 
@@ -80,60 +65,13 @@ let broadcast = (line: string): unit =>
     failure mode: a platform whose diagnostic socket cannot bind must still serve,
     and simply carries no tap port. */
 let start = (~env=NodeProcess.env, ~onBound: int => unit=_ => (), ()): unit =>
-  switch (settingFromEnv(~env), server.contents) {
-  | (Off, _) | (_, Some(_)) => ()
-  | (setting, None) =>
-    let requested = switch setting {
-    | Fixed(p) => p
-    // 0 lets the OS pick, so parallel platforms in one directory never collide and
-    // no unrelated service can be advertised as ours.
-    | Off | Ephemeral => 0
-    }
-    let s = NodeNet.createServer(socket => {
-      socket->NodeNet.setEncoding("utf8")
-      socket->NodeNet.onSocketError(_ => drop(socket))
-      socket->NodeNet.onSocketClose(() => drop(socket))
-      connections := connections.contents->Array.concat([socket])
-    })
-    s->NodeNet.onServerError(err => {
-      log.warn(
-        ~comp="EventTap",
-        `could not listen: ${err->JsExn.message->Option.getOr("unknown error")}`,
-      )
-      server := None
-      listeningPort := None
-    })
-    // A diagnostic listener must never be why the process stays alive.
-    s->NodeNet.unref
-    s->NodeNet.listen(requested, "127.0.0.1", () =>
-      switch s->NodeNet.address->Nullable.toOption {
-      | Some(addr) =>
-        let bound = addr["port"]
-        listeningPort := Some(bound)
-        log.info(~comp="EventTap", `listening on 127.0.0.1:${bound->Int.toString}`)
-        onBound(bound)
-      | None => ()
-      }
-    )
-    server := Some(s)
-  }
+  feed->LocalFeed.start(~setting=settingFromEnv(~env), ~onBound, ())
 
 /** Test seam: forgets connections and server without closing anything. */
-let resetForTests = () => {
-  connections := []
-  server := None
-  listeningPort := None
-}
+let resetForTests = () => feed->LocalFeed.resetForTests
 
 let addConnectionForTests = (socket: NodeNet.socket) =>
-  connections := connections.contents->Array.concat([socket])
+  feed->LocalFeed.addConnectionForTests(socket)
 
 /** Test seam: actually releases the port, so a suite can bind it again. */
-let stopForTests = (): promise<unit> =>
-  switch server.contents {
-  | None => Promise.resolve()
-  | Some(s) =>
-    connections.contents->Array.forEach(NodeNet.destroySocket)
-    resetForTests()
-    Promise.make((resolve, _reject) => s->NodeNet.closeServer(() => resolve()))
-  }
+let stopForTests = (): promise<unit> => feed->LocalFeed.stopForTests