react-native-nitro-logger 0.1.0

package/lib/module/destinations/Batcher.js

@@ -0,0 +1,647 @@
+"use strict";
+
+import { utf8Length } from "../utf8.js";
+
+/**
+ * The part of a `FileSink` the batcher drives. Narrow on purpose: it is what
+ * lets the whole backpressure and loss protocol be tested against a scripted
+ * double, with no native runtime and no filesystem.
+ */
+
+/** Entries that never reached the file, and the bytes they would have been. */
+
+/** Why the sink cut this handle off. Both are terminal for the batcher. */
+
+/**
+ * What a bounded drain achieved.
+ *
+ * Deliberately not the sink's `FlushOutcome`: the sink reports monotonic
+ * per-handle totals, whereas `unreportedEntries` / `unreportedBytes` are the
+ * losses that still have no notice in the file. That is the number a caller
+ * can act on, and conflating the two is how "we already logged that" turns
+ * into a loss no one ever hears about.
+ */
+
+/** Monotonic totals, JS-side and sink-side, at one instant. */
+
+/** How far a bounded drain has got. See {@link advanced}. */
+
+const DEFAULTS = {
+  batchBytes: 4096,
+  flushIntervalMs: 100,
+  maxPendingEntries: 1000,
+  maxPendingBytes: 512 * 1024,
+  watermarkBytes: 256 * 1024,
+  maxBatchBytes: 256 * 1024
+};
+
+/** Upper bound on any deadline handed to the sink, in milliseconds. */
+const MAX_DEADLINE_MS = 30_000;
+
+/** Consecutive no-progress rounds before a bounded drain gives up. */
+const MAX_STALLS = 8;
+
+/** Pushes per timer tick, so catching up cannot monopolise the JS thread. */
+const PUSHES_PER_TICK = 4;
+
+/**
+ * Buffers formatted records and feeds them to a sink under backpressure.
+ *
+ * Three things happen here that do not happen anywhere else.
+ *
+ * **Backpressure.** The sink's queue is bounded, so once it passes the
+ * watermark the batcher stops pushing and polls `getStatus()` instead — which
+ * is why that call is specified never to wait behind writer I/O. Records
+ * accumulate in the JS buffer meanwhile, itself bounded by an entry count and
+ * a byte count.
+ *
+ * **Drop-newest.** When the JS buffer is full the arriving record is dropped,
+ * not the oldest one held. Under a sustained overload the two policies lose
+ * the same volume; they differ in what survives, and the older records are
+ * the ones with the context explaining how the overload started.
+ *
+ * **Loss is owed until it is written.** Every drop — here or in the sink —
+ * accrues to a counter that is only cleared once a notice describing it has
+ * been accepted, and is re-armed if the flush that should have made that
+ * notice durable says otherwise. A loss can therefore be reported twice; it
+ * cannot be reported zero times. Silence has to mean nothing was lost, or the
+ * counters are decoration.
+ */
+export class Batcher {
+  pending = [];
+  pendingBytes = 0;
+  paused = false;
+  fenced = false;
+  disposed = false;
+  /**
+   * A notice could not be delivered on its own — unrenderable, or refused by
+   * the sink — and nothing about ticking again would change that.
+   *
+   * The debt stays owed and still shows in `unreported()`; what stops is the
+   * retrying on a timer, which would go on for the life of the process
+   * achieving nothing. The next record to arrive reopens it — that retry
+   * rides a batch that carries the record, so it cannot spin — as does an
+   * explicit `flush()`.
+   */
+  noticeBlocked = false;
+  /** Highest sink totals seen, and every byte this side has dropped. */
+  observed = zeroCursor();
+  /** Covered by a notice the sink has accepted. */
+  acked = zeroCursor();
+  /** Covered by a notice a durable flush has confirmed. */
+  confirmed = zeroCursor();
+  degraded = 0;
+  constructor(target, options) {
+    this.target = target;
+    this.renderNotice = options.renderNotice;
+    this.onFenced = options.onFenced;
+    this.batchBytes = positive(options.batchBytes, DEFAULTS.batchBytes);
+    this.flushIntervalMs = positive(options.flushIntervalMs, DEFAULTS.flushIntervalMs);
+    this.maxPendingEntries = positive(options.maxPendingEntries, DEFAULTS.maxPendingEntries);
+    this.maxPendingBytes = positive(options.maxPendingBytes, DEFAULTS.maxPendingBytes);
+    this.watermarkBytes = positive(options.watermarkBytes, DEFAULTS.watermarkBytes);
+    this.maxBatchBytes = positive(options.maxBatchBytes, DEFAULTS.maxBatchBytes);
+  }
+
+  // ── Producing ───────────────────────────────────────────────────────────
+
+  /**
+   * Buffer one formatted record. Never performs I/O beyond handing a full
+   * batch to the sink, and never throws: a logging call must not fail the
+   * code that made it.
+   */
+  add(record) {
+    if (this.disposed || this.fenced) {
+      this.dropped(record);
+      return;
+    }
+    const bytes = utf8Length(record) + 1; // the record's own newline
+    if (this.pending.length >= this.maxPendingEntries || this.pendingBytes + bytes > this.maxPendingBytes) {
+      this.dropped(record, bytes);
+      this.ensureTimer();
+      return;
+    }
+    this.pending.push({
+      text: record,
+      bytes
+    });
+    this.pendingBytes += bytes;
+    // A record to ride with is a fresh chance for a notice the sink refused
+    // earlier, and the reason it refused is usually temporary — a queue that
+    // was full a moment ago. Retrying on this event cannot spin the way a
+    // timer can: the batch carries a record, so it makes progress either way,
+    // and if the notice fails again the dead ends below block it again.
+    // Waiting instead for the next explicit flush means a process that dies
+    // first reports the loss zero times.
+    this.noticeBlocked = false;
+    if (!this.paused && this.pendingBytes >= this.batchBytes) {
+      this.pushOnce();
+    }
+    this.ensureTimer();
+  }
+
+  /**
+   * Record a loss that happened before the batcher saw it — a record that
+   * could not be rendered, or one too large to be rendered honestly. It is
+   * owed a notice on exactly the same terms as anything dropped here.
+   */
+  noteLoss(entries, bytes) {
+    this.observed.localEntries += toCount(entries);
+    this.observed.localBytes += toCount(bytes);
+    this.ensureTimer();
+  }
+
+  /** Losses with no notice in the file yet. */
+  unreported() {
+    return this.delta();
+  }
+
+  /** Bytes buffered on this side, not yet handed to the sink. */
+  bufferedBytes() {
+    return this.pendingBytes;
+  }
+
+  /**
+   * Payload-free bitmask of what has stopped working underneath — rotation,
+   * gzip, prune, sidecar, protection.
+   *
+   * This mirrors the sink's own mask, which accumulates bits and drops them
+   * only when a durable purge baselines everything. That is deliberate: these
+   * are things an app wants to know happened *at all*, and a mask that cleared
+   * itself the moment the next batch succeeded would report nothing the one
+   * time it mattered.
+   */
+  degradation() {
+    return this.degraded;
+  }
+  isFenced() {
+    return this.fenced;
+  }
+
+  // ── Draining ────────────────────────────────────────────────────────────
+
+  /**
+   * Drain to the sink and fsync, bounded by a wall-clock deadline.
+   *
+   * Backpressure is overridden for the duration: the whole point of a flush
+   * is to push through a full queue rather than wait for it to clear, so a
+   * rejected batch is followed by a bounded sink flush and retried.
+   *
+   * The postcondition is honest rather than absolute. Under a disk that stays
+   * full, this returns `durable: false` with the losses preserved — the
+   * alternative, insisting everything is either durable or noticed, is a
+   * promise no implementation can keep.
+   */
+  flush(deadlineMs) {
+    this.cancelTimer();
+    if (this.disposed || this.fenced) return this.outcome(false, false, 0);
+    const deadlineAt = Date.now() + clampDeadline(deadlineMs);
+    this.paused = false;
+    // An explicit flush is the retry: a notice the sink refused on its own
+    // gets one more chance here before being set aside again.
+    this.noticeBlocked = false;
+    let timedOut = false;
+    let stalls = 0;
+    let attempts = 0;
+    const maxAttempts = this.maxPendingEntries + MAX_STALLS * 2 + 16;
+    while (this.pending.length > 0 || this.owesNotice()) {
+      if (attempts >= maxAttempts || Date.now() >= deadlineAt) {
+        timedOut = true;
+        break;
+      }
+      attempts += 1;
+      const before = this.position();
+      const result = this.pushOnce();
+      if (result === 'empty' || result === 'fenced') break;
+      if (result === 'full') {
+        // Ask the sink to write what it has, then retry.
+        const remaining = deadlineAt - Date.now();
+        if (remaining <= 0) {
+          timedOut = true;
+          break;
+        }
+        const mid = this.targetFlush(remaining);
+        if (mid.timedOut) timedOut = true;
+      }
+
+      // Progress is MEASURED, never inferred from the result: a notice-only
+      // batch that fails removes no records and settles no debt, and a sink
+      // that finds a fresh loss on every append can hold the debt constant
+      // indefinitely — both look like progress to a check that only asks
+      // whether the push said 'failed'.
+      if (advanced(before, this.position())) {
+        stalls = 0;
+      } else {
+        stalls += 1;
+        if (stalls >= MAX_STALLS) break;
+      }
+    }
+    const final = this.targetFlush(Math.max(0, deadlineAt - Date.now()));
+    if (final.timedOut) timedOut = true;
+    const settled = final.durable && this.pending.length === 0 && !this.owesNotice();
+    if (settled) {
+      // Every notice accepted so far is now on disk.
+      this.confirmed = {
+        ...this.acked
+      };
+    } else {
+      // An accepted notice that no flush has confirmed is not a notice yet.
+      // Re-arming risks writing it twice, which beats losing it.
+      this.acked = {
+        ...this.confirmed
+      };
+    }
+
+    // The final sync is itself a place losses are discovered — a batch the
+    // writer could not land shows up in the counters it returns. Re-arm, or a
+    // loss learned about here waits for the next log call to be reported, and
+    // an app that has stopped logging never makes one.
+    this.ensureTimer();
+    return this.outcome(settled, timedOut, final.pendingBytes);
+  }
+
+  /**
+   * Release timers and let the buffer go. Idempotent.
+   *
+   * Deliberately does not flush: `LogDestination` calls `flush()` before
+   * `dispose()`, and a dispose that quietly blocked on a stalled disk would
+   * turn tearing down a destination into a hang.
+   */
+  dispose() {
+    this.cancelTimer();
+    this.disposed = true;
+    this.pending = [];
+    this.pendingBytes = 0;
+  }
+
+  /**
+   * Forget everything buffered and start the loss counters over, returning
+   * what was discarded.
+   *
+   * This is the purge path. The counts go back to the caller instead of into
+   * a notice, because a "4,182 entries dropped" line written into a file that
+   * was just cleared for compliance reasons describes the clearing, and the
+   * caller already knows it cleared the file.
+   */
+  discard() {
+    const discardedEntries = this.pending.length;
+    const discardedBytes = this.pendingBytes;
+    this.pending = [];
+    this.pendingBytes = 0;
+    this.syncCounters();
+    const owed = this.delta();
+    this.baseline();
+    this.paused = false;
+    return {
+      entries: discardedEntries + owed.entries,
+      bytes: discardedBytes + owed.bytes
+    };
+  }
+
+  /**
+   * Resume against a fresh generation after the owner has rebound.
+   *
+   * The sink cursors are re-read from scratch rather than carried over,
+   * because the old totals are not a baseline for the new handle's. Whether
+   * the sink resets its per-handle counters on rebind or keeps them running
+   * is not something this side can know — and getting it wrong is silent in
+   * the worse direction: keeping a stale maximum would swallow every new loss
+   * smaller than the pre-purge total, reporting it zero times.
+   *
+   * Local counters are deliberately left alone. Records this side dropped
+   * after the fence went up are real drops of real entries, and they belong
+   * to the new file as much as to the old one.
+   */
+  rebind() {
+    this.fenced = false;
+    this.paused = false;
+    this.noticeBlocked = false;
+    this.observed.sinkEntries = 0;
+    this.observed.sinkBytes = 0;
+    this.syncCounters();
+    this.acked.sinkEntries = this.observed.sinkEntries;
+    this.acked.sinkBytes = this.observed.sinkBytes;
+    this.confirmed.sinkEntries = this.observed.sinkEntries;
+    this.confirmed.sinkBytes = this.observed.sinkBytes;
+  }
+
+  // ── Internals ───────────────────────────────────────────────────────────
+
+  /**
+   * Hand at most one batch to the sink.
+   *
+   * The loss snapshot is taken BEFORE the call and acknowledged to that
+   * snapshot rather than to the totals the call returns. A drop that happens
+   * during this very append is not described by the notice riding in it, and
+   * acknowledging the post-call totals would bury it.
+   */
+  pushOnce() {
+    const lines = [];
+    let entryCount = 0;
+    let entryBytes = 0;
+    for (const item of this.pending) {
+      if (entryCount > 0 && entryBytes + item.bytes > this.maxBatchBytes) break;
+      lines.push(item.text);
+      entryBytes += item.bytes;
+      entryCount += 1;
+    }
+    const snapshot = {
+      ...this.observed
+    };
+    const owed = this.delta();
+    let carriesNotice = false;
+    if (!this.noticeBlocked && (owed.entries > 0 || owed.bytes > 0)) {
+      const notice = this.noticeText(owed);
+      if (notice !== undefined) {
+        lines.push(notice);
+        carriesNotice = true;
+      } else if (entryCount === 0) {
+        // A notice that will not render, and nothing else to send. Trying
+        // again in a hundred milliseconds will produce the same nothing, so
+        // the debt is set aside rather than retried on a timer for the life
+        // of the process. It is still owed, and an explicit flush reopens it.
+        this.noticeBlocked = true;
+      }
+    }
+    if (lines.length === 0) return 'empty';
+
+    // Whether this batch is carrying the notice and nothing else, which is
+    // what makes a rejection unrecoverable by retrying: there is no record to
+    // give up to make it smaller, and no smaller notice to send.
+    const noticeOnly = entryCount === 0;
+
+    // The notice goes after the records it does not describe, so a reader
+    // meets the surviving entries first and the gap where the others were.
+    const batch = `${lines.join('\n')}\n`;
+    let result;
+    try {
+      result = this.target.appendBatch(batch, lines.length);
+    } catch {
+      // A throwing sink is a failing sink. The batch is gone either way.
+      this.loseHead(entryCount, entryBytes);
+      if (noticeOnly) this.noticeBlocked = true;
+      return 'failed';
+    }
+    this.observeCounts(result.lostEntries, result.lostBytes, result.degraded);
+    if (result.accepted) {
+      this.loseHead(entryCount, 0, false);
+      if (carriesNotice) this.acked = snapshot;
+      if (toCount(result.queuedBytes) >= this.watermarkBytes) this.paused = true;
+      return 'sent';
+    }
+    const reason = result.rejectReason ?? 'failed';
+    if (reason === 'staleGeneration' || reason === 'closed') {
+      this.fence(reason);
+      return 'fenced';
+    }
+    if (reason === 'full') {
+      // An empty sink that still refuses means the batch is larger than the
+      // sink can ever hold, not that it is busy. Waiting for room that will
+      // never come wedges every later record behind this one.
+      if (toCount(result.queuedBytes) === 0) {
+        if (carriesNotice) {
+          // The notice may be the whole reason this did not fit, so it goes
+          // first — before any record is given up for it. Setting it aside
+          // beats pausing on a sink that has already given its final answer:
+          // the debt is kept and offered again on the next explicit flush,
+          // and meanwhile records are not held behind a line about old ones.
+          this.noticeBlocked = true;
+          return 'failed';
+        }
+        const head = this.pending[0];
+        if (head !== undefined) {
+          // Records alone, and still too big: give up the oldest and try a
+          // smaller batch.
+          this.loseHead(1, head.bytes);
+        }
+        return 'failed';
+      }
+      this.paused = true;
+      return 'full';
+    }
+    this.loseHead(entryCount, entryBytes);
+    // A notice-only batch the sink rejected outright leaves the state exactly
+    // as it was: nothing removed, nothing settled. Retrying it on the timer
+    // is a loop with no exit.
+    if (noticeOnly) this.noticeBlocked = true;
+    return 'failed';
+  }
+
+  /**
+   * Remove the batch's records from the head of the buffer, optionally
+   * counting them as lost.
+   */
+  loseHead(count, bytes, lost = true) {
+    if (count === 0) return;
+    const removed = this.pending.splice(0, count);
+    for (const item of removed) this.pendingBytes -= item.bytes;
+    if (this.pendingBytes < 0) this.pendingBytes = 0;
+    if (lost) {
+      this.observed.localEntries += count;
+      this.observed.localBytes += bytes;
+    }
+  }
+  dropped(record, bytes) {
+    this.observed.localEntries += 1;
+    this.observed.localBytes += bytes ?? utf8Length(record) + 1;
+  }
+  fence(reason) {
+    // Pre-purge records must never be replayed into a post-purge file, and a
+    // notice about them is a statement about data that was deliberately
+    // deleted. Both go.
+    this.pending = [];
+    this.pendingBytes = 0;
+    this.syncCounters();
+    this.baseline();
+    this.fenced = true;
+    this.paused = false;
+    this.cancelTimer();
+    try {
+      this.onFenced?.(reason);
+    } catch {
+      // the owner's problem, not the pipeline's
+    }
+  }
+
+  /**
+   * Bring the sink's counters up to date without writing anything.
+   *
+   * Cursors normally advance off append results, which means a loss the sink
+   * has recorded but not yet had occasion to report is invisible here. Before
+   * drawing a line under the past — a purge, a fence — that window has to be
+   * closed, or a loss from the old file crosses over and gets described as if
+   * it had happened to the new one.
+   */
+  syncCounters() {
+    try {
+      const status = this.target.getStatus();
+      this.observeCounts(status.lostEntries, status.lostBytes, status.degraded);
+    } catch {
+      // An unreadable probe just means the line is drawn where we stand.
+    }
+  }
+
+  /** Declare every loss seen so far as settled, reporting none of it. */
+  baseline() {
+    this.acked = {
+      ...this.observed
+    };
+    this.confirmed = {
+      ...this.observed
+    };
+  }
+  noticeText(lost) {
+    let text;
+    try {
+      text = this.renderNotice(lost);
+    } catch {
+      return undefined;
+    }
+    return typeof text === 'string' && text.length > 0 ? text : undefined;
+  }
+  delta() {
+    return {
+      entries: Math.max(0, this.observed.sinkEntries - this.acked.sinkEntries + (this.observed.localEntries - this.acked.localEntries)),
+      bytes: Math.max(0, this.observed.sinkBytes - this.acked.sinkBytes + (this.observed.localBytes - this.acked.localBytes))
+    };
+  }
+  owesNotice() {
+    const owed = this.delta();
+    return owed.entries > 0 || owed.bytes > 0;
+  }
+
+  /** Where the drain has got to: records still buffered, loss still owed. */
+  position() {
+    const owed = this.delta();
+    return {
+      entries: this.pending.length,
+      bytes: this.pendingBytes,
+      owedEntries: owed.entries,
+      owedBytes: owed.bytes
+    };
+  }
+
+  /**
+   * Fold sink counters in. They are monotonic per handle, so the maximum
+   * seen is the truth; a sink that reported a smaller number than last time
+   * would otherwise drive the delta negative and cancel a real loss.
+   */
+  observeCounts(lostEntries, lostBytes, degraded) {
+    this.observed.sinkEntries = Math.max(this.observed.sinkEntries, toCount(lostEntries));
+    this.observed.sinkBytes = Math.max(this.observed.sinkBytes, toCount(lostBytes));
+    this.degraded = toCount(degraded);
+  }
+  targetFlush(deadlineMs) {
+    let outcome;
+    try {
+      outcome = this.target.flush(clampDeadline(deadlineMs));
+    } catch {
+      return {
+        durable: false,
+        timedOut: true,
+        pendingBytes: 0,
+        queuedBytes: 0,
+        lostBytes: this.observed.sinkBytes,
+        lostEntries: this.observed.sinkEntries,
+        degraded: this.degraded
+      };
+    }
+    this.observeCounts(outcome.lostEntries, outcome.lostBytes, outcome.degraded);
+    return outcome;
+  }
+  outcome(durable, timedOut, sinkPending) {
+    const owed = this.delta();
+    return {
+      durable,
+      timedOut,
+      // Both sides of the handoff: what never left the JS buffer, plus what
+      // the sink took but has not made durable.
+      pendingBytes: this.pendingBytes + toCount(sinkPending),
+      unreportedEntries: owed.entries,
+      unreportedBytes: owed.bytes,
+      degraded: this.degraded
+    };
+  }
+
+  // ── Timer ───────────────────────────────────────────────────────────────
+
+  ensureTimer() {
+    if (this.timer !== undefined || this.disposed || this.fenced) return;
+    // A blocked notice is not a reason to keep ticking: the sink has already
+    // refused it, and the next explicit flush is what retries.
+    const owed = this.owesNotice() && !this.noticeBlocked;
+    if (this.pending.length === 0 && !this.paused && !owed) return;
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
+      this.onTick();
+    }, this.flushIntervalMs);
+  }
+  cancelTimer() {
+    if (this.timer !== undefined) {
+      clearTimeout(this.timer);
+      this.timer = undefined;
+    }
+  }
+  onTick() {
+    if (this.disposed || this.fenced) return;
+    if (this.paused) {
+      // The non-enqueuing probe: this is the call that is specified to be
+      // answerable while the writer thread is stalled on disk, and the whole
+      // pause/resume cycle rests on that.
+      try {
+        const status = this.target.getStatus();
+        this.observeCounts(status.lostEntries, status.lostBytes, status.degraded);
+        if (toCount(status.queuedBytes) < this.watermarkBytes) {
+          this.paused = false;
+        }
+      } catch {
+        // stay paused; try again next tick
+      }
+    }
+    if (!this.paused) {
+      for (let i = 0; i < PUSHES_PER_TICK; i += 1) {
+        const result = this.pushOnce();
+        if (result !== 'sent') break;
+        if (this.paused) break;
+      }
+    }
+    this.ensureTimer();
+  }
+}
+function zeroCursor() {
+  return {
+    sinkEntries: 0,
+    sinkBytes: 0,
+    localEntries: 0,
+    localBytes: 0
+  };
+}
+
+/**
+ * Did the drain get anywhere between these two positions?
+ *
+ * The two halves are compared separately rather than summed, because a batch
+ * the sink refused moves records out of the buffer and into the debt they now
+ * owe a notice — a conserved total, and real progress. Summing them says the
+ * drain is stuck at exactly the moment it is working through a failing sink,
+ * and abandons the records queued behind the ones it just gave up on.
+ */
+function advanced(before, after) {
+  if (after.entries < before.entries || after.bytes < before.bytes) return true;
+  return after.owedEntries < before.owedEntries || after.owedBytes < before.owedBytes;
+}
+
+/** A count from across the bridge; anything not a positive number is zero. */
+function toCount(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function positive(value, fallback) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function clampDeadline(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
+    return 0;
+  }
+  return Math.min(Math.floor(value), MAX_DEADLINE_MS);
+}
+//# sourceMappingURL=Batcher.js.map

