signalk-questdb 2.4.0 → 2.5.1

package/dist/index.js

@@ -255,13 +255,6 @@ export default (app) => {
             return;
         app.setPluginStatus(recordingStatus(host, port));
     };
-    // Contexts seen live while a startup restore is in flight. A stored fix
-    // must never overwrite a vessel that has already transmitted since boot —
-    // that would move it backwards on the chart. Populated by the recorder
-    // subscription and cleared as soon as the restore settles, so this stays a
-    // startup-window set rather than an unbounded one.
-    const liveContexts = new Set();
-    let trackLiveContexts = false;
     const withLifecycleLock = (fn) => {
         const run = lifecycleChain.then(fn, fn);
         // Keep the chain alive regardless of this op's outcome.
@@ -556,10 +549,10 @@ export default (app) => {
         const matches = matcher.matches(path);
         return mode === "exclude" ? !matches : matches;
     }
-    function isThrottled(path, context, defaultRate) {
+    function isThrottled(path, context, defaultRate, source) {
         // Per-path override wins when one matches; otherwise the default rate.
         const overrideRate = rateMatcher?.rateFor(path) ?? null;
-        return throttle.shouldDrop(path, context, overrideRate ?? defaultRate, Date.now());
+        return throttle.shouldDrop(path, context, overrideRate ?? defaultRate, Date.now(), source);
     }
     const WAL_NOTIFICATION_PATH = "notifications.signalk-questdb.walSuspended";
     // Dedupe key of the last emitted notification. The monitor reports every
@@ -1189,21 +1182,22 @@ export default (app) => {
         app.registerHistoryApiProvider(v2Provider);
         const v1Provider = createHistoryProviderV1(queryClient, app.selfContext, (msg) => app.debug(msg), archive);
         app.registerHistoryProvider(v1Provider);
-        // Arm live-context tracking before the first delta can arrive, so the
-        // restore sees every vessel that transmitted during startup.
-        liveContexts.clear();
-        trackLiveContexts = config.restoreOnStart;
-        const bus = app.streambundle.getBus();
+        // getBus() carries only the source that Signal K's source priorities
+        // prefer on each path, the value instruments show. recordAllSources
+        // reads the unfiltered bus instead, so a source that loses the ranking
+        // is recorded as well: the raw paddlewheel next to a corrected STW
+        // (issue #235).
+        const bus = config.recordAllSources
+            ? app.streambundle.getUnfilteredBus()
+            : app.streambundle.getBus();
         const unsub = bus.onValue((delta) => {
             if (!writer)
                 return;
             const { path, value, context } = delta;
             // Values this plugin replayed at startup come straight back around
             // through the streambundle. Recording them would re-stamp historical
-            // fixes with the current receive time — inventing present-tense
-            // positions for vessels that may be long gone — and marking their
-            // context live would defeat the guard that stops a restore from
-            // overwriting a vessel that actually transmitted.
+            // fixes with the current receive time, inventing present-tense
+            // positions for vessels that may be long gone.
             if (delta.$source === RESTORE_SOURCE)
                 return;
             // The delta's sourceRef, stored as the rows' `source` column so
@@ -1212,13 +1206,21 @@ export default (app) => {
             // syntax. Undefined when the delta carries none — the column stays
             // null, same as rows written before it existed.
             const source = typeof delta.$source === "string" ? delta.$source : undefined;
-            // Note the context BEFORE any early return or filter: identity-only
-            // deltas return below, and path filters and throttles decide what gets
-            // STORED — but any delta at all proves the vessel is transmitting now,
-            // which is what makes its stored position obsolete for the restore.
-            if (trackLiveContexts) {
-                liveContexts.add(context === app.selfContext ? "self" : context);
-            }
+            // Recording every source keeps each one apart. It gets its own
+            // sampling window: the shared one would keep whichever source arrives
+            // first, so the fastest receiver would crowd out the ones recorded to
+            // compare against it. And its nulls forget only its own last values:
+            // a gateway sending "not available" several times a second would
+            // otherwise make every other source's unchanged values due again at
+            // each sampling window instead of each heartbeat.
+            const perSource = config.recordAllSources ? source : undefined;
+            // Meta updates ride the same bus as values, flagged isMeta. They
+            // describe a path (units, description, displayName), they are not a
+            // reading of it. Routed like a value object, their keys were stored
+            // as rows such as `….units` and `….displayName`, again each time a
+            // plugin republished its meta.
+            if (delta.isMeta)
+                return;
             // Static vessel identity (issue #91): names arrive as empty-path
             // object deltas, which the path guard below would drop. Stored as
             // path "name" in the string table; history-v1 replays them in the
@@ -1257,7 +1259,7 @@ export default (app) => {
             // the change gate must forget the path, so the first reading after the
             // gap is recorded even when it equals the last one before it.
             if (path && value === null) {
-                changeGate?.forget(path, context === app.selfContext ? "self" : context);
+                changeGate?.forget(path, context === app.selfContext ? "self" : context, perSource);
             }
             if (!path || value === undefined || value === null)
                 return;
@@ -1304,13 +1306,14 @@ export default (app) => {
                     return;
                 // Throttled per path AND context: the sampling rate bounds each
                 // vessel's stream, not the fleet's (issue #93). The stored context
-                // ("self" vs raw) is the key, matching what the rows carry. The key
-                // deliberately does NOT include source: the sampling rate bounds the
-                // per-path row volume, and keying per source would multiply it by the
-                // number of receivers. With two sources alternating, each window
-                // keeps whichever arrived first — a source-filtered read then sees
-                // roughly every other sample, which the rate already allows for.
-                if (isThrottled(path, isSelf ? "self" : context, config.defaultSamplingRate ?? 2000))
+                // ("self" vs raw) is the key, matching what the rows carry. Unless
+                // recordAllSources asks for every source, the key deliberately does
+                // NOT include source: the sampling rate bounds the per-path row
+                // volume, and keying per source would multiply it by the number of
+                // receivers. With two sources alternating, each window keeps
+                // whichever arrived first — a source-filtered read then sees roughly
+                // every other sample, which the rate already allows for.
+                if (isThrottled(path, isSelf ? "self" : context, config.defaultSamplingRate ?? 2000, perSource))
                     return;
             }
             // Rows are stamped with the server receive time, deliberately NOT the
@@ -1365,7 +1368,7 @@ export default (app) => {
                         continue;
                     if (changeGate?.isRepeat(leaf.path, ctx, source, leaf.value, now))
                         continue;
-                    if (isThrottled(leaf.path, ctx, config.defaultSamplingRate ?? 2000))
+                    if (isThrottled(leaf.path, ctx, config.defaultSamplingRate ?? 2000, perSource))
                         continue;
                     changeGate?.wrote(leaf.path, ctx, source, leaf.value, now);
                     if (typeof leaf.value === "number") {
@@ -1547,11 +1550,10 @@ export default (app) => {
         // reads pluginRunning and everything before this point can still throw
         // and abandon the start.
         //
-        // The recorder is already subscribed, so live deltas keep arriving while
-        // the (slow, whole-table) restore query runs. Those are newer by
-        // definition: replaying a stored fix over a vessel that just transmitted
-        // would move it BACKWARDS on the chart. liveContexts records what the
-        // recorder saw and the restore skips those contexts entirely.
+        // Live deltas keep arriving while the (slow, whole-table) restore query
+        // runs, and some arrived before the recorder subscribed. The restore
+        // reads the model and leaves alone whatever it already holds, so neither
+        // is overwritten by an older stored value.
         if (config.restoreOnStart) {
             const restoreGeneration = lifecycleGeneration;
             void restoreFromHistory({
@@ -1566,7 +1568,7 @@ export default (app) => {
                 },
                 selfContext: app.selfContext,
                 debug: (msg) => app.debug(msg),
-                hasLiveData: (context) => liveContexts.has(context),
+                getPath: (path) => app.getPath?.(path),
             }, {
                 maxAgeMs: config.restoreMaxAgeMinutes * 60_000,
                 restoreSelf: config.recordSelf,
@@ -1606,16 +1608,6 @@ export default (app) => {
                     const { host, port } = questdbEndpoints.ilp;
                     publishRecordingStatus(host, port);
                 }
-            })
-                .finally(() => {
-                // Only needed to shield the restore; tracking every context for the
-                // life of the plugin would be an unbounded set. Guarded on the
-                // generation so a slow restore settling after a restart does not
-                // disarm the tracking the NEW start just armed.
-                if (lifecycleGeneration !== restoreGeneration)
-                    return;
-                liveContexts.clear();
-                trackLiveContexts = false;
             });
         }
     }
@@ -1656,10 +1648,6 @@ export default (app) => {
             startAbort?.abort();
             imageCheckAbort?.abort();
             pluginRunning = false;
-            // A start aborted before its restore ran would otherwise leave tracking
-            // armed, accumulating contexts for a restore that never happens.
-            trackLiveContexts = false;
-            liveContexts.clear();
             // Stale across a restart otherwise: the card would still claim a
             // restore count from the previous run.
             restoreSummary = null;