@cadenza.io/service 2.17.77 → 2.17.79

package/dist/browser/index.js

@@ -813,6 +813,18 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
   }
   return result;
 }
+function shouldTraceIotDbRegistryPath(localServiceName, targetServiceName) {
+  return targetServiceName === "IotDbService" && localServiceName !== "IotDbService";
+}
+function summarizeTransportDescriptors(transports) {
+  return transports.map((transport) => ({
+    uuid: transport.uuid,
+    serviceInstanceId: transport.serviceInstanceId,
+    role: transport.role,
+    origin: transport.origin,
+    protocols: transport.protocols
+  }));
+}
 function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {}) {
   const remoteInsertTask = CadenzaService.createCadenzaDBInsertTask(
     tableName,
@@ -1203,6 +1215,21 @@ var ServiceRegistry = class _ServiceRegistry {
           trackedInstance.acceptingWork = snapshot.acceptingWork;
           trackedInstance.reportedAt = trackedInstance.reportedAt ?? (/* @__PURE__ */ new Date()).toISOString();
         }
+        if (shouldTraceIotDbRegistryPath(this.serviceName, serviceName)) {
+          console.log("[CADENZA_REGISTRY_DEBUG] handle_instance_update", {
+            localServiceName: this.serviceName,
+            localServiceInstanceId: this.serviceInstanceId,
+            targetServiceName: serviceName,
+            targetServiceInstanceId: uuid7,
+            existingInstance: !!existing,
+            deleted,
+            remoteInterest: this.deputies.has(serviceName) || this.remoteIntents.has(serviceName) || this.remoteSignals.has(serviceName),
+            hasDeputies: this.deputies.has(serviceName),
+            hasRemoteIntents: this.remoteIntents.has(serviceName),
+            hasRemoteSignals: this.remoteSignals.has(serviceName),
+            transports: trackedInstance ? summarizeTransportDescriptors(trackedInstance.transports) : []
+          });
+        }
         if (!serviceInstance.isBootstrapPlaceholder) {
           this.reconcileBootstrapPlaceholderInstance(serviceName, uuid7, emit);
         }
@@ -1258,6 +1285,27 @@ var ServiceRegistry = class _ServiceRegistry {
             break;
           }
         }
+        if (shouldTraceIotDbRegistryPath(
+          this.serviceName,
+          ownerInstance?.serviceName ?? ctx.serviceName ?? void 0
+        )) {
+          console.log("[CADENZA_REGISTRY_DEBUG] handle_transport_update", {
+            localServiceName: this.serviceName,
+            localServiceInstanceId: this.serviceInstanceId,
+            transport: {
+              uuid: transport.uuid,
+              serviceInstanceId: transport.serviceInstanceId,
+              role: transport.role,
+              origin: transport.origin,
+              protocols: transport.protocols,
+              deleted: transport.deleted
+            },
+            ownerFound: !!ownerInstance,
+            ownerServiceName: ownerInstance?.serviceName,
+            ownerInstanceId: ownerInstance?.uuid,
+            ownerTransports: ownerInstance ? summarizeTransportDescriptors(ownerInstance.transports) : []
+          });
+        }
         if (!ownerInstance) {
           return false;
         }
@@ -1313,12 +1361,29 @@ var ServiceRegistry = class _ServiceRegistry {
       "Tracks remote dependency instances for runtime heartbeat monitoring."
     ).doOn("meta.service_registry.dependee_registered");
     const normalizeServiceInstancesFromSync = (ctx) => this.normalizeServiceInstancesFromSync(ctx);
+    const getLocalTraceContext = () => ({
+      localServiceName: this.serviceName,
+      localServiceInstanceId: this.serviceInstanceId
+    });
     CadenzaService.createMetaTask("Split service instances", function* (ctx) {
       const serviceInstances = normalizeServiceInstancesFromSync(ctx);
       if (serviceInstances.length === 0) {
         return;
       }
       for (const serviceInstance of serviceInstances) {
+        const { localServiceName, localServiceInstanceId } = getLocalTraceContext();
+        if (shouldTraceIotDbRegistryPath(
+          localServiceName,
+          serviceInstance.serviceName
+        )) {
+          console.log("[CADENZA_REGISTRY_DEBUG] split_service_instance", {
+            localServiceName,
+            localServiceInstanceId,
+            targetServiceName: serviceInstance.serviceName,
+            targetServiceInstanceId: serviceInstance.uuid,
+            transports: summarizeTransportDescriptors(serviceInstance.transports)
+          });
+        }
         yield { serviceInstance };
       }
     }).doOn(
@@ -1576,6 +1641,21 @@ var ServiceRegistry = class _ServiceRegistry {
         const serviceInstances = this.normalizeServiceInstancesFromSync(
           inquiryResult
         );
+        if (shouldTraceIotDbRegistryPath(this.serviceName, "IotDbService")) {
+          const tracedInstances = serviceInstances.filter((instance) => instance.serviceName === "IotDbService").map((instance) => ({
+            uuid: instance.uuid,
+            isActive: instance.isActive,
+            isNonResponsive: instance.isNonResponsive,
+            isBlocked: instance.isBlocked,
+            transports: summarizeTransportDescriptors(instance.transports)
+          }));
+          console.log("[CADENZA_REGISTRY_DEBUG] full_sync_instances", {
+            localServiceName: this.serviceName,
+            localServiceInstanceId: this.serviceInstanceId,
+            totalServiceInstances: serviceInstances.length,
+            tracedInstances
+          });
+        }
         return {
           ...ctx,
           signalToTaskMaps,
@@ -1672,6 +1752,44 @@ var ServiceRegistry = class _ServiceRegistry {
         let retries = __retries ?? 0;
         let triedInstances = __triedInstances ?? [];
         const preferredRole = this.getRoutingTransportRole();
+        const allInstances = this.instances.get(__serviceName) ?? [];
+        const candidateDiagnostics = shouldTraceIotDbRegistryPath(
+          this.serviceName,
+          __serviceName ?? void 0
+        ) ? allInstances.map((instance) => ({
+          uuid: instance.uuid,
+          isActive: instance.isActive,
+          isNonResponsive: instance.isNonResponsive,
+          isBlocked: instance.isBlocked,
+          isFrontend: instance.isFrontend,
+          transports: summarizeTransportDescriptors(instance.transports),
+          selectedTransport: instance.isFrontend ? null : this.selectTransportForInstance(
+            instance,
+            context,
+            preferredRole
+          ) ? {
+            uuid: this.selectTransportForInstance(
+              instance,
+              context,
+              preferredRole
+            ).uuid,
+            role: this.selectTransportForInstance(
+              instance,
+              context,
+              preferredRole
+            ).role,
+            origin: this.selectTransportForInstance(
+              instance,
+              context,
+              preferredRole
+            ).origin,
+            protocols: this.selectTransportForInstance(
+              instance,
+              context,
+              preferredRole
+            ).protocols
+          } : null
+        })) : void 0;
         const instances = this.instances.get(__serviceName)?.filter((instance) => {
           if (targetServiceInstanceId && instance.uuid !== targetServiceInstanceId) {
             return false;
@@ -1704,6 +1822,20 @@ var ServiceRegistry = class _ServiceRegistry {
           }
           return (a.numberOfRunningGraphs ?? 0) - (b.numberOfRunningGraphs ?? 0);
         });
+        if (candidateDiagnostics) {
+          console.log("[CADENZA_REGISTRY_DEBUG] get_balanced_instance", {
+            localServiceName: this.serviceName,
+            localServiceInstanceId: this.serviceInstanceId,
+            targetServiceName: __serviceName,
+            preferredRole,
+            useSocket: this.useSocket,
+            targetServiceInstanceId,
+            retries,
+            triedInstances,
+            candidateDiagnostics,
+            filteredInstanceIds: instances?.map((instance) => instance.uuid) ?? []
+          });
+        }
         if (!instances || instances.length === 0 || retries > this.retryCount) {
           context.errored = true;
           context.__error = this.isFrontend && preferredRole === "public" ? `No public transport available for ${__serviceName}.` : `No routeable ${preferredRole} transport available for ${__serviceName}. Retries: ${retries}.`;
@@ -2830,6 +2962,27 @@ var ServiceRegistry = class _ServiceRegistry {
       instance,
       this.useSocket ? "socket" : "rest"
     );
+    if (shouldTraceIotDbRegistryPath(this.serviceName, instance.serviceName)) {
+      console.log("[CADENZA_REGISTRY_DEBUG] ensure_dependee_client_for_instance", {
+        localServiceName: this.serviceName,
+        localServiceInstanceId: this.serviceInstanceId,
+        targetServiceName: instance.serviceName,
+        targetServiceInstanceId: instance.uuid,
+        useSocket: this.useSocket,
+        routeableRole: this.getRoutingTransportRole(),
+        hasDeputies: this.deputies.has(instance.serviceName),
+        hasRemoteIntents: this.remoteIntents.has(instance.serviceName),
+        hasRemoteSignals: this.remoteSignals.has(instance.serviceName),
+        clientCreatedTransportIds: instance.clientCreatedTransportIds ?? [],
+        transports: summarizeTransportDescriptors(instance.transports),
+        selectedTransport: transport ? {
+          uuid: transport.uuid,
+          role: transport.role,
+          origin: transport.origin,
+          protocols: transport.protocols
+        } : null
+      });
+    }
     if (!transport || this.hasTransportClientCreated(instance, transport.uuid)) {
       return false;
     }