signalk-chiplog 2.2.0 → 2.3.1

package/CHANGELOG.md

@@ -6,6 +6,44 @@ 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
+
+- **InfluxDB query timeout** setting (`influxQueryTimeoutSeconds`, 30 s by default): how long a retrospective replay
+  waits for the InfluxDB server to answer before giving up on it as unreachable or overloaded, now configurable instead
+  of a fixed 30 seconds — useful against a Raspberry Pi that is simply slow to answer a six-hour chunk.
+
+### Fixed
+
+- **Retrospective replay backfilling a gap before passages already logged live** no longer dated every reconstructed
+  passage to the most recent existing passage's end time. Detection's guard against an out-of-order departure looked at
+  the latest `end_time` in the whole logbook rather than only at passages that actually preceded the new one, so filling
+  in an earlier gap — installing Chiplog after the fact, or after a stop — pinned every reconstructed departure to that
+  unrelated, later date, and the replay summary reported no passage found for the requested period even though entries
+  had been created.
+
 ## [2.2.0] - 2026-09-18
 
 ### Added
@@ -249,7 +287,9 @@ 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.2.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
 [2.0.0]: https://github.com/ricard33/signalk-chiplog/compare/v1.2.0...v2.0.0

package/README.md

@@ -1,7 +1,7 @@
 # Chiplog
 
