kahu-signalk 0.0.16 → 0.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kahu-signalk",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "Contribute AIS and ARPA targets from your vessel to crowdsourcing for marine safety!",
   "keywords": [
     "signalk-node-server-plugin",

package/plugin/connector.js

@@ -75,7 +75,7 @@ class Connector {
     const content = response.Response;
 
     if (content["kahu.ErrorResponseMessage"] !== undefined) {
-      throw content.Error.exception;
+      throw content["kahu.ErrorResponseMessage"].exception;
     } else if (type !== undefined && content[type] === undefined) {
       throw (
         "Received response for wrong method: expected " +

package/plugin/index.js

@@ -149,6 +149,7 @@ module.exports = (app) => {
           getOwnPosition: () => app.getSelfPath("navigation.position")?.value,
           statusFn: (msg) => app.setPluginStatus(`Mayara: ${msg}`),
           pollIntervalMs: plugin.settings.mayara.poll_interval_ms || 2000,
+          verboseLogs: plugin.settings.mayara.verbose_logs === true,
         });
         plugin.mayaraIngestor.start();
       }
@@ -345,6 +346,11 @@ module.exports = (app) => {
                 default: 2000,
                 title: "Mayara HTTP fallback poll interval (ms)",
               },
+              verbose_logs: {
+                type: "boolean",
+                default: false,
+                title: "Enable verbose Mayara logs",
+              },
             },
           },
         },

package/plugin/mayara.js

