@blamejs/blamejs-shop 0.0.44

package/lib/vendor/blamejs/lib/log-stream-local.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Local file-based log sink with append-only journaling + rotation.
+ *
+ * Each event is written as one JSON line (jsonl format — one row per
+ * event). Files rotate by size (default 100 MiB) and/or age (default
+ * 7 days). Old rotations are gzip-compressed automatically and capped at
+ * a configured count (default 30) — older rotations are deleted.
+ *
+ * The active log file is opened in append mode and never updated in place.
+ * Operators can apply OS-level immutability (Linux chattr +a) to the
+ * directory if they want stronger tamper-resistance — the framework
+ * doesn't fight that; appends still work.
+ *
+ * Config:
+ *   {
+ *     dir:                './logs/operational'
+ *     maxFileBytes:       C.BYTES.mib(100)
+ *     maxFileAgeMs:       C.TIME.days(7)
+ *     keepRotations:      30
+ *     compressRotations:  true
+ *     fileMode:           0o600
+ *     fileNamePrefix:     'blamejs'
+ *   }
+ */
+var nodeFs = require("node:fs");
+var nodePath = require("node:path");
+var zlib = require("node:zlib");
+var atomicFile = require("./atomic-file");
+var C = require("./constants");
+var { boot } = require("./log");
+var time = require("./time");
+var { LogStreamError } = require("./framework-error");
+
+var log = boot("log-stream-local");
+
+var DEFAULTS = {
+  maxFileBytes:      C.BYTES.mib(100),
+  maxFileAgeMs:      C.TIME.days(7),
+  keepRotations:     30,
+  compressRotations: true,
+  fileMode:          0o600,
+  fileNamePrefix:    "blamejs",
+};
+
+var _err = LogStreamError.factory;
+
+function create(config) {
+  if (!config || !config.dir) throw new Error("log-stream local requires { dir }");
+  var cfg = Object.assign({}, DEFAULTS, config);
+  var dir = nodePath.resolve(cfg.dir);
+  if (!nodeFs.existsSync(dir)) nodeFs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+
+  var activePath = nodePath.join(dir, cfg.fileNamePrefix + ".log");
+  var fd = null;
+  var openedAt = 0;
+  var bytesWritten = 0;
+
+  function _open() {
+    fd = nodeFs.openSync(activePath, "a", cfg.fileMode);
+    openedAt = Date.now();
+    try {
+      var stat = nodeFs.fstatSync(fd);
+      bytesWritten = stat.size;
+    } catch (_e) {
+      bytesWritten = 0;
+    }
+  }
+  _open();
+
+  function _shouldRotate() {
+    if (cfg.maxFileBytes && bytesWritten >= cfg.maxFileBytes) return true;
+    if (cfg.maxFileAgeMs && (Date.now() - openedAt) >= cfg.maxFileAgeMs) return true;
+    return false;
+  }
+
+  function _rotate() {
+    try {
+      if (fd != null) {
+        try { nodeFs.closeSync(fd); }
+        catch (e) { log.warn("rotate-close-failed: " + e.message); }
+        fd = null;
+      }
+      // Build rotated filename: blamejs-YYYYMMDDTHHMMSSZ.log
+      var stamp = time.toIso8601NoMs(new Date()).replace(/[-:]/g, "");
+      var rotated = nodePath.join(dir, cfg.fileNamePrefix + "-" + stamp + ".log");
+      if (nodeFs.existsSync(activePath)) {
+        nodeFs.renameSync(activePath, rotated);
+        if (cfg.compressRotations) {
+          var data = nodeFs.readFileSync(rotated);
+          var gz = zlib.gzipSync(data);
+          atomicFile.writeSync(rotated + ".gz", gz, { fileMode: cfg.fileMode });
+          nodeFs.unlinkSync(rotated);
+        }
+      }
+      _pruneOld();
+    } finally {
+      _open();
+    }
+  }
+
+  function _pruneOld() {
+    if (!cfg.keepRotations || cfg.keepRotations <= 0) return;
+    var entries = atomicFile.listDir(dir, {
+      filter: function (f) {
+        return f.startsWith(cfg.fileNamePrefix + "-") &&
+          (f.endsWith(".log") || f.endsWith(".log.gz"));
+      },
+      includeStat: true,
+    }).sort(function (a, b) { return b.mtimeMs - a.mtimeMs; });   // newest first
+    for (var i = cfg.keepRotations; i < entries.length; i++) {
+      try { nodeFs.unlinkSync(entries[i].fullPath); } catch (_e) { /* best effort */ }
+    }
+  }
+
+  function emit(record) {
+    if (_shouldRotate()) _rotate();
+    var line = JSON.stringify(record) + "\n";
+    var buf = Buffer.from(line, "utf8");
+    nodeFs.writeSync(fd, buf, 0, buf.length, null);
+    bytesWritten += buf.length;
+    return Promise.resolve({ bytes: buf.length });
+  }
+
+  function close() {
+    if (fd != null) {
+      try { nodeFs.fsyncSync(fd); } catch (_e) { /* best effort */ }
+      try { nodeFs.closeSync(fd); }
+      catch (e) { log.warn("close-failed: " + e.message); }
+      fd = null;
+    }
+    return Promise.resolve();
+  }
+
+  function getActivePath() { return activePath; }
+
+  return {
+    protocol:      "local",
+    emit:          emit,
+    close:         close,
+    rotate:        function () { _rotate(); return Promise.resolve(); },
+    getActivePath: getActivePath,
+  };
+}
+
+module.exports = { create: create };

