spice-couchbase 2.0.63 → 2.0.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-couchbase",
-  "version": "2.0.63",
+  "version": "2.0.64",
   "description": "",
   "main": "build/index.js",
   "scripts": {

package/src/connectionHealth.js

@@ -215,8 +215,43 @@ function createHealthMonitor({
     };
   }
 
+  // KV is checked with a bucket ping, not a document operation: the boot-time
+  // collection handle can name a collection that does not exist (a named
+  // scope has no `_default` collection), and KV operations against it retry
+  // until they time out even though every real request succeeds.
+  async function probeKv(bucket, timeout) {
+    let report;
+    try {
+      report = await bucket.ping({
+        serviceTypes: [couchbase.ServiceType.KeyValue],
+        timeout,
+      });
+    } catch (error) {
+      throw labelled(error, "KV ping");
+    }
+    const endpoints = Object.values(report?.services || {}).flat();
+    // One node answering is enough. A single node being down is the cluster's
+    // problem, and a fresh connection would not fix it.
+    if (!endpoints.some((endpoint) => endpoint?.state === couchbase.PingState.Ok)) {
+      const states = endpoints
+        .map((endpoint) => couchbase.PingState[endpoint?.state] ?? endpoint?.state)
+        .join(", ");
+      throw labelled(
+        new Error(`no endpoint responded (${states || "no endpoints"})`),
+        "KV ping",
+      );
+    }
+  }
+
+  function labelled(error, label) {
+    const wrapped = new Error(`${label} failed: ${describe(error)}`);
+    wrapped.cause = error;
+    wrapped.spiceConnectivity = true;
+    return wrapped;
+  }
+
   async function probe(handles) {
-    if (!handles?.cluster || !handles?.collection) {
+    if (!handles?.cluster || !handles?.bucket) {
       const error = new Error("No cluster handles to probe");
       error.spiceConnectivity = true;
       throw error;
@@ -225,8 +260,10 @@ function createHealthMonitor({
     // The hard deadline is the point: a wedged SDK may never honour its own.
     await deadline(
       Promise.all([
-        handles.collection.exists("__spice_health_probe__", { timeout }),
-        handles.cluster.query("SELECT 1", { timeout }),
+        probeKv(handles.bucket, timeout),
+        handles.cluster.query("SELECT 1", { timeout }).catch((error) => {
+          throw labelled(error, "Query probe");
+        }),
       ]),
       timeout + 1000,
       "Couchbase health probe",
@@ -326,10 +363,14 @@ function createHealthMonitor({
           couchbase.ServiceType?.Query,
         ].filter(Boolean);
         await deadline(
-          handles.bucket.waitUntilReady(
-            settings.reconnectTimeoutMs,
-            serviceTypes.length ? { serviceTypes } : undefined,
-          ),
+          handles.bucket
+            .waitUntilReady(
+              settings.reconnectTimeoutMs,
+              serviceTypes.length ? { serviceTypes } : undefined,
+            )
+            .catch((error) => {
+              throw labelled(error, "waitUntilReady");
+            }),
           settings.reconnectTimeoutMs + 1000,
           "Couchbase waitUntilReady",
         );

package/src/connectionHealth.test.js

@@ -28,6 +28,7 @@ function fakeCluster(id, { healthy = true, hang = false } = {}) {
     hang,
     closed: 0,
     queries: 0,
+    kvStates: [couchbase.PingState.Ok],
     async close() {
       cluster.closed += 1;
     },
@@ -45,6 +46,13 @@ function fakeCluster(id, { healthy = true, hang = false } = {}) {
         async waitUntilReady() {
           if (!cluster.healthy) throw timeoutError();
         },
+        ping() {
+          if (cluster.hang) return new Promise(() => {});
+          if (!cluster.healthy) return Promise.reject(timeoutError());
+          return Promise.resolve({
+            services: { kv: cluster.kvStates.map((state) => ({ state })) },
+          });
+        },
         scope(scopeName) {
           return {
             name: scopeName,
@@ -53,11 +61,10 @@ function fakeCluster(id, { healthy = true, hang = false } = {}) {
               return {
                 name: collectionName,
                 cluster,
+                // Like `_default` inside a named scope: the collection does
+                // not exist, so KV operations on it always time out.
                 exists() {
-                  if (cluster.hang) return new Promise(() => {});
-                  return cluster.healthy ?
-                      Promise.resolve({ exists: false })
-                    : Promise.reject(timeoutError());
+                  return Promise.reject(timeoutError());
                 },
               };
             },
@@ -166,6 +173,48 @@ test("a healthy probe leaves the connection alone", async () => {
   assert.equal(monitor.status().default.healthy, true);
 });
 
+test("the probe does not depend on the boot-time collection existing", async () => {
+  // The fake collection's KV operations always time out; ping still succeeds.
+  const { monitor, opened } = setup({ settings: { probeFailureThreshold: 1 } });
+  assert.equal(await monitor.check("default"), true);
+  assert.equal(opened.length, 0);
+  assert.equal(monitor.status().default.healthy, true);
+});
+
+test("one answering KV node is enough, none is unhealthy", async () => {
+  const { monitor, initial, opened } = setup({
+    settings: { probeFailureThreshold: 1 },
+  });
+  const { Ok, Timeout, Error: Failed } = couchbase.PingState;
+  initial.kvStates = [Timeout, Ok, Failed];
+  assert.equal(await monitor.check("default"), true);
+  assert.equal(opened.length, 0);
+
+  initial.kvStates = [Timeout, Failed];
+  await monitor.check("default");
+  assert.equal(opened.length, 1);
+});
+
+test("probe failures say which check failed", async () => {
+  const { monitor, initial } = setup({
+    settings: { probeFailureThreshold: 1 },
+    connect: async () => fakeCluster("bad", { healthy: false }),
+  });
+  initial.kvStates = [];
+  await monitor.check("default");
+  assert.match(monitor.status().default.lastError, /waitUntilReady failed/);
+
+  const query = setup({ settings: { probeFailureThreshold: 1 } });
+  query.initial.query = () => Promise.reject(timeoutError());
+  await query.monitor.check("default");
+  assert.match(query.logs.join("\n"), /unhealthy: Query probe failed/);
+
+  const kv = setup({ settings: { probeFailureThreshold: 1 } });
+  kv.initial.kvStates = [];
+  await kv.monitor.check("default");
+  assert.match(kv.logs.join("\n"), /unhealthy: KV ping failed: no endpoint responded/);
+});
+
 test("non-connectivity errors never trigger a probe", async () => {
   const { monitor, initial } = setup();
   for (let i = 0; i < 10; i++) {