@@ -4,12 +4,20 @@ const WebSocket = require("ws");
 const rad2deg = (rad) => (Number.isFinite(rad) ? (rad * 180) / Math.PI : null);
 
 class MayaraIngestor {
-  constructor({ baseUrl, routecache, getOwnPosition, statusFn, pollIntervalMs }) {
+  constructor({
+    baseUrl,
+    routecache,
+    getOwnPosition,
+    statusFn,
+    pollIntervalMs,
+    verboseLogs,
+  }) {
     this.baseUrl = (baseUrl || "http://localhost:6502").replace(/\/+$/, "");
     this.routecache = routecache;
     this.getOwnPosition = getOwnPosition || (() => null);
     this.statusFn = statusFn || (() => {});
     this.pollIntervalMs = pollIntervalMs || 2000;
+    this.verboseLogs = Boolean(verboseLogs);
 
     this.ws = null;
     this.pollTimer = null;
@@ -17,17 +25,43 @@ class MayaraIngestor {
     this.reconnectMs = 1000;
     this.wsFailCount = 0;
     this.destroyed = false;
+    this.halted = false;
 
     this.radarIds = [];
     this.targetUuids = new Map();
+    this._log("init", {
+      baseUrl: this.baseUrl,
+      pollIntervalMs: this.pollIntervalMs,
+      verboseLogs: this.verboseLogs,
+    });
+  }
+
+  _log(state, details = {}) {
+    const pairs =
+      details && typeof details === "object"
+        ? Object.entries(details)
+            .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+            .join(" ")
+        : `message=${JSON.stringify(String(details))}`;
+    const line = `[MayaraIngestor] state=${state}${pairs ? ` ${pairs}` : ""}`;
+    this.statusFn(line);
+    console.error(line);
+  }
+
+  _logVerbose(state, details = {}) {
+    if (!this.verboseLogs) return;
+    this._log(state, details);
   }
 
   async start() {
+    if (this.halted) return;
+    this._log("start", { message: "starting ingestor" });
     await this._discoverRadars();
-    this._connectWebSocket();
+    if (!this.halted) this._connectWebSocket();
   }
 
   async destroy() {
+    this._log("stop", { message: "destroy requested" });
     this.destroyed = true;
     if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
     if (this.pollTimer) clearInterval(this.pollTimer);
@@ -38,19 +72,57 @@ class MayaraIngestor {
       try {
         this.ws.close();
       } catch (err) {
-        this.statusFn(`Mayara WS close error: ${err.message}`);
+        this._log("ws_close_error", { error: err.message });
+      }
+    }
+    this.ws = null;
+    this._log("stop", { message: "ingestor destroyed" });
+  }
+
+  _halt(reason, details = {}) {
+    if (this.halted || this.destroyed) return;
+    this.halted = true;
+    this._log("halted", { reason, ...details });
+
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    this.reconnectTimer = null;
+    this.pollTimer = null;
+
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch (err) {
+        this._log("ws_close_error", { error: err.message });
       }
     }
     this.ws = null;
   }
 
+  _isServerUnreachable(err) {
+    if (!err) return false;
+    const message = String(err?.message || "").toLowerCase();
+    const code = String(err?.code || err?.cause?.code || "").toUpperCase();
+    return (
+      code === "ECONNREFUSED" ||
+      code === "ENOTFOUND" ||
+      code === "EHOSTUNREACH" ||
+      code === "ETIMEDOUT" ||
+      message.includes("fetch failed") ||
+      message.includes("connection refused") ||
+      message.includes("host unreachable")
+    );
+  }
+
   async _discoverRadars() {
+    if (this.destroyed || this.halted) return;
+    this._log("discover", { message: "requesting radar list" });
     try {
       const res = await fetch(
         `${this.baseUrl}/signalk/v2/api/vessels/self/radars`,
       );
       if (!res.ok) {
-        this.statusFn(`Mayara radar discovery failed: HTTP ${res.status}`);
+        this._log("discover_http_error", { status: res.status });
         return;
       }
       const payload = await res.json();
@@ -65,9 +137,15 @@ class MayaraIngestor {
         this.radarIds = [];
       }
 
-      this.statusFn(`Mayara discovered ${this.radarIds.length} radar(s)`);
+      this._log("discover_ok", { radarCount: this.radarIds.length });
     } catch (err) {
-      this.statusFn(`Mayara radar discovery error: ${err.message}`);
+      this._log("discover_error", { error: err.message });
+      if (this._isServerUnreachable(err)) {
+        this._halt("discover-unreachable", {
+          error: err.message,
+          code: err?.code || err?.cause?.code || null,
+        });
+      }
     }
   }
 
@@ -80,8 +158,9 @@ class MayaraIngestor {
   }
 
   _connectWebSocket() {
-    if (this.destroyed) return;
+    if (this.destroyed || this.halted) return;
     const wsUrl = this._buildWsUrl();
+    this._log("ws_connecting", { wsUrl });
 
     this.ws = new WebSocket(wsUrl);
 
@@ -92,23 +171,36 @@ class MayaraIngestor {
         clearInterval(this.pollTimer);
         this.pollTimer = null;
       }
-      this.statusFn("Mayara WS connected");
+      this._log("ws_open", { message: "connected" });
       this.ws.send(
         JSON.stringify({
           context: "vessels.self",
           subscribe: [{ path: "radars.*.targets.*", policy: "instant" }],
         }),
       );
+      this._log("ws_subscribe", { path: "radars.*.targets.*", policy: "instant" });
     });
 
     this.ws.on("message", (raw) => this._handleDelta(raw));
-    this.ws.on("error", (err) => this.statusFn(`Mayara WS error: ${err.message}`));
+    this.ws.on("error", (err) => {
+      this._log("ws_error", { error: err.message });
+      if (this._isServerUnreachable(err)) {
+        this._halt("ws-unreachable", {
+          error: err.message,
+          code: err?.code || err?.cause?.code || null,
+        });
+      }
+    });
     this.ws.on("close", () => this._scheduleReconnect());
   }
 
   _scheduleReconnect() {
-    if (this.destroyed) return;
+    if (this.destroyed || this.halted) return;
     this.wsFailCount += 1;
+    this._log(
+      "ws_close",
+      { failCount: this.wsFailCount, reconnectMs: this.reconnectMs },
+    );
 
     if (this.wsFailCount >= 3) this._startHttpFallback();
 
@@ -126,13 +218,37 @@ class MayaraIngestor {
   }
 
   _insertTarget(radarId, targetId, target) {
-    if (!target || target.status !== "tracking") return;
+    if (!target || target.status !== "tracking") {
+      this._logVerbose("target_skip", {
+        radarId,
+        targetId,
+        reason: "non-tracking",
+        status: target?.status,
+      });
+      return;
+    }
     const lat = target.position?.latitude;
     const lon = target.position?.longitude;
-    if (!Number.isFinite(lat) || !Number.isFinite(lon)) return;
+    if (!Number.isFinite(lat) || !Number.isFinite(lon)) {
+      this._logVerbose("target_skip", {
+        radarId,
+        targetId,
+        reason: "invalid-lat-lon",
+        latitude: lat,
+        longitude: lon,
+      });
+      return;
+    }
 
     const ownPos = this.getOwnPosition?.();
-    if (!ownPos?.latitude || !ownPos?.longitude) return;
+    if (!ownPos?.latitude || !ownPos?.longitude) {
+      this._logVerbose("target_skip", {
+        radarId,
+        targetId,
+        reason: "no-own-position",
+      });
+      return;
+    }
 
     this.routecache.insert({
       target_id: this._getTargetUuid(radarId, targetId),
@@ -154,6 +270,16 @@ class MayaraIngestor {
       courseOverGroundTrue: rad2deg(target.motion?.course),
       name: `ARPA-${targetId}`,
     });
+    this._logVerbose("target_insert", {
+      radarId,
+      targetId,
+      latitude: lat,
+      longitude: lon,
+      distance: target.position?.distance ?? null,
+      bearingRad: target.position?.bearing ?? null,
+      speed: target.motion?.speed ?? null,
+      courseRad: target.motion?.course ?? null,
+    });
   }
 
   _handleDelta(raw) {
@@ -161,15 +287,26 @@ class MayaraIngestor {
     try {
       msg = JSON.parse(raw.toString());
     } catch (err) {
+      this._log("delta_parse_error", { error: err.message });
       return;
     }
+    this._logVerbose("delta_received", { updates: msg?.updates?.length || 0 });
 
     for (const update of msg?.updates || []) {
       for (const value of update?.values || []) {
         const path = value?.path || "";
         const match = path.match(/^radars\.([^.]+)\.targets\.([^.]+)$/);
-        if (!match) continue;
-        if (!value.value) continue;
+        if (!match) {
+          this._logVerbose("delta_skip", {
+            reason: "path-not-radar-target",
+            path: path || "<empty>",
+          });
+          continue;
+        }
+        if (!value.value) {
+          this._logVerbose("delta_skip", { reason: "missing-value", path });
+          continue;
+        }
         const radarId = match[1];
         const targetId = match[2];
         this._insertTarget(radarId, targetId, value.value);
@@ -178,8 +315,8 @@ class MayaraIngestor {
   }
 
   _startHttpFallback() {
-    if (this.pollTimer || this.destroyed) return;
-    this.statusFn("Mayara WS unstable, enabling HTTP fallback polling");
+    if (this.pollTimer || this.destroyed || this.halted) return;
+    this._log("http_fallback_start", { reason: "ws-unstable" });
     this.pollTimer = setInterval(async () => {
       if (this.destroyed) return;
       if (!this.radarIds.length) await this._discoverRadars();
@@ -188,14 +325,21 @@ class MayaraIngestor {
           const res = await fetch(
             `${this.baseUrl}/signalk/v2/api/vessels/self/radars/${radarId}/targets`,
           );
-          if (!res.ok) continue;
+          if (!res.ok) {
+            this._log("http_poll_http_error", { radarId, status: res.status });
+            continue;
+          }
           const targets = await res.json();
-          if (!Array.isArray(targets)) continue;
+          if (!Array.isArray(targets)) {
+            this._log("http_poll_skip", { radarId, reason: "response-not-array" });
+            continue;
+          }
+          this._logVerbose("http_poll_ok", { radarId, targetCount: targets.length });
           for (const target of targets) {
             this._insertTarget(radarId, target?.id, target);
           }
         } catch (err) {
-          this.statusFn(`Mayara HTTP poll error: ${err.message}`);
+          this._log("http_poll_error", { radarId, error: err.message });
         }
       }
     }, this.pollIntervalMs);