@wtfalch/reporting 0.1.0 → 0.1.1

package/dist/writer.d.ts

@@ -27,11 +27,18 @@ export declare class Writer {
     private enqueue;
     /** Once per idle period through `defer`, and always on the timer. */
     private schedule;
-    /** Drain until empty or the deadline. One flush in flight at a time; a second call waits on the first. */
+    /**
+     * Drain until the queue is empty and nothing is in flight, or the deadline.
+     * Two callers overlap all the time (the timer and a request's `after()`,
+     * the tick and its own timer), so "empty" is not enough: a row another
+     * flush spliced off the queue a moment ago is still on its way, and a
+     * caller that returned on an empty queue would read the table too early.
+     * Every caller therefore waits for whatever is in flight and looks again.
+     */
     flush(opts?: {
         deadlineMs?: number;
     }): Promise<void>;
-    private lastFailed;
+    /** One insert of one batch. Resolves true on success; never throws. */
     private flushOnce;
     stats(): Stats;
 }

package/dist/writer.js

@@ -95,25 +95,41 @@ export class Writer {
             this.timer.unref?.();
         }
     }
-    /** Drain until empty or the deadline. One flush in flight at a time; a second call waits on the first. */
+    /**
+     * Drain until the queue is empty and nothing is in flight, or the deadline.
+     * Two callers overlap all the time (the timer and a request's `after()`,
+     * the tick and its own timer), so "empty" is not enough: a row another
+     * flush spliced off the queue a moment ago is still on its way, and a
+     * caller that returned on an empty queue would read the table too early.
+     * Every caller therefore waits for whatever is in flight and looks again.
+     */
     async flush(opts = {}) {
         const deadline = Date.now() + (opts.deadlineMs ?? 5000);
-        if (this.inFlight)
-            await this.inFlight;
-        while (this.queue.length > 0 && Date.now() < deadline) {
-            this.inFlight = this.flushOnce();
-            try {
+        while (Date.now() < deadline) {
+            if (this.inFlight) {
                 await this.inFlight;
+                continue;
+            }
+            if (this.queue.length === 0)
+                break;
+            const attempt = this.flushOnce();
+            this.inFlight = attempt;
+            let ok = false;
+            try {
+                ok = await attempt;
             }
             finally {
-                this.inFlight = null;
+                if (this.inFlight === attempt)
+                    this.inFlight = null;
             }
-            if (this.failedFlushes > 0 && this.queue.length > 0 && this.lastFailed)
+            // A failed insert leaves its rows queued; do not spin on the database
+            // inside one call. The timer and the next defer try again.
+            if (!ok)
                 break;
         }
         this.deferred = false;
     }
-    lastFailed = false;
+    /** One insert of one batch. Resolves true on success; never throws. */
     async flushOnce() {
         const batch = this.queue.splice(0, this.o.batchSize);
         if (this.droppedSinceReport > 0) {
@@ -133,11 +149,10 @@ export class Writer {
         try {
             await this.o.db.insert(reportingEvents).values(batch);
             this.flushed += batch.length;
-            this.lastFailed = false;
+            return true;
         }
         catch (error) {
             this.failedFlushes += 1;
-            this.lastFailed = true;
             // Back at the front, so order survives; the bound still applies, and
             // whatever does not fit is counted as dropped rather than kept for ever.
             const room = Math.max(0, this.o.queueLimit - this.queue.length);
@@ -146,6 +161,7 @@ export class Writer {
             this.droppedSinceReport += batch.length - kept.length;
             this.queue.unshift(...kept);
             this.o.log.error({ err: describe(error), rows: batch.length, queued: this.queue.length }, 'reporting: flush failed; rows stay queued');
+            return false;
         }
     }
     stats() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wtfalch/reporting",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "The estate's operational event log and housekeeping tick: a writer that never fails a request, a claim protocol that needs no scheduler, and the readers an operator opens. Per-app Postgres, host-supplied logger, framework-neutral core with a Next entry.",
   "repository": {
     "type": "git",