package/lib/vendor/blamejs/lib/log-stream-otlp-grpc.js

@@ -0,0 +1,410 @@
+"use strict";
+/**
+ * OTLP gRPC log sink — OpenTelemetry Protocol logs over gRPC.
+ *
+ * Companion to lib/log-stream-otlp.js (HTTP/JSON). The OTel collector
+ * accepts both transports; gRPC is the higher-throughput path with
+ * less per-batch overhead and is preferred for production deployments
+ * pushing >100K logs/s.
+ *
+ * Wire format:
+ *   - HTTP/2 (node:http2) POST to
+ *     /opentelemetry.proto.collector.logs.v1.LogsService/Export
+ *   - content-type: application/grpc+proto
+ *   - te: trailers
+ *   - Body: 1-byte compression flag (0 = none) + 4-byte big-endian
+ *           length + protobuf-encoded ExportLogsServiceRequest
+ *   - Response status: HTTP/2 trailer `grpc-status` (0 = OK)
+ *
+ * The protobuf body is encoded by hand via lib/protobuf-encoder.js —
+ * no schema parser ships in the bundle, consistent with the framework's
+ * vendoring stance. The OTel logs schema is small and stable
+ * (https://github.com/open-telemetry/opentelemetry-proto/blob/main/
+ *  opentelemetry/proto/logs/v1/logs.proto).
+ *
+ * Severity mapping follows the OTel spec: debug=5 / info=9 / warn=13 /
+ * error=17.
+ */
+var http2 = require("node:http2");
+var C = require("./constants");
+var { boot } = require("./log");
+var pb = require("./protobuf-encoder");
+var safeAsync = require("./safe-async");
+var safeUrl = require("./safe-url");
+var { tearDownH2Session } = require("./http2-teardown");
+var { LogStreamError } = require("./framework-error");
+
+var _err = LogStreamError.factory;
+var _log = boot("log-stream-otlp-grpc");
+
+var DEFAULTS = {
+  scopeName:     "blamejs",
+  batchSize:     100,
+  maxBatchAgeMs: C.TIME.seconds(5),
+  timeoutMs:     C.TIME.seconds(30),
+  // Ring-buffer cap (event count, not bytes); routed through C.BYTES
+  // identity passthrough so the file's literal arithmetic has a single
+  // source of truth.
+  bufferLimit:   C.BYTES.bytes(10000),
+};
+
+var SEVERITY = {
+  debug: { number: 5,  text: "DEBUG" },
+  info:  { number: 9,  text: "INFO"  },
+  warn:  { number: 13, text: "WARN"  },
+  error: { number: 17, text: "ERROR" },
+};
+
+// ---- Protobuf message shapes (OTel logs.proto) ----
+//
+// Field numbers match
+// https://github.com/open-telemetry/opentelemetry-proto/blob/main/
+//   opentelemetry/proto/{common,resource,logs}/v1/*.proto
+//
+// AnyValue (common.proto) — proto3 oneof; we emit one of:
+//   string_value = 1, bool_value = 2, int_value = 3 (int64 varint),
+//   double_value = 4, bytes_value = 7
+function _encodeAnyValue(v) {
+  if (v == null)             return pb.string(1, "");                   // string_value=""
+  if (typeof v === "string") return pb.string(1, v);
+  if (typeof v === "boolean")return pb.bool(2, v);
+  if (typeof v === "number") {
+    if (Number.isInteger(v) && v >= 0) return pb.uint64(3, v);          // int_value (proto3 int64 varint)
+    return pb.double(4, v);                                              // double_value
+  }
+  if (Buffer.isBuffer(v))    return pb.bytes(7, v);
+  // Fallback — JSON-stringify objects/arrays into string_value rather
+  // than implementing the full ArrayValue / KeyValueList branches.
+  // Operators wanting structured nested attributes shape their record
+  // up-front into top-level scalars or stringified JSON.
+  try { return pb.string(1, JSON.stringify(v)); }
+  catch (_e) { return pb.string(1, String(v)); }
+}
+
+// KeyValue (common.proto): key=1 (string), value=2 (AnyValue)
+function _encodeKeyValue(key, value) {
+  return Buffer.concat([
+    pb.string(1, key),
+    pb.embeddedMessage(2, _encodeAnyValue(value)),
+  ]);
+}
+
+function _encodeAttributes(obj) {
+  if (!obj) return [];
+  var out = [];
+  var keys = Object.keys(obj);
+  for (var i = 0; i < keys.length; i++) {
+    var k = keys[i];
+    var v = obj[k];
+    if (v === undefined) continue;
+    out.push(_encodeKeyValue(k, v));
+  }
+  return out;
+}
+
+// Resource (resource.proto): attributes=1 (repeated KeyValue),
+// dropped_attributes_count=2
+function _encodeResource(attrs) {
+  var kvs = _encodeAttributes(attrs);
+  if (kvs.length === 0) return Buffer.alloc(0);
+  var pieces = kvs.map(function (kvBody) { return pb.embeddedMessage(1, kvBody); });
+  return Buffer.concat(pieces);
+}
+
+// InstrumentationScope (common.proto): name=1, version=2
+function _encodeScope(name, version) {
+  return Buffer.concat([
+    pb.string(1, name || DEFAULTS.scopeName),
+    pb.string(2, version || ""),
+  ]);
+}
+
+// LogRecord (logs.proto):
+//   time_unix_nano = 1 (fixed64)
+//   severity_number = 2 (enum / varint)
+//   severity_text = 3 (string)
+//   body = 5 (AnyValue)
+//   attributes = 6 (repeated KeyValue)
+//   observed_time_unix_nano = 11 (fixed64)
+function _encodeLogRecord(record) {
+  var sev = SEVERITY[record.level] || SEVERITY.info;
+  var tsMs = record.ts || Date.now();
+  // Convert ms to ns. Use BigInt to avoid 53-bit precision loss on
+  // operators emitting > year-2255 timestamps. For ms-resolution
+  // records the LSB nanos are 0; we still send fixed64.
+  var tsNs = BigInt(tsMs) * 1000000n;
+  var attrPieces = _encodeAttributes(record.meta).map(function (kvBody) {
+    return pb.embeddedMessage(6, kvBody);
+  });
+  var msg = (record.message != null ? String(record.message) : "");
+  return Buffer.concat([
+    pb.fixed64(1, tsNs),
+    pb.uint32(2, sev.number),
+    pb.string(3, sev.text),
+    pb.embeddedMessage(5, pb.string(1, msg)),   // body.string_value
+    Buffer.concat(attrPieces),
+    pb.fixed64(11, tsNs),
+  ]);
+}
+
+// ScopeLogs (logs.proto): scope=1 (InstrumentationScope),
+// log_records=2 (repeated LogRecord), schema_url=3
+function _encodeScopeLogs(records, scopeName, scopeVersion) {
+  var recordPieces = records.map(function (rec) {
+    return pb.embeddedMessage(2, _encodeLogRecord(rec));
+  });
+  return Buffer.concat([
+    pb.embeddedMessage(1, _encodeScope(scopeName, scopeVersion)),
+    Buffer.concat(recordPieces),
+  ]);
+}
+
+// ResourceLogs (logs.proto): resource=1 (Resource),
+// scope_logs=2 (repeated ScopeLogs), schema_url=3
+function _encodeResourceLogs(records, cfg) {
+  var resourceBody = _encodeResource(_resourceAttrs(cfg));
+  var scopeLogsBody = _encodeScopeLogs(records, cfg.scopeName, cfg.scopeVersion);
+  return Buffer.concat([
+    pb.embeddedMessage(1, resourceBody),
+    pb.embeddedMessage(2, scopeLogsBody),
+  ]);
+}
+
+// ExportLogsServiceRequest (collector logs.proto):
+//   resource_logs = 1 (repeated ResourceLogs)
+function _encodeExportRequest(records, cfg) {
+  return pb.embeddedMessage(1, _encodeResourceLogs(records, cfg));
+}
+
+function _resourceAttrs(cfg) {
+  var attrs = Object.assign({}, cfg.resourceAttributes || {});
+  if (cfg.serviceName)    attrs["service.name"]    = cfg.serviceName;
+  if (cfg.serviceVersion) attrs["service.version"] = cfg.serviceVersion;
+  return attrs;
+}
+
+// ---- gRPC framing ----
+
+function _frame(messageBuf) {
+  // 1 byte (compression flag, 0 = uncompressed) + 4 bytes (length, BE)
+  // + message bytes.
+  var hdr = Buffer.alloc(5);
+  hdr[0] = 0;
+  hdr.writeUInt32BE(messageBuf.length, 1);
+  return Buffer.concat([hdr, messageBuf]);
+}
+
+// ---- HTTP/2 client ----
+//
+// One client per sink instance. The OTLP gRPC server keeps the
+// connection alive across many Export calls; we re-create on
+// disconnect.
+function _makeClient(cfg) {
+  var url = safeUrl.parse(cfg.url, {
+    allowedProtocols: cfg.allowedProtocols || safeUrl.ALLOW_HTTP_TLS,
+    errorClass:       LogStreamError,
+  });
+  var authority = url.protocol + "//" + url.host;
+  var sessionOpts = {};
+  if (cfg.ca) sessionOpts.ca = cfg.ca;
+  if (cfg.servername) sessionOpts.servername = cfg.servername;
+  if (cfg.allowInsecure) sessionOpts.rejectUnauthorized = false;
+  var session = http2.connect(authority, sessionOpts);
+  session.on("error", function () { /* surfaced through request err */ });
+  if (typeof session.unref === "function") session.unref();
+  return session;
+}
+
+function _doExport(session, cfg, records) {
+  return new Promise(function (resolve, reject) {
+    var body = _encodeExportRequest(records, cfg);
+    var framed = _frame(body);
+
+    var headers = Object.assign({
+      ":method":             "POST",
+      ":path":               "/opentelemetry.proto.collector.logs.v1.LogsService/Export",
+      "content-type":        "application/grpc+proto",
+      "te":                  "trailers",
+      "grpc-encoding":       "identity",
+      "grpc-accept-encoding": "identity",
+    }, cfg.headers || {});
+
+    var req = session.request(headers);
+    var resStatus = null;
+    var trailers = null;
+    var errored = false;
+
+    var timer = setTimeout(function () {
+      errored = true;
+      // Best-effort cancel of the in-flight HTTP/2 request — close()
+      // can throw on an already-torn-down stream; the timeout error
+      // below is the authoritative signal so we swallow + log only.
+      try { req.close(http2.constants.NGHTTP2_CANCEL); }
+      catch (e) { _log.debug("otlp-grpc-timer-cancel: " + (e && e.message || e)); }
+      reject(_err("ETIMEDOUT",
+        "otlp-grpc: request timed out after " + cfg.timeoutMs + "ms"));
+    }, cfg.timeoutMs);
+
+    req.on("response", function (h) {
+      resStatus = h[":status"];
+    });
+    req.on("trailers", function (t) { trailers = t; });
+    req.on("error", function (e) {
+      if (errored) return;
+      errored = true;
+      clearTimeout(timer);
+      reject(_err("HTTP2_ERROR", "otlp-grpc: " + (e && e.message || String(e))));
+    });
+    req.on("close", function () {
+      if (errored) return;
+      clearTimeout(timer);
+      if (resStatus !== 200) {
+        return reject(_err("HTTP_ERROR",
+          "otlp-grpc: HTTP/2 status " + resStatus));
+      }
+      // Trailers MUST carry grpc-status. The OTel collector returns
+      // grpc-status: 0 on success.
+      var grpcStatus = trailers && trailers["grpc-status"];
+      var grpcMessage = trailers && trailers["grpc-message"];
+      if (grpcStatus === undefined) {
+        return reject(_err("HTTP_ERROR",
+          "otlp-grpc: response missing grpc-status trailer"));
+      }
+      if (String(grpcStatus) !== "0") {
+        return reject(_err("HTTP_ERROR",
+          "otlp-grpc: grpc-status " + grpcStatus +
+          (grpcMessage ? " — " + grpcMessage : "")));
+      }
+      resolve();
+    });
+
+    req.end(framed);
+  });
+}
+
+// ---- Public sink factory ----
+
+function create(config) {
+  if (!config || !config.url) {
+    throw _err("BAD_OPT", "log-stream otlp-grpc: { url } is required");
+  }
+  // Reject http:// without explicit allowInsecure — gRPC endpoints
+  // are virtually always TLS in real deployments.
+  var allowedProtocols = config.allowedProtocols || safeUrl.ALLOW_HTTP_TLS;
+  safeUrl.parse(config.url, {
+    allowedProtocols: allowedProtocols,
+    errorClass:       LogStreamError,
+  });
+
+  var cfg = Object.assign({}, DEFAULTS, config);
+  cfg.batchSize     = Number(cfg.batchSize)     || DEFAULTS.batchSize;
+  cfg.maxBatchAgeMs = Number(cfg.maxBatchAgeMs) || DEFAULTS.maxBatchAgeMs;
+  cfg.timeoutMs     = Number(cfg.timeoutMs)     || DEFAULTS.timeoutMs;
+  cfg.bufferLimit   = Number(cfg.bufferLimit)   || DEFAULTS.bufferLimit;
+
+  var onDrop = typeof config.onDrop === "function" ? config.onDrop : null;
+  var _emitDrop = safeAsync.makeDropCallback(onDrop,
+    function (e) { _log.debug("otlp-grpc-onDrop-threw: " + (e && e.message || e)); });
+
+  var buffer = [];
+  var inFlight = false;
+  var closed = false;
+  var session = null;
+  var inflightPromise = null;
+  var flushScheduler = safeAsync.makeScheduledFlush(cfg.maxBatchAgeMs, function () { return _flush(); });
+
+  function _ensureSession() {
+    if (session && !session.destroyed) return session;
+    session = _makeClient(cfg);
+    return session;
+  }
+
+  async function _flush() {
+    if (inFlight || buffer.length === 0) return;
+    inFlight = true;
+    try {
+      while (buffer.length > 0 && !closed) {
+        var batch = buffer.splice(0, cfg.batchSize);
+        try {
+          var s = _ensureSession();
+          inflightPromise = _doExport(s, cfg, batch);
+          await inflightPromise;
+        } catch (e) {
+          _emitDrop("send-failed", batch, e);
+        } finally {
+          inflightPromise = null;
+        }
+      }
+    } finally {
+      inFlight = false;
+    }
+  }
+
+  function emit(record) {
+    if (closed) {
+      _emitDrop("sink-closed", [record], null);
+      return Promise.resolve({ accepted: false, reason: "closed" });
+    }
+    if (buffer.length >= cfg.bufferLimit) {
+      var dropped = buffer.shift();
+      _emitDrop("overflow", [dropped], null);
+    }
+    buffer.push(record);
+    if (buffer.length >= cfg.batchSize) {
+      // Drain immediately; don't await — emit is fire-and-forget on the
+      // hot path. Errors surface via onDrop.
+      _flush().catch(function () {});
+    } else if (!closed) {
+      flushScheduler.schedule();
+    }
+    return Promise.resolve({ accepted: true, queued: buffer.length });
+  }
+
+  async function close() {
+    closed = true;
+    flushScheduler.cancel();
+    // Drain the in-flight Export before tearing down the HTTP/2 session.
+    // The promise rejection (if any) was already routed through onDrop
+    // by _flush — we only await here to avoid racing the teardown.
+    if (inflightPromise) {
+      try { await inflightPromise; }
+      catch (e) { _log.debug("otlp-grpc-close-drain: " + (e && e.message || e)); }
+    }
+    var pending = buffer.splice(0, buffer.length);
+    if (pending.length > 0) {
+      try {
+        var s = _ensureSession();
+        await _doExport(s, cfg, pending);
+      } catch (e) {
+        _emitDrop("send-failed", pending, e);
+      }
+    }
+    // Tear down the HTTP/2 session via the shared close+destroy helper.
+    // By this point we've already awaited inflightPromise and run a
+    // final _doExport for any buffered records, so there's nothing left
+    // to drain. See lib/http2-teardown.js for the rationale on why
+    // close() alone leaves the underlying socket connected on Linux.
+    tearDownH2Session(session);
+    session = null;
+  }
+
+  return {
+    protocol: "otlp-grpc",
+    emit:     emit,
+    close:    close,
+    // Test hooks — encode without sending.
+    _encodeForTest:    function (records) { return _encodeExportRequest(records, cfg); },
+    _frameForTest:     _frame,
+  };
+}
+
+module.exports = {
+  create:                create,
+  // Exposed for layer-0 tests that verify the wire encoding without
+  // standing up an HTTP/2 server.
+  _encodeAnyValue:       _encodeAnyValue,
+  _encodeKeyValue:       _encodeKeyValue,
+  _encodeLogRecord:      _encodeLogRecord,
+  _encodeExportRequest:  _encodeExportRequest,
+  _frame:                _frame,
+};