@cadenza.io/service 2.17.3 → 2.17.5

package/dist/browser/index.mjs

@@ -1573,50 +1573,10 @@ var ServiceRegistry = class _ServiceRegistry {
       "meta.service_registry.selected_instance_for_fetch",
       "meta.service_registry.socket_failed"
     );
-    this.getStatusTask = CadenzaService.createMetaTask("Get status", (ctx) => {
-      if (!this.serviceName) {
-        return {
-          __status: "error",
-          __error: "No service name defined",
-          errored: true
-        };
-      }
-      if (!this.serviceInstanceId) {
-        return {
-          __status: "error",
-          __error: "No service instance id defined",
-          errored: true
-        };
-      }
-      const report = this.buildLocalRuntimeStatusReport("full");
-      if (!report) {
-        return {
-          ...ctx,
-          __status: "error",
-          __error: "No local service instance available for status check",
-          errored: true
-        };
-      }
-      return {
-        ...ctx,
-        __status: "ok",
-        __serviceName: report.serviceName,
-        __serviceInstanceId: report.serviceInstanceId,
-        __numberOfRunningGraphs: report.numberOfRunningGraphs,
-        __health: report.health ?? {},
-        __active: report.isActive,
-        reportedAt: report.reportedAt,
-        serviceName: report.serviceName,
-        serviceInstanceId: report.serviceInstanceId,
-        numberOfRunningGraphs: report.numberOfRunningGraphs,
-        health: report.health ?? {},
-        isActive: report.isActive,
-        isNonResponsive: report.isNonResponsive,
-        isBlocked: report.isBlocked,
-        state: report.state,
-        acceptingWork: report.acceptingWork
-      };
-    }).doOn(
+    this.getStatusTask = CadenzaService.createMetaTask(
+      "Get status",
+      (ctx) => this.resolveLocalStatusCheck(ctx)
+    ).doOn(
       "meta.socket.status_check_requested",
       "meta.rest.status_check_requested"
     );
@@ -1833,12 +1793,14 @@ var ServiceRegistry = class _ServiceRegistry {
             this.useSocket ? "socket" : "rest"
           ) : void 0;
           const message = error instanceof Error ? error.message : String(error);
+          const diagnostics = error && typeof error === "object" && "runtimeStatusFallback" in error && error.runtimeStatusFallback && typeof error.runtimeStatusFallback === "object" ? error.runtimeStatusFallback : void 0;
           CadenzaService.log(
             "Runtime status fallback inquiry failed.",
             {
               serviceName,
               serviceInstanceId,
-              error: message
+              error: message,
+              diagnostics
             },
             "warning"
           );
@@ -2328,6 +2290,110 @@ var ServiceRegistry = class _ServiceRegistry {
     }
     return this.getInstance(this.serviceName, this.serviceInstanceId);
   }
