@meri-imperiumi/signalk-triplogger 1.3.2 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [Unreleased]
+
+## [1.4.0] - 2026-09-09
+
+### Added
+- Option to publish the current trip log (`log_path`) and the total log
+  (`totals_path`) under configurable Signal K paths, for setups where the
+  standard `navigation.trip.log`/`navigation.log` paths are owned by another
+  provider. Non-standard paths are announced with `units: m` metadata
+
+### Fixed
+- Don't overwrite the current trip log at startup: log preparation is now
+  serialized so distance appends and state handling always run against the
+  persisted log once it has finished loading from disk
+
 ## [1.3.2] - 2026-08-23
 
 ### Added

package/index.js

@@ -27,37 +27,56 @@ module.exports = (app) => {
     return join(app.getDataDirPath(), `${logName}.json`);
   }
 
+  let logsPrepared = Promise.resolve();
+
   function prepareLogs() {
-    const newLogs = getLogNames();
-    return Promise.all(Object.keys(logs).map((logName) => {
-      // Close old logs
-      if (newLogs.indexOf(logName) === -1) {
-        // If log is not in the new log list, end it
-        const oldLog = logs[logName];
-        delete logs[logName];
-        return oldLog.endTrip();
-      }
-      return Promise.resolve();
-    }))
-      .then(() => Promise.all(newLogs.map((logName) => {
-        // Load new logs
-        if (!logs[logName]) {
-          // New log, or saved log?
-          logs[logName] = new Logger(getLogPath(logName));
-          return logs[logName].exists()
-            .then((exists) => {
-              if (!exists) {
-                // New log, no need to load
-                return Promise.resolve();
-              }
-              return logs[logName].load();
-            });
+    // Serialize preparations: a Logger instance is created synchronously,
+    // but only loaded from disk asynchronously. Without serialization a
+    // second call (for example, a position delta right after a state
+    // delta at startup) would see the instance already in `logs` and
+    // proceed before `load()` has finished, appending to and saving a
+    // fresh zeroed log over the persisted one.
+    const preparation = logsPrepared.then(() => {
+      const newLogs = getLogNames();
+      return Promise.all(Object.keys(logs).map((logName) => {
+        // Close old logs
+        if (newLogs.indexOf(logName) === -1) {
+          // If log is not in the new log list, end it
+          const oldLog = logs[logName];
+          delete logs[logName];
+          return oldLog.endTrip();
         }
         return Promise.resolve();
-      })));
+      }))
+        .then(() => Promise.all(newLogs.map((logName) => {
+          // Load new logs
+          if (!logs[logName]) {
+            // New log, or saved log?
+            const log = new Logger(getLogPath(logName));
+            logs[logName] = log;
+            return log.exists()
+              .then((exists) => {
+                if (!exists) {
+                  // New log, no need to load
+                  return Promise.resolve();
+                }
+                return log.load();
+              });
+          }
+          return Promise.resolve();
+        })));
+    });
+    // Keep the chain usable even if a single preparation fails
+    logsPrepared = preparation.catch(() => {});
+    return preparation;
   }
 
   plugin.start = (options) => {
+    // Paths the logs are published under. Configure these when another
+    // provider owns the standard paths, for example when a club's total
+    // log is maintained elsewhere for their maintenance schedule.
+    const tripLogPath = options.log_path || 'navigation.trip.log';
+    const totalLogPath = options.totals_path || 'navigation.log';
     const subscription = {
       context: 'vessels.self',
       subscribe: [
@@ -77,7 +96,7 @@ module.exports = (app) => {
       const resetTime = logs.current.log.started;
       const values = [
         {
-          path: 'navigation.trip.log',
+          path: tripLogPath,
           value: logs.current.log.total,
         },
         {
@@ -88,7 +107,7 @@ module.exports = (app) => {
       if (options.totals) {
         const base = options.totals_base || 0;
         values.push({
-          path: 'navigation.log',
+          path: totalLogPath,
           value: logs.total.log.total + base,
         });
       }
@@ -118,14 +137,14 @@ module.exports = (app) => {
         .then(() => {
           const values = [
             {
-              path: 'navigation.trip.log',
+              path: tripLogPath,
               value: logs.current.log.total,
             },
           ];
           if (options.totals) {
             const base = options.totals_base || 0;
             values.push({
-              path: 'navigation.log',
+              path: totalLogPath,
               value: logs.total.log.total + base,
             });
           }
@@ -141,6 +160,9 @@ module.exports = (app) => {
               },
             ],
           });
+        })
+        .catch((err) => {
+          app.error(`Error:${err}`);
         });
     }
 
@@ -158,9 +180,53 @@ module.exports = (app) => {
             resetTrip();
             setStatus('New trip has started. Log reset');
           }
+        })
+        .catch((err) => {
+          app.error(`Error:${err}`);
         });
     }
 
+    function sendMeta() {
+      // Non-standard paths are not in the Signal K schema, so consumers
+      // cannot know their units. Tell the server they are meters.
+      const meta = [];
+      if (tripLogPath !== 'navigation.trip.log') {
+        meta.push({
+          path: tripLogPath,
+          value: {
+            units: 'm',
+            displayName: 'Current trip log',
+            description: 'Distance travelled during the current trip',
+          },
+        });
+      }
+      if (options.totals && totalLogPath !== 'navigation.log') {
+        meta.push({
+          path: totalLogPath,
+          value: {
+            units: 'm',
+            displayName: 'Total log',
+            description: 'Total distance travelled',
+          },
+        });
+      }
+      if (meta.length === 0) {
+        return;
+      }
+      app.handleMessage(plugin.id, {
+        context: `vessels.${app.selfId}`,
+        updates: [
+          {
+            source: {
+              label: plugin.id,
+            },
+            timestamp: (new Date().toISOString()),
+            meta,
+          },
+        ],
+      });
+    }
+
     app.subscriptionmanager.subscribe(
       subscription,
       unsubscribes,
@@ -204,6 +270,15 @@ module.exports = (app) => {
       },
     );
 
+    // Load persisted logs eagerly so that a trip ongoing from a previous
+    // session is continued when deltas arrive, instead of being reset
+    prepareLogs().catch((err) => {
+      app.error(`Error:${err}`);
+    });
+
+    // Declare units for any non-standard paths we publish to
+    sendMeta();
+
     setStatus('Waiting for updates');
   };
 
@@ -220,10 +295,20 @@ module.exports = (app) => {
         default: 10000,
         title: 'How often to update log, in milliseconds',
       },
+      log_path: {
+        type: 'string',
+        default: 'navigation.trip.log',
+        title: 'Signal K path to publish the current trip log to',
+      },
       totals: {
         type: 'boolean',
         default: true,
-        title: 'Publish a total number in navigation.log',
+        title: 'Publish a total number in the total log path',
+      },
+      totals_path: {
+        type: 'string',
+        default: 'navigation.log',
+        title: 'Signal K path to publish the total log to',
       },
       totals_base: {
         type: 'number',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meri-imperiumi/signalk-triplogger",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "description": "Log the length of the current trip",
   "main": "index.js",
   "scripts": {

package/tests/plugin.test.js

@@ -260,6 +260,217 @@ test('totals option also publishes navigation.log', async () => {
   assert.ok(value > 100, `navigation.log value was ${value}`);
 });
 
+test('startup with an ongoing trip continues it instead of resetting to zero', async () => {
+  const app = new FakeSignalKApp();
+  // An ongoing trip from a previous session: started, never ended.
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: null,
+    total: 5000,
+    states: { sailing: 5000 },
+  });
+  const plugin = makePlugin(app);
+  plugin.start({ totals: false });
+
+  // Emit state and positions back-to-back, in the same tick, so they
+  // race against the async log loading from disk. This used to overwrite
+  // current.json with a fresh zeroed log before the saved one was loaded.
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [{ values: [{ path: 'navigation.state', value: 'sailing' }] }],
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.0, longitude: 24.0 } }] },
+    ],
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.001, longitude: 24.0 } }] },
+    ],
+  });
+  await waitFor(() => app.messages
+    .flatMap(({ message }) => message.updates.flatMap((u) => u.values))
+    .some((v) => v.path === 'navigation.trip.log'));
+  plugin.stop();
+
+  // The persisted trip must survive startup: no reset to zero, and the
+  // newly logged distance accumulates on top of the existing total.
+  const current = readLog(app, 'current');
+  assert.ok(
+    current.total >= 5000,
+    `current.total was ${current.total}, expected the ongoing trip to continue`,
+  );
+  assert.ok(
+    !app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+    `unexpected new-trip reset at startup: ${JSON.stringify(app.statusMessages)}`,
+  );
+
+  // The published trip log should also continue from the persisted total.
+  const tripValues = app.messages
+    .flatMap(({ message }) => message.updates.flatMap((u) => u.values))
+    .filter((v) => v.path === 'navigation.trip.log');
+  assert.ok(tripValues.length > 0, 'no navigation.trip.log delta was emitted');
+  assert.ok(
+    tripValues[tripValues.length - 1].value >= 5000,
+    `last trip.log value was ${tripValues[tripValues.length - 1].value}`,
+  );
+});
+
+/**
+ * Flatten all value objects the app has received from the plugin.
+ * Meta-only messages have no `values`, so those updates are skipped.
+ *
+ * @param {FakeSignalKApp} app
+ * @returns {Array<{path: string, value: number}>}
+ */
+function emittedValues(app) {
+  return app.messages.flatMap(
+    ({ message }) => message.updates.filter((u) => u.values).flatMap((u) => u.values),
+  );
+}
+
+/**
+ * Flatten all meta entries the app has received from the plugin.
+ *
+ * @param {FakeSignalKApp} app
+ * @returns {Array<{path: string, value: object}>}
+ */
+function emittedMeta(app) {
+  return app.messages.flatMap(
+    ({ message }) => message.updates.filter((u) => u.meta).flatMap((u) => u.meta),
+  );
+}
+
+test('custom log_path publishes the trip log under the configured path', async () => {
+  const app = new FakeSignalKApp();
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: '2026-01-01T01:00:00.000Z',
+    total: 0,
+    states: {},
+  });
+  const plugin = makePlugin(app);
+  plugin.start({
+    log_path: 'navigation.trip.currentTripLog',
+    totals: false,
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [{ values: [{ path: 'navigation.state', value: 'sailing' }] }],
+  });
+  await waitFor(
+    () => app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+  );
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.0, longitude: 24.0 } }] },
+    ],
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.001, longitude: 24.0 } }] },
+    ],
+  });
+  await waitFor(
+    () => emittedValues(app).some(
+      (v) => v.path === 'navigation.trip.currentTripLog' && v.value > 0,
+    ),
+  );
+  plugin.stop();
+
+  // The trip log is published under the configured custom path...
+  assert.ok(
+    emittedValues(app).some((v) => v.path === 'navigation.trip.currentTripLog'),
+    'no delta was emitted to navigation.trip.currentTripLog',
+  );
+  // ...and not under the standard path
+  assert.ok(
+    !emittedValues(app).some((v) => v.path === 'navigation.trip.log'),
+    'navigation.trip.log should not be written when log_path is set',
+  );
+  // The non-standard path is announced with units metadata
+  const tripMeta = emittedMeta(app).find((m) => m.path === 'navigation.trip.currentTripLog');
+  assert.ok(tripMeta, 'no meta was sent for the custom trip log path');
+  assert.strictEqual(tripMeta.value.units, 'm');
+});
+
+test('custom totals_path publishes the total under the configured path', async () => {
+  const app = new FakeSignalKApp();
+  seedLog(app, 'current', {
+    started: '2026-01-01T00:00:00.000Z',
+    ended: '2026-01-01T01:00:00.000Z',
+    total: 0,
+    states: {},
+  });
+  const plugin = makePlugin(app);
+  plugin.start({
+    totals: true,
+    totals_base: 100,
+    totals_path: 'navigation.log.clubTotal',
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [{ values: [{ path: 'navigation.state', value: 'motoring' }] }],
+  });
+  await waitFor(
+    () => app.statusMessages.some((m) => /new trip/i.test(m.msg)),
+  );
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.0, longitude: 24.0 } }] },
+    ],
+  });
+  emitDelta(app, {
+    context: 'vessels.self',
+    updates: [
+      { values: [{ path: 'navigation.position', value: { latitude: 60.002, longitude: 24.0 } }] },
+    ],
+  });
+  await waitFor(
+    () => emittedValues(app).some(
+      (v) => v.path === 'navigation.log.clubTotal' && v.value > 100,
+    ),
+  );
+  plugin.stop();
+
+  // The total is published under the configured custom path...
+  assert.ok(
+    emittedValues(app).some((v) => v.path === 'navigation.log.clubTotal'),
+    'no delta was emitted to navigation.log.clubTotal',
+  );
+  // ...and not under the standard path
+  assert.ok(
+    !emittedValues(app).some((v) => v.path === 'navigation.log'),
+    'navigation.log should not be written when totals_path is set',
+  );
+  // The trip log keeps its standard path unless configured otherwise
+  assert.ok(
+    emittedValues(app).some((v) => v.path === 'navigation.trip.log'),
+    'navigation.trip.log should still be emitted with only totals_path set',
+  );
+  // The non-standard path is announced with units metadata
+  const totalMeta = emittedMeta(app).find((m) => m.path === 'navigation.log.clubTotal');
+  assert.ok(totalMeta, 'no meta was sent for the custom totals path');
+  assert.strictEqual(totalMeta.value.units, 'm');
+  // No meta is needed for the standard trip path
+  assert.ok(
+    !emittedMeta(app).some((m) => m.path === 'navigation.trip.log'),
+    'standard paths should not get meta',
+  );
+});
+
+test('standard paths send no meta messages', () => {
+  const { app, plugin } = makeStarted();
+  assert.strictEqual(emittedMeta(app).length, 0);
+  plugin.stop();
+});
+
 test('stop clears subscriptions', () => {
   const { app, plugin } = makeStarted();
   assert.strictEqual(app.subscriptionmanager.subscriptions.length, 1);