@reventlessdev/reventless-local 3.0.0-alpha.316 → 3.0.0-alpha.318

package/src/adapter/LocalLogFeed.res.mjs

@@ -0,0 +1,295 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as LocalFeed$ReventlessLocal from "./LocalFeed.res.mjs";
+
+function makeRing(maxCount, maxBytes) {
+  return {
+    maxCount: maxCount,
+    maxBytes: maxBytes,
+    entries: [],
+    head: 0,
+    bytes: 0
+  };
+}
+
+function size(r) {
+  return r.entries.length - r.head | 0;
+}
+
+function entryBytes(e) {
+  return e.item.line.length;
+}
+
+function push(r, e) {
+  if (!(r.maxCount > 0 && r.maxBytes > 0)) {
+    return;
+  }
+  r.entries.push(e);
+  r.bytes = r.bytes + e.item.line.length | 0;
+  while (size(r) > 0 && (size(r) > r.maxCount || r.bytes > r.maxBytes)) {
+    r.bytes = r.bytes - r.entries[r.head].item.line.length | 0;
+    r.head = r.head + 1 | 0;
+  };
+  if (r.head > 1024 && (r.head << 1) > r.entries.length) {
+    r.entries = r.entries.slice(r.head, r.entries.length);
+    r.head = 0;
+    return;
+  }
+}
+
+function toArray(r) {
+  return r.entries.slice(r.head, r.entries.length);
+}
+
+function ringBytes(r) {
+  return r.bytes;
+}
+
+function clear(r) {
+  r.entries = [];
+  r.head = 0;
+  r.bytes = 0;
+}
+
+let ringEnvVar = "REVENTLESS_LOG_RING";
+
+let problemRingEnvVar = "REVENTLESS_LOG_PROBLEM_RING";
+
+function boundsOf(value, count, bytes) {
+  let match = Stdlib_Option.map(value, v => v.trim().split(","));
+  if (match === undefined) {
+    return [
+      count,
+      bytes
+    ];
+  }
+  let len = match.length;
+  if (len >= 3) {
+    return [
+      count,
+      bytes
+    ];
+  }
+  switch (len) {
+    case 0 :
+      return [
+        count,
+        bytes
+      ];
+    case 1 :
+      let c = match[0];
+      return [
+        Stdlib_Option.getOr(Stdlib_Int.fromString(c.trim(), undefined), count),
+        bytes
+      ];
+    case 2 :
+      let c$1 = match[0];
+      let b = match[1];
+      return [
+        Stdlib_Option.getOr(Stdlib_Int.fromString(c$1.trim(), undefined), count),
+        Stdlib_Option.getOr(Stdlib_Int.fromString(b.trim(), undefined), bytes)
+      ];
+  }
+}
+
+let recent = {
+  maxCount: 5000,
+  maxBytes: 8388608,
+  entries: [],
+  head: 0,
+  bytes: 0
+};
+
+let problems = {
+  maxCount: 1000,
+  maxBytes: 2097152,
+  entries: [],
+  head: 0,
+  bytes: 0
+};
+
+function isProblem(level) {
+  switch (level) {
+    case "Debug" :
+    case "Info" :
+      return false;
+    case "Warn" :
+    case "Error" :
+      return true;
+  }
+}
+
+function snapshot() {
+  let seen = new Set();
+  return toArray(recent).concat(toArray(problems)).filter(e => {
+    if (seen.has(e.seq)) {
+      return false;
+    } else {
+      seen.add(e.seq);
+      return true;
+    }
+  }).toSorted((a, b) => a.seq - b.seq | 0);
+}
+
+function facetsOf(r) {
+  return {
+    plugin: r.plugin,
+    level: r.level,
+    comp: r.comp,
+    correlationId: r.annotations["correlationId"]
+  };
+}
+
+function itemOf(r) {
+  return {
+    line: JSON.stringify(Logger$ReventlessCore.recordToJson(r)),
+    facets: facetsOf(r)
+  };
+}
+
+let honours = [
+  "Plugins",
+  "Level",
+  "Components",
+  "CorrelationId"
+];
+
+function recentRecords(filter, limit) {
+  let selected = snapshot().filter(e => LocalFeed$ReventlessLocal.matches(honours, filter, e.item.facets)).map(e => e.record);
+  if (limit !== undefined && limit >= 0 && selected.length > limit) {
+    return selected.slice(selected.length - limit | 0, selected.length);
+  } else {
+    return selected;
+  }
+}
+
+let envVar = "REVENTLESS_LOG_FEED";
+
+let feed = LocalFeed$ReventlessLocal.make("LogFeed", honours, () => snapshot().map(e => e.item), undefined, 16777216, undefined, undefined);
+
+function port() {
+  return LocalFeed$ReventlessLocal.port(feed);
+}
+
+function hasReaders() {
+  return LocalFeed$ReventlessLocal.hasReaders(feed);
+}
+
+let seq = {
+  contents: 0
+};
+
+let removeSink = {
+  contents: undefined
+};
+
+function onRecord(record) {
+  seq.contents = seq.contents + 1 | 0;
+  let entry_seq = seq.contents;
+  let entry_item = itemOf(record);
+  let entry = {
+    seq: entry_seq,
+    record: record,
+    item: entry_item
+  };
+  push(recent, entry);
+  if (isProblem(record.level)) {
+    push(problems, entry);
+  }
+  if (LocalFeed$ReventlessLocal.hasReaders(feed)) {
+    return LocalFeed$ReventlessLocal.publish(feed, entry_item);
+  }
+}
+
+function keepProblem(record) {
+  if (!isProblem(record.level)) {
+    return;
+  }
+  seq.contents = seq.contents + 1 | 0;
+  let entry_seq = seq.contents;
+  let entry_item = itemOf(record);
+  let entry = {
+    seq: entry_seq,
+    record: record,
+    item: entry_item
+  };
+  push(problems, entry);
+  if (LocalFeed$ReventlessLocal.hasReaders(feed)) {
+    return LocalFeed$ReventlessLocal.publish(feed, entry_item);
+  }
+}
+
+function install(envOpt) {
+  let env = envOpt !== undefined ? envOpt : process.env;
+  let match = boundsOf(env[ringEnvVar], 5000, 8388608);
+  recent.maxCount = match[0];
+  recent.maxBytes = match[1];
+  let match$1 = boundsOf(env[problemRingEnvVar], 1000, 2097152);
+  problems.maxCount = match$1[0];
+  problems.maxBytes = match$1[1];
+  let match$2 = removeSink.contents;
+  if (match$2 !== undefined) {
+    return;
+  } else {
+    removeSink.contents = Logger$ReventlessCore.addSink(onRecord);
+    return;
+  }
+}
+
+function start(envOpt, onBoundOpt, param) {
+  let env = envOpt !== undefined ? envOpt : process.env;
+  let onBound = onBoundOpt !== undefined ? onBoundOpt : param => {};
+  LocalFeed$ReventlessLocal.start(feed, LocalFeed$ReventlessLocal.settingOf(env[envVar]), onBound, undefined);
+}
+
+function resetForTests() {
+  Stdlib_Option.forEach(removeSink.contents, remove => remove());
+  removeSink.contents = undefined;
+  clear(recent);
+  clear(problems);
+  LocalFeed$ReventlessLocal.resetForTests(feed);
+}
+
+function stopForTests() {
+  return LocalFeed$ReventlessLocal.stopForTests(feed);
+}
+
+let Logger;
+
+export {
+  Logger,
+  makeRing,
+  size,
+  entryBytes,
+  push,
+  toArray,
+  ringBytes,
+  clear,
+  ringEnvVar,
+  problemRingEnvVar,
+  boundsOf,
+  recent,
+  problems,
+  isProblem,
+  snapshot,
+  facetsOf,
+  itemOf,
+  honours,
+  recentRecords,
+  envVar,
+  feed,
+  port,
+  hasReaders,
+  seq,
+  removeSink,
+  onRecord,
+  keepProblem,
+  install,
+  start,
+  resetForTests,
+  stopForTests,
+}
+/* feed Not a pure module */