+  summarizeTransportForDebug(transport) {
+    if (!transport) {
+      return void 0;
+    }
+    return {
+      uuid: transport.uuid,
+      role: transport.role,
+      origin: transport.origin,
+      protocols: transport.protocols,
+      clientCreated: transport.clientCreated
+    };
+  }
+  summarizeInstanceForRuntimeStatusFallback(instance) {
+    return {
+      exists: Boolean(instance),
+      runtimeState: instance?.runtimeState,
+      acceptingWork: instance?.acceptingWork,
+      reportedAt: instance?.reportedAt ?? null,
+      isDatabase: instance?.isDatabase,
+      isFrontend: instance?.isFrontend,
+      transports: (instance?.transports ?? []).map((transport) => ({
+        uuid: transport.uuid,
+        role: transport.role,
+        origin: transport.origin,
+        protocols: transport.protocols,
+        clientCreated: transport.clientCreated
+      }))
+    };
+  }
+  summarizeRuntimeStatusInquiryReports(inquiryResult) {
+    const reports = Array.isArray(inquiryResult.runtimeStatusReports) ? inquiryResult.runtimeStatusReports : [];
+    return reports.map((candidate) => {
+      const normalized = this.normalizeRuntimeStatusReport(candidate);
+      if (normalized) {
+        return {
+          serviceName: normalized.serviceName,
+          serviceInstanceId: normalized.serviceInstanceId,
+          transportId: normalized.transportId,
+          state: normalized.state,
+          acceptingWork: normalized.acceptingWork,
+          reportedAt: normalized.reportedAt
+        };
+      }
+      const raw = candidate && typeof candidate === "object" ? candidate : {};
+      const rawState = raw.state === "healthy" || raw.state === "degraded" || raw.state === "overloaded" || raw.state === "unavailable" ? raw.state : void 0;
+      return {
+        serviceName: typeof raw.serviceName === "string" ? raw.serviceName : typeof raw.__serviceName === "string" ? raw.__serviceName : void 0,
+        serviceInstanceId: typeof raw.serviceInstanceId === "string" ? raw.serviceInstanceId : typeof raw.__serviceInstanceId === "string" ? raw.__serviceInstanceId : void 0,
+        transportId: typeof raw.transportId === "string" ? raw.transportId : typeof raw.serviceTransportId === "string" ? raw.serviceTransportId : void 0,
+        state: rawState,
+        acceptingWork: typeof raw.acceptingWork === "boolean" ? raw.acceptingWork : void 0,
+        reportedAt: typeof raw.reportedAt === "string" ? raw.reportedAt : void 0
+      };
+    });
+  }
+  createRuntimeStatusFallbackError(message, diagnostics) {
+    return Object.assign(new Error(message), {
+      runtimeStatusFallback: diagnostics
+    });
+  }
+  resolveLocalStatusCheck(ctx = {}) {
+    if (!this.serviceName) {
+      return {
+        __status: "error",
+        __error: "No service name defined",
+        errored: true
+      };
+    }
+    if (!this.serviceInstanceId) {
+      return {
+        __status: "error",
+        __error: "No service instance id defined",
+        errored: true
+      };
+    }
+    const report = this.buildLocalRuntimeStatusReport("full");
+    if (!report) {
+      return {
+        ...ctx,
+        __status: "error",
+        __error: "No local service instance available for status check",
+        errored: true
+      };
+    }
+    return {
+      ...ctx,
+      __status: "ok",
+      __serviceName: report.serviceName,
+      __serviceInstanceId: report.serviceInstanceId,
+      __numberOfRunningGraphs: report.numberOfRunningGraphs,
+      __health: report.health ?? {},
+      __active: report.isActive,
+      reportedAt: report.reportedAt,
+      serviceName: report.serviceName,
+      serviceInstanceId: report.serviceInstanceId,
+      numberOfRunningGraphs: report.numberOfRunningGraphs,
+      health: report.health ?? {},
+      isActive: report.isActive,
+      isNonResponsive: report.isNonResponsive,
+      isBlocked: report.isBlocked,
+      state: report.state,
+      acceptingWork: report.acceptingWork
+    };
+  }
   resolveTransportProtocolOrder(ctx) {
     const explicit = ctx.__preferredTransportProtocol === "rest" || ctx.__preferredTransportProtocol === "socket" ? ctx.__preferredTransportProtocol : void 0;
     const preferred = explicit ?? (this.useSocket ? "socket" : "rest");
@@ -2603,32 +2669,48 @@ var ServiceRegistry = class _ServiceRegistry {
   }
   async resolveRuntimeStatusFallbackInquiry(serviceName, serviceInstanceId, options = {}) {
     const instance = this.getInstance(serviceName, serviceInstanceId);
-    if (instance) {
-      const directReport = await this.requestRuntimeStatusViaRest(
-        instance,
-        serviceName,
-        serviceInstanceId
-      );
-      if (directReport) {
-        if (!this.applyRuntimeStatusReport(directReport)) {
-          throw new Error(
-            `No tracked instance for runtime fallback ${serviceName}/${serviceInstanceId}`
-          );
-        }
-        this.lastHeartbeatAtByInstance.set(serviceInstanceId, Date.now());
-        this.missedHeartbeatsByInstance.set(serviceInstanceId, 0);
-        return {
-          report: directReport,
-          inquiryMeta: {
-            inquiry: META_RUNTIME_STATUS_INTENT,
-            responded: 1,
-            failed: 0,
-            timedOut: 0,
-            pending: 0,
-            directStatusCheck: true
+    const directStatusCheck = instance ? await this.requestRuntimeStatusViaRest(
+      instance,
+      serviceName,
+      serviceInstanceId
+    ) : {
+      report: null,
+      diagnostic: {
+        attempted: false,
+        outcome: "instance_missing"
+      }
+    };
+    if (directStatusCheck.report) {
+      if (!this.applyRuntimeStatusReport(directStatusCheck.report)) {
+        throw this.createRuntimeStatusFallbackError(
+          `No tracked instance for runtime fallback ${serviceName}/${serviceInstanceId}`,
+          {
+            target: {
+              serviceName,
+              serviceInstanceId
+            },
+            instance: this.summarizeInstanceForRuntimeStatusFallback(instance),
+            directStatusCheck: directStatusCheck.diagnostic,
+            inquiry: {
+              meta: {},
+              reportTargets: []
+            }
           }
-        };
+        );
       }
+      this.lastHeartbeatAtByInstance.set(serviceInstanceId, Date.now());
+      this.missedHeartbeatsByInstance.set(serviceInstanceId, 0);
+      return {
+        report: directStatusCheck.report,
+        inquiryMeta: {
+          inquiry: META_RUNTIME_STATUS_INTENT,
+          responded: 1,
+          failed: 0,
+          timedOut: 0,
+          pending: 0,
+          directStatusCheck: true
+        }
+      };
     }
     const inquiryResult = await CadenzaService.inquire(
       META_RUNTIME_STATUS_INTENT,
@@ -2650,13 +2732,37 @@ var ServiceRegistry = class _ServiceRegistry {
       serviceInstanceId
     );
     if (!report) {
-      throw new Error(
-        `No runtime status report for ${serviceName}/${serviceInstanceId}`
+      throw this.createRuntimeStatusFallbackError(
+        `No runtime status report for ${serviceName}/${serviceInstanceId}`,
+        {
+          target: {
+            serviceName,
+            serviceInstanceId
+          },
+          instance: this.summarizeInstanceForRuntimeStatusFallback(instance),
+          directStatusCheck: directStatusCheck.diagnostic,
+          inquiry: {
+            meta: inquiryResult.__inquiryMeta && typeof inquiryResult.__inquiryMeta === "object" ? inquiryResult.__inquiryMeta : {},
+            reportTargets: this.summarizeRuntimeStatusInquiryReports(inquiryResult)
+          }
+        }
       );
     }
     if (!this.applyRuntimeStatusReport(report)) {
-      throw new Error(
-        `No tracked instance for runtime fallback ${serviceName}/${serviceInstanceId}`
+      throw this.createRuntimeStatusFallbackError(
+        `No tracked instance for runtime fallback ${serviceName}/${serviceInstanceId}`,
+        {
+          target: {
+            serviceName,
+            serviceInstanceId
+          },
+          instance: this.summarizeInstanceForRuntimeStatusFallback(instance),
+          directStatusCheck: directStatusCheck.diagnostic,
+          inquiry: {
+            meta: inquiryResult.__inquiryMeta && typeof inquiryResult.__inquiryMeta === "object" ? inquiryResult.__inquiryMeta : {},
+            reportTargets: this.summarizeRuntimeStatusInquiryReports(inquiryResult)
+          }
+        }
       );
     }
     this.lastHeartbeatAtByInstance.set(serviceInstanceId, Date.now());
@@ -2668,11 +2774,23 @@ var ServiceRegistry = class _ServiceRegistry {
   }
   async requestRuntimeStatusViaRest(instance, serviceName, serviceInstanceId) {
     if (typeof globalThis.fetch !== "function") {
-      return null;
+      return {
+        report: null,
+        diagnostic: {
+          attempted: false,
+          outcome: "fetch_unavailable"
+        }
+      };
     }
     const transport = this.getRouteableTransport(instance, "rest");
     if (!transport) {
-      return null;
+      return {
+        report: null,
+        diagnostic: {
+          attempted: false,
+          outcome: "no_rest_transport"
+        }
+      };
     }
     const controller = typeof AbortController === "function" ? new AbortController() : null;
     const timeoutId = controller ? setTimeout(() => controller.abort(), this.runtimeStatusFallbackTimeoutMs) : null;
@@ -2682,7 +2800,16 @@ var ServiceRegistry = class _ServiceRegistry {
         signal: controller?.signal
       });
       if ("ok" in response && response.ok === false) {
-        return null;
+        return {
+          report: null,
+          diagnostic: {
+            attempted: true,
+            outcome: "http_error",
+            transport: this.summarizeTransportForDebug(transport),
+            responseStatus: typeof response.status === "number" ? response.status : void 0,
+            responseStatusText: typeof response.statusText === "string" ? response.statusText : void 0
+          }
+        };
       }
       const payload = typeof response.json === "function" ? await response.json() : response;
       const report = this.normalizeRuntimeStatusReport({
@@ -2692,14 +2819,46 @@ var ServiceRegistry = class _ServiceRegistry {
         transportProtocols: payload?.transportProtocols ?? transport.protocols
       });
       if (!report) {
-        return null;
+        return {
+          report: null,
+          diagnostic: {
+            attempted: true,
+            outcome: "invalid_report",
+            transport: this.summarizeTransportForDebug(transport),
+            payloadKeys: payload && typeof payload === "object" ? Object.keys(payload).sort() : []
+          }
+        };
       }
       if (report.serviceName !== serviceName || report.serviceInstanceId !== serviceInstanceId) {
-        return null;
+        return {
+          report: null,
+          diagnostic: {
+            attempted: true,
+            outcome: "identity_mismatch",
+            transport: this.summarizeTransportForDebug(transport),
+            payloadServiceName: report.serviceName,
+            payloadServiceInstanceId: report.serviceInstanceId
+          }
+        };
       }
-      return report;
-    } catch {
-      return null;
+      return {
+        report,
+        diagnostic: {
+          attempted: true,
+          outcome: "matched",
+          transport: this.summarizeTransportForDebug(transport)
+        }
+      };
+    } catch (error) {
+      return {
+        report: null,
+        diagnostic: {
+          attempted: true,
+          outcome: "fetch_error",
+          transport: this.summarizeTransportForDebug(transport),
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
     } finally {
       if (timeoutId) {
         clearTimeout(timeoutId);
@@ -3825,13 +3984,7 @@ var SocketController = class _SocketController {
               ws.on(
                 "status_check",
                 (ctx, callback) => {
-                  CadenzaService.createEphemeralMetaTask(
-                    "Resolve status check",
-                    callback,
-                    "Resolves a status check request",
-                    { register: false }
-                  ).doAfter(CadenzaService.serviceRegistry.getStatusTask);
-                  CadenzaService.emit("meta.socket.status_check_requested", ctx);
+                  callback(CadenzaService.serviceRegistry.resolveLocalStatusCheck(ctx));
                 }
               );
               ws.on("disconnect", () => {