geonix 1.32.0 → 1.32.2

package/README.md

@@ -295,6 +295,7 @@ Each returned part has:
 | `GX_LEVEL` | `info` | Log level: `debug`, `info`, `warn`, `error` |
 | `GX_STREAM_TIMEOUT` | `90000` | Max wait for a stream consumer to connect (ms) |
 | `GX_INACTIVITY_TIMEOUT` | `90000` | TCP proxy (HTTP-over-NATS) inactivity timeout (ms) |
+| `GX_HEALTH_TIMEOUT` | `2000` | Registry health-probe timeout per advertised address (ms) |
 | `GX_SECRET` | — | Encryption key: AES-256-GCM payloads + HMAC-SHA256 subjects. Services without the same key cannot communicate. |
 | `GX_DEBUG_ENDPOINT` | — | Mount path for the debug router (e.g. `/_debug`). Disabled when unset. |
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "geonix",
-    "version": "1.32.0",
+    "version": "1.32.2",
     "type": "module",
     "description": "",
     "bin": {

package/src/Registry.js

@@ -8,6 +8,11 @@ import { logger } from "./Logger.js";
 
 const REGISTRY_ENTRY_TIMEOUT = 5000;
 const GARBAGE_COLLECTOR_INTERVAL = 500;
+const HEALTH_TIMEOUT = 2000;
+
+// Read via function so tests can mutate the env after module load. Mirrors the
+// pattern used by getTransportTimeout / getStreamTimeout (per CLAUDE.md N6).
+const getHealthTimeout = () => parseInt(process.env.GX_HEALTH_TIMEOUT, 10) || HEALTH_TIMEOUT;
 
 /**
  * Maintains a local, in-process view of all services currently present on the NATS bus.
@@ -43,7 +48,7 @@ class Registry extends EventEmitter {
         this.#isActive = false;
     }
 
-    async #checkHealth(address, addresses, onFirstHealthy, timeout = 500) {
+    async #checkHealth(address, addresses, onFirstHealthy, timeout = getHealthTimeout()) {
         try {
             const result = await (await fetchWithTimeout(`http://${address}/!!_gx/health`, {}, timeout)).json();
 
@@ -137,17 +142,22 @@ class Registry extends EventEmitter {
         }
     }
 
-    // Refresh timeout for a known entry; if the beacon carries an `.a` that differs from
-    // the cached advertised list, kick off a re-probe to rebuild the healthy subset.
+    // Refresh timeout for a known entry; kick off a re-probe when either (a) the advertised
+    // list changed, or (b) the entry's healthy `a` is empty and the source is still advertising
+    // addresses — that's the "all probes failed at registration" case that needs to retry.
     #refreshKnown(entry, advertised) {
         entry.timeout = Date.now() + REGISTRY_ENTRY_TIMEOUT;
         if (!Array.isArray(advertised)) {
             return;
         }
-        if (this.#sameAddresses(entry.advertised ?? [], advertised)) {
+        const changed = !this.#sameAddresses(entry.advertised ?? [], advertised);
+        const stuckEmpty = (entry.a?.length ?? 0) === 0 && advertised.length > 0;
+        if (!changed && !stuckEmpty) {
             return;
         }
-        entry.advertised = [...advertised];
+        if (changed) {
+            entry.advertised = [...advertised];
+        }
         this.#reprobe(entry).catch((e) => logger.error("registry.reprobe:", e));
     }
 

package/src/Request.js

@@ -73,11 +73,16 @@ export async function Request(service, method, args, context, options) {
     return directRequest(identifier, method, args, context, options, service);
 }
 
+let _httpInstanceRoundRobin = 0;
 let _httpRpcRoundRobin = 0;
 
+const DEFAULT_HTTP_TIMEOUT = 300_000;
+
 /**
  * Sends a request directly to a resolved registry identifier without performing a registry
- * lookup. Prefers HTTP RPC for single-instance services; falls back to NATS otherwise.
+ * lookup. Prefers HTTP RPC; for multi-instance services round-robins across instances that
+ * have advertised addresses. Falls back to NATS when no instance has addresses or the HTTP
+ * attempt fails.
  *
  * @param {string} identifier - Registry identifier in the form `"Name@version"` or an instance ID.
  * @param {string} method - Method name to invoke on the service.
@@ -92,53 +97,53 @@ export async function directRequest(identifier, method, args, context, options,
     const originator = rpcContext.getStore()?.originator;
     const requestBegin = Date.now();
 
-    // try HTTP RPC first if the service has a single known instance with addresses
-    // (multiple instances use NATS so queue-group distribution is preserved)
+    // HTTP path: round-robin across instances that have advertised addresses; within the
+    // chosen instance, round-robin across addresses (loopback-prefer kept by isLoopbackAddress).
+    // NATS handles the fallback when no usable instance exists or the HTTP attempt fails.
     const entries = registry.getEntriesForIdentifier(identifier);
-    if (entries.length === 1) {
-        const addresses = entries[0].a || [];
-        if (addresses.length > 0) {
-            const loopback = addresses.filter(isLoopbackAddress);
-            const remote = addresses.filter((a) => !isLoopbackAddress(a));
-            const pool = loopback.length > 0 ? loopback : remote;
-            const address = pool[_httpRpcRoundRobin++ % pool.length];
-
-            const url = `http://${address}/!!_gx/rpc/${hash(entries[0].i)}`;
-            const rpcPayload = { m: method, a: args, c: context, o: originator };
-            const fetchBody = _payloadKey
-                ? encryptPayload(Buffer.from(JSON.stringify(rpcPayload)))
-                : JSON.stringify(rpcPayload);
-            const contentType = _payloadKey ? "application/octet-stream" : "application/json";
-
-            let httpResponse;
-            try {
-                const res = await fetchWithTimeout(
-                    url,
-                    {
-                        method: "POST",
-                        headers: { "content-type": contentType },
-                        body: fetchBody,
-                    },
-                    options?.httpTimeout ?? 5000,
-                );
-                if (res.ok) {
-                    httpResponse = _payloadKey
-                        ? JSON.parse(decryptPayload(Buffer.from(await res.arrayBuffer())))
-                        : await res.json();
-                }
-            } catch (e) {
-                logger.debug("directRequest: HTTP RPC failed, falling back to NATS", address, e.message);
+    const usable = entries.filter((e) => e.a?.length > 0);
+    if (usable.length > 0) {
+        const instance = usable[_httpInstanceRoundRobin++ % usable.length];
+        const loopback = instance.a.filter(isLoopbackAddress);
+        const remote = instance.a.filter((a) => !isLoopbackAddress(a));
+        const pool = loopback.length > 0 ? loopback : remote;
+        const address = pool[_httpRpcRoundRobin++ % pool.length];
+
+        const url = `http://${address}/!!_gx/rpc/${hash(instance.i)}`;
+        const rpcPayload = { m: method, a: args, c: context, o: originator };
+        const fetchBody = _payloadKey
+            ? encryptPayload(Buffer.from(JSON.stringify(rpcPayload)))
+            : JSON.stringify(rpcPayload);
+        const contentType = _payloadKey ? "application/octet-stream" : "application/json";
+
+        let httpResponse;
+        try {
+            const res = await fetchWithTimeout(
+                url,
+                {
+                    method: "POST",
+                    headers: { "content-type": contentType },
+                    body: fetchBody,
+                },
+                options?.httpTimeout ?? DEFAULT_HTTP_TIMEOUT,
+            );
+            if (res.ok) {
+                httpResponse = _payloadKey
+                    ? JSON.parse(decryptPayload(Buffer.from(await res.arrayBuffer())))
+                    : await res.json();
             }
+        } catch (e) {
+            logger.debug("directRequest: HTTP RPC failed, falling back to NATS", address, e.message);
+        }
 
-            if (httpResponse) {
-                if (httpResponse.e) {
-                    throw Error(`Request: remote error: ${httpResponse.e}`);
-                }
-                if (isStream(httpResponse.r)) {
-                    return JSON.parse(await streamToString(httpResponse.r));
-                }
-                return httpResponse.r;
+        if (httpResponse) {
+            if (httpResponse.e) {
+                throw Error(`Request: remote error: ${httpResponse.e}`);
+            }
+            if (isStream(httpResponse.r)) {
+                return JSON.parse(await streamToString(httpResponse.r));
             }
+            return httpResponse.r;
         }
     }
 

package/src/Util.js

@@ -211,6 +211,15 @@ export function getNetworkAddresses() {
     for (const interfaceAddresses of Object.values(interfaces)) {
         if (!interfaceAddresses) { continue; }
         for (const addressObject of interfaceAddresses) {
+            // Skip IPv6 link-local addresses (fe80::/10). They require a zone identifier
+            // (e.g. %eth0) to route, which `fetch()` doesn't accept — advertising them
+            // just wastes a probe slot.
+            if (
+                addressObject.family === "IPv6" &&
+                addressObject.address.toLowerCase().startsWith("fe80:")
+            ) {
+                continue;
+            }
             const addr = addressObject.family === "IPv4"
                 ? addressObject.address
                 : addressObject.family === "IPv6"