package/src/adapter/LocalPgEventLogRead.res

@@ -0,0 +1,85 @@
+// The Postgres backend's part in the read across every event log and in the
+// tap's positions: its logs are read backwards by `global_seq` (aggregate) and
+// `position` (DCB), and each appended event's position is noted for the tap.
+
+module AggOps = ReventlessPostgres.EventLogStorage_Postgres_Ops
+module DcbOps = ReventlessPostgres.DcbEventLogStorage_Postgres_Ops
+
+/** For an aggregate log's `onAppended`: notes each event's `global_seq`. */
+let noteAppended = (~name: string) =>
+  (pairs: array<(string, int)>) =>
+    pairs->Array.forEach(((msgId, position)) =>
+      LocalEventLogRead.note(~log=name, ~msgId, ~position=position->Int.toFloat)
+    )
+
+let registerAggregate = (~pool: ReventlessPostgres.PgDriver.pool, ~name: string) =>
+  LocalEventLogRead.register(~log=name, ~kind=Aggregate, async (~bound, ~limit, ~correlationId) =>
+    (
+      await AggOps.readBackwards(
+        pool,
+        ~name,
+        ~bound=bound->Option.map(b =>
+          switch b {
+          | LocalEventLogRead.Below(p) => AggOps.Below(p)
+          | AtMost(p) => AggOps.AtMost(p)
+          }
+        ),
+        ~limit,
+        ~correlationId,
+      )
+    )->Array.map(((position, entityId, payload)) =>
+      LocalEventLogRead.storedOfFlat(~log=name, ~position, ~entityId, payload)
+    )
+  )
+
+let registerDcb = (~pool: ReventlessPostgres.PgDriver.pool, ~name: string) =>
+  LocalEventLogRead.register(~log=name, ~kind=Dcb, async (~bound, ~limit, ~correlationId) =>
+    (
+      await DcbOps.readBackwards(
+        pool,
+        ~name,
+        ~bound=bound->Option.map(b =>
+          switch b {
+          | LocalEventLogRead.Below(p) => DcbOps.Below(p)
+          | AtMost(p) => DcbOps.AtMost(p)
+          }
+        ),
+        ~limit,
+        ~correlationId,
+      )
+    )->Array.map(((position, e)): LocalEventLogRead.stored => {
+      log: name,
+      position,
+      eventType: e.eventType,
+      tags: e.tags,
+      payload: e.data,
+      meta: e.meta->Reventless.Util_Sury.toJson(Reventless.Message.metaSchema),
+      recordedAt: e.recordedAt,
+    })
+  )
+
+/** A DCB append that also notes where each event went. The append returns only
+    its last cursor, so the positions are read back once. */
+let notingDcbAppend = (
+  ~pool: ReventlessPostgres.PgDriver.pool,
+  ~name: string,
+  append: (
+    array<ReventlessCore.DcbEventLog_Adapter.rawStoredEvent>,
+    ~condition: Reventless.DcbTag.appendCondition=?,
+  ) => promise<result<Reventless.DcbTag.sequencePosition, ReventlessInfra.DcbEventLog.appendError>>,
+) =>
+  async (events, ~condition=?) => {
+    let result = await append(events, ~condition?)
+    switch result {
+    | Ok(cursor) =>
+      switch await DcbOps.positionsOfAppend(pool, ~name, ~cursor) {
+      | positions =>
+        positions->Array.forEach(((msgId, position)) =>
+          LocalEventLogRead.note(~log=name, ~msgId, ~position)
+        )
+      | exception _ => ()
+      }
+    | Error(_) => ()
+    }
+    result
+  }

