@cadenza.io/service 2.17.47 → 2.17.48

package/dist/browser/index.js

@@ -6246,10 +6246,21 @@ function buildSyncInsertQueryData(ctx, queryData = {}) {
 function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, options = {}) {
   const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
   const remoteInsertTask = isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(tableName, queryData, options) : void 0;
+  const debugTable = shouldDebugSyncTable(tableName);
   if (!localInsertTask && !remoteInsertTask) {
     return void 0;
   }
   const targetTask = localInsertTask ?? remoteInsertTask;
+  if (debugTable) {
+    logSyncDebug("insert_task_resolved", {
+      tableName,
+      localInsertTaskName: localInsertTask?.name ?? null,
+      remoteInsertTaskName: remoteInsertTask?.name ?? null,
+      targetTaskName: targetTask.name,
+      queryData,
+      options
+    });
+  }
   const executionRequestedSignal = `meta.sync_controller.insert_execution_requested:${tableName}`;
   const executionResolvedSignal = `meta.sync_controller.insert_execution_resolved:${tableName}`;
   const executionFailedSignal = `meta.sync_controller.insert_execution_failed:${tableName}`;
@@ -6283,6 +6294,26 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
       isHidden: true
     }
   ).doOn(executionRequestedSignal).emitsOnFail(executionFailedSignal);
+  if (debugTable) {
+    prepareExecutionTask.then(
+      CadenzaService.createMetaTask(
+        `Log prepared graph sync insert execution for ${tableName}`,
+        (ctx) => {
+          logSyncDebug("insert_prepare", {
+            tableName,
+            targetTaskName: targetTask.name,
+            ctx
+          });
+          return ctx;
+        },
+        `Logs prepared ${tableName} sync insert payloads.`,
+        {
+          register: false,
+          isHidden: true
+        }
+      )
+    );
+  }
   const finalizeExecutionTask = CadenzaService.createMetaTask(
     `Finalize graph sync insert execution for ${tableName}`,
     (ctx, emit) => {
@@ -6299,6 +6330,14 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
         ...ctx,
         queryData: ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : originalQueryData
       };
+      if (debugTable) {
+        logSyncDebug("insert_finalize", {
+          tableName,
+          targetTaskName: targetTask.name,
+          success: didSyncInsertSucceed(normalizedContext),
+          ctx: normalizedContext
+        });
+      }
       pendingResolverContexts.delete(ctx.__resolverRequestId);
       emit(executionResolvedSignal, normalizedContext);
       return normalizedContext;
@@ -6311,6 +6350,27 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
   );
   targetTask.then(finalizeExecutionTask).emitsOnFail(executionFailedSignal);
   prepareExecutionTask.then(targetTask);
