@steve31415/baselib 3.36.2 → 3.37.0

package/dist/log-browser.js

@@ -88,7 +88,7 @@ export function createBrowserLogger(opts = {}) {
             // keeping are often the ones an offline stretch causes: while the
             // browser reports itself offline, failed attempts don't count, so a
             // batch waits out the outage (until the page dies or the buffer cap
-            // evicts it) instead of being dropped after ~60 s.
+            // evicts it) instead of being dropped after its 6 attempts (~5 min).
             isOffline: () => navigator.onLine === false,
             onGiveUp: (batch, error, reason) => console.warn(`log ship dropped a batch (${reason}): ${String(error)}`, {
                 batch_id: batch.id,

package/dist/log-core.d.ts

@@ -54,13 +54,16 @@ export interface ShipperOptions {
     token: string;
     batchSize?: number;
     intervalMs?: number;
-    /** Total delivery attempts per batch (default 4). */
+    /** Total delivery attempts per batch (default 6; see DEFAULT_RETRY_DELAYS_MS). */
     maxAttempts?: number;
-    /** Backoff before attempt 2, 3, … (default [5s, 15s, 40s]). On an idle
-     *  Cloud Run instance the CPU is throttled between requests, so these
+    /** Backoff before attempt 2, 3, … (default DEFAULT_RETRY_DELAYS_MS). On an
+     *  idle Cloud Run instance the CPU is throttled between requests, so these
      *  fire at the next CPU window (next request or shutdown), not on the
-     *  wall clock. */
+     *  wall clock — which only stretches the budget. */
     retryDelaysMs?: number[];
+    /** While isOffline() is true, how long a batch waits before its next
+     *  (uncounted) attempt (default 40 s). */
+    offlineRetryMs?: number;
     /** Per-attempt fetch timeout (default 10s; 3s aborted most of the fleet's
      *  attempts in the two weeks to 2026-08-28). */
     attemptTimeoutMs?: number;
@@ -74,8 +77,8 @@ export interface ShipperOptions {
     /** True while the platform knows it has no network (the browser passes
      *  `navigator.onLine === false`). A failed attempt made while offline says
      *  nothing about the batch or the ingest service, so it is not counted
-     *  toward maxAttempts and not reported: the batch waits and retries at the
-     *  longest backoff delay, or at once on resume(). The signal only decides
+     *  toward maxAttempts and not reported: the batch waits and retries after
+     *  offlineRetryMs, or at once on resume(). The signal only decides
      *  what a failure means — attempts still run while "offline". */
     isOffline?: () => boolean;
     /** A delivery attempt failed; the batch will be retried. */
@@ -86,6 +89,21 @@ export interface ShipperOptions {
      *  keep, listed in `failures`. Those events are lost; the rest landed. */
     onPartialFailure?: (batch: ShippedBatch, failed: number, failures: unknown[]) => void;
 }
+/** The default retry budget: 6 attempts with 5 + 15 + 40 + 90 + 150 s =
+ *  5 minutes of backoff between the first and the last.
+ *
+ *  Deliberate choice, 2026-10-15 (watchdog task dc78e9b2): the earlier
+ *  4 attempts over 5 + 15 + 40 s (~60 s) dropped a mirror batch on
+ *  2026-10-14, when Axiom ingest answered 503 on and off for ~150 s — 2.5×
+ *  the budget — the only ingest outage in the 4 weeks of markers on record.
+ *  5 minutes covers that episode twice over. Headroom: at the fleet's peak
+ *  five-minute volume (mirror, 1 538 events, ~0.3 MB, 2026-10-08..15) the
+ *  events held through a 5-minute outage fill ~31% of the 5 000-event /
+ *  5 MB buffer cap, so the cap, not the attempt count, bounds a longer
+ *  outage. Longer delays cost nothing on a throttled instance (they ride the
+ *  next CPU window either way) and only matter while ingest is failing. */
+export declare const DEFAULT_MAX_ATTEMPTS = 6;
+export declare const DEFAULT_RETRY_DELAYS_MS: readonly number[];
 export declare class LogShipper {
     private readonly opts;
     private queue;
@@ -102,6 +120,7 @@ export declare class LogShipper {
     private readonly intervalMs;
     private readonly maxAttempts;
     private readonly retryDelaysMs;
+    private readonly offlineRetryMs;
     private readonly attemptTimeoutMs;
     private readonly maxBufferedEvents;
     private readonly maxBufferedBytes;

package/dist/log-core.js

@@ -45,6 +45,21 @@ export function serializeError(err) {
 export function truncate(s, max) {
     return s.length <= max ? s : s.slice(0, max) + `…[+${s.length - max}]`;
 }
+/** The default retry budget: 6 attempts with 5 + 15 + 40 + 90 + 150 s =
+ *  5 minutes of backoff between the first and the last.
+ *
+ *  Deliberate choice, 2026-10-15 (watchdog task dc78e9b2): the earlier
+ *  4 attempts over 5 + 15 + 40 s (~60 s) dropped a mirror batch on
+ *  2026-10-14, when Axiom ingest answered 503 on and off for ~150 s — 2.5×
+ *  the budget — the only ingest outage in the 4 weeks of markers on record.
+ *  5 minutes covers that episode twice over. Headroom: at the fleet's peak
+ *  five-minute volume (mirror, 1 538 events, ~0.3 MB, 2026-10-08..15) the
+ *  events held through a 5-minute outage fill ~31% of the 5 000-event /
+ *  5 MB buffer cap, so the cap, not the attempt count, bounds a longer
+ *  outage. Longer delays cost nothing on a throttled instance (they ride the
+ *  next CPU window either way) and only matter while ingest is failing. */
+export const DEFAULT_MAX_ATTEMPTS = 6;
+export const DEFAULT_RETRY_DELAYS_MS = [5_000, 15_000, 40_000, 90_000, 150_000];
 const RESPONSE_BODY_MAX = 300;
 /** A 4xx is a verdict on the bytes, not the moment: retrying the identical
  *  body cannot succeed. 408 (timeout) and 429 (rate limit) are the exceptions. */
@@ -88,6 +103,7 @@ export class LogShipper {
     intervalMs;
     maxAttempts;
     retryDelaysMs;
+    offlineRetryMs;
     attemptTimeoutMs;
     maxBufferedEvents;
     maxBufferedBytes;
@@ -95,8 +111,9 @@ export class LogShipper {
         this.opts = opts;
         this.batchSize = opts.batchSize ?? 50;
         this.intervalMs = opts.intervalMs ?? 2000;
-        this.maxAttempts = opts.maxAttempts ?? 4;
-        this.retryDelaysMs = opts.retryDelaysMs ?? [5_000, 15_000, 40_000];
+        this.maxAttempts = opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+        this.retryDelaysMs = opts.retryDelaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+        this.offlineRetryMs = opts.offlineRetryMs ?? 40_000;
         this.attemptTimeoutMs = opts.attemptTimeoutMs ?? 10_000;
         this.maxBufferedEvents = opts.maxBufferedEvents ?? 5_000;
         this.maxBufferedBytes = opts.maxBufferedBytes ?? 5 * 1024 * 1024;
@@ -259,7 +276,7 @@ export class LogShipper {
             if (!outcome.ok && !outcome.terminal && this.opts.isOffline?.()) {
                 // Uncounted: the budget is for failures that could be the batch's
                 // or the service's, and an offline failure is neither.
-                batch.nextAttemptAt = Date.now() + this.retryDelaysMs[this.retryDelaysMs.length - 1];
+                batch.nextAttemptAt = Date.now() + this.offlineRetryMs;
                 this.schedulePump();
                 return;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "3.36.2",
+  "version": "3.37.0",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",