@meri-imperiumi/signalk-triplogger 1.3.2 → 1.4.1

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [Unreleased]
+
+## [1.4.1] - 2026-09-10
+
+### Fixed
+- Fix server crash when a log file is corrupt, empty, or not a JSON
+  object: parse errors are now caught inside the read callback instead of
+  escaping as an uncaught exception that killed signalk-server. The bad
+  file is backed up as `<name>.json.corrupt` and a fresh log is started
+- Persist logs atomically (temp file + fsync + rename) so a crash or
+  power loss mid-write can no longer truncate log files
+
+## [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/Logger.js

@@ -1,15 +1,24 @@
 const fs = require('fs');
+const { promisify } = require('util');
+
+const fsWriteFile = promisify(fs.writeFile);
+const fsOpen = promisify(fs.open);
+const fsFsync = promisify(fs.fsync);
+const fsClose = promisify(fs.close);
+const fsRename = promisify(fs.rename);
 
 function toNM(meters) {
   return (meters / 1852).toFixed(2);
 }
 
 class Logger {
-  constructor(filename) {
+  constructor(filename, onError) {
     this.state = null;
     this.filename = filename;
+    this.onError = onError;
     this.reset();
     this.unsaved = false;
+    this.saves = Promise.resolve();
   }
 
   reset() {
@@ -70,18 +79,36 @@ class Logger {
   }
 
   save() {
+    // Serialize writes: concurrent saves writing to the same temp file
+    // could interleave, and an older snapshot could be renamed over a
+    // newer one. Each save runs only after the previous one settles.
+    const previous = this.saves;
+    this.saves = previous.then(
+      () => this.write(),
+      () => this.write(),
+    );
+    return this.saves;
+  }
+
+  async write() {
     if (!this.unsaved) {
-      return Promise.resolve();
+      return;
     }
-    return new Promise((resolve, reject) => {
-      fs.writeFile(this.filename, JSON.stringify(this.log, null, 2), (err) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve();
-      });
-    });
+    const tmpFile = `${this.filename}.tmp`;
+    await fsWriteFile(tmpFile, JSON.stringify(this.log, null, 2));
+    // Flush the temp file to disk before renaming: without fsync, a
+    // power loss can persist the rename while the file's contents never
+    // made it to disk, recreating a truncated log
+    const fd = await fsOpen(tmpFile, 'r+');
+    try {
+      await fsFsync(fd);
+    } finally {
+      await fsClose(fd);
+    }
+    // Rename over an existing file is atomic: readers see either the
+    // old log or the new one, never a partially written one
+    await fsRename(tmpFile, this.filename);
+    this.unsaved = false;
   }
 
   exists() {
@@ -103,9 +130,29 @@ class Logger {
           reject(err);
           return;
         }
-        this.log = JSON.parse(contents);
-        this.unsaved = false;
-        resolve();
+        try {
+          const parsed = JSON.parse(contents);
+          if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('Not a JSON object');
+          }
+          this.log = parsed;
+          this.unsaved = false;
+          resolve();
+        } catch (parseError) {
+          // Corrupt (for example truncated by a crash mid-write) or empty
+          // log file. Back it up for manual recovery and start a fresh log
+          // instead of failing the whole plugin.
+          const backup = `${this.filename}.corrupt`;
+          fs.rename(this.filename, backup, () => {
+            this.reset();
+            if (this.onError) {
+              this.onError(
+                `Corrupt log file ${this.filename} (${parseError.message}). Backed up to ${backup}, starting a fresh log`,
+              );
+            }
+            resolve();
+          });
+        }
       });
     });
   }

package/index.js

@@ -27,37 +27,59 @@ 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),
+              (message) => app.error(message),
+            );
+            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 +99,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 +110,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 +140,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 +163,9 @@ module.exports = (app) => {
               },
             ],
           });
+        })
+        .catch((err) => {
+          app.error(`Error:${err}`);
         });
     }
 
