@expo/event-log 0.0.1-init

package/dist/event-log.mjs

@@ -0,0 +1,977 @@
+import e from "node:path";
+
+import { performance as i } from "node:perf_hooks";
+
+import { E as n, I as s, L as r, e as o, f as c, b as h, S as a, D as f, g as d, h as u, i as p } from "./chunks/tap-chunk.mjs";
+
+export { l as list, t as tap } from "./chunks/tap-chunk.mjs";
+
+import { Buffer as g } from "node:buffer";
+
+import { EventEmitter as y } from "node:events";
+
+import m from "node:fs";
+
+import w from "node:net";
+
+import { createInterface as S } from "node:readline";
+
+import { isMainThread as v, threadId as k } from "node:worker_threads";
+
+const L = Symbol.for(`@expo/event-log/state-${n}`);
+
+const _ = function getEventLogState() {
+  const e = globalThis;
+  return e[L] ??= {
+    logPath: process.cwd(),
+    eventLoggerInfo: null
+  };
+}();
+
+function setLogPath(e) {
+  _.logPath = e;
+}
+
+function setPrimarySink(e) {
+  _.primarySink = e;
+}
+
+function setEventLoggerInfo(e) {
+  _.eventLoggerInfo = e;
+}
+
+function writeRawLine(e) {
+  const t = e.endsWith("\n") ? e : `${e}\n`;
+  _.primarySink?._writeln(t);
+}
+
+const P = 16387;
+
+const b = i.timeOrigin;
+
+let E;
+
+let I = "";
+
+function writeEvent(e, t, i, n, s) {
+  e._writeln(function serializeEvent(e, t, i, n, s) {
+    const r = getEventTimestamp();
+    if (!n?._w) {
+      const n = i ? JSON.stringify(i).slice(1) : "";
+      return n.length > 1 ? `{"_e":"${e}:${t}","_t":${r},${n}\n` : `{"_e":"${e}:${t}","_t":${r}}\n`;
+    }
+    let o = `{"_e":"${e}:${t}","_t":${r}`;
+    if (n?._w) {
+      o += `,"_w":${stringifyWorkerId(n._w)}`;
+    }
+    return `${appendPayload(o, i)}}\n`;
+  }(t, i, n, s));
+}
+
+function writeCompleteEvent(e, t, i, n, s, r, o) {
+  let c = `{"_e":"${t}:${i}","_t":${getEventTimestamp()},"_d":${r}`;
+  if (o?._w) {
+    c += `,"_w":${stringifyWorkerId(o._w)}`;
+  }
+  e._writeln(`${function appendMergedPayload(e, t, i) {
+    if (!t) {
+      return appendPayload(e, i);
+    }
+    if (!i) {
+      return appendPayload(e, t);
+    }
+    const n = new Set(Object.keys(i));
+    for (const i of Object.keys(t)) {
+      if (n.has(i)) {
+        continue;
+      }
+      const s = JSON.stringify(t[i]);
+      if (void 0 !== s) {
+        e += `,${JSON.stringify(i)}:${s}`;
+      }
+    }
+    return appendPayload(e, i);
+  }(c, n, s)}}\n`);
+}
+
+function getEventTimestamp() {
+  return b + i.now();
+}
+
+function stringifyWorkerId(e) {
+  if (e !== E) {
+    E = e;
+    I = JSON.stringify(e);
+  }
+  return I;
+}
+
+function appendPayload(e, t) {
+  if (!t) {
+    return e;
+  }
+  const i = JSON.stringify(t);
+  return i && i.length > 2 ? `${e},${i.slice(1, -1)}` : e;
+}
+
+class LogStream extends y {
+  #e=-1;
+  #t=null;
+  #i=null;
+  #n=!0;
+  #s=!1;
+  #r=!1;
+  #o=!1;
+  #c=!1;
+  #h=!1;
+  #l=!1;
+  #a="";
+  #f=0;
+  #d=[];
+  #u=0;
+  #p=0;
+  #g=(e, t) => this.#y(e, t);
+  constructor(e, t = {}) {
+    super();
+    this.#n = !1 !== t.closeFd;
+    if ("number" == typeof e) {
+      try {
+        m.fsyncSync(e);
+      } catch {}
+      this.#e = e;
+      process.nextTick(() => this.emit("ready"));
+    } else if ("string" == typeof e) {
+      this.#m(e);
+    }
+  }
+  get file() {
+    return this.#t;
+  }
+  get fd() {
+    return this.#e;
+  }
+  get writing() {
+    return this.#s;
+  }
+  get writable() {
+    return !this.#c && !this.#r;
+  }
+  reopen(e = this.#t) {
+    if (null == this.#t) {
+      throw new Error("Cannot reopen an fd-only LogStream");
+    }
+    if (this.#c || this.#r) {
+      return;
+    }
+    if (e) {
+      this.#t = e;
+    }
+    if (this.#h) {
+      this.once("ready", () => this.reopen(e));
+      return;
+    }
+    this.#l = !0;
+    if (!this.#s) {
+      this.#w();
+    }
+  }
+  #w() {
+    if (null == this.#t) {
+      return;
+    }
+    this.#l = !1;
+    this.#i = this.#e;
+    this.#m(this.#t);
+  }
+  #y(e, t) {
+    if (e) {
+      if ("EAGAIN" === e.code || "EBUSY" === e.code) {
+        setTimeout(() => this.#S(), 100);
+      } else {
+        this.#s = !1;
+        this.emit("error", e);
+      }
+    } else {
+      this.emit("write", t);
+      if (t === this.#a.length) {
+        this.#f -= this.#a.length;
+        this.#a = "";
+        if (this.#d.length - this.#u > this.#p) {
+          this.#S();
+        } else if (this.#l) {
+          this.#s = !1;
+          this.#w();
+        } else if (this.#r) {
+          this.#s = !1;
+          this.#v();
+        } else {
+          this.#s = !1;
+          if (this.#o) {
+            this.emit("drain");
+          }
+        }
+      } else {
+        if (g.byteLength(this.#a) > t) {
+          const e = g.from(this.#a).toString("utf8", t);
+          this.#f -= this.#a.length - e.length;
+          this.#a = e;
+        } else {
+          this.#f -= this.#a.length;
+          this.#a = "";
+        }
+        if (this.#a || this.#d.length - this.#u > this.#p) {
+          this.#S();
+        } else if (this.#l) {
+          this.#s = !1;
+          this.#w();
+        } else if (this.#r) {
+          this.#s = !1;
+          this.#v();
+        } else {
+          this.#s = !1;
+          if (this.#o) {
+            this.emit("drain");
+          }
+        }
+      }
+    }
+  }
+  #m(t) {
+    this.#h = !0;
+    this.#s = !0;
+    const onOpened = (e, i) => {
+      const n = this.#i;
+      this.#i = null;
+      if (e) {
+        this.#s = !1;
+        this.#h = !1;
+        this.emit("error", e);
+      } else {
+        this.#e = i;
+        this.#t = t;
+        this.#h = !1;
+        this.#s = !1;
+        this.emit("ready");
+        if (null != n && n !== this.#e && !isStdFd(n)) {
+          fsFsync(n, () => m.close(n, () => {}));
+        }
+        if (this.#c) {} else if (!this.writing && this.#d.length - this.#u > this.#p || this.#o) {
+          this.#S();
+        }
+      }
+    };
+    m.mkdir(e.dirname(t), {
+      recursive: !0
+    }, e => {
+      if (e) {
+        return onOpened(e);
+      }
+      m.open(t, "a", 438, onOpened);
+    });
+  }
+  #v() {
+    if (-1 === this.#e) {
+      this.once("ready", () => this.#v());
+      return;
+    }
+    this.#c = !0;
+    this.#p = 0;
+    this.#d.length = 0;
+    this.#u = 0;
+    const onClose = e => {
+      if (e) {
+        this.emit("error", e);
+        this.emit("close", e);
+      } else {
+        if (this.#r && !this.#s) {
+          this.emit("finish");
+        }
+        this.emit("close");
+      }
+    };
+    fsFsync(this.#e, e => {
+      if (!e && this.#n && !isStdFd(this.#e)) {
+        m.close(this.#e, onClose);
+      } else {
+        onClose();
+      }
+    });
+  }
+  #S() {
+    this.#s = !0;
+    if (!this.#a) {
+      const e = this.#d.length - this.#p;
+      if (e > this.#u) {
+        this.#a = this.#d[this.#u++] || "";
+        while (this.#u < e && this.#a.length < P) {
+          this.#a += this.#d[this.#u++];
+        }
+        if (this.#u === this.#d.length) {
+          this.#d.length = 0;
+          this.#u = 0;
+        }
+      }
+    }
+    m.write(this.#e, this.#a, this.#g);
+  }
+  _end() {
+    if (!this.#c && !this.#r) {
+      this.#r = !0;
+      if (this.#h) {
+        this.once("ready", () => this._end());
+      } else if (!this.#s && this.#e >= 0) {
+        if (this.#d.length - this.#u > this.#p) {
+          this.#S();
+        } else {
+          this.#v();
+        }
+      }
+    }
+    return this;
+  }
+  end(e, t, i) {
+    const n = i || t || e;
+    const s = "function" != typeof e ? e : void 0;
+    const r = "function" == typeof n ? n : void 0;
+    if ("string" == typeof s) {
+      this.write(s, "string" == typeof t ? t : "utf8");
+    } else if (null != s) {
+      this.write(s);
+    }
+    if (r) {
+      this.once("close", r);
+    }
+    return this._end();
+  }
+  destroy() {
+    if (!this.#c) {
+      this.#v();
+    }
+  }
+  flush(e) {
+    if (this.#c) {
+      e?.();
+    } else {
+      const onDrain = () => {
+        if (!this.#c) {
+          fsFsync(this.#e, t => {
+            this.#o = !1;
+            if ("EBADF" === t?.code) {
+              e?.();
+            } else {
+              e?.(t);
+            }
+          });
+        } else {
+          this.#o = !1;
+          e?.();
+        }
+        this.off("error", onError);
+      };
+      const onError = t => {
+        this.#o = !1;
+        this.off("drain", onDrain);
+        e?.(t);
+      };
+      this.#o = !0;
+      this.once("drain", onDrain);
+      this.once("error", onError);
+      if (!this.#s) {
+        if (this.#d.length - this.#u > this.#p || this.#a) {
+          this.#S();
+        } else {
+          process.nextTick(() => this.emit("drain"));
+        }
+      }
+    }
+  }
+  _writeln(e) {
+    this.#f += e.length;
+    if (!this.#s && this.#d.length === this.#u && !this.#a) {
+      this.#s = !0;
+      this.#a = e;
+      m.write(this.#e, e, this.#g);
+    } else {
+      this.#d.push(e);
+      if (!this.#s) {
+        this.#S();
+      }
+    }
+    return this.#f < P;
+  }
+  _write(e) {
+    if (this.#c) {
+      return !1;
+    }
+    if (0 === this.#p && 10 === e.charCodeAt(e.length - 1)) {
+      return this._writeln(e);
+    }
+    this.#f += e.length;
+    let t = 0;
+    let i = -1;
+    while ((i = e.indexOf("\n", t)) > -1) {
+      const n = e.slice(t, i + 1);
+      if (this.#p > 0) {
+        this.#d[this.#d.length - 1] += n;
+      } else {
+        this.#d.push(n);
+      }
+      this.#p = 0;
+      t = ++i;
+    }
+    if (t < e.length) {
+      const i = e.slice(t);
+      if (this.#p > 0) {
+        this.#d[this.#d.length - 1] += i;
+      } else {
+        this.#d.push(e.slice(t));
+      }
+      this.#p = 1;
+    }
+    if (!this.#s && this.#d.length - this.#u > this.#p) {
+      this.#S();
+    }
+    return this.#f < P;
+  }
+  write(e, t, i) {
+    const n = i || t;
+    const s = "string" == typeof t ? t : "utf8";
+    const r = "string" == typeof e ? e : g.from(e).toString(s);
+    const o = "function" == typeof n ? n : void 0;
+    try {
+      return this._write(r);
+    } finally {
+      o?.();
+    }
+  }
+  [Symbol.dispose]() {
+    this.destroy();
+  }
+}
+
+class WritableStreamSink {
+  constructor(e) {
+    this.stream = e;
+  }
+  get writable() {
+    return !1 !== this.stream.writable;
+  }
+  _writeln(e) {
+    return this.stream.write(e);
+  }
+  end(e) {
+    this.stream.end(e);
+    return this;
+  }
+  destroy() {
+    const e = this.stream;
+    e.destroy?.();
+  }
+}
+
+const isStdFd = e => {
+  switch (e) {
+   case 1:
+   case 2:
+   case process.stdout.fd:
+   case process.stderr.fd:
+    return !0;
+
+   default:
+    return !1;
+  }
+};
+
+const fsFsync = (e, t) => {
+  try {
+    m.fsync(e, t);
+  } catch (e) {
+    t(e);
+  }
+};
+
+const NOOP_DONE = () => {};
+
+function events(t) {
+  function log(e, i) {
+    if (_.primarySink) {
+      writeEvent(_.primarySink, t, e, i, _.eventMeta);
+    }
+  }
+  log.span = function span(e, n) {
+    if (!_.primarySink) {
+      return NOOP_DONE;
+    }
+    const s = i.now();
+    return function done(e, r) {
+      if (!_.primarySink) {
+        return;
+      }
+      writeCompleteEvent(_.primarySink, t, e, n, r, i.now() - s, _.eventMeta);
+    };
+  };
+  log.path = function relativePath(t) {
+    try {
+      return null != t && e.isAbsolute(t) ? e.relative(_.logPath, t).replace(/\\/g, "/") || "." : t ?? null;
+    } catch {
+      return t || null;
+    }
+  };
+  log.category = t;
+  return log;
+}
+
+const $ = Symbol.for("@expo/event-log/process-origin");
+
+function setLocalProcessOrigin(e) {
+  const t = globalThis;
+  if (e) {
+    t[$] = e;
+  } else {
+    delete t[$];
+  }
+}
+
+function getProcessOrigin() {
+  if (!v) {
+    return {
+      kind: "worker_thread",
+      id: String(k)
+    };
+  }
+  const e = globalThis[$];
+  const t = process.env[s];
+  if (t && t !== e) {
+    return {
+      kind: "event_log_child",
+      id: t
+    };
+  }
+  if (process.env.NODE_UNIQUE_ID) {
+    return {
+      kind: "child_process",
+      id: process.env.NODE_UNIQUE_ID
+    };
+  }
+  return null;
+}
+
+class IpcSink {
+  #k=null;
+  #L=!1;
+  #c=!1;
+  #_=!1;
+  #d=[];
+  #P=Date.now();
+  #b;
+  #E;
+  constructor(e, t = {}) {
+    this.socketPath = e;
+    this.#b = t.retryMs ?? 50;
+    this.#E = t.maxRetryMs ?? 750;
+    this.#I();
+  }
+  get writable() {
+    return !this.#c;
+  }
+  _writeln(e) {
+    if (this.#c) {
+      return !1;
+    }
+    if (this.#L && this.#k) {
+      return this.#k.write(e);
+    }
+    this.#d.push(e);
+    return !1;
+  }
+  end(e) {
+    this.destroy();
+    e?.();
+    return this;
+  }
+  destroy() {
+    this.#c = !0;
+    this.#d.length = 0;
+    this.#k?.destroy();
+  }
+  #I() {
+    if (this.#c || this.#L) {
+      return;
+    }
+    if (Date.now() - this.#P > this.#E) {
+      this.destroy();
+      return;
+    }
+    const e = w.connect(this.socketPath);
+    this.#k = e;
+    e.once("connect", () => {
+      this.#_ = !1;
+      this.#L = !0;
+      for (const t of this.#d.splice(0)) {
+        e.write(t);
+      }
+    });
+    e.once("error", () => {
+      if (this.#L) {
+        return;
+      }
+      e.destroy();
+      this.#$();
+    });
+    e.once("close", () => {
+      if (this.#c) {
+        return;
+      }
+      this.#L = !1;
+      if (this.#k === e) {
+        this.#k = null;
+      }
+      this.#$();
+    });
+  }
+  #$() {
+    if (this.#_ || this.#c) {
+      return;
+    }
+    this.#_ = !0;
+    setTimeout(() => {
+      this.#_ = !1;
+      this.#I();
+    }, this.#b);
+  }
+}
+
+const O = Symbol.for("@expo/event-log/process-cleanup");
+
+function getProcessCleanupState() {
+  const e = globalThis;
+  return e[O] ??= {
+    registered: !1,
+    callbacks: new Set
+  };
+}
+
+function runProcessCleanup() {
+  for (const e of getProcessCleanupState().callbacks) {
+    try {
+      e();
+    } catch {}
+  }
+}
+
+function listenUnixSocket(e, t) {
+  let i = !1;
+  let n = !1;
+  let s = !1;
+  const close = () => {
+    s = !0;
+    if (n && !i) {
+      e.close();
+    }
+  };
+  e.once("listening", () => {
+    n = !0;
+    if (s) {
+      close();
+    }
+  });
+  e.once("close", () => {
+    i = !0;
+    n = !1;
+  });
+  e.on("error", () => {
+    i = !0;
+    try {
+      e.close(() => {});
+    } catch {}
+  });
+  e.listen(t);
+  return close;
+}
+
+let x;
+
+const j = events("root");
+
+function installEventLogger(t) {
+  if (_.primarySink) {
+    return;
+  }
+  const i = parseLogTarget(process.env[r]) ?? parseLogTarget("string" == typeof t || "number" == typeof t ? t : void 0);
+  if (null != i) {
+    if ("number" == typeof i) {
+      o(i);
+    }
+    setEventLoggerInfo(function getExplicitTargetInfo(e) {
+      if ("number" == typeof e) {
+        return {
+          destination: 1 === e ? "stdout" : 2 === e ? "stderr" : "fd",
+          isUserVisibleOutput: 1 === e || 2 === e,
+          fd: e
+        };
+      }
+      return {
+        destination: "file",
+        isUserVisibleOutput: !1,
+        file: e
+      };
+    }(i));
+    activateSink(new LogStream(i));
+    return;
+  }
+  const n = process.env[c];
+  if (n) {
+    !function connectToParent(e) {
+      const t = function getProcessWorkerId() {
+        const e = getProcessOrigin();
+        return e ? `${e.kind}:${e.id}` : void 0;
+      }();
+      if (t) {
+        !function setEventMeta(e) {
+          _.eventMeta = e;
+        }({
+          _w: t
+        });
+      }
+      const i = new IpcSink(e);
+      setPrimarySink(i);
+      setEventLoggerInfo({
+        destination: "ipc",
+        isUserVisibleOutput: !1
+      });
+      j("init", getInitMetadata());
+    }(n);
+    return;
+  }
+  if (t && "object" == typeof t) {
+    x = function createSession(t) {
+      h();
+      const i = u();
+      const n = e.join(i, String(process.pid));
+      m.rmSync(n, {
+        recursive: !0,
+        force: !0
+      });
+      m.mkdirSync(n, {
+        recursive: !0
+      });
+      const r = t.maxSegments ?? f;
+      const o = t.maxSegmentSize ?? p;
+      const l = e.join(n, a.liveSocket);
+      const g = e.join(n, a.ipcSocket);
+      const y = new LogStream(e.join(n, "0.jsonl"));
+      const v = new Set;
+      let k = 0;
+      let L = !1;
+      y.on("write", t => {
+        k += t;
+        if (k < o) {
+          return;
+        }
+        k = 0;
+        !function rotateSegments(t, i) {
+          m.rmSync(e.join(t, i - 1 + ".jsonl"), {
+            force: !0
+          });
+          for (let n = i - 1; n >= 1; n--) {
+            const i = e.join(t, n - 1 + ".jsonl");
+            const s = e.join(t, `${n}.jsonl`);
+            try {
+              m.renameSync(i, s);
+            } catch {}
+          }
+        }(n, r);
+        y.reopen();
+      });
+      const _ = w.createServer(e => {
+        const t = function createSocketSink(e) {
+          const t = e._handle?.fd;
+          if ("number" == typeof t && t >= 0) {
+            return new LogStream(t, {
+              closeFd: !1
+            });
+          }
+          return new WritableStreamSink(e);
+        }(e);
+        v.add(t);
+        e.on("close", () => {
+          v.delete(t);
+          t.destroy();
+        });
+        e.on("error", () => {
+          v.delete(t);
+          t.destroy();
+          e.destroy();
+        });
+      });
+      const P = w.createServer(e => {
+        const i = S({
+          input: e
+        });
+        i.on("line", t.onWorkerLine);
+        e.on("close", () => i.close());
+        e.on("error", () => i.close());
+      });
+      const b = listenUnixSocket(_, l);
+      const E = listenUnixSocket(P, g);
+      const I = String(process.pid);
+      process.env[c] = g;
+      process.env[s] = I;
+      setLocalProcessOrigin(I);
+      const $ = {
+        pid: process.pid,
+        formatVersion: d,
+        startedAt: Date.now(),
+        command: t.command ?? process.argv.slice(1).join(" "),
+        cwd: process.cwd(),
+        maxSegments: r,
+        version: t.version,
+        socket: a.liveSocket,
+        ipcSocket: a.ipcSocket,
+        origin: createSessionOrigin()
+      };
+      !function writeJsonAtomic(e, t) {
+        const i = `${e}.${process.pid}.tmp`;
+        m.writeFileSync(i, JSON.stringify(t, null, 2));
+        m.renameSync(i, e);
+      }(e.join(n, a.meta), $);
+      const O = {
+        get writable() {
+          return y.writable;
+        },
+        get file() {
+          return y.file;
+        },
+        _writeln(e) {
+          const t = y._writeln(e);
+          for (const t of v) {
+            t._writeln(e);
+          }
+          return t;
+        },
+        end(e) {
+          y.end(e);
+          for (const e of v) {
+            e.end();
+          }
+          return this;
+        },
+        destroy() {
+          y.destroy();
+          for (const e of v) {
+            e.destroy();
+          }
+        }
+      };
+      const destroy = () => {
+        if (L) {
+          return;
+        }
+        L = !0;
+        O.destroy();
+        b();
+        E();
+        m.rmSync(l, {
+          force: !0
+        });
+        m.rmSync(g, {
+          force: !0
+        });
+        if (process.env[c] === g) {
+          delete process.env[c];
+        }
+        if (process.env[s] === I) {
+          delete process.env[s];
+        }
+        setLocalProcessOrigin(void 0);
+      };
+      !function registerProcessCleanup(e) {
+        const t = getProcessCleanupState();
+        t.callbacks.add(e);
+        if (t.registered) {
+          return;
+        }
+        t.registered = !0;
+        process.once("exit", runProcessCleanup);
+        for (const e of [ "SIGINT", "SIGTERM", "SIGHUP" ]) {
+          process.once(e, () => {
+            runProcessCleanup();
+            process.kill(process.pid, e);
+          });
+        }
+      }(destroy);
+      return {
+        sessionDir: n,
+        meta: $,
+        sink: O,
+        destroy
+      };
+    }({
+      ...t,
+      onWorkerLine: writeRawLine
+    });
+    setLogPath(x.sessionDir);
+    setEventLoggerInfo({
+      destination: "session",
+      isUserVisibleOutput: !1,
+      sessionDir: x.sessionDir
+    });
+    activateSink(x.sink, t.version);
+    return;
+  }
+}
+
+const isEventLoggerActive = () => _.primarySink?.writable ? _.eventLoggerInfo : null;
+
+function parseLogTarget(t) {
+  if ("number" == typeof t) {
+    return Number.isSafeInteger(t) && t > 0 ? t : void 0;
+  }
+  if (!t) {
+    return;
+  }
+  const i = parseInt(t, 10);
+  if (`${i}` === t && i > 0 && Number.isSafeInteger(i)) {
+    return i;
+  }
+  try {
+    const i = e.parse(t);
+    const n = e.format(i);
+    setLogPath(i.dir || process.cwd());
+    return n;
+  } catch {
+    return;
+  }
+}
+
+function getInitMetadata(e) {
+  return {
+    format: "v0-jsonl",
+    formatVersion: d,
+    version: e ?? "UNVERSIONED",
+    processOrigin: getProcessOrigin() ?? void 0
+  };
+}
+
+function activateSink(e, t) {
+  setPrimarySink(e);
+  j("init", getInitMetadata(t));
+}
+
+function createSessionOrigin() {
+  const e = {
+    npmLifecycleEvent: process.env.npm_lifecycle_event,
+    npmExecPath: process.env.npm_execpath,
+    npmPackageName: process.env.npm_package_name
+  };
+  return {
+    argv: process.argv.slice(1),
+    execPath: process.execPath,
+    cwd: process.cwd(),
+    ppid: process.ppid || void 0,
+    env: Object.values(e).some(Boolean) ? e : void 0
+  };
+}
+
+export { events, installEventLogger, isEventLoggerActive };
+//# sourceMappingURL=event-log.mjs.map