signalk-chiplog 2.3.0 → 2.3.1

package/CHANGELOG.md

@@ -6,6 +6,27 @@ All notable changes to Chiplog are documented here. The format follows
 
 ## [Unreleased]
 
+## [2.3.1] - 2026-09-18
+
+### Added
+
+- **Retrospective analysis now shows what has been reconstructed so far while it is still running**, not only once it
+  finishes: passages, distance, engine/sail time, track points and events update after every committed slice instead of
+  only the clock position. A run that fails partway — an InfluxDB query timing out on a slow host — keeps that same
+  summary next to the error, instead of leaving a bare error message with no way to tell what was saved.
+- **A retrospective replay retries an InfluxDB query that times out** up to 3 times, 5 seconds apart, instead of failing
+  the whole run on what is often just a Raspberry Pi momentarily busy sharing its InfluxDB with Signal K itself; the
+  webapp shows which attempt is under way while it waits. The timeout covers the whole round trip, including a chunk's
+  JSON still streaming in after the connection answered, not just getting a connection in the first place. Each window
+  of history is also fetched in smaller, two-hour chunks instead of six, so a slow host has less to answer per request.
+
+### Fixed
+
+- **A retrospective replay running alongside live tracking** could have a live detection tick, track sample or event
+  check land on the passage the replay was reconstructing — mistaking it for the current one, since both read the same
+  `active` row — and close it early or splice live position and instrument data into a past passage. Live detection,
+  track sampling and event watching now pause for as long as a replay is running.
+
 ## [2.3.0] - 2026-09-18
 
 ### Added
@@ -266,7 +287,8 @@ First release.
 - REST API under `/plugins/signalk-chiplog/api`, documented in [docs/API.md](docs/API.md).
 - Single SQLite database through Node's built-in `node:sqlite`: no native module to build.
 
-[Unreleased]: https://github.com/ricard33/signalk-chiplog/compare/v2.3.0...HEAD
+[Unreleased]: https://github.com/ricard33/signalk-chiplog/compare/v2.3.1...HEAD
+[2.3.1]: https://github.com/ricard33/signalk-chiplog/compare/v2.3.0...v2.3.1
 [2.3.0]: https://github.com/ricard33/signalk-chiplog/compare/v2.2.0...v2.3.0
 [2.2.0]: https://github.com/ricard33/signalk-chiplog/compare/v2.1.0...v2.2.0
 [2.1.0]: https://github.com/ricard33/signalk-chiplog/compare/v2.0.0...v2.1.0

package/index.js