@@ -158,9 +183,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 +273,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 +298,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.1",
   "description": "Log the length of the current trip",
   "main": "index.js",
   "scripts": {

package/tests/logger.test.js

@@ -0,0 +1,148 @@
+/**
+ * Smoke tests for the Logger: persistence, atomic saves, and recovery
+ * from corrupt or empty log files.
+ * @file logger.test.js
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  mkdtempSync,
+  readFileSync,
+  writeFileSync,
+  existsSync,
+} = require('node:fs');
+const { tmpdir } = require('node:os');
+const { join } = require('node:path');
+
+const Logger = require('../Logger');
+
+/**
+ * Build a Logger with a fresh temp directory, a log filename inside it,
+ * and an error collector for the onError callback.
+ *
+ * @returns {{dir: string, filename: string, logger: Logger, errors: string[]}}
+ */
+function makeLogger() {
+  const dir = mkdtempSync(join(tmpdir(), 'triplogger-logger-'));
+  const filename = join(dir, '2026-09-11.json');
+  const errors = [];
+  const logger = new Logger(filename, (message) => errors.push(message));
+  return {
+    dir,
+    filename,
+    logger,
+    errors,
+  };
+}
+
+/**
+ * Read a file in the logger's directory as JSON.
+ *
+ * @param {string} dir
+ * @param {string} name file name without directory
+ * @returns {object}
+ */
+function readJson(dir, name) {
+  return JSON.parse(readFileSync(join(dir, name), 'utf-8'));
+}
+
+test('save persists the log as valid JSON and leaves no temp files', async () => {
+  const { dir, filename, logger } = makeLogger();
+  logger.setState('sailing');
+  logger.appendTrip(1000);
+  await logger.save();
+
+  const persisted = readJson(dir, '2026-09-11.json');
+  assert.strictEqual(persisted.total, 1000);
+  assert.strictEqual(persisted.states.sailing, 1000);
+  assert.ok(!existsSync(`${filename}.tmp`), 'temp file was left behind');
+});
+
+test('load restores a persisted log', async () => {
+  const { filename } = makeLogger();
+  const first = new Logger(filename);
+  first.setState('motoring');
+  first.appendTrip(500);
+  await first.save();
+
+  const errors = [];
+  const second = new Logger(filename, (m) => errors.push(m));
+  await second.load();
+  assert.strictEqual(second.toJSON().total, 500);
+  assert.strictEqual(second.toJSON().states.motoring, 500);
+  assert.strictEqual(errors.length, 0);
+});
+
+test('overlapping saves persist the newest state without corrupting the file', async () => {
+  const { dir, filename, logger } = makeLogger();
+  logger.appendTrip(1);
+  const first = logger.save();
+  // Mutate while the first save is still in flight
+  logger.appendTrip(2);
+  const second = logger.save();
+  await Promise.all([first, second]);
+
+  assert.strictEqual(readJson(dir, '2026-09-11.json').total, 3);
+  assert.ok(!existsSync(`${filename}.tmp`), 'temp file was left behind');
+});
+
+test('load recovers from a truncated log file by backing it up', async () => {
+  const {
+    dir,
+    filename,
+    logger,
+    errors,
+  } = makeLogger();
+  const corrupt = '{"started": "2026-09-11T00:00:00.000Z", "total": 50';
+  writeFileSync(filename, corrupt, 'utf-8');
+
+  await logger.load();
+
+  // The corrupt contents are preserved for manual recovery
+  assert.ok(existsSync(`${filename}.corrupt`), 'no .corrupt backup was made');
+  assert.strictEqual(readFileSync(`${filename}.corrupt`, 'utf-8'), corrupt);
+  // The corruption was reported
+  assert.ok(errors.length > 0, 'corruption was not reported via onError');
+  assert.match(errors[0], /corrupt/i);
+  // The logger works from a fresh log afterwards
+  assert.strictEqual(logger.toJSON().total, 0);
+  logger.appendTrip(100);
+  await logger.save();
+  assert.strictEqual(readJson(dir, '2026-09-11.json').total, 100);
+});
+
+test('load recovers from an empty log file', async () => {
+  const {
+    dir,
+    filename,
+    logger,
+    errors,
+  } = makeLogger();
+  writeFileSync(filename, '', 'utf-8');
+
+  await logger.load();
+
+  assert.ok(existsSync(`${filename}.corrupt`));
+  assert.ok(errors.length > 0, 'corruption was not reported via onError');
+  logger.appendTrip(100);
+  await logger.save();
+  assert.strictEqual(readJson(dir, '2026-09-11.json').total, 100);
+});
+
+test('load recovers from a log file containing a JSON scalar', async () => {
+  const { filename, logger, errors } = makeLogger();
+  writeFileSync(filename, 'null', 'utf-8');
+
+  await logger.load();
+
+  assert.ok(existsSync(`${filename}.corrupt`));
+  assert.ok(errors.length > 0, 'corruption was not reported via onError');
+  assert.strictEqual(logger.toJSON().total, 0);
+});
+
+test('load still rejects on read errors', async () => {
+  const { filename } = makeLogger();
+  const logger = new Logger(filename);
+  await assert.rejects(() => logger.load(), /ENOENT/);
+});

package/tests/plugin.test.js

@@ -260,6 +260,263 @@ 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('a corrupt persisted log is backed up and logging continues', async () => {
+  const app = new FakeSignalKApp();
+  // A log truncated by a crash mid-write. With the old code this threw
+  // an uncaught exception from the readFile callback, killing the whole
+  // server process on every startup.
+  const corrupt = '{"started": "2026-09-11T00:00:00.000Z", "total": 5000';
+  writeFileSync(join(app.dataPath, 'current.json'), corrupt, 'utf-8');
+  const plugin = makePlugin(app);
+  plugin.start({ totals: false });
+
+  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' && v.value > 0));
+  plugin.stop();
+
+  // The corrupt contents are preserved for manual recovery...
+  assert.strictEqual(
+    readFileSync(join(app.dataPath, 'current.json.corrupt'), 'utf-8'),
+    corrupt,
+  );
+  // ...and the corruption was reported
+  assert.ok(
+    app.errors.some((e) => /corrupt/i.test(e)),
+    `got ${JSON.stringify(app.errors)}`,
+  );
+  // Logging continues from a fresh log
+  const current = readLog(app, 'current');
+  assert.ok(current.total > 0, `current.total was ${current.total}`);
+});
+
 test('stop clears subscriptions', () => {
   const { app, plugin } = makeStarted();
   assert.strictEqual(app.subscriptionmanager.subscriptions.length, 1);