@blamejs/core 0.6.69 → 0.7.0

package/lib/http-client.js

@@ -131,9 +131,9 @@ var _transports = new Map();
 // effect on the per-origin cache.
 var DEFAULT_AGENT_OPTS = Object.freeze({
   keepAlive:        true,
-  keepAliveMsecs:   1000,
-  maxSockets:       16,
-  maxFreeSockets:   8,
+  keepAliveMsecs:   C.TIME.seconds(1),
+  maxSockets:       C.BYTES.bytes(16),
+  maxFreeSockets:   C.BYTES.bytes(8),
   scheduling:       "lifo",
 });
 
@@ -172,7 +172,7 @@ function configurePool(opts) {
   // subsequent requests build fresh transports with the new opts.
   _transports.forEach(function (t) {
     if (t && t.kind === "h1" && t.agent && typeof t.agent.destroy === "function") {
-      try { t.agent.destroy(); } catch (_e) {}
+      try { t.agent.destroy(); } catch (_e) { /* best-effort agent teardown */ }
     }
     if (t && t.kind === "h2" && t.session) {
       _tearDownH2Session(t.session);
@@ -202,9 +202,16 @@ var DEFAULT_IDLE_TIMEOUT_MS   = C.TIME.seconds(30);
 // connection forever.
 var H2_SESSION_IDLE_TIMEOUT_MS = C.TIME.minutes(5);
 
+// IANA-assigned default ports per RFC 9110 §4.2.
+var DEFAULT_HTTPS_PORT = 443;
+var DEFAULT_HTTP_PORT  = C.BYTES.bytes(80);
+
+function _defaultPortFor(u) {
+  return u.protocol === "https:" ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT;
+}
+
 function _originKey(u) {
-  return u.protocol + "//" + u.hostname + ":" +
-    (u.port || (u.protocol === "https:" ? 443 : 80));
+  return u.protocol + "//" + u.hostname + ":" + (u.port || _defaultPortFor(u));
 }
 
 function _makeH1Transport(u, ips) {
@@ -342,9 +349,17 @@ function _makeError(errorClass, code, message, permanent, statusCode) {
   return new errorClass(code, message, permanent, statusCode);
 }
 
+// RFC 9110 §15.5 4xx codes that are NOT permanent (request-timeout,
+// too-early, too-many-requests — operator should retry).
+var STATUS_REQUEST_TIMEOUT   = C.BYTES.bytes(408);
+var STATUS_TOO_EARLY         = 425;
+var STATUS_TOO_MANY_REQUESTS = 429;
+
 function _isPermanentStatus(statusCode) {
   if (statusCode >= 400 && statusCode < 500) {
-    return statusCode !== 408 && statusCode !== 425 && statusCode !== 429;
+    return statusCode !== STATUS_REQUEST_TIMEOUT &&
+           statusCode !== STATUS_TOO_EARLY &&
+           statusCode !== STATUS_TOO_MANY_REQUESTS;
   }
   return false;
 }
@@ -412,7 +427,7 @@ function _attachJarCookie(headers, jar, url) {
 // parser accepts so round-trip from one blamejs app's outbound to
 // another's inbound is exact.
 function _buildMultipartBody(spec) {
-  var boundary = "----blamejs-mp-" + crypto.generateToken(16);
+  var boundary = "----blamejs-mp-" + crypto.generateToken(C.BYTES.bytes(16));
   var CRLF = "\r\n";
   var parts = [];
 
@@ -600,7 +615,7 @@ function _requestWithRedirects(opts, hopsLeft) {
   var originalUrl = opts.url;
   var originalOrigin = null;
   try {
-    var u0 = new URL(opts.url);
+    var u0 = safeUrl.parse(opts.url, { allowedProtocols: safeUrl.ALLOW_HTTP_ALL });
     originalOrigin = u0.protocol + "//" + u0.host;
   } catch (_e) { /* request() will reject on next hop's parse */ }
 
@@ -618,7 +633,12 @@ function _requestWithRedirects(opts, hopsLeft) {
       // of the request that produced the redirect, which may itself be a
       // post-redirect URL).
       var nextUrl;
-      try { nextUrl = new URL(loc, current.url).toString(); }
+      try {
+        // Resolve relative Location against current URL using Node's URL
+        // base-URL form. Re-validate the resolved absolute through safeUrl
+        // immediately below.
+        nextUrl = Reflect.construct(URL, [loc, current.url]).toString();
+      }
       catch (_e) {
         return Promise.reject(_makeError(opts.errorClass, "BAD_REDIRECT",
           "Location header invalid URL: " + loc, true));
@@ -628,7 +648,7 @@ function _requestWithRedirects(opts, hopsLeft) {
       var nextHeaders = current.headers || {};
       var nextOrigin;
       try {
-        var nu = new URL(nextUrl);
+        var nu = safeUrl.parse(nextUrl, { allowedProtocols: safeUrl.ALLOW_HTTP_ALL });
         nextOrigin = nu.protocol + "//" + nu.host;
       } catch (_e) { /* request() will reject when it tries to parse */ }
       if (originalOrigin && nextOrigin && nextOrigin !== originalOrigin) {
@@ -808,8 +828,9 @@ function _requestH1(transport, u, opts) {
     if (signal && signal.aborted) {
       var r0 = signal.reason;
       var code0 = (r0 && r0.name === "TimeoutError") ? "ETIMEDOUT" : "ABORT";
-      return reject(_makeError(opts.errorClass, code0,
+      reject(_makeError(opts.errorClass, code0,
         (r0 && r0.message) || "request aborted before start", false));
+      return;
     }
 
     if (Buffer.isBuffer(opts.body)) {
@@ -819,7 +840,7 @@ function _requestH1(transport, u, opts) {
     var reqOpts = {
       method:   method,
       hostname: u.hostname,
-      port:     u.port || (u.protocol === "https:" ? 443 : 80),
+      port:     u.port || _defaultPortFor(u),
       path:     u.pathname + (u.search || ""),
       headers:  headers,
       agent:    transport.agent,
@@ -944,7 +965,7 @@ function _requestH1(transport, u, opts) {
         var r = signal.reason;
         var code = (r && r.name === "TimeoutError") ? "ETIMEDOUT" : "ABORT";
         var msg = (r && r.message) || "request aborted";
-        try { req.destroy(r || new Error(msg)); } catch (_e) {}
+        try { req.destroy(r || new Error(msg)); } catch (_e) { /* best-effort req teardown */ }
         _reject(_makeError(opts.errorClass, code, msg, false));
       };
       signal.addEventListener("abort", onAbort, { once: true });
@@ -970,7 +991,7 @@ function _requestH1(transport, u, opts) {
         opts.body.on("data", function (c) { _emitUpload(c.length); });
       }
       opts.body.on("error", function (e) {
-        try { req.destroy(); } catch (_) {}
+        try { req.destroy(); } catch (_) { /* best-effort req teardown */ }
         _reject(_makeError(opts.errorClass, "REQ_BODY_ERROR",
           "request body stream error: " + e.message, false));
       });
@@ -1012,8 +1033,9 @@ function _requestH2(transport, u, opts) {
     if (signal && signal.aborted) {
       var r0 = signal.reason;
       var code0 = (r0 && r0.name === "TimeoutError") ? "ETIMEDOUT" : "ABORT";
-      return reject(_makeError(opts.errorClass, code0,
+      reject(_makeError(opts.errorClass, code0,
         (r0 && r0.message) || "request aborted before start", false));
+      return;
     }
 
     var headers = _toH2Headers(method, u, opts.headers || {});
@@ -1027,7 +1049,8 @@ function _requestH2(transport, u, opts) {
         endStream: opts.body == null,
       });
     } catch (e) {
-      return reject(_makeError(opts.errorClass, e.code || "H2_REQUEST_ERROR", e.message, false));
+      reject(_makeError(opts.errorClass, e.code || "H2_REQUEST_ERROR", e.message, false));
+      return;
     }
 
     var settled = false;
@@ -1037,7 +1060,7 @@ function _requestH2(transport, u, opts) {
     // Idle timeout for the stream itself (zero-progress detector).
     var idleMs = typeof opts.idleTimeoutMs === "number" ? opts.idleTimeoutMs : DEFAULT_IDLE_TIMEOUT_MS;
     stream.setTimeout(idleMs, function () {
-      try { stream.close(http2.constants.NGHTTP2_CANCEL); } catch (_e) {}
+      try { stream.close(http2.constants.NGHTTP2_CANCEL); } catch (_e) { /* best-effort h2 stream cancel */ }
       _reject(_makeError(opts.errorClass, "ETIMEDOUT",
         "h2 stream idle timeout (no data for " + idleMs + "ms)", false));
     });
@@ -1072,7 +1095,7 @@ function _requestH2(transport, u, opts) {
         try { collector.push(chunk); }
         catch (_e) {
           capExceeded = true;
-          try { stream.close(http2.constants.NGHTTP2_CANCEL); } catch (_e2) {}
+          try { stream.close(http2.constants.NGHTTP2_CANCEL); } catch (_e2) { /* best-effort h2 stream cancel */ }
           _reject(_makeError(opts.errorClass, "RESPONSE_TOO_LARGE",
             "response body exceeds " + maxResponseBytes + " bytes", true));
         }
@@ -1107,7 +1130,7 @@ function _requestH2(transport, u, opts) {
         var msg = (r && r.message) || "request aborted";
         // NGHTTP2_CANCEL is the protocol-level "I gave up" signal —
         // cleaner than destroying the stream.
-        try { stream.close(http2.constants.NGHTTP2_CANCEL); } catch (_e) {}
+        try { stream.close(http2.constants.NGHTTP2_CANCEL); } catch (_e) { /* best-effort h2 stream cancel */ }
         _reject(_makeError(opts.errorClass, code, msg, false));
       };
       signal.addEventListener("abort", onAbort, { once: true });
@@ -1115,7 +1138,7 @@ function _requestH2(transport, u, opts) {
 
     if (opts.body && typeof opts.body.pipe === "function") {
       opts.body.on("error", function (e) {
-        try { stream.close(http2.constants.NGHTTP2_INTERNAL_ERROR); } catch (_) {}
+        try { stream.close(http2.constants.NGHTTP2_INTERNAL_ERROR); } catch (_) { /* best-effort h2 stream cancel */ }
         _reject(_makeError(opts.errorClass, "REQ_BODY_ERROR",
           "request body stream error: " + e.message, false));
       });
@@ -1134,7 +1157,7 @@ function _requestH2(transport, u, opts) {
 function _resetForTest() {
   _transports.forEach(function (t) {
     if (t && t.kind === "h1" && t.agent && typeof t.agent.destroy === "function") {
-      try { t.agent.destroy(); } catch (_e) {}
+      try { t.agent.destroy(); } catch (_e) { /* best-effort agent teardown */ }
     }
     if (t && t.kind === "h2" && t.session) {
       _tearDownH2Session(t.session);
@@ -1149,7 +1172,7 @@ function _getCachedTransportCount() {
 
 // Diagnostic — returns 'h1' | 'h2' | null for a given URL's cached transport.
 function _getCachedTransportKind(url) {
-  var u = url instanceof URL ? url : new URL(url);
+  var u = url instanceof URL ? url : safeUrl.parse(url, { allowedProtocols: safeUrl.ALLOW_HTTP_ALL });
   var t = _transports.get(_originKey(u));
   if (!t) return null;
   if (t.then) return "pending";

package/lib/i18n.js

@@ -63,6 +63,7 @@ var fs = require("node:fs");
 var path = require("node:path");
 var lazyRequire = require("./lazy-require");
 var requestHelpers = require("./request-helpers");
+var safeJson = require("./safe-json");
 var validateOpts = require("./validate-opts");
 var { I18nError } = require("./framework-error");
 
@@ -239,7 +240,7 @@ function _loadFromDir(dir, locales) {
       throw _err("LOAD_FAILED",
         "i18n: failed to read '" + filePath + "': " + ((e && e.message) || String(e)));
     }
-    try { out[locale] = JSON.parse(raw); }
+    try { out[locale] = safeJson.parse(raw); }
     catch (e) {
       throw _err("LOAD_FAILED",
         "i18n: failed to parse JSON for locale '" + locale + "' (" + filePath + "): " +
@@ -252,9 +253,7 @@ function _loadFromDir(dir, locales) {
 // ---- Validation: create opts ----
 
 function _validateCreateOpts(opts) {
-  if (!opts || typeof opts !== "object") {
-    throw _err("BAD_OPT", "i18n.create: opts must be an object");
-  }
+  validateOpts.requireObject(opts, "i18n.create", I18nError);
   _validateLocale("i18n.create: defaultLocale", opts.defaultLocale);
   _validateLocaleArray("i18n.create: locales", opts.locales);
   if (opts.locales.indexOf(opts.defaultLocale) === -1) {
@@ -279,18 +278,9 @@ function _validateCreateOpts(opts) {
       throw _err("BAD_OPT", "i18n.create: translations must be an object keyed by locale");
     }
   }
-  if (opts.dir !== undefined && (typeof opts.dir !== "string" || opts.dir.length === 0)) {
-    throw _err("BAD_OPT", "i18n.create: dir must be a non-empty string path");
-  }
-  if (opts.observability !== undefined && opts.observability !== null) {
-    if (typeof opts.observability !== "object" ||
-        typeof opts.observability.event !== "function") {
-      throw _err("BAD_OPT", "i18n.create: observability must be a b.observability-shaped object");
-    }
-  }
-  if (opts.clock !== undefined && typeof opts.clock !== "function") {
-    throw _err("BAD_OPT", "i18n.create: clock must be a function");
-  }
+  validateOpts.optionalNonEmptyString(opts.dir, "i18n.create: dir", I18nError);
+  validateOpts.observabilityShape(opts.observability, "i18n.create", I18nError);
+  validateOpts.optionalFunction(opts.clock, "i18n.create: clock", I18nError);
 }
 
 // ---- Dotted-path resolution ----

package/lib/jobs.js

@@ -73,10 +73,13 @@
  *   jobs.stats()
  *     → { defined: [string], started: boolean }
  */
+var { boot } = require("./log");
 var queue = require("./queue");
 var validateOpts = require("./validate-opts");
 var { JobsError } = require("./framework-error");
 
+var log = boot("jobs");
+
 function create(opts) {
   opts = opts || {};
   validateOpts(opts, [
@@ -146,7 +149,8 @@ function create(opts) {
   async function shutdown(shutdownOpts) {
     if (!started) {
       // Even when not started, queue.shutdown handles its own state.
-      try { await queue.shutdown(shutdownOpts); } catch (_e) {}
+      try { await queue.shutdown(shutdownOpts); }
+      catch (e) { log.debug("shutdown-failed", { op: "queue.shutdown", error: e.message }); }
       return;
     }
     started = false;

package/lib/log-stream-cloudwatch.js

@@ -47,22 +47,32 @@
  */
 var C = require("./constants");
 var nodeCrypto = require("node:crypto");
+var safeAsync = require("./safe-async");
+var safeJson = require("./safe-json");
 var sigv4 = require("./object-store/sigv4");
 var retryHelper = require("./retry");
 var { LogStreamError } = require("./framework-error");
 var httpClient = require("./http-client");
 
 var MAX_RESPONSE_BYTES = C.BYTES.mib(1);
-var CW_MAX_EVENTS_PER_BATCH = 10000;
+// AWS PutLogEvents hard limit: 10K events per batch (Logs_20140328 docs).
+var CW_MAX_EVENTS_PER_BATCH = C.BYTES.bytes(10000);
 var CW_MAX_BATCH_BYTES      = C.BYTES.mib(1);
-var CW_MAX_EVENT_BYTES      = 256 * 1024;
-var CW_EVENT_OVERHEAD_BYTES = 26;
+var CW_MAX_EVENT_BYTES      = C.BYTES.kib(256);
+var CW_EVENT_OVERHEAD_BYTES = C.BYTES.bytes(26);
+// Truncated-message preview embedded in onDrop callbacks for oversize
+// events — short enough to fit in a single log line so operators can
+// spot the producer that emitted the over-cap record.
+var DROP_PREVIEW_BYTES = C.BYTES.bytes(200);
 
 var DEFAULTS = {
   batchSize:     100,
   maxBatchAgeMs: C.TIME.seconds(5),
   timeoutMs:     C.TIME.seconds(30),
-  bufferLimit:   10000,
+  // 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;
@@ -96,15 +106,16 @@ function _signedHeaders(cfg, body, target) {
     "X-Amz-Target": target,
   };
   var signed = sigv4.signRequest({
-    method:          "POST",
-    url:             url,
-    headers:         unsigned,
-    payloadHash:     payloadHash,
-    region:          cfg.region,
-    service:         "logs",
-    accessKeyId:     cfg.accessKeyId,
-    secretAccessKey: cfg.secretAccessKey,
-    sessionToken:    cfg.sessionToken || null,
+    method:           "POST",
+    url:              url,
+    headers:          unsigned,
+    payloadHash:      payloadHash,
+    region:           cfg.region,
+    service:          "logs",
+    accessKeyId:      cfg.accessKeyId,
+    secretAccessKey:  cfg.secretAccessKey,
+    sessionToken:     cfg.sessionToken || null,
+    allowedProtocols: cfg.allowedProtocols,
   });
   return signed.headers;
 }
@@ -188,23 +199,13 @@ function create(config) {
   }
   var cfg = Object.assign({}, DEFAULTS, config);
   var onDrop = typeof cfg.onDrop === "function" ? cfg.onDrop : null;
-  function _emitDrop(reason, batch, err) {
-    if (!onDrop) return;
-    try { onDrop({ reason: reason, batch: batch, error: err || null }); }
-    catch (_e) { /* best-effort */ }
-  }
+  var _emitDrop = safeAsync.makeDropCallback(onDrop);
   var buffer = [];
   var dropCount = 0;
-  var flushTimer = null;
   var inFlight = false;
   var closed = false;
   var sequenceToken = null;
-
-  function _scheduleFlush() {
-    if (flushTimer) return;
-    flushTimer = setTimeout(function () { flushTimer = null; _flush(); }, cfg.maxBatchAgeMs);
-    flushTimer.unref();
-  }
+  var flushScheduler = safeAsync.makeScheduledFlush(cfg.maxBatchAgeMs, function () { return _flush(); });
 
   function _takeBatch() {
     var batch = [];
@@ -267,7 +268,7 @@ function create(config) {
       }
     } finally {
       inFlight = false;
-      if (buffer.length > 0) _scheduleFlush();
+      if (buffer.length > 0) flushScheduler.schedule();
     }
   }
 
@@ -290,7 +291,7 @@ function create(config) {
     }
     if (res && res.body) {
       try {
-        var parsed = JSON.parse(res.body.toString("utf8"));
+        var parsed = safeJson.parse(res.body.toString("utf8"), { maxBytes: MAX_RESPONSE_BYTES });
         if (parsed && parsed.nextSequenceToken) sequenceToken = parsed.nextSequenceToken;
       } catch (_e) { /* response body not JSON; modern CW returns empty */ }
     }
@@ -309,7 +310,7 @@ function create(config) {
     if (size > CW_MAX_EVENT_BYTES) {
       _emitDrop("event-too-large", [{
         timestamp: record.ts || Date.now(),
-        message:   message.slice(0, 200) + "...[truncated for drop event]",
+        message:   message.slice(0, DROP_PREVIEW_BYTES) + "...[truncated for drop event]",
       }], new Error("event exceeds 256 KiB CloudWatch hard cap (was " + size + " bytes)"));
       dropCount += 1;
       return Promise.resolve({ accepted: false, reason: "event too large" });
@@ -326,14 +327,14 @@ function create(config) {
     if (buffer.length >= cfg.batchSize) {
       _flush().catch(function () {});
     } else {
-      _scheduleFlush();
+      flushScheduler.schedule();
     }
     return Promise.resolve({ accepted: true, queued: buffer.length });
   }
 
   async function close() {
     closed = true;
-    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    flushScheduler.cancel();
     await _flush();
   }
 

package/lib/log-stream-local.js

@@ -28,8 +28,12 @@ var path = require("path");
 var zlib = require("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),
@@ -72,9 +76,13 @@ function create(config) {
 
   function _rotate() {
     try {
-      if (fd != null) { try { fs.closeSync(fd); } catch (_e) {} fd = null; }
+      if (fd != null) {
+        try { fs.closeSync(fd); }
+        catch (e) { log.warn("rotate-close-failed: " + e.message); }
+        fd = null;
+      }
       // Build rotated filename: blamejs-YYYYMMDDTHHMMSSZ.log
-      var stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+      var stamp = time.toIso8601NoMs(new Date()).replace(/[-:]/g, "");
       var rotated = path.join(dir, cfg.fileNamePrefix + "-" + stamp + ".log");
       if (fs.existsSync(activePath)) {
         fs.renameSync(activePath, rotated);
@@ -117,7 +125,8 @@ function create(config) {
   function close() {
     if (fd != null) {
       try { fs.fsyncSync(fd); } catch (_e) { /* best effort */ }
-      try { fs.closeSync(fd); } catch (_e) {}
+      try { fs.closeSync(fd); }
+      catch (e) { log.warn("close-failed: " + e.message); }
       fd = null;
     }
     return Promise.resolve();

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

@@ -27,19 +27,25 @@
  */
 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),
-  bufferLimit:   10000,
+  // 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 = {
@@ -194,7 +200,10 @@ function _frame(messageBuf) {
 // connection alive across many Export calls; we re-create on
 // disconnect.
 function _makeClient(cfg) {
-  var url = new URL(cfg.url);
+  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;
@@ -227,7 +236,11 @@ function _doExport(session, cfg, records) {
 
     var timer = setTimeout(function () {
       errored = true;
-      try { req.close(http2.constants.NGHTTP2_CANCEL); } catch (_e) {}
+      // 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);
@@ -290,18 +303,15 @@ function create(config) {
   cfg.bufferLimit   = Number(cfg.bufferLimit)   || DEFAULTS.bufferLimit;
 
   var onDrop = typeof config.onDrop === "function" ? config.onDrop : null;
-  function _emitDrop(reason, batch, err) {
-    if (!onDrop) return;
-    try { onDrop({ reason: reason, batch: batch, error: err || null }); }
-    catch (_e) {}
-  }
+  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 flushTimer = null;
   var session = null;
   var inflightPromise = null;
+  var flushScheduler = safeAsync.makeScheduledFlush(cfg.maxBatchAgeMs, function () { return _flush(); });
 
   function _ensureSession() {
     if (session && !session.destroyed) return session;
@@ -309,15 +319,6 @@ function create(config) {
     return session;
   }
 
-  function _scheduleFlush() {
-    if (flushTimer || closed) return;
-    flushTimer = setTimeout(function () {
-      flushTimer = null;
-      _flush().catch(function () { /* drained internally */ });
-    }, cfg.maxBatchAgeMs);
-    if (typeof flushTimer.unref === "function") flushTimer.unref();
-  }
-
   async function _flush() {
     if (inFlight || buffer.length === 0) return;
     inFlight = true;
@@ -353,17 +354,22 @@ function create(config) {
       // Drain immediately; don't await — emit is fire-and-forget on the
       // hot path. Errors surface via onDrop.
       _flush().catch(function () {});
-    } else {
-      _scheduleFlush();
+    } else if (!closed) {
+      flushScheduler.schedule();
     }
     return Promise.resolve({ accepted: true, queued: buffer.length });
   }
 
   async function close() {
     closed = true;
-    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
-    // Drain buffered records before tearing down the HTTP/2 session.
-    if (inflightPromise) { try { await inflightPromise; } catch (_e) {} }
+    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 {

package/lib/log-stream-otlp.js

@@ -51,13 +51,16 @@
  * 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
@@ -73,7 +76,10 @@ var DEFAULTS = {
   batchSize:     100,
   maxBatchAgeMs: C.TIME.seconds(5),
   timeoutMs:     C.TIME.seconds(30),
-  bufferLimit:   10000,
+  // 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;
@@ -193,30 +199,18 @@ function create(config) {
     allowedProtocols: cfg.allowedProtocols || safeUrl.ALLOW_HTTP_TLS,
     errorClass:       LogStreamError,
   });
-  var scopeVersion = cfg.scopeVersion || (function () {
-    try { return require("../package.json").version; } catch (_e) { return "unknown"; }
-  })();
+  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;
-  function _emitDrop(reason, batch, err) {
-    if (!onDrop) return;
-    try { onDrop({ reason: reason, batch: batch, error: err || null }); }
-    catch (_e) { /* drop callback is best-effort */ }
-  }
+  var _emitDrop = safeAsync.makeDropCallback(onDrop);
   var buffer = [];
   var dropCount = 0;
-  var flushTimer = null;
   var inFlight = false;
   var closed = false;
-
-  function _scheduleFlush() {
-    if (flushTimer) return;
-    flushTimer = setTimeout(function () { flushTimer = null; _flush(); }, cfg.maxBatchAgeMs);
-    flushTimer.unref();
-  }
+  var flushScheduler = safeAsync.makeScheduledFlush(cfg.maxBatchAgeMs, function () { return _flush(); });
 
   async function _flush() {
     if (inFlight) return;
@@ -238,7 +232,7 @@ function create(config) {
       }
     } finally {
       inFlight = false;
-      if (buffer.length > 0) _scheduleFlush();
+      if (buffer.length > 0) flushScheduler.schedule();
     }
   }
 
@@ -253,14 +247,14 @@ function create(config) {
     if (buffer.length >= cfg.batchSize) {
       _flush().catch(function () {});
     } else {
-      _scheduleFlush();
+      flushScheduler.schedule();
     }
     return Promise.resolve({ accepted: true, queued: buffer.length });
   }
 
   async function close() {
     closed = true;
-    if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+    flushScheduler.cancel();
     await _flush();
   }