@@ -274,6 +274,20 @@ module.exports = function (app) {
   };
 
   function runDetection() {
+    // A retrospective replay drives the same detector against a past window,
+    // holding its own passage 'active' in log_entries for as long as it takes
+    // to close it there — live detection, track sampling and event watching
+    // must not touch that row in the meantime, or a live tick would treat a
+    // reconstructed passage as the current one and close it early or splice
+    // live data into it.
+    if (replayJob?.status().running) {
+      const status = 'Retrospective replay in progress — live tracking paused';
+      if (status !== lastStatus) {
+        app.setPluginStatus(status);
+        lastStatus = status;
+      }
+      return;
+    }
     try {
       const outcome = detector.tick();
       usbExport.afterDetection(outcome);
@@ -471,11 +485,19 @@ module.exports = function (app) {
     timers = [
       setInterval(runDetection, TICK_INTERVAL_MS),
       setInterval(
-        guarded('Track recording', () => recorder.sample()),
+        guarded('Track recording', () => {
+          if (!replayJob?.status().running) {
+            recorder.sample();
+          }
+        }),
         SAMPLE_INTERVAL_MS
       ),
       setInterval(
-        guarded('Event watching', () => watcher.check()),
+        guarded('Event watching', () => {
+          if (!replayJob?.status().running) {
+            watcher.check();
+          }
+        }),
         CHECK_INTERVAL_MS
       ),
       setInterval(

package/lib/influx-history.js

@@ -18,13 +18,19 @@ const DEFAULT_QUERY_TIMEOUT_SECONDS = 30;
 
 // A resource-constrained host (a Raspberry Pi running both Signal K and
 // InfluxDB) can be brought down by one query spanning weeks across every
-// path at once; six hours at a time keeps each request's result small
+// path at once; two hours at a time keeps each request's result small
 // regardless of how long the requested range is, with a short pause between
 // them so the database is never asked for the next one while still
 // recovering from the last.
-const CHUNK_MS = 6 * 60 * 60 * 1000;
+const CHUNK_MS = 2 * 60 * 60 * 1000;
 const CHUNK_PAUSE_MS = 200;
 
+// A query that times out is retried rather than failing the whole replay
+// outright -- a Raspberry Pi sharing its InfluxDB with Signal K itself is
+// often just busy for a moment, not actually unreachable.
+const QUERY_MAX_RETRIES = 3;
+const QUERY_RETRY_DELAY_MS = 5 * 1000;
+
 // The motion scan asks for one mean per minute, light enough to cover a week
 // per request.
 const SCAN_BUCKET_MS = 60 * 1000;
@@ -112,7 +118,9 @@ function createInfluxHistory({
   selfContext,
   queryTimeoutSeconds = INFLUX_DEFAULTS.influxQueryTimeoutSeconds,
   fetch = globalThis.fetch,
-  signal
+  signal,
+  onRetry = () => {},
+  retryDelayMs = QUERY_RETRY_DELAY_MS
 }) {
   const queryTimeoutMs = queryTimeoutSeconds * 1000;
   // path -> [{ time, node }], ascending by time; `node` is what readSelfPath
@@ -136,36 +144,59 @@ function createInfluxHistory({
       epoch: 'ms',
       q: statements.join(';')
     });
-    const timeout = AbortSignal.timeout(queryTimeoutMs);
-    let response;
-    try {
-      response = await fetch(url, {
-        method: 'POST',
-        headers,
-        body,
-        signal: signal ? AbortSignal.any([timeout, signal]) : timeout
-      });
-    } catch (err) {
-      if (signal?.aborted) {
-        throw err;
-      }
-      if (err.name === 'TimeoutError') {
+
+    // One full round trip: the timeout signal covers reading the response
+    // body too, not just getting the headers back, so a database that is slow
+    // to stream a large chunk's JSON times out here just as it would waiting
+    // for the connection -- both must retry the same way.
+    async function attempt() {
+      const timeout = AbortSignal.timeout(queryTimeoutMs);
+      let response;
+      try {
+        response = await fetch(url, {
+          method: 'POST',
+          headers,
+          body,
+          signal: signal ? AbortSignal.any([timeout, signal]) : timeout
+        });
+      } catch (err) {
+        if (signal?.aborted || err.name === 'TimeoutError') {
+          throw err;
+        }
+        // Node's fetch wraps a connection failure (wrong host, refused,
+        // certificate…) as a bare "fetch failed"; the actual reason is here.
         throw new Error(
-          `InfluxDB at ${protocol}://${host}:${port} did not answer within ${queryTimeoutSeconds}s`,
+          `Could not reach InfluxDB at ${protocol}://${host}:${port}: ${err.cause?.message ?? err.message}`,
           { cause: err }
         );
       }
-      // Node's fetch wraps a connection failure (wrong host, refused,
-      // certificate…) as a bare "fetch failed"; the actual reason is here.
-      throw new Error(
-        `Could not reach InfluxDB at ${protocol}://${host}:${port}: ${err.cause?.message ?? err.message}`,
-        { cause: err }
-      );
+      if (!response.ok) {
+        throw new Error(`InfluxDB query failed: ${response.status} ${await response.text()}`);
+      }
+      return response.json();
     }
-    if (!response.ok) {
-      throw new Error(`InfluxDB query failed: ${response.status} ${await response.text()}`);
+
+    let payload;
+    // Each attempt gets its own full timeout budget, not a shared one left
+    // over from the last -- a query that timed out once is retried outright,
+    // not with less time to answer than before.
+    for (let retries = 0; ; retries += 1) {
+      try {
+        payload = await attempt();
+        onRetry(null);
+        break;
+      } catch (err) {
+        if (signal?.aborted || err.name !== 'TimeoutError') {
+          throw err;
+        }
+        const message = `InfluxDB at ${protocol}://${host}:${port} did not answer within ${queryTimeoutSeconds}s`;
+        if (retries >= QUERY_MAX_RETRIES) {
+          throw new Error(message, { cause: err });
+        }
+        onRetry(retries + 1, QUERY_MAX_RETRIES, message);
+        await sleep(retryDelayMs);
+      }
     }
-    const payload = await response.json();
     return payload.results.map((result) => {
       if (result.error) {
         throw new Error(`InfluxDB query error: ${result.error}`);
@@ -482,4 +513,4 @@ function createInfluxHistory({
   return { preload, clear, scanMotion, readSelfPath };
 }
 
-module.exports = { createInfluxHistory, INFLUX_DEFAULTS };
+module.exports = { createInfluxHistory, INFLUX_DEFAULTS, CHUNK_MS, QUERY_MAX_RETRIES };

package/lib/replay-job.js

@@ -13,7 +13,8 @@ function createReplayJob({
   clock = Date.now,
   log = () => {},
   fetch = globalThis.fetch,
-  onDone = () => {}
+  onDone = () => {},
+  retryDelayMs
 }) {
   let current = null;
   let lastResult = null;
@@ -73,7 +74,19 @@ function createReplayJob({
       selfContext: settings.influxSelfContext || app.selfContext,
       queryTimeoutSeconds: settings.influxQueryTimeoutSeconds,
       fetch,
-      signal
+      signal,
+      retryDelayMs,
+      onRetry: (attempt, of, message) => {
+        if (attempt !== null) {
+          log(
+            'error',
+            `Retrospective replay: InfluxDB query timed out, retrying (attempt ${attempt}/${of}): ${message}`
+          );
+        }
+        if (current) {
+          current.retry = attempt === null ? null : { attempt, of, message };
+        }
+      }
     });
     try {
       await runWindowedReplay({
@@ -91,6 +104,11 @@ function createReplayJob({
         onProgress: (nowMs) => {
           if (current) {
             current.now = iso(nowMs);
+            // Recomputed each slice so the webapp can show what has actually
+            // been committed so far, not just how far the clock has got --
+            // the only way to know anything was saved if the run then times
+            // out or otherwise fails.
+            current.summary = summarise(afterId, to);
           }
         }
       });
@@ -105,7 +123,13 @@ function createReplayJob({
           summary: summarise(afterId, to)
         };
       } else {
-        lastError = { at: iso(clock()), from, to, message: err.message };
+        lastError = {
+          at: iso(clock()),
+          from,
+          to,
+          message: err.message,
+          summary: summarise(afterId, to)
+        };
         log('error', `Retrospective replay failed (${from} to ${to}): ${err.message}`);
       }
     } finally {
@@ -141,7 +165,15 @@ function createReplayJob({
         );
       }
       const controller = new AbortController();
-      current = { from, to, startedAt: iso(clock()), now: from, phase: 'scanning', controller };
+      current = {
+        from,
+        to,
+        startedAt: iso(clock()),
+        now: from,
+        phase: 'scanning',
+        retry: null,
+        controller
+      };
       lastError = null;
       perform(from, to, controller.signal);
       return { from, to };
@@ -163,7 +195,9 @@ function createReplayJob({
           from: current.from,
           to: current.to,
           now: current.now,
-          phase: current.phase
+          phase: current.phase,
+          summary: current.summary ?? null,
+          retry: current.retry
         },
         lastResult,
         lastError

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-chiplog",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Nautical logbook for Signal K: automatic entries, handwritten notes",
   "main": "index.js",
   "files": [
@@ -36,7 +36,8 @@
       "./docs/screenshots/04-entry-app.png"
     ],
     "recommends": [
-      "signalk-to-influxdb"
+      "signalk-to-influxdb",
+      "signalk-autostate"
     ]
   },
   "author": "Cedric RICARD <ricard33@gmail.com>",

package/public/js/components/ReplayView.mjs

@@ -26,19 +26,35 @@ function Progress({ progress }) {
           time: `${format.shortDate(progress.now)} ${format.time(progress.now)}`
         })}
       </p>
+      ${
+        progress.retry &&
+        html`<p class="notice">
+          ${t('replay.retrying', {
+            attempt: progress.retry.attempt,
+            of: progress.retry.of,
+            message: progress.retry.message
+          })}
+        </p>`
+      }
+      ${
+        progress.phase === 'replaying' &&
+        html`<${Summary} summary=${progress.summary} live=${true} />`
+      }
     </div>
   `;
 }
 
-// What the latest run added -- also after a cancellation, since what was
-// reconstructed up to that point stays on record.
-function Summary({ summary }) {
+// What a run added, live while it is still going (so a timeout partway
+// through still leaves something to show for it) and again for the final
+// outcome -- also after a cancellation, since what was reconstructed up to
+// that point stays on record either way.
+function Summary({ summary, live = false }) {
   const { t, format } = useLocale();
   if (!summary) {
     return null;
   }
   if (summary.passages === 0) {
-    return html`<p class="muted">${t('replay.summaryEmpty')}</p>`;
+    return live ? null : html`<p class="muted">${t('replay.summaryEmpty')}</p>`;
   }
   const facts = [
     ['replay.summaryPassages', format.count(summary.passages)],
@@ -66,12 +82,15 @@ function Outcome({ status }) {
   const { t, format } = useLocale();
   if (status.lastError) {
     const { lastError } = status;
-    return html`<p class="notice notice-error">
-      ${t('replay.failed', {
-        time: format.time(lastError.at),
-        message: lastError.message
-      })}
-    </p>`;
+    return html`
+      <p class="notice notice-error">
+        ${t('replay.failed', {
+          time: format.time(lastError.at),
+          message: lastError.message
+        })}
+      </p>
+      <${Summary} summary=${lastError.summary} />
+    `;
   }
   if (status.lastResult) {
     const { lastResult } = status;

package/public/js/i18n.mjs

@@ -351,6 +351,7 @@ export const MESSAGES = {
     'replay.start': 'Reconstruct',
     'replay.cancel': 'Cancel',
     'replay.progress': '{percent}% — at {time}',
+    'replay.retrying': 'Retrying after a timeout (attempt {attempt}/{of}): {message}',
     'replay.done': 'Reconstruction finished at {time}.',
     'replay.cancelled': 'Reconstruction cancelled at {time}.',
     'replay.failed': 'Reconstruction failed at {time}: {message}',
@@ -802,6 +803,8 @@ export const MESSAGES = {
     'replay.start': 'Reconstruire',
     'replay.cancel': 'Annuler',
     'replay.progress': '{percent} % — à {time}',
+    'replay.retrying':
+      'Nouvelle tentative après un délai dépassé (essai {attempt}/{of}) : {message}',
     'replay.done': 'Reconstruction terminée à {time}.',
     'replay.cancelled': 'Reconstruction annulée à {time}.',
     'replay.failed': 'Échec de la reconstruction à {time} : {message}',