+  if (debugTable) {
+    CadenzaService.createMetaTask(
+      `Log failed graph sync insert execution for ${tableName}`,
+      (ctx) => {
+        logSyncDebug("insert_failed", {
+          tableName,
+          targetTaskName: targetTask.name,
+          ctx
+        });
+        if (typeof ctx.__resolverRequestId === "string") {
+          pendingResolverContexts.delete(ctx.__resolverRequestId);
+        }
+        return false;
+      },
+      `Logs failed ${tableName} sync insert executions.`,
+      {
+        register: false,
+        isHidden: true
+      }
+    ).doOn(executionFailedSignal);
+  }
   return CadenzaService.createMetaTask(
     `Resolve graph sync insert for ${tableName}`,
     (ctx, emit) => new Promise((resolve) => {
@@ -6366,6 +6426,104 @@ var AUTHORITY_QUERY_RESULT_KEYS = {
   intent_registry: "intentRegistrys"
 };
 var EARLY_SYNC_REQUEST_DELAYS_MS = [2e3, 1e4, 3e4];
+var SYNC_DEBUG_PREFIX = "[CADENZA_SYNC_DEBUG]";
+var SYNC_DEBUG_TABLES = /* @__PURE__ */ new Set([
+  "task",
+  "routine",
+  "task_to_routine_map",
+  "signal_registry",
+  "intent_registry",
+  "signal_to_task_map",
+  "intent_to_task_map"
+]);
+var SYNC_DEBUG_TASK_NAMES = /* @__PURE__ */ new Set([
+  "Query service_instance",
+  "Query service_instance_transport",
+  "Query intent_to_task_map",
+  "Query signal_to_task_map",
+  "Prepare for signal sync",
+  "Compile sync data and broadcast",
+  "Forward service instance sync",
+  "Forward service transport sync",
+  "Forward intent to task map sync",
+  "Forward signal to task map sync"
+]);
+var SYNC_DEBUG_ROUTINE_NAMES = /* @__PURE__ */ new Set(["Sync services"]);
+var SYNC_DEBUG_INTENT_NAMES = /* @__PURE__ */ new Set([
+  "meta-service-registry-full-sync",
+  "runner-traffic-runtime-get",
+  "iot-telemetry-ingest",
+  "query-pg-CadenzaDBPostgresActor-service_instance",
+  "query-pg-CadenzaDBPostgresActor-service_instance_transport",
+  "query-pg-CadenzaDBPostgresActor-intent_to_task_map",
+  "query-pg-CadenzaDBPostgresActor-signal_to_task_map"
+]);
+function shouldDebugSyncTable(tableName) {
+  return SYNC_DEBUG_TABLES.has(tableName);
+}
+function shouldDebugSyncTaskName(taskName) {
+  return typeof taskName === "string" && SYNC_DEBUG_TASK_NAMES.has(taskName);
+}
+function shouldDebugSyncRoutineName(routineName) {
+  return typeof routineName === "string" && SYNC_DEBUG_ROUTINE_NAMES.has(routineName);
+}
+function shouldDebugSyncIntentName(intentName) {
+  return typeof intentName === "string" && SYNC_DEBUG_INTENT_NAMES.has(intentName);
+}
+function summarizeSyncDebugValue(value, depth = 0) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value instanceof Set) {
+    return {
+      __type: "Set",
+      size: value.size,
+      values: Array.from(value).slice(0, 8).map((item) => summarizeSyncDebugValue(item, depth + 1))
+    };
+  }
+  if (value instanceof Map) {
+    return {
+      __type: "Map",
+      size: value.size
+    };
+  }
+  if (Array.isArray(value)) {
+    return {
+      __type: "Array",
+      length: value.length,
+      items: value.slice(0, 5).map((item) => summarizeSyncDebugValue(item, depth + 1))
+    };
+  }
+  if (typeof value === "object") {
+    if (depth >= 2) {
+      return "[object]";
+    }
+    const output = {};
+    const entries = Object.entries(value).filter(
+      ([key]) => ![
+        "functionString",
+        "tagIdGetter",
+        "__functionString",
+        "__getTagCallback",
+        "joinedContexts",
+        "task",
+        "taskInstance",
+        "tasks"
+      ].includes(key)
+    ).slice(0, 12);
+    for (const [key, nestedValue] of entries) {
+      output[key] = summarizeSyncDebugValue(nestedValue, depth + 1);
+    }
+    return output;
+  }
+  return String(value);
+}
+function logSyncDebug(event, payload) {
+  console.log(`${SYNC_DEBUG_PREFIX} ${event}`, summarizeSyncDebugValue(payload));
+}
 function resolveSyncQueryRows(ctx, tableName) {
   const resultKey = AUTHORITY_QUERY_RESULT_KEYS[tableName];
   const rows = ctx?.[resultKey];
@@ -6612,6 +6770,16 @@ var GraphSyncController = class _GraphSyncController {
               if (!nextTask?.registered) {
                 continue;
               }
+              if (shouldDebugSyncRoutineName(routine.name) || shouldDebugSyncTaskName(nextTask.name)) {
+                logSyncDebug("task_to_routine_split", {
+                  routineName: routine.name,
+                  routineVersion: routine.version,
+                  taskName: nextTask.name,
+                  taskVersion: nextTask.version,
+                  serviceName: serviceName2,
+                  registered: nextTask.registered
+                });
+              }
               yield {
                 __syncing: ctx.__syncing,
                 data: {
@@ -6742,6 +6910,18 @@ var GraphSyncController = class _GraphSyncController {
         for (const task of tasks) {
           if (task.registered) continue;
           const { __functionString, __getTagCallback } = task.export();
+          if (shouldDebugSyncTaskName(task.name)) {
+            logSyncDebug("task_registration_split", {
+              taskName: task.name,
+              taskVersion: task.version,
+              serviceName: serviceName2,
+              register: task.register,
+              registered: task.registered,
+              hidden: task.hidden,
+              observedSignals: Array.from(task.observedSignals),
+              handledIntents: Array.from(task.handlesIntents)
+            });
+          }
           yield {
             __syncing: ctx.__syncing,
             data: {
@@ -6794,6 +6974,13 @@ var GraphSyncController = class _GraphSyncController {
       { concurrency: 30 }
     )?.then(
       CadenzaService.createMetaTask("Record registration", (ctx, emit) => {
+        if (shouldDebugSyncTaskName(ctx.__taskName)) {
+          logSyncDebug("task_registration_result", {
+            taskName: ctx.__taskName,
+            success: didSyncInsertSucceed(ctx),
+            ctx
+          });
+        }
         if (!didSyncInsertSucceed(ctx)) {
           return;
         }
@@ -6820,6 +7007,16 @@ var GraphSyncController = class _GraphSyncController {
       "Prepare created task for immediate sync",
       (ctx) => {
         const task = ctx.taskInstance ?? (ctx.data?.name ? CadenzaService.get(String(ctx.data.name)) : void 0);
+        if (shouldDebugSyncTaskName(task?.name ?? ctx?.data?.name)) {
+          logSyncDebug("task_created_for_immediate_sync", {
+            incomingTaskName: ctx?.data?.name ?? null,
+            resolvedTaskName: task?.name ?? null,
+            exists: Boolean(task),
+            hidden: task?.hidden ?? null,
+            register: task?.register ?? null,
+            registered: task?.registered ?? null
+          });
+        }
         if (!task || task.hidden || !task.register || task.registered) {
           return false;
         }
@@ -7004,6 +7201,17 @@ var GraphSyncController = class _GraphSyncController {
             continue;
           }
           const { isGlobal } = decomposeSignalName(_signal);
+          if (shouldDebugSyncTaskName(task.name)) {
+            logSyncDebug("signal_to_task_map_split", {
+              taskName: task.name,
+              signalName: _signal,
+              rawSignal: signal,
+              serviceName: serviceName2,
+              observerRegistered: CadenzaService.signalBroker.signalObservers?.get(
+                _signal
+              )?.registered
+            });
+          }
           emit("meta.sync_controller.signal_task_map_split", {
             __syncing: ctx.__syncing,
             data: {
@@ -7142,6 +7350,15 @@ var GraphSyncController = class _GraphSyncController {
           if (!intentDefinition) {
             continue;
           }
+          if (shouldDebugSyncTaskName(task.name) || shouldDebugSyncIntentName(intent)) {
+            logSyncDebug("intent_to_task_map_split", {
+              taskName: task.name,
+              taskVersion: task.version,
+              intentName: intent,
+              serviceName: serviceName2,
+              intentDefinition
+            });
+          }
           emit("meta.sync_controller.intent_task_map_split", {
             __syncing: ctx.__syncing,
             data: {
@@ -7171,6 +7388,13 @@ var GraphSyncController = class _GraphSyncController {
           if (!ctx.__intentDefinition || !ctx.__intentMapData) {
             return false;
           }
+          if (shouldDebugSyncTaskName(ctx.__taskName) || shouldDebugSyncIntentName(ctx.__intent)) {
+            logSyncDebug("intent_definition_prepare", {
+              taskName: ctx.__taskName,
+              intentName: ctx.__intent,
+              intentDefinition: ctx.__intentDefinition
+            });
+          }
           return {
             ...ctx,
             data: ctx.__intentDefinition
@@ -7184,6 +7408,13 @@ var GraphSyncController = class _GraphSyncController {
               if (!ctx.__intentMapData) {
                 return false;
               }
+              if (shouldDebugSyncTaskName(ctx.__taskName) || shouldDebugSyncIntentName(ctx.__intent)) {
+                logSyncDebug("intent_map_payload_restore", {
+                  taskName: ctx.__taskName,
+                  intentName: ctx.__intent,
+                  intentMapData: ctx.__intentMapData
+                });
+              }
               return {
                 ...ctx,
                 data: ctx.__intentMapData