package/src/adapter/LocalPgEventLogRead.res.mjs

@@ -0,0 +1,91 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as LocalEventLogRead$ReventlessLocal from "./LocalEventLogRead.res.mjs";
+import * as EventLogStorage_Postgres_Ops$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/EventLogStorage_Postgres_Ops.res.mjs";
+import * as DcbEventLogStorage_Postgres_Ops$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/DcbEventLogStorage_Postgres_Ops.res.mjs";
+
+function noteAppended(name) {
+  return pairs => {
+    pairs.forEach(param => LocalEventLogRead$ReventlessLocal.note(name, param[0], param[1]));
+  };
+}
+
+function registerAggregate(pool, name) {
+  LocalEventLogRead$ReventlessLocal.register(name, "Aggregate", async (bound, limit, correlationId) => (await EventLogStorage_Postgres_Ops$ReventlessPostgres.readBackwards(pool, name, Stdlib_Option.map(bound, b => {
+    if (b.TAG === "Below") {
+      return {
+        TAG: "Below",
+        _0: b._0
+      };
+    } else {
+      return {
+        TAG: "AtMost",
+        _0: b._0
+      };
+    }
+  }), limit, correlationId)).map(param => LocalEventLogRead$ReventlessLocal.storedOfFlat(name, param[0], param[1], param[2])));
+}
+
+function registerDcb(pool, name) {
+  LocalEventLogRead$ReventlessLocal.register(name, "Dcb", async (bound, limit, correlationId) => (await DcbEventLogStorage_Postgres_Ops$ReventlessPostgres.readBackwards(pool, name, Stdlib_Option.map(bound, b => {
+    if (b.TAG === "Below") {
+      return {
+        TAG: "Below",
+        _0: b._0
+      };
+    } else {
+      return {
+        TAG: "AtMost",
+        _0: b._0
+      };
+    }
+  }), limit, correlationId)).map(param => {
+    let e = param[1];
+    return {
+      log: name,
+      position: param[0],
+      eventType: e.eventType,
+      tags: e.tags,
+      payload: e.data,
+      meta: Util_Sury$Reventless.toJson(e.meta, Message$Reventless.metaSchema),
+      recordedAt: e.recordedAt
+    };
+  }));
+}
+
+function notingDcbAppend(pool, name, append) {
+  return async (events, condition) => {
+    let result = await append(events, condition);
+    if (result.TAG === "Ok") {
+      let exit = 0;
+      let positions;
+      try {
+        positions = await DcbEventLogStorage_Postgres_Ops$ReventlessPostgres.positionsOfAppend(pool, name, result._0);
+        exit = 1;
+      } catch (exn) {
+        
+      }
+      if (exit === 1) {
+        positions.forEach(param => LocalEventLogRead$ReventlessLocal.note(name, param[0], param[1]));
+      }
+    }
+    return result;
+  };
+}
+
+let AggOps;
+
+let DcbOps;
+
+export {
+  AggOps,
+  DcbOps,
+  noteAppended,
+  registerAggregate,
+  registerDcb,
+  notingDcbAppend,
+}
+/* Message-Reventless Not a pure module */