-An automated logbook for [Signal K](https://signalk.org). Chiplog writes the logbook from the data already on your
-boat's Signal K server — passages, track, engine and sail, instrument readings, alarms — and lets the crew add what
+An automated nautical logbook for [Signal K](https://signalk.org). Chiplog writes the logbook from the data already on
+your boat's Signal K server — passages, track, engine and sail, instrument readings, alarms — and lets the crew add what
 sensors cannot know from a tablet at the helm: manoeuvres, notes and handwriting.
 
 - **One entry per passage**, opened when the boat leaves and closed as soon as it arrives, carrying on after short stops
@@ -348,6 +348,7 @@ In the Signal K admin, **Apps & Plugins → Configuration → Chiplog**.
 | InfluxDB database                                                | —                                             |                                                                                                                                                                                  |
 | InfluxDB username / password                                     | —                                             | Leave empty if the database needs none.                                                                                                                                          |
 | InfluxDB protocol                                                | http                                          | `http` or `https`.                                                                                                                                                               |
+| InfluxDB query timeout                                           | 30 s                                          | Each retrospective query gives up and reports an error past this, instead of hanging against an unreachable or overloaded database.                                              |
 | InfluxDB vessel context                                          | this server's own                             | Only needed running the replay from a different Signal K server than the one that wrote the history, e.g. development pointed at a production database.                          |
 
 ## Signal K data used 🔌
@@ -497,9 +498,10 @@ context** in the plugin configuration.
 ### A retrospective analysis takes minutes then fails with no clear reason
 
 The InfluxDB server did not answer — unreachable, overloaded, a firewall or a VPN not connected. Each query now gives up
-after 30 seconds with the connection problem it ran into, rather than hanging until some far longer, less informative
-failure; check that the server named in the plugin configuration is reachable from wherever Signal K runs, and that it
-is not overloaded.
+after **InfluxDB query timeout** (30 seconds by default) with the connection problem it ran into, rather than hanging
+until some far longer, less informative failure; check that the server named in the plugin configuration is reachable
+from wherever Signal K runs, and that it is not overloaded — or raise the timeout if it is simply slow to answer a
+six-hour chunk.
 
 ### A retrospective analysis over several days makes the InfluxDB server unresponsive
 

package/index.js

@@ -256,6 +256,14 @@ module.exports = function (app) {
         enum: ['http', 'https'],
         default: INFLUX_DEFAULTS.influxProtocol
       },
+      influxQueryTimeoutSeconds: {
+        type: 'number',
+        title: 'InfluxDB query timeout (seconds)',
+        description:
+          'Each retrospective query is given up on and reported as an error past this, rather than hanging indefinitely against an unreachable or overloaded database',
+        default: INFLUX_DEFAULTS.influxQueryTimeoutSeconds,
+        minimum: 1
+      },
       influxSelfContext: {
         type: 'string',
         title: 'InfluxDB vessel context',
@@ -266,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);
@@ -384,6 +406,8 @@ module.exports = function (app) {
         influxUsername: config.influxUsername || null,
         influxPassword: config.influxPassword || null,
         influxProtocol: config.influxProtocol || INFLUX_DEFAULTS.influxProtocol,
+        influxQueryTimeoutSeconds:
+          config.influxQueryTimeoutSeconds ?? INFLUX_DEFAULTS.influxQueryTimeoutSeconds,
         influxSelfContext: config.influxSelfContext || null
       };
 
@@ -461,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/detection.js

@@ -314,11 +314,16 @@ function createPassageDetector({ db, readSelfPath, settings, clock = Date.now })
   }
 
   function openPassage(now, position, departure) {
+    const startIso = iso(departure.time);
+    // Only a passage that actually precedes this departure can push it later
+    // -- not just whichever entry happens to hold the latest end_time. A
+    // retrospective replay filling a gap before passages logged live (SPEC
+    // §4.10) would otherwise have every reconstructed departure clamped to
+    // the most recent (unrelated, later) passage's end.
     const previousEnd = db
-      .prepare('SELECT MAX(end_time) AS endTime FROM log_entries')
-      .get().endTime;
-    const startTime =
-      previousEnd && iso(departure.time) < previousEnd ? previousEnd : iso(departure.time);
+      .prepare('SELECT MAX(end_time) AS endTime FROM log_entries WHERE start_time < ?')
+      .get(startIso).endTime;
+    const startTime = previousEnd && startIso < previousEnd ? previousEnd : startIso;
     const start = departure.position ?? position;
     const place = initialPlaceName(db, start, settings.placeMatchRadius);
 

package/lib/influx-history.js

@@ -12,17 +12,25 @@ const { AUTOSTATE_SOURCE_PREFIX, MAX_AGE_MS, UNDERWAY_STATES } = require('./dete
 // packets, a VPN not connected) can otherwise hang far longer than this --
 // Node's fetch has no default timeout of its own -- for an error that is no
 // clearer once it finally arrives, so `query` bounds every request itself.
-const QUERY_TIMEOUT_MS = 30 * 1000;
+// Configurable (`influxQueryTimeoutSeconds`): a Raspberry Pi under load can
+// need longer than the default to answer a six-hour chunk.
+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;
@@ -34,7 +42,8 @@ const INFLUX_DEFAULTS = {
   influxPort: 8086,
   influxDatabase: '',
   influxUsername: '',
-  influxPassword: ''
+  influxPassword: '',
+  influxQueryTimeoutSeconds: DEFAULT_QUERY_TIMEOUT_SECONDS
 };
 
 // Everything detection, track recording and observations read live (SPEC
@@ -107,9 +116,13 @@ function createInfluxHistory({
   username,
   password,
   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
   // answers, built once here rather than on every read.
   const series = new Map();
@@ -131,36 +144,59 @@ function createInfluxHistory({
       epoch: 'ms',
       q: statements.join(';')
     });
-    const timeout = AbortSignal.timeout(QUERY_TIMEOUT_MS);
-    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 ${QUERY_TIMEOUT_MS / 1000}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}`);
@@ -477,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;
@@ -71,8 +72,21 @@ function createReplayJob({
       username: settings.influxUsername,
       password: settings.influxPassword,
       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({
@@ -90,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);
           }
         }
       });
@@ -104,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 {
@@ -140,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 };
@@ -162,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,7 +1,7 @@
 {
   "name": "signalk-chiplog",
-  "version": "2.2.0",
-  "description": "Automated digital logbook plugin for Signal K, with keyboard/handwritten entry on tablet",
+  "version": "2.3.1",
+  "description": "Nautical logbook for Signal K: automatic entries, handwritten notes",
   "main": "index.js",
   "files": [
     "index.js",
@@ -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}',