@meri-imperiumi/signalk-triplogger 1.4.0 → 1.4.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [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

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

@@ -52,7 +52,10 @@ module.exports = (app) => {
           // Load new logs
           if (!logs[logName]) {
             // New log, or saved log?
-            const log = new Logger(getLogPath(logName));
+            const log = new Logger(
+              getLogPath(logName),
+              (message) => app.error(message),
+            );
             logs[logName] = log;
             return log.exists()
               .then((exists) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meri-imperiumi/signalk-triplogger",
-  "version": "1.4.0",
+  "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

@@ -471,6 +471,52 @@ test('standard paths send no meta messages', () => {
   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);