digitalkin 1.0.0.dev12__tar.gz → 1.0.0.dev14__tar.gz

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.0.dev12
+Version: 1.0.0.dev14
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/pyproject.toml

@@ -37,7 +37,7 @@
         "pydantic-settings>=2.14.1",
         "redis[hiredis]>=7.4.0,<8",
     ]
-    version = "1.0.0.dev12"
+    version = "1.0.0.dev14"
 
     [project.optional-dependencies]
         performance = [ "uvloop>=0.21" ]

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/__version__.py

@@ -5,4 +5,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("digitalkin")
 except PackageNotFoundError:
-    __version__ = "1.0.0.dev12"
+    __version__ = "1.0.0.dev14"

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/core/common/factories.py

@@ -64,16 +64,10 @@ class ModuleFactory:
             raise ValueError(msg)
 
         logger.debug(
-            "Creating module instance: %s for job: %s",
+            "Creating module instance: %s (setup_version_id=%s)",
             module_class.__name__,
-            job_id,
-            extra={
-                "module_class": module_class.__name__,
-                "job_id": job_id,
-                "mission_id": mission_id,
-                "setup_id": setup_id,
-                "setup_version_id": setup_version_id,
-            },
+            setup_version_id,
+            extra={"job_id": job_id, "mission_id": mission_id, "setup_id": setup_id},
         )
 
         return module_class(
@@ -116,5 +110,5 @@ class QueueFactory:
             msg = "maxsize must be >= 0"
             raise ValueError(msg)
 
-        logger.debug("Creating bounded queue with maxsize: %d", maxsize, extra={"maxsize": maxsize})
+        logger.debug("Creating bounded queue with maxsize: %d", maxsize)
         return asyncio.Queue(maxsize=maxsize)

digitalkin-1.0.0.dev14/src/digitalkin/core/exceptions.py

@@ -0,0 +1,33 @@
+"""Exceptions for the DigitalKin core package."""
+
+
+class BackpressureTimeoutError(Exception):
+    """Producer's XADD throttled past the backpressure timeout.
+
+    Throttled past :data:`GatewayBackpressureSettings.backpressure_timeout_s`.
+    Caller (typically the module's ``_on_output`` callback) must surface
+    this as ``stream.error(code=BACKPRESSURE_TIMEOUT)`` via the
+    ``_emit_fatal_to_redis`` path so the consumer sees a typed sentinel
+    instead of a silent stall.
+    """
+
+
+class BulkheadFullError(Exception):
+    """Raised when a bulkhead semaphore cannot be acquired within timeout."""
+
+
+class RedisUnreachableError(Exception):
+    """Raised at gateway boot when Redis ping fails.
+
+    Redis is a required dependency for gateway operation (stream persistence,
+    pub/sub signals). Failing fast at boot is preferable to lazy first-request
+    failures that surface as opaque task errors.
+    """
+
+    def __init__(self, masked_url: str) -> None:
+        """Initialize the error with a (masked) Redis URL for context.
+
+        Args:
+            masked_url: Redis connection URL with credentials masked.
+        """
+        super().__init__(f"Redis ping failed at gateway boot ({masked_url})")

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/core/task_manager/base_task_manager.py

@@ -103,14 +103,11 @@ class BaseTaskManager(ABC):
             if get_task_manager_settings().max_queued_tasks > 0:
                 self._system_gate.release()
             logger.info(
-                "Task cleaned up (%d remaining)",
+                "Task cleaned up (%d remaining) final_status=%s cancellation_reason=%s",
                 len(self.tasks_sessions),
-                extra={
-                    "mission_id": mission_id,
-                    "task_id": task_id,
-                    "final_status": final_status,
-                    "cancellation_reason": cancellation_reason,
-                },
+                final_status,
+                cancellation_reason,
+                extra={"mission_id": mission_id, "task_id": task_id},
             )
 
     async def _validate_task_creation(self, task_id: str, mission_id: str, coro: Coroutine[Any, Any, None]) -> None:
@@ -302,6 +299,13 @@ class BaseTaskManager(ABC):
         )
 
         session = self.tasks_sessions[task_id]