package/lib/module/destinations/Batcher.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["utf8Length","DEFAULTS","batchBytes","flushIntervalMs","maxPendingEntries","maxPendingBytes","watermarkBytes","maxBatchBytes","MAX_DEADLINE_MS","MAX_STALLS","PUSHES_PER_TICK","Batcher","pending","pendingBytes","paused","fenced","disposed","noticeBlocked","observed","zeroCursor","acked","confirmed","degraded","constructor","target","options","renderNotice","onFenced","positive","add","record","dropped","bytes","length","ensureTimer","push","text","pushOnce","noteLoss","entries","localEntries","toCount","localBytes","unreported","delta","bufferedBytes","degradation","isFenced","flush","deadlineMs","cancelTimer","outcome","deadlineAt","Date","now","clampDeadline","timedOut","stalls","attempts","maxAttempts","owesNotice","before","position","result","remaining","mid","targetFlush","advanced","final","Math","max","settled","durable","dispose","discard","discardedEntries","discardedBytes","syncCounters","owed","baseline","rebind","sinkEntries","sinkBytes","lines","entryCount","entryBytes","item","snapshot","carriesNotice","notice","noticeText","undefined","noticeOnly","batch","join","appendBatch","loseHead","observeCounts","lostEntries","lostBytes","accepted","queuedBytes","reason","rejectReason","fence","head","count","lost","removed","splice","status","getStatus","owedEntries","owedBytes","sinkPending","unreportedEntries","unreportedBytes","timer","setTimeout","onTick","clearTimeout","i","after","value","Number","isFinite","floor","fallback","min"],"sourceRoot":"../../../src","sources":["destinations/Batcher.ts"],"mappings":"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","ignoreList":[]}