@blamejs/blamejs-shop 0.0.44

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

@@ -0,0 +1,286 @@
+"use strict";
+/**
+ * OTLP/HTTP-JSON log sink — OpenTelemetry Protocol logs over HTTP/JSON.
+ *
+ * Per the OTLP spec (v1.3+, Logs Data Model), log records are wrapped in
+ * a ResourceLogs envelope and POSTed to the operator's collector
+ * endpoint. Marshalling is OTel-native: timeUnixNano (string), severity
+ * mapping per OTel spec, attribute typing.
+ *
+ * Operator config:
+ *
+ *   {
+ *     url:                 "https://otel-collector.example.com:4318/v1/logs"
+ *                          // OR the collector root — "/v1/logs" auto-appended
+ *     headers:             { ... }   // additional headers (api keys, tenant ids)
+ *     auth:                'none' | 'bearer' | 'basic' | 'header'
+ *     token / username+password
+ *     serviceName:         "my-service"   // emitted as resource service.name
+ *     serviceVersion:      "1.2.3"        // resource service.version
+ *     resourceAttributes:  { env: "prod", region: "us-east-1" }
+ *                          // additional resource attributes
+ *     scopeName:           "blamejs"      // instrumentation scope name
+ *     batchSize:           100
+ *     maxBatchAgeMs:       C.TIME.seconds(5)
+ *     timeoutMs:           C.TIME.seconds(30)
+ *     retry:               { maxAttempts, baseDelayMs, ... }
+ *     bufferLimit:         10000   // ring-buffer cap; drops oldest on overflow
+ *     onDrop:              function ({ reason, batch, error }) { ... }
+ *   }
+ *
+ * Severity mapping (per OTel Logs Data Model):
+ *   debug → 5 (DEBUG)
+ *   info  → 9 (INFO)
+ *   warn  → 13 (WARN)
+ *   error → 17 (ERROR)
+ *
+ * Endpoint convention: most OTel collectors expose:
+ *   <base>:4318/v1/logs   — HTTP/JSON path (per OTLP HTTP §4.5)
+ *   <base>:4317           — gRPC path (NOT supported here)
+ *
+ * If `url` ends in `/v1/logs` it's used as-is. If not, `/v1/logs` is
+ * appended (collector root → logs endpoint). Operators with a custom
+ * routing prefix pass the full URL.
+ *
+ * Why JSON not protobuf: protobuf needs a schema parser (vendored dep
+ * or hand-rolled). The OTLP/HTTP spec accepts both Content-Type:
+ * application/json and application/x-protobuf; the JSON variant is the
+ * "no extra deps" path consistent with the framework's vendoring stance.
+ * Operators benchmarking >100K logs/s ship the OTel Collector locally
+ * (collector → upstream gRPC) — this sink hands JSON to the local
+ * collector which forwards.
+ */
+var C = require("./constants");
+var pkg = require("../package.json");
+var retryHelper = require("./retry");
+var { LogStreamError } = require("./framework-error");
+var httpClient = require("./http-client");
+var safeAsync = require("./safe-async");
+var safeUrl = require("./safe-url");
+var authHeader = require("./auth-header");
+
+var MAX_RESPONSE_BYTES = C.BYTES.mib(1);
+var FRAMEWORK_VERSION = (pkg && pkg.version) || "unknown";
+
+// OTel Logs Data Model severity numbers.
+// https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-severitynumber
+var SEVERITY = {
+  debug: { number: 5,  text: "DEBUG" },
+  info:  { number: 9,  text: "INFO"  },
+  warn:  { number: 13, text: "WARN"  },
+  error: { number: 17, text: "ERROR" },
+};
+
+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 _err = LogStreamError.factory;
+
+function _resolveUrl(url) {
+  // If the URL already ends in "/v1/logs" (with or without trailing slash),
+  // use as-is. Otherwise treat as the collector root and append.
+  var trimmed = url.replace(/\/+$/, "");
+  if (/\/v1\/logs$/.test(trimmed)) return trimmed;
+  return trimmed + "/v1/logs";
+}
+
+function _authHeaders(config) {
+  if (config.auth === "header") return Object.assign({}, config.headers || {});
+  return authHeader.fromConfig(config);
+}
+
+// OTel attribute encoding — JSON form per OTLP spec. Each attribute is
+// { key: <name>, value: { <type>Value: <v> } } where the type field
+// matches the JS type at the boundary.
+function _encodeAttrValue(v) {
+  if (v === null || v === undefined) return null;
+  var t = typeof v;
+  if (t === "string")  return { stringValue: v };
+  if (t === "boolean") return { boolValue: v };
+  if (t === "number") {
+    if (Number.isInteger(v)) return { intValue: String(v) };       // OTLP int is string-encoded
+    return { doubleValue: v };
+  }
+  if (Array.isArray(v)) {
+    return { arrayValue: { values: v.map(function (e) { return _encodeAttrValue(e); }).filter(Boolean) } };
+  }
+  if (t === "object") {
+    return { kvlistValue: { values: _encodeAttrs(v) } };
+  }
+  return { stringValue: String(v) };
+}
+
+function _encodeAttrs(obj) {
+  if (!obj || typeof obj !== "object") return [];
+  return Object.keys(obj).map(function (k) {
+    var encoded = _encodeAttrValue(obj[k]);
+    if (!encoded) return null;
+    return { key: k, value: encoded };
+  }).filter(Boolean);
+}
+
+function _resourceAttrs(cfg) {
+  var attrs = {};
+  if (cfg.serviceName)    attrs["service.name"]    = cfg.serviceName;
+  if (cfg.serviceVersion) attrs["service.version"] = cfg.serviceVersion;
+  if (cfg.resourceAttributes && typeof cfg.resourceAttributes === "object") {
+    Object.assign(attrs, cfg.resourceAttributes);
+  }
+  return attrs;
+}
+
+function _toLogRecord(record) {
+  var sev = SEVERITY[record.level] || SEVERITY.info;
+  // OTel timeUnixNano is a string (JSON can't safely represent 64-bit ints).
+  var nanos = String(BigInt(record.ts) * 1000000n);
+  var attrs = record.meta ? _encodeAttrs(record.meta) : [];
+  return {
+    timeUnixNano:     nanos,
+    observedTimeUnixNano: nanos,
+    severityNumber:   sev.number,
+    severityText:     sev.text,
+    body:             { stringValue: record.message == null ? "" : String(record.message) },
+    attributes:       attrs,
+  };
+}
+
+function _serializeBatch(records, cfg, scopeVersion) {
+  var resourceAttrs = _resourceAttrs(cfg);
+  return Buffer.from(JSON.stringify({
+    resourceLogs: [
+      {
+        resource: {
+          attributes: _encodeAttrs(resourceAttrs),
+        },
+        scopeLogs: [
+          {
+            scope: {
+              name:    cfg.scopeName,
+              version: scopeVersion,
+            },
+            logRecords: records.map(_toLogRecord),
+          },
+        ],
+      },
+    ],
+  }), "utf8");
+}
+
+function _post(url, body, headers, timeoutMs, allowedProtocols, allowInternal) {
+  return httpClient.request({
+    method:           "POST",
+    url:              url,
+    headers:          headers,
+    body:             body,
+    idleTimeoutMs:    timeoutMs,
+    maxResponseBytes: MAX_RESPONSE_BYTES,
+    errorClass:       LogStreamError,
+    allowedProtocols: allowedProtocols,
+    allowInternal:    allowInternal,
+  });
+}
+
+function create(config) {
+  if (!config || !config.url) throw _err("BAD_OPT", "log-stream otlp requires { url }");
+  var cfg = Object.assign({}, DEFAULTS, config);
+  var resolvedUrl = _resolveUrl(cfg.url);
+  // Validate URL shape + scheme at create time. Default HTTPS-only;
+  // operators with an internal cleartext OTel collector pass
+  // cfg.allowedProtocols (safeUrl.ALLOW_HTTP_ALL).
+  safeUrl.parse(resolvedUrl, {
+    allowedProtocols: cfg.allowedProtocols || safeUrl.ALLOW_HTTP_TLS,
+    errorClass:       LogStreamError,
+  });
+  var scopeVersion = cfg.scopeVersion || FRAMEWORK_VERSION;
+  var headers = Object.assign({
+    "Content-Type": "application/json",
+    "Accept":       "application/json",
+  }, _authHeaders(cfg));
+  var onDrop = typeof cfg.onDrop === "function" ? cfg.onDrop : null;
+  var _emitDrop = safeAsync.makeDropCallback(onDrop);
+  var buffer = [];
+  var dropCount = 0;
+  var inFlight = false;
+  var closed = false;
+  var flushScheduler = safeAsync.makeScheduledFlush(cfg.maxBatchAgeMs, function () { return _flush(); });
+
+  async function _flush() {
+    if (inFlight) return;
+    if (buffer.length === 0) return;
+    inFlight = true;
+    try {
+      while (buffer.length > 0 && !closed) {
+        var batch = buffer.splice(0, cfg.batchSize);
+        var body = _serializeBatch(batch, cfg, scopeVersion);
+        try {
+          await retryHelper.withRetry(function () {
+            return _post(resolvedUrl, body, headers, cfg.timeoutMs, cfg.allowedProtocols, cfg.allowInternal);
+          }, cfg.retry);
+        } catch (e) {
+          dropCount += batch.length;
+          _emitDrop("retry-exhausted", batch, e);
+          break;
+        }
+      }
+    } finally {
+      inFlight = false;
+      if (buffer.length > 0) flushScheduler.schedule();
+    }
+  }
+
+  function emit(record) {
+    if (closed) return Promise.resolve({ accepted: false, reason: "sink closed" });
+    if (buffer.length >= cfg.bufferLimit) {
+      var dropped = buffer.shift();
+      dropCount += 1;
+      _emitDrop("overflow", [dropped], null);
+    }
+    buffer.push(record);
+    if (buffer.length >= cfg.batchSize) {
+      _flush().catch(function () {});
+    } else {
+      flushScheduler.schedule();
+    }
+    return Promise.resolve({ accepted: true, queued: buffer.length });
+  }
+
+  async function close() {
+    closed = true;
+    flushScheduler.cancel();
+    await _flush();
+  }
+
+  function stats() {
+    return {
+      queued:   buffer.length,
+      dropped:  dropCount,
+      inFlight: inFlight,
+      url:      resolvedUrl,
+    };
+  }
+
+  return {
+    protocol: "otlp",
+    emit:     emit,
+    close:    close,
+    stats:    stats,
+    flush:    _flush,
+  };
+}
+
+module.exports = {
+  create:       create,
+  // Exposed for tests + advanced operator wiring.
+  _resolveUrl:  _resolveUrl,
+  _encodeAttrs: _encodeAttrs,
+  _toLogRecord: _toLogRecord,
+  SEVERITY:     SEVERITY,
+};

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

@@ -0,0 +1,310 @@
+"use strict";
+/**
+ * Syslog log-stream sink — RFC 5424 framing over UDP / TCP / TLS.
+ *
+ * Wire format (RFC 5424 §6):
+ *   <PRI>VERSION SP TIMESTAMP SP HOSTNAME SP APP-NAME SP PROCID SP MSGID SP STRUCTURED-DATA SP MSG
+ *
+ *   PRI    = (facility * 8) + severity
+ *   facility (default 16 = local0; 1 = user — operators commonly pick
+ *            local0..local7 for app-emitted records)
+ *   severity is mapped from the framework's level field:
+ *     debug → 7, info → 6, warn → 4, error → 3
+ *
+ * Transport:
+ *   udp                — single datagram per record (no framing)
+ *   tcp                — octet-counting framing (RFC 6587 §3.4.1):
+ *                        "<length> <message>" with a SPACE between
+ *                        length and the rfc5424 message bytes
+ *   tls                — same octet-counting framing on a TLS socket
+ *                        (RFC 5425). Standard port 6514.
+ *
+ * Defaults match RFC 3164/5424 conventions: appName = "blamejs",
+ * facility = local0 (16), hostname = os.hostname(), structuredData = "-".
+ *
+ * Flow control:
+ *   The TCP / TLS variants buffer pending writes during socket
+ *   reconnect and replay them on the new connection. UDP is best-effort
+ *   (datagrams that race a closed socket are dropped to onDrop).
+ */
+var dgram = require("node:dgram");
+var net   = require("node:net");
+var os    = require("node:os");
+var nodeTls   = require("node:tls");
+var C = require("./constants");
+var { boot } = require("./log");
+var safeAsync = require("./safe-async");
+var safeBuffer = require("./safe-buffer");
+var safeUrl = require("./safe-url");
+var { LogStreamError } = require("./framework-error");
+
+var _err = LogStreamError.factory;
+var log  = boot("log-stream-syslog");
+
+// RFC 5424 facility codes (0-23). 0x10 = 16 = local0 — the
+// conventional facility for app-emitted records.
+var DEFAULT_FACILITY    = 0x10;
+var DEFAULT_APP_NAME    = "blamejs";
+var DEFAULT_PROC_ID     = String(process.pid);
+var DEFAULT_MSG_ID      = "-";
+var DEFAULT_STRUCT_DATA = "-";
+var TCP_DEFAULT_PORT    = 514;
+var TLS_DEFAULT_PORT    = 6514;
+var UDP_DEFAULT_PORT    = 514;
+var DEFAULT_TIMEOUT_MS  = C.TIME.seconds(10);
+var DEFAULT_RECONNECT_BASE_MS = 250;
+var DEFAULT_RECONNECT_MAX_MS  = C.TIME.seconds(30);
+var DEFAULT_BUFFER_LIMIT = C.BYTES.bytes(10000);
+
+// RFC 5424 severity codes from the framework's level names.
+var LEVEL_TO_SEVERITY = {
+  debug: 7,
+  info:  6,
+  warn:  4,
+  error: 3,
+};
+
+function _toRfc3339(tsMs) {
+  return new Date(tsMs).toISOString();
+}
+
+function _formatRfc5424(record, cfg) {
+  var severity = LEVEL_TO_SEVERITY[record.level] != null
+    ? LEVEL_TO_SEVERITY[record.level] : 6;
+  // RFC 5424 §6.2.1: PRI = facility << 3 | severity (severity is 3 bits).
+  var pri = (cfg.facility << 3) + severity;
+  var ts  = _toRfc3339(record.ts || Date.now());
+  // Body — JSON-encode meta + message together so the structured
+  // payload survives the wire as a single MSG token. Operators with
+  // their own RFC 5424 STRUCTURED-DATA producers pass cfg.structuredData
+  // (string) to override the default "-".
+  var body = record.message || "";
+  if (record.meta && Object.keys(record.meta).length > 0) {
+    try { body += " " + JSON.stringify(record.meta); }
+    catch (_e) { /* best-effort */ }
+  }
+  // Strip CR / LF from MSG content. RFC 5424 §6.4 requires PRINTUSASCII
+  // / UTF-8 with no embedded control chars in MSG. Without this, an
+  // operator-controlled record.message containing `\n<14>1 2026-...`
+  // produces a fake separate-priority record on a SIEM that splits on
+  // newlines (rsyslog with omfile does). Replace with U+2424 (SYMBOL
+  // FOR NEWLINE) so the operator can still see the intent.
+  body = safeBuffer.stripCrlf(String(body), "␤");
+  return "<" + pri + ">1 " + ts + " " + cfg.hostname + " " +
+         cfg.appName + " " + cfg.procId + " " + cfg.msgId + " " +
+         (cfg.structuredData || "-") + " " + body;
+}
+
+function create(config) {
+  if (!config) throw _err("BAD_OPT", "log-stream syslog requires { url } (e.g. udp://host:514, tcp://host:514, tls://host:6514)");
+  var url = config.url;
+  if (typeof url !== "string" || url.length === 0) {
+    throw _err("BAD_OPT", "log-stream syslog requires { url } (string)");
+  }
+  // Parse URL — accept udp://, tcp://, tls:// only.
+  var parsed;
+  try {
+    parsed = safeUrl.parse(url, {
+      allowedProtocols: ["udp:", "tcp:", "tls:"],
+      errorClass:       LogStreamError,
+    });
+  } catch (e) {
+    throw _err("BAD_URL", "log-stream syslog: bad url '" + url + "': " +
+      ((e && e.message) || String(e)));
+  }
+  var transport = parsed.protocol.replace(/:$/, "").toLowerCase();
+  var defaultPort = transport === "tls" ? TLS_DEFAULT_PORT
+                  : transport === "tcp" ? TCP_DEFAULT_PORT
+                  : UDP_DEFAULT_PORT;
+  var host = parsed.hostname;
+  var port = parsed.port ? parseInt(parsed.port, 10) : defaultPort;
+
+  var cfg = {
+    transport:        transport,
+    host:             host,
+    port:             port,
+    facility:         (typeof config.facility === "number" && config.facility >= 0 && config.facility <= 23)
+                        ? Math.floor(config.facility) : DEFAULT_FACILITY,
+    appName:          config.appName || DEFAULT_APP_NAME,
+    procId:           config.procId  || DEFAULT_PROC_ID,
+    msgId:            config.msgId   || DEFAULT_MSG_ID,
+    hostname:         config.hostname || os.hostname(),
+    structuredData:   config.structuredData || DEFAULT_STRUCT_DATA,
+    timeoutMs:        config.timeoutMs || DEFAULT_TIMEOUT_MS,
+    bufferLimit:      config.bufferLimit || DEFAULT_BUFFER_LIMIT,
+    reconnectBaseMs:  config.reconnectBaseMs || DEFAULT_RECONNECT_BASE_MS,
+    reconnectMaxMs:   config.reconnectMaxMs  || DEFAULT_RECONNECT_MAX_MS,
+    ca:               config.ca || null,
+    rejectUnauthorized: config.rejectUnauthorized !== false,
+    servername:       config.servername || null,
+  };
+  // safeUrl-style guard for the URL — reject userinfo (no auth in
+  // syslog wire) so a stray "syslog://user:pw@host" doesn't silently
+  // get through.
+  if (parsed.username || parsed.password) {
+    throw _err("BAD_URL",
+      "log-stream syslog: url must not contain userinfo");
+  }
+  // Track the operator's onDrop so dropped events surface.
+  var onDrop = typeof config.onDrop === "function" ? config.onDrop : null;
+  var _emitDrop = safeAsync.makeDropCallback(onDrop,
+    function (e) { log.warn("onDrop-callback-failed: " + e.message); });
+
+  // ---- UDP transport ----
+  if (transport === "udp") {
+    var udpFamily = host.indexOf(":") !== -1 ? "udp6" : "udp4";
+    var udpSock = dgram.createSocket(udpFamily);
+    udpSock.unref && udpSock.unref();
+    var udpClosed = false;
+    udpSock.on("error", function () { /* non-fatal — datagrams race */ });
+
+    return {
+      protocol: "syslog-udp",
+      emit: function (record) {
+        if (udpClosed) {
+          _emitDrop("sink-closed", [record], null);
+          return Promise.resolve({ accepted: false, reason: "closed" });
+        }
+        var msg = _formatRfc5424(record, cfg);
+        var buf = Buffer.from(msg, "utf8");
+        return new Promise(function (resolve) {
+          udpSock.send(buf, 0, buf.length, cfg.port, cfg.host, function (err) {
+            if (err) _emitDrop("udp-send-error", [record], err);
+            resolve({ accepted: !err, queued: 0 });
+          });
+        });
+      },
+      close: function () {
+        udpClosed = true;
+        try { udpSock.close(); }
+        catch (e) { log.warn("udp-close-failed: " + e.message); }
+        return Promise.resolve();
+      },
+    };
+  }
+
+  // ---- TCP / TLS transport — octet-counting framing (RFC 6587) ----
+  // Buffer outgoing records during socket-down windows; replay on
+  // reconnect. Operator opts: bufferLimit caps the queue; oldest
+  // dropped first with the onDrop "overflow" reason.
+  var sock = null;
+  var sockReady = false;
+  var connecting = false;
+  var queue = [];
+  var closed = false;
+  var reconnectAttempt = 0;
+
+  function _writeFramed(record) {
+    var msg = _formatRfc5424(record, cfg);
+    var msgBuf = Buffer.from(msg, "utf8");
+    var prefix = Buffer.from(msgBuf.length + " ", "utf8");
+    sock.write(Buffer.concat([prefix, msgBuf]));
+  }
+
+  function _connect() {
+    if (closed || connecting) return;
+    connecting = true;
+    sockReady = false;
+    var connectOpts = { host: cfg.host, port: cfg.port };
+    var onConnect = function () {
+      connecting = false;
+      sockReady = true;
+      reconnectAttempt = 0;
+      // Drain queue in arrival order on (re)connect.
+      while (queue.length > 0 && sockReady) {
+        try { _writeFramed(queue.shift()); }
+        catch (e) { _emitDrop("write-error", [/* drained */], e); break; }
+      }
+    };
+    if (transport === "tls") {
+      var tlsOpts = Object.assign({}, connectOpts, {
+        rejectUnauthorized: cfg.rejectUnauthorized,
+        minVersion:         "TLSv1.3",
+      });
+      if (cfg.ca) tlsOpts.ca = cfg.ca;
+      if (cfg.servername) tlsOpts.servername = cfg.servername;
+      sock = nodeTls.connect(tlsOpts, onConnect);
+    } else {
+      sock = net.connect(connectOpts, onConnect);
+    }
+    sock.unref && sock.unref();
+    sock.on("error", function () { /* reconnect handled in the close listener */ });
+    sock.on("close", function () {
+      sockReady = false;
+      connecting = false;
+      try { sock.destroy(); }
+      catch (e) { log.warn("sock-destroy-failed: " + e.message); }
+      sock = null;
+      if (closed) return;
+      reconnectAttempt += 1;
+      var delay = Math.min(cfg.reconnectMaxMs,
+        cfg.reconnectBaseMs * Math.pow(2, reconnectAttempt - 1));
+      var t = setTimeout(_connect, delay);
+      t.unref && t.unref();
+    });
+  }
+  _connect();
+
+  return {
+    protocol: "syslog-" + transport,
+    emit: function (record) {
+      if (closed) {
+        _emitDrop("sink-closed", [record], null);
+        return Promise.resolve({ accepted: false, reason: "closed" });
+      }
+      if (sockReady) {
+        try { _writeFramed(record); }
+        catch (e) {
+          _emitDrop("write-error", [record], e);
+          return Promise.resolve({ accepted: false, reason: "write-error" });
+        }
+        return Promise.resolve({ accepted: true, queued: 0 });
+      }
+      // Socket not yet up — buffer with overflow-by-oldest semantics.
+      if (queue.length >= cfg.bufferLimit) {
+        var dropped = queue.shift();
+        _emitDrop("overflow", [dropped], null);
+      }
+      queue.push(record);
+      return Promise.resolve({ accepted: true, queued: queue.length });
+    },
+    close: function () {
+      // Give an in-flight (re)connect a brief window to complete and
+      // drain the buffer. Without this, records emitted just before
+      // shutdown race the slower TLS handshake and surface as
+      // "sink-closed" drops even though the framework had a viable
+      // connection in progress.
+      var DRAIN_TIMEOUT_MS = C.TIME.seconds(3);
+      var started = Date.now();
+      return new Promise(function (resolve) {
+        function _finish() {
+          closed = true;
+          var pending = queue.splice(0, queue.length);
+          if (pending.length > 0) _emitDrop("sink-closed", pending, null);
+          try { if (sock) sock.end(); }
+          catch (e) { log.warn("sock-end-failed: " + e.message); }
+          try { if (sock) sock.destroy(); }
+          catch (e) { log.warn("sock-destroy-failed: " + e.message); }
+          sock = null;
+          resolve();
+        }
+        function _tick() {
+          if (queue.length === 0 || Date.now() - started > DRAIN_TIMEOUT_MS) {
+            return _finish();
+          }
+          // Keep the timer ref'd — close() is being awaited; if we
+          // unref the drain-tick timer the event loop can exit between
+          // ticks (UDP/TCP socket are also unref'd) and the close
+          // promise pends forever silently.
+          setTimeout(_tick, 25);
+        }
+        _tick();
+      });
+    },
+    // Test-only: returns the in-flight queue size for assertions.
+    _queueSizeForTest: function () { return queue.length; },
+    _formatRfc5424ForTest: function (rec) { return _formatRfc5424(rec, cfg); },
+  };
+}
+
+module.exports = { create: create };