+        if session.signal_service is None:
+            logger.warning(
+                "Cannot send signal - task has no signal_service (config-setup session?): '%s'",
+                task_id,
+                extra={"mission_id": mission_id, "task_id": task_id, "signal_type": signal_type},
+            )
+            return False
         await session.signal_service.send_signal(
             task_id,
             SignalMessage(

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/core/task_manager/local_task_manager.py

@@ -76,26 +76,22 @@ class LocalTaskManager(BaseTaskManager):
             self.tasks[task_id] = supervisor_task
 
             logger.info(
-                "Local task created and started: '%s'",
+                "Local task created and started: '%s' (total_tasks=%d)",
                 task_id,
-                extra={
-                    "mission_id": mission_id,
-                    "task_id": task_id,
-                    "total_tasks": len(self.tasks),
-                },
+                len(self.tasks),
+                extra={"mission_id": mission_id, "task_id": task_id},
             )
 
-        except Exception as e:
+        except Exception:
             coro.close()
             # Release the slot if cleanup won't (session never registered).
             if task_id not in self.tasks_sessions:
                 self._task_slot.release()
             else:
                 await self._cleanup_task(task_id, mission_id=mission_id)
-            logger.error(
+            logger.exception(
                 "Failed to create local task: '%s'",
                 task_id,
-                extra={"mission_id": mission_id, "task_id": task_id, "error": str(e)},
-                exc_info=True,
+                extra={"mission_id": mission_id, "task_id": task_id},
             )
             raise

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/core/task_manager/redis/redis_client.py

@@ -69,17 +69,24 @@ class RedisClient:  # noqa: PLR0904
         )
 
     async def verify(self) -> bool:
-        """Verify Redis is reachable by sending a PING.
+        """Verify Redis is reachable by pinging both pools.
+
+        Pings ``_client`` and ``_blocking_client`` concurrently so the first
+        XADD and first XREAD don't each pay DNS+TCP+AUTH on cold pools.
 
         Timeout comes from ``RedisPoolSettings.health_check_timeout`` (env
         ``DIGITALKIN_REDIS_HEALTH_CHECK_TIMEOUT``).
 
         Returns:
-            True if Redis responded, False if unreachable.
+            True if both pools responded, False if either is unreachable.
         """
         try:
             timeout = get_redis_settings().pool.health_check_timeout
-            return await asyncio.wait_for(self._client.ping(), timeout=timeout)  # type: ignore[arg-type]
+            results = await asyncio.gather(
+                asyncio.wait_for(self._client.ping(), timeout=timeout),  # type: ignore[arg-type]
+                asyncio.wait_for(self._blocking_client.ping(), timeout=timeout),  # type: ignore[arg-type]
+            )
+            return all(results)
         except Exception:
             logger.warning("Redis health check failed for %s", GatewayValidator.mask_redis_url(self.url), exc_info=True)
             return False

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/core/task_manager/remote_task_manager.py

@@ -57,26 +57,22 @@ class RemoteTaskManager(BaseTaskManager):
             coro.close()
 
             logger.info(
-                "Remote task registered: '%s'",
+                "Remote task registered: '%s' (total_sessions=%d)",
                 task_id,
-                extra={
-                    "mission_id": mission_id,
-                    "task_id": task_id,
-                    "total_sessions": len(self.tasks_sessions),
-                },
+                len(self.tasks_sessions),
+                extra={"mission_id": mission_id, "task_id": task_id},
             )
 
-        except Exception as e:
+        except Exception:
             coro.close()
             # Release semaphore if session was never registered (cleanup won't release it)
             if task_id not in self.tasks_sessions:
                 self._task_slot.release()
             else:
                 await self._cleanup_task(task_id, mission_id=mission_id)
-            logger.error(
+            logger.exception(
                 "Failed to register remote task: '%s'",
                 task_id,
-                extra={"mission_id": mission_id, "task_id": task_id, "error": str(e)},
-                exc_info=True,
+                extra={"mission_id": mission_id, "task_id": task_id},
             )
             raise

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/core/task_manager/task_session.py

@@ -26,7 +26,7 @@ if TYPE_CHECKING:
 class TaskSession:
     """Ephemeral lifecycle context for one task, optionally persisted to Redis."""
 
-    signal_service: TaskManagerStrategy
+    signal_service: TaskManagerStrategy | None
     module: BaseModule
 
     _status: str
@@ -69,7 +69,9 @@ class TaskSession:
             queue_maxsize: Maximum size for the queue (0 = unlimited)
             state_manager: Optional Redis state manager for persistent status tracking
         """
-        assert module.context.task_manager is not None  # noqa: S101 — TaskSession requires it; set before run
+        # signal_service is None for config-setup TaskSessions (no signals to dispatch); see
+        # SingleJobManager.create_config_setup_instance_job. Real-task sessions get it wired
+        # by preload_instance setting context.task_manager before _create_session runs.
         self.signal_service = module.context.task_manager
         self.module = module
         self._state_manager = state_manager
@@ -185,21 +187,22 @@ class TaskSession:
 
         ack_t0 = time.perf_counter_ns()
         ack_ok = False
-        try:
-            await self.signal_service.send_signal(
-                self.task_id,
-                SignalMessage(
-                    task_id=self.task_id,
-                    mission_id=self.mission_id,
-                    setup_id=self.setup_id,
-                    setup_version_id=self.setup_version_id,
-                    action=SignalType.ACK_CANCEL,
-                    cancellation_reason=reason,
-                ).model_dump(exclude_none=True),
-            )
-            ack_ok = True
-        except Exception:
-            logger.warning("Cancel ack failed (best-effort)", extra=self.session_ids)
+        if self.signal_service is not None:
+            try:
+                await self.signal_service.send_signal(
+                    self.task_id,
+                    SignalMessage(
+                        task_id=self.task_id,
+                        mission_id=self.mission_id,
+                        setup_id=self.setup_id,
+                        setup_version_id=self.setup_version_id,
+                        action=SignalType.ACK_CANCEL,
+                        cancellation_reason=reason,
+                    ).model_dump(exclude_none=True),
+                )
+                ack_ok = True
+            except Exception:
+                logger.warning("Cancel ack failed (best-effort)", extra=self.session_ids)
         ack_ns = time.perf_counter_ns() - ack_t0
 
         pub_ns = self.last_signal_published_ns
@@ -239,21 +242,22 @@ class TaskSession:
 
         ack_t0 = time.perf_counter_ns()
         ack_ok = False
-        try:
-            await self.signal_service.send_signal(
-                self.task_id,
-                SignalMessage(
-                    task_id=self.task_id,
-                    mission_id=self.mission_id,
-                    setup_id=self.setup_id,
-                    setup_version_id=self.setup_version_id,
-                    action=SignalType.ACK_STOP,
-                    cancellation_reason=CancellationReason.SIGNAL_SERVICE_STOP,
-                ).model_dump(exclude_none=True),
-            )
-            ack_ok = True
-        except Exception:
-            logger.warning("Stop ack failed (best-effort)", extra=self.session_ids)
+        if self.signal_service is not None:
+            try:
+                await self.signal_service.send_signal(
+                    self.task_id,
+                    SignalMessage(
+                        task_id=self.task_id,
+                        mission_id=self.mission_id,
+                        setup_id=self.setup_id,
+                        setup_version_id=self.setup_version_id,
+                        action=SignalType.ACK_STOP,
+                        cancellation_reason=CancellationReason.SIGNAL_SERVICE_STOP,
+                    ).model_dump(exclude_none=True),
+                )
+                ack_ok = True
+            except Exception:
+                logger.warning("Stop ack failed (best-effort)", extra=self.session_ids)
         ack_ns = time.perf_counter_ns() - ack_t0
 
         pub_ns = self.last_signal_published_ns
@@ -280,7 +284,7 @@ class TaskSession:
             return
         self._cleanup_done = True
 
-        logger.debug("Cleanup: draining queue", extra={"task_id": self.task_id, "queue_size": self.queue.qsize()})
+        logger.debug("Cleanup: draining queue (queue_size=%d)", self.queue.qsize(), extra=ids)
         try:
             while not self.queue.empty():
                 self.queue.get_nowait()

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/grpc_servers/gateway_servicer.py

@@ -15,6 +15,7 @@ from google.protobuf import struct_pb2
 from grpc._cython.cygrpc import UsageError as _GrpcUsageError  # noqa: PLC2701
 from redis.exceptions import RedisError
 
+from digitalkin.core.exceptions import RedisUnreachableError
 from digitalkin.core.profiling.step_timer import StepTimer
 from digitalkin.core.task_manager.redis.proto_streams import ProtoStreamReader
 from digitalkin.core.task_manager.redis.redis_signal import SharedRedisListener
@@ -131,7 +132,16 @@ class GatewayServicer:
         return task
 
     async def start(self) -> None:
-        """Start the M2M call-registry TTL sweeper and PSUBSCRIBE the signal listener."""
+        """Start the M2M call-registry TTL sweeper and PSUBSCRIBE the signal listener.
+
+        Pre-warms both Redis pools so the first XADD and first XREAD don't pay
+        DNS+TCP+AUTH on cold connections.
+
+        Raises:
+            RedisUnreachableError: Redis ping failed; gateway cannot serve traffic.
+        """
+        if not await self._redis_client.verify():
+            raise RedisUnreachableError(GatewayValidator.mask_redis_url(self._redis_client.url))
         await self._m2m.start()
         listener = SharedRedisListener.singleton_or_none()
         if listener is not None:

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/grpc_servers/module_server.py

@@ -246,11 +246,11 @@ class ModuleServer(BaseServer):
         advertise_address = get_server_settings().channel.advertise_host or get_server_settings().channel.host
 
         logger.info(
-            "Registering module with registry at %s:%d version=%s",
+            "Registering module with registry at %s:%d version=%s module_id=%s",
             advertise_address,
             get_server_settings().channel.port,
             version,
-            extra={"module_id": module_id},
+            module_id,
         )
 
         result = await self.registry.register(
@@ -265,10 +265,10 @@ class ModuleServer(BaseServer):
             raise RuntimeError(msg)
 
         logger.info(
-            "Module registered successfully at %s:%d",
+            "Module registered successfully at %s:%d module_id=%s",
             advertise_address,
             get_server_settings().channel.port,
-            extra={"module_id": result.module_id},
+            result.module_id,
         )
 
     async def start_async(self) -> None:

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/grpc_servers/utils/grpc_client_wrapper.py

@@ -243,6 +243,12 @@ class GrpcClientWrapper:
             except grpc.RpcError as e:
                 last_error = e
                 if e.code() not in self._RETRYABLE_CODES or attempt == max_retries:
+                    logger.warning(
+                        "circuit-breaker tick: %s.%s [%s]",
+                        self.service_name,
+                        query_endpoint,
+                        e.code().name,
+                    )
                     cb.record_failure()
                     break
                 logger.warning(

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/logger.py

@@ -235,3 +235,8 @@ logger = LoggerFactory.setup_logger(
     "digitalkin",
     level=LoggerFactory.LEVEL_NAMES.get(get_logging_settings().level.upper(), logging.INFO),
 )
+
+# Backwards-compatible re-exports for downstream that imported these directly
+# (e.g. ``archetype_ada/logger.py``). Aliases to the staticmethods, identical behaviour.
+setup_logger = LoggerFactory.setup_logger
+add_file_handler = LoggerFactory.add_file_handler

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/mixins/cost_mixin.py

@@ -28,7 +28,7 @@ class CostMixin:
         try:
             await context.cost.add(name, cost_config_name, quantity)
         except Exception:
-            logger.error("Failed to add cost '%s' (config=%s), continuing", name, cost_config_name, exc_info=True)
+            logger.exception("Failed to add cost '%s' (config=%s), continuing", name, cost_config_name)
 
     @staticmethod
     async def get_cost(context: ModuleContext, name: str) -> list[CostData]:

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/models/module/tool_cache.py

@@ -205,11 +205,9 @@ class ToolCache(BaseModel):
             )
         self.entries[setup_id] = tool_module_info
         logger.debug(
-            "Tool cached",
-            extra={
-                "setup_id": setup_id,
-                "module_id": tool_module_info.module_id,
-            },
+            "Tool cached: module_id=%s",
+            tool_module_info.module_id,
+            extra={"setup_id": setup_id},
         )
 
     def get(

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/modules/_base_module.py

@@ -560,7 +560,7 @@ class BaseModule(  # Module SDK base class requires many public methods # noqa:
                     )
                 )
             except Exception:
-                logger.exception("Failed to send error callback")
+                logger.exception("Failed to send error callback", extra=self.context.session.current_ids())
         else:
             self._status = ModuleStatus.STOPPING
 
@@ -627,7 +627,7 @@ class BaseModule(  # Module SDK base class requires many public methods # noqa:
             self._status = ModuleStatus.FAILED
             short_description = "Error initializing module"
             error_detail = f"{type(e).__name__}: {e}" if str(e) else type(e).__name__
-            logger.exception("%s: %s", short_description, error_detail)
+            logger.exception("%s: %s", short_description, error_detail, extra=self.context.session.current_ids())
             await callback(
                 ModuleCodeModel(
                     code="Error",
@@ -645,7 +645,7 @@ class BaseModule(  # Module SDK base class requires many public methods # noqa:
             timer.mark("run_lifecycle")
         except Exception:
             self._status = ModuleStatus.FAILED
-            logger.exception("Error during module lifecyle")
+            logger.exception("Error during module lifecycle", extra=self.context.session.current_ids())
         finally:
             timer.log("module.start", task_id=self.context.session.current_ids().get("job_id", ""))
             await self.stop()
@@ -691,7 +691,7 @@ class BaseModule(  # Module SDK base class requires many public methods # noqa:
             )
         except Exception:
             self._status = ModuleStatus.FAILED
-            logger.exception("Error stopping module")
+            logger.exception("Error stopping module", extra=self.context.session.current_ids())
 
     async def _resolve_tools(self, config_setup_data: SetupModelT) -> None:
         """Resolve tool references and build cache.

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin/services/storage/grpc_storage.py

@@ -105,8 +105,8 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
             )
             resp = await self.exec_grpc_query("ReadRecord", req)
             return self._build_record_from_proto(resp.stored_data)
-        except Exception:
-            logger.debug("gRPC ReadRecord failed for %s:%s", collection, record_id)
+        except Exception as e:
+            logger.info("gRPC ReadRecord failed for %s:%s: %s", collection, record_id, e)
             return None
 
     async def _update(
@@ -137,8 +137,8 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
             )
             resp = await self.exec_grpc_query("UpdateRecord", req)
             return self._build_record_from_proto(resp.stored_data)
-        except Exception:
-            logger.warning("gRPC UpdateRecord failed for %s:%s", collection, record_id)
+        except Exception as e:
+            logger.warning("gRPC UpdateRecord failed for %s:%s: %s", collection, record_id, e)
             return None
 
     async def _remove(self, collection: str, record_id: str) -> bool:
@@ -159,11 +159,12 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
                 record_id=record_id,
             )
             await self.exec_grpc_query("RemoveRecord", req)
-        except Exception:
+        except Exception as e:
             logger.warning(
-                "gRPC RemoveRecord failed for %s:%s",
+                "gRPC RemoveRecord failed for %s:%s: %s",
                 collection,
                 record_id,
+                e,
             )
             return False
         return True
@@ -185,8 +186,8 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
             )
             resp = await self.exec_grpc_query("ListRecords", req)
             return [self._build_record_from_proto(r) for r in resp.records]
-        except Exception:
-            logger.warning("gRPC ListRecords failed for %s", collection)
+        except Exception as e:
+            logger.warning("gRPC ListRecords failed for %s: %s", collection, e)
             return []
 
     async def _remove_collection(self, collection: str) -> bool:
@@ -204,8 +205,8 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
                 collection=collection,
             )
             await self.exec_grpc_query("RemoveCollection", req)
-        except Exception:
-            logger.warning("gRPC RemoveCollection failed for %s", collection)
+        except Exception as e:
+            logger.warning("gRPC RemoveCollection failed for %s: %s", collection, e)
             return False
         return True
 

{digitalkin-1.0.0.dev12 → digitalkin-1.0.0.dev14}/src/digitalkin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.0.dev12
+Version: 1.0.0.dev14
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International

digitalkin-1.0.0.dev12/src/digitalkin/core/exceptions.py

@@ -1,16 +0,0 @@
-"""Exceptions for the DigitalKin core package."""
-
-
-class BackpressureTimeoutError(Exception):
-    """Producer's XADD throttled past the backpressure timeout.
-
-    Throttled past :data:`GatewayBackpressureSettings.backpressure_timeout_s`.
-    Caller (typically the module's ``_on_output`` callback) must surface
-    this as ``stream.error(code=BACKPRESSURE_TIMEOUT)`` via the
-    ``_emit_fatal_to_redis`` path so the consumer sees a typed sentinel
-    instead of a silent stall.
-    """
-
-
-class BulkheadFullError(Exception):
-    """Raised when a bulkhead semaphore cannot be acquired within timeout."""