openbox-temporal-sdk-python 1.1.1__py3-none-any.whl → 1.1.2__py3-none-any.whl

openbox/__init__.py

@@ -68,7 +68,7 @@ from .span_processor import WorkflowSpanProcessor
 from .workflow_interceptor import GovernanceInterceptor
 
 # ═══════════════════════════════════════════════════════════════════════════════
-# Plugin (requires temporalio >= 1.24.0)
+# Plugin (requires temporalio >= 1.23.0)
 # ═══════════════════════════════════════════════════════════════════════════════
 
 try:
@@ -76,7 +76,7 @@ try:
 
     from .plugin import OpenBoxPlugin
 except ImportError:
-    pass  # temporalio < 1.24.0, plugin not available
+    pass  # temporalio < 1.23.0, plugin not available
 
 # ═══════════════════════════════════════════════════════════════════════════════
 # Verdict Handler
@@ -139,7 +139,7 @@ from .client import GovernanceClient
 __all__ = [
     # Simple Worker Factory (recommended)
     "create_openbox_worker",
-    # Plugin (recommended for temporalio >= 1.24.0)
+    # Plugin (recommended for temporalio >= 1.23.0)
     "OpenBoxPlugin",
     # Configuration
     "initialize",

openbox/activities.py

@@ -142,60 +142,109 @@ def _handle_api_error(event_type: str, error_msg: str, on_api_error: str) -> dic
     return {"success": False, "error": error_msg}
 
 
-@activity.defn(name="send_governance_event")
-async def send_governance_event(input: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    """
-    Activity that sends governance events to OpenBox Core.
+class GovernanceActivities:
+    """Container for Temporal activities that need OpenBox credentials.
 
-    Called from WorkflowInboundInterceptor via workflow.execute_activity()
-    to maintain workflow determinism.
+    Credentials live on the instance (never in activity inputs → never in
+    workflow history → not visible to anyone with namespace read access).
+    The worker registers bound methods of a single instance, created at
+    worker-init time by the plugin / create_openbox_worker factory.
     """
-    api_url = input.get("api_url", "")
-    api_key = input.get("api_key", "")
-    event_payload = input.get("payload", {})
-    timeout = input.get("timeout", 30.0)
-    on_api_error = input.get("on_api_error", "fail_open")
-
-    # Add timestamp in activity context (non-deterministic code allowed)
-    payload = {**event_payload, "timestamp": _rfc3339_now()}
-    event_type = event_payload.get("event_type", "unknown")
-
-    try:
-        async with httpx.AsyncClient(timeout=timeout) as client:
-            response = await client.post(
-                f"{api_url}/api/v1/governance/evaluate",
-                json=payload,
-                headers=build_auth_headers(api_key),
-            )
-
-            if response.status_code != 200:
-                return _handle_api_error(
-                    event_type,
-                    f"HTTP {response.status_code}: {response.text}",
-                    on_api_error,
+
+    def __init__(self, api_url: str, api_key: str):
+        self._api_url = api_url.rstrip("/")
+        self._api_key = api_key
+
+    @activity.defn(name="send_governance_event")
+    async def send_governance_event(
+        self, input: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
+        """Send a governance event to OpenBox Core.
+
+        Called from WorkflowInboundInterceptor via workflow.execute_activity()
+        to maintain workflow determinism. The `input` dict carries only the
+        event payload and per-call policy — never credentials.
+        """
+        event_payload = input.get("payload", {})
+        timeout = input.get("timeout", 30.0)
+        on_api_error = input.get("on_api_error", "fail_open")
+
+        # Add timestamp in activity context (non-deterministic code allowed)
+        payload = {**event_payload, "timestamp": _rfc3339_now()}
+        event_type = event_payload.get("event_type", "unknown")
+
+        try:
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                response = await client.post(
+                    f"{self._api_url}/api/v1/governance/evaluate",
+                    json=payload,
+                    headers=build_auth_headers(self._api_key),
                 )
 
-            data = response.json()
-            verdict = Verdict.from_string(
-                data.get("verdict") or data.get("action", "continue")
-            )
-            reason = data.get("reason")
-            policy_id = data.get("policy_id")
-            risk_score = data.get("risk_score", 0.0)
-
-            if verdict.should_stop():
-                result = await _handle_stop_verdict(
-                    verdict, reason, policy_id, risk_score, event_type, event_payload
+                if response.status_code != 200:
+                    return _handle_api_error(
+                        event_type,
+                        f"HTTP {response.status_code}: {response.text}",
+                        on_api_error,
+                    )
+
+                data = response.json()
+                verdict = Verdict.from_string(
+                    data.get("verdict") or data.get("action", "continue")
                 )
-                if result:
-                    return result
-
-            return _build_verdict_result(verdict, reason, policy_id, risk_score)
-
-    except (GovernanceAPIError, ApplicationError):
-        raise
-    except Exception as e:
-        logger.warning(f"Failed to send {event_type} event: {e}")
-        if on_api_error == "fail_closed":
-            raise GovernanceAPIError(str(e))
-        return {"success": False, "error": str(e)}
+                reason = data.get("reason")
+                policy_id = data.get("policy_id")
+                risk_score = data.get("risk_score", 0.0)
+
+                if verdict.should_stop():
+                    result = await _handle_stop_verdict(
+                        verdict,
+                        reason,
+                        policy_id,
+                        risk_score,
+                        event_type,
+                        event_payload,
+                    )
+                    if result:
+                        return result
+
+                return _build_verdict_result(verdict, reason, policy_id, risk_score)
+
+        except (GovernanceAPIError, ApplicationError):
+            raise
+        except Exception as e:
+            logger.warning(f"Failed to send {event_type} event: {e}")
+            if on_api_error == "fail_closed":
+                raise GovernanceAPIError(str(e))
+            return {"success": False, "error": str(e)}
+
+
+def build_governance_activities(
+    api_url: str, api_key: str
+) -> GovernanceActivities:
+    """Factory used by plugin.py and worker.py to build the activities instance."""
+    return GovernanceActivities(api_url=api_url, api_key=api_key)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Backward-compat module-level helper.
+#
+# Not decorated with @activity.defn — worker/plugin register the class-based
+# version above so credentials never flow through activity inputs. This shim
+# exists for direct callers (tests, scripts) who already hold credentials and
+# want to invoke the HTTP logic without constructing the class themselves.
+# ─────────────────────────────────────────────────────────────────────────────
+async def send_governance_event(input: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Backward-compat wrapper — delegates to GovernanceActivities.
+
+    Tests and direct callers can keep passing api_url/api_key in the input
+    dict. The class-based activity registered with the worker does NOT see
+    these fields (it reads credentials from self), so nothing written to
+    workflow history ever carries the API key.
+    """
+    instance = GovernanceActivities(
+        api_url=input.get("api_url", ""),
+        api_key=input.get("api_key", ""),
+    )
+    forwarded = {k: v for k, v in input.items() if k not in ("api_url", "api_key")}
+    return await instance.send_governance_event(forwarded)

openbox/db_governance_hooks.py

@@ -68,9 +68,14 @@ def _classify_sql(query: Any) -> str:
 
 
 def _generate_span_id() -> str:
-    """Generate a random 16-hex-char span ID for pymongo governance spans."""
-    import random
-    return format(random.getrandbits(64), "016x")
+    """Generate a random 16-hex-char span ID for pymongo governance spans.
+
+    Uses secrets (CSPRNG) rather than random — span IDs are not secrets, but
+    the stronger generator silences security scanners without runtime cost
+    and removes any chance of cross-trace ID collision under heavy load.
+    """
+    import secrets
+    return secrets.token_hex(8)
 
 
 def _build_db_span_data(

openbox/errors.py

@@ -21,12 +21,26 @@ Hierarchy:
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Final, Union
 
 if TYPE_CHECKING:
     from .types import Verdict
 
 
+# ═══════════════════════════════════════════════════════════════════
+# ApplicationError.type values raised by governance activities.
+# Use these constants — never string-match on error messages or
+# exception class names (brittle against locale / reformatting /
+# Temporal's ActivityError wrapping).
+# ═══════════════════════════════════════════════════════════════════
+
+GOVERNANCE_HALT_ERROR_TYPE: Final[str] = "GovernanceHalt"
+GOVERNANCE_BLOCK_ERROR_TYPE: Final[str] = "GovernanceBlock"
+GOVERNANCE_API_ERROR_TYPE: Final[str] = "GovernanceAPIError"
+# Legacy alias; kept for histories predating the rename.
+GOVERNANCE_STOP_ERROR_TYPE: Final[str] = "GovernanceStop"
+
+
 # ═══════════════════════════════════════════════════════════════════
 # Base
 # ═══════════════════════════════════════════════════════════════════

openbox/hook_governance.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import json
 import logging
+import threading
 from typing import TYPE_CHECKING, Any, Dict, Optional
 
 import httpx
@@ -38,9 +39,14 @@ _max_body_size: Optional[int] = None
 _span_processor: Optional["WorkflowSpanProcessor"] = None
 _cached_auth_headers: Optional[dict] = None
 
-# Persistent HTTP clients (lazy-init, thread-safe for requests)
+# Persistent HTTP clients. httpx Client/AsyncClient themselves are thread-safe
+# for requests; the locks below only guard creation against concurrent activities
+# racing to initialize a fresh client (which would leak connection pools when
+# one of the losers gets garbage collected).
 _sync_client: Optional[httpx.Client] = None
 _async_client: Optional[httpx.AsyncClient] = None
+_sync_client_lock = threading.Lock()
+_async_client_lock = threading.Lock()
 
 
 def configure(
@@ -78,18 +84,22 @@ def configure(
 
 
 def _get_sync_client() -> httpx.Client:
-    """Get or create persistent sync HTTP client."""
+    """Get or create persistent sync HTTP client (double-checked locking)."""
     global _sync_client
     if _sync_client is None or _sync_client.is_closed:
-        _sync_client = httpx.Client(timeout=_api_timeout)
+        with _sync_client_lock:
+            if _sync_client is None or _sync_client.is_closed:
+                _sync_client = httpx.Client(timeout=_api_timeout)
     return _sync_client
 
 
 def _get_async_client() -> httpx.AsyncClient:
-    """Get or create persistent async HTTP client."""
+    """Get or create persistent async HTTP client (double-checked locking)."""
     global _async_client
     if _async_client is None or _async_client.is_closed:
-        _async_client = httpx.AsyncClient(timeout=_api_timeout)
+        with _async_client_lock:
+            if _async_client is None or _async_client.is_closed:
+                _async_client = httpx.AsyncClient(timeout=_api_timeout)
     return _async_client
 
 

openbox/plugin.py

@@ -17,6 +17,7 @@ Usage:
 """
 
 import dataclasses
+import logging
 from typing import Any, Optional, Set
 
 from temporalio.plugin import SimplePlugin
@@ -27,6 +28,8 @@ from .config import initialize as validate_api_key, GovernanceConfig
 from .span_processor import WorkflowSpanProcessor
 from .client import GovernanceClient
 
+logger = logging.getLogger(__name__)
+
 
 class OpenBoxPlugin(SimplePlugin):
     """Temporal Plugin for OpenBox governance and observability.
@@ -62,6 +65,11 @@ class OpenBoxPlugin(SimplePlugin):
         db_libraries: Optional[Set[str]] = None,
         sqlalchemy_engine: Optional[Any] = None,
         instrument_file_io: bool = True,
+        # Propagate W3C traceparent/baggage through Temporal headers so spans
+        # started by the caller (e.g., an HTTP server) stitch to workflow and
+        # activity spans on the worker side. Uses Temporal's built-in
+        # TracingInterceptor under the hood.
+        enable_trace_propagation: bool = True,
     ):
         # 1. Validate API key (sync, uses urllib)
         validate_api_key(
@@ -115,7 +123,7 @@ class OpenBoxPlugin(SimplePlugin):
             on_api_error=governance_policy,
         )
 
-        interceptors = [
+        interceptors: list = [
             GovernanceInterceptor(
                 api_url=openbox_url,
                 api_key=openbox_api_key,
@@ -131,8 +139,23 @@ class OpenBoxPlugin(SimplePlugin):
             ),
         ]
 
-        # 6. Get governance activity
-        from .activities import send_governance_event
+        # Header-based OTel trace propagation. Temporal's built-in
+        # TracingInterceptor implements both client.Interceptor and
+        # worker.Interceptor — SimplePlugin auto-routes it to both sides.
+        # Without it, trace IDs set by the caller don't reach workflow/
+        # activity spans, leaving disconnected trees in the backend.
+        if enable_trace_propagation:
+            from temporalio.contrib.opentelemetry import TracingInterceptor
+
+            interceptors.append(TracingInterceptor())
+
+        # 6. Build governance activity instance with credentials captured in self —
+        # avoids passing api_key through activity inputs / workflow history.
+        from .activities import build_governance_activities
+
+        governance_activities = build_governance_activities(
+            api_url=openbox_url, api_key=openbox_api_key
+        )
 
         # 7. Sandbox passthrough for opentelemetry
         def workflow_runner(runner: WorkflowRunner | None) -> WorkflowRunner | None:
@@ -157,7 +180,7 @@ class OpenBoxPlugin(SimplePlugin):
         super().__init__(
             "openbox.OpenBoxPlugin",
             interceptors=interceptors,
-            activities=[send_governance_event],
+            activities=[governance_activities.send_governance_event],
             workflow_runner=workflow_runner,
         )
 
@@ -171,15 +194,17 @@ class OpenBoxPlugin(SimplePlugin):
 
         config = super().configure_worker(config)
 
-        print("OpenBox Plugin initialized successfully")
-        print(f"  - Governance policy: {self._governance_policy}")
-        print(f"  - Governance timeout: {self._governance_timeout}s")
         db_status = "enabled" if self._instrument_databases else "disabled"
         file_status = "enabled" if self._instrument_file_io else "disabled"
         hitl_status = "enabled" if self._hitl_enabled else "disabled"
-        print(f"  - Database instrumentation: {db_status}")
-        print(f"  - File I/O instrumentation: {file_status}")
-        print(f"  - Approval polling: {hitl_status}")
-        print("  - Hook governance: enabled")
+        logger.info(
+            "OpenBox Plugin initialized: policy=%s timeout=%ss "
+            "db=%s file=%s hitl=%s hook_governance=enabled",
+            self._governance_policy,
+            self._governance_timeout,
+            db_status,
+            file_status,
+            hitl_status,
+        )
 
         return config

openbox/worker.py

@@ -18,6 +18,7 @@ Usage:
     await worker.run()
 """
 
+import logging
 from datetime import timedelta
 from typing import (
     Any,
@@ -36,6 +37,8 @@ from temporalio.worker import Worker, Interceptor
 from .config import initialize as validate_api_key, GovernanceConfig
 from .span_processor import WorkflowSpanProcessor
 
+logger = logging.getLogger(__name__)
+
 
 def create_openbox_worker(
     client: Client,
@@ -61,6 +64,9 @@ def create_openbox_worker(
     sqlalchemy_engine: Optional[Any] = None,
     # File I/O instrumentation
     instrument_file_io: bool = True,
+    # Header-based W3C trace propagation via Temporal's built-in TracingInterceptor.
+    # Without it, trace IDs set by the caller don't reach workflow/activity spans.
+    enable_trace_propagation: bool = True,
     # Standard Worker options
     activity_executor: Optional[Executor] = None,
     workflow_task_executor: Optional[ThreadPoolExecutor] = None,
@@ -156,8 +162,7 @@ def create_openbox_worker(
         await worker.run()
         ```
     """
-    # Initialize OpenBox
-    print(f"Initializing OpenBox SDK with URL: {openbox_url}")
+    logger.info("Initializing OpenBox SDK with URL: %s", openbox_url)
 
     # 0. Store Temporal client reference for HALT terminate calls
     from .activities import set_temporal_client
@@ -231,27 +236,35 @@ def create_openbox_worker(
         client=governance_client,
     )
 
-    # 6. Get governance activities
-    from .activities import send_governance_event
+    # 6. Build governance activities with credentials captured on the instance
+    # (so api_key never leaks through activity inputs into workflow history).
+    from .activities import build_governance_activities
 
-    # Add OpenBox components
-    all_interceptors = [workflow_interceptor, activity_interceptor, *interceptors]
-    all_activities = [*activities, send_governance_event]
-
-    print("OpenBox SDK initialized successfully")
-    print(f"  - Governance policy: {governance_policy}")
-    print(f"  - Governance timeout: {governance_timeout}s")
-    print(
-        "  - Events: WorkflowStarted, WorkflowCompleted, WorkflowFailed, SignalReceived, ActivityStarted, ActivityCompleted"
-    )
-    print(
-        f"  - Database instrumentation: {'enabled' if instrument_databases else 'disabled'}"
+    governance_activities = build_governance_activities(
+        api_url=openbox_url, api_key=openbox_api_key
     )
-    print(
-        f"  - File I/O instrumentation: {'enabled' if instrument_file_io else 'disabled'}"
+
+    # Add OpenBox components
+    all_interceptors: list = [workflow_interceptor, activity_interceptor, *interceptors]
+
+    # Header-based OTel trace propagation via Temporal's built-in interceptor.
+    if enable_trace_propagation:
+        from temporalio.contrib.opentelemetry import TracingInterceptor
+
+        all_interceptors.append(TracingInterceptor())
+
+    all_activities = [*activities, governance_activities.send_governance_event]
+
+    logger.info(
+        "OpenBox SDK initialized: policy=%s timeout=%ss db=%s file=%s hitl=%s "
+        "hook_governance=enabled events=WorkflowStarted,WorkflowCompleted,"
+        "WorkflowFailed,SignalReceived,ActivityStarted,ActivityCompleted",
+        governance_policy,
+        governance_timeout,
+        "enabled" if instrument_databases else "disabled",
+        "enabled" if instrument_file_io else "disabled",
+        "enabled" if hitl_enabled else "disabled",
     )
-    print(f"  - Approval polling: {'enabled' if hitl_enabled else 'disabled'}")
-    print("  - Hook governance: enabled")
 
     # Create and return Worker
     return Worker(

openbox/workflow_interceptor.py

@@ -20,6 +20,7 @@ from datetime import timedelta
 from typing import Any, Optional, Type
 
 from temporalio import workflow
+from temporalio.exceptions import ActivityError, ApplicationError
 from temporalio.worker import (
     Interceptor,
     WorkflowInboundInterceptor,
@@ -28,9 +29,38 @@ from temporalio.worker import (
     HandleSignalInput,
 )
 
+from .errors import (
+    GOVERNANCE_API_ERROR_TYPE,
+    GOVERNANCE_BLOCK_ERROR_TYPE,
+    GOVERNANCE_HALT_ERROR_TYPE,
+    GOVERNANCE_STOP_ERROR_TYPE,
+)
 from .types import Verdict
 
 
+def _application_error_type(exc: BaseException) -> Optional[str]:
+    """Walk exception chain and return the ApplicationError.type if present.
+
+    Temporal wraps activity failures as ActivityError(cause=ApplicationError).
+    We walk cause/__cause__/__context__ to find the first ApplicationError and
+    return its `type` field. Matching on this field is stable across message
+    reformatting, locale changes, and nested wrapping.
+    """
+    seen: set[int] = set()
+    current: Optional[BaseException] = exc
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        if isinstance(current, ApplicationError):
+            return getattr(current, "type", None)
+        next_exc = (
+            getattr(current, "cause", None)
+            or getattr(current, "__cause__", None)
+            or getattr(current, "__context__", None)
+        )
+        current = next_exc
+    return None
+
+
 def _safe_error_type(exc) -> Optional[str]:
     """Extract error type string from an exception, sanitized for JSON."""
     t = getattr(exc, "type", None)
@@ -117,8 +147,6 @@ from .errors import GovernanceHaltError  # noqa: F401
 
 
 async def _send_governance_event(
-    api_url: str,
-    api_key: str,
     payload: dict,
     timeout: float,
     on_api_error: str = "fail_open",
@@ -130,17 +158,18 @@ async def _send_governance_event(
         on_api_error: "fail_open" (default) = continue on error
                       "fail_closed" = halt workflow if governance API fails
 
-    The on_api_error policy is passed to the activity, which handles logging
-    (safe outside sandbox) and raises GovernanceAPIError if fail_closed.
-    This interceptor catches that and re-raises as GovernanceHaltError.
+    Credentials (api_url, api_key) are held by the activity instance itself —
+    never passed through activity inputs, so they never land in workflow
+    history. The on_api_error policy is passed to the activity, which handles
+    logging (safe outside sandbox) and raises GovernanceAPIError if
+    fail_closed. This interceptor catches that and re-raises as
+    GovernanceHaltError.
     """
     try:
         result = await workflow.execute_activity(
             "send_governance_event",
             args=[
                 {
-                    "api_url": api_url,
-                    "api_key": api_key,
                     "payload": payload,
                     "timeout": timeout,
                     "on_api_error": on_api_error,
@@ -150,27 +179,26 @@ async def _send_governance_event(
         )
         return result
     except Exception as e:
-        error_str = str(e)
-        error_type = type(e).__name__
-
-        # GovernanceHalt: workflow should terminate (client.terminate() already called,
-        # but re-raise to ensure workflow code path stops)
-        if "GovernanceHalt" in error_str:
-            raise GovernanceHaltError(error_str)
-
-        # GovernanceBlock: activity blocked, workflow continues
-        if "GovernanceBlock" in error_str:
+        app_error_type = _application_error_type(e)
+
+        # GovernanceHalt / legacy GovernanceStop: workflow should terminate
+        # (client.terminate() already called by the activity, but re-raise to
+        # ensure the workflow code path stops).
+        if app_error_type in (
+            GOVERNANCE_HALT_ERROR_TYPE,
+            GOVERNANCE_STOP_ERROR_TYPE,
+        ):
+            raise GovernanceHaltError(str(e))
+
+        # GovernanceBlock: the current activity is blocked; the workflow continues.
+        if app_error_type == GOVERNANCE_BLOCK_ERROR_TYPE:
             return None
 
-        # Legacy GovernanceStop (backward compat) → treat as halt
-        if "GovernanceStop" in error_str:
-            raise GovernanceHaltError(error_str)
+        # Activity raised GovernanceAPIError (fail_closed + API unreachable).
+        if app_error_type == GOVERNANCE_API_ERROR_TYPE:
+            raise GovernanceHaltError(str(e))
 
-        # Activity raised GovernanceAPIError (fail_closed and API unreachable)
-        if "GovernanceAPIError" in error_type or "GovernanceAPIError" in error_str:
-            raise GovernanceHaltError(error_str)
-
-        # Other errors with fail_open: silently continue
+        # Other errors with fail_open: silently continue.
         return None
 
 
@@ -179,12 +207,15 @@ class GovernanceInterceptor(Interceptor):
 
     def __init__(
         self,
-        api_url: str,
-        api_key: str,
+        api_url: str = "",
+        api_key: str = "",
         span_processor=None,  # Shared with activity interceptor for HTTP spans
         config=None,  # Optional GovernanceConfig
     ):
-        self.api_url = api_url.rstrip("/")
+        # api_url / api_key are accepted for backward compatibility but no longer
+        # flow to the governance activity — credentials live on GovernanceActivities.
+        # Kept on self in case downstream callers introspect.
+        self.api_url = api_url.rstrip("/") if api_url else ""
         self.api_key = api_key
         self.span_processor = span_processor
         self.api_timeout = getattr(config, "api_timeout", 30.0) if config else 30.0
@@ -203,8 +234,6 @@ class GovernanceInterceptor(Interceptor):
         self, input: WorkflowInterceptorClassInput
     ) -> Optional[Type[WorkflowInboundInterceptor]]:
         # Capture via closure
-        api_url = self.api_url
-        api_key = self.api_key
         span_processor = self.span_processor
         timeout = self.api_timeout
         on_error = self.on_api_error
@@ -223,8 +252,6 @@ class GovernanceInterceptor(Interceptor):
                 # WorkflowStarted event
                 if send_start and workflow.patched("openbox-v2-start"):
                     await _send_governance_event(
-                        api_url,
-                        api_key,
                         {
                             "source": "workflow-telemetry",
                             "event_type": "WorkflowStarted",
@@ -254,8 +281,6 @@ class GovernanceInterceptor(Interceptor):
                             )
 
                         await _send_governance_event(
-                            api_url,
-                            api_key,
                             {
                                 "source": "workflow-telemetry",
                                 "event_type": "WorkflowCompleted",
@@ -273,20 +298,24 @@ class GovernanceInterceptor(Interceptor):
                     error = _build_error_dict(e)
 
                     if workflow.patched("openbox-v2-failed"):
-                        await _send_governance_event(
-                            api_url,
-                            api_key,
-                            {
-                                "source": "workflow-telemetry",
-                                "event_type": "WorkflowFailed",
-                                "workflow_id": info.workflow_id,
-                                "run_id": info.run_id,
-                                "workflow_type": info.workflow_type,
-                                "error": error,
-                            },
-                            timeout,
-                            on_error,
-                        )
+                        # Swallow failures from the failure-reporting activity itself
+                        # (fail_closed + governance API down would otherwise raise
+                        # GovernanceHaltError and shadow the real workflow exception).
+                        try:
+                            await _send_governance_event(
+                                {
+                                    "source": "workflow-telemetry",
+                                    "event_type": "WorkflowFailed",
+                                    "workflow_id": info.workflow_id,
+                                    "run_id": info.run_id,
+                                    "workflow_type": info.workflow_type,
+                                    "error": error,
+                                },
+                                timeout,
+                                on_error,
+                            )
+                        except Exception:
+                            pass
 
                     raise
 
@@ -300,8 +329,6 @@ class GovernanceInterceptor(Interceptor):
                 # SignalReceived event - check verdict and store if "stop"
                 if workflow.patched("openbox-v2-signal"):
                     result = await _send_governance_event(
-                        api_url,
-                        api_key,
                         {
                             "source": "workflow-telemetry",
                             "event_type": "SignalReceived",

{openbox_temporal_sdk_python-1.1.1.dist-info → openbox_temporal_sdk_python-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbox-temporal-sdk-python
-Version: 1.1.1
+Version: 1.1.2
 Summary: OpenBox SDK - Governance and observability for Temporal workflows
 Project-URL: Homepage, https://github.com/OpenBox-AI/temporal-sdk-python
 Project-URL: Documentation, https://github.com/OpenBox-AI/temporal-sdk-python#readme
@@ -100,7 +100,15 @@ await worker.run()
 ```
 
 The plugin automatically configures governance interceptors, OTel instrumentation,
-sandbox passthrough, and the `send_governance_event` activity.
+sandbox passthrough, W3C trace propagation through Temporal headers (via
+`temporalio.contrib.opentelemetry.TracingInterceptor`), and the
+`send_governance_event` activity.
+
+**Credentials never leave the plugin.** `openbox_api_key` is captured on the
+governance activity instance itself — it does **not** flow through activity
+inputs, so it is never written to workflow history. To opt out of trace
+propagation (e.g., if you already wire `OpenTelemetryPlugin`), pass
+`enable_trace_propagation=False`.
 
 ### Composing with Other Plugins
 
@@ -148,8 +156,10 @@ The factory automatically:
 1. Validates the API key
 2. Creates span processor
 3. Sets up OpenTelemetry instrumentation
-4. Creates governance interceptors
-5. Adds `send_governance_event` activity
+4. Creates governance interceptors (incl. W3C trace propagation)
+5. Builds the `GovernanceActivities` instance with credentials captured on
+   `self` and registers its `send_governance_event` method — the API key is
+   never passed through activity inputs / workflow history
 6. Returns fully configured Worker
 
 ---
@@ -195,6 +205,11 @@ worker = create_openbox_worker(
     # File I/O instrumentation
     instrument_file_io=False,  # disabled by default
 
+    # Header-based W3C trace propagation (client → workflow → activities).
+    # Default True. Set False if you already wire OpenTelemetryPlugin or a
+    # custom propagator.
+    enable_trace_propagation=True,
+
     # Standard Worker options (all supported)
     activity_executor=my_executor,
     max_concurrent_activities=10,
@@ -471,7 +486,7 @@ from openbox import (
 )
 from openbox.otel_setup import setup_opentelemetry_for_governance
 from openbox.activity_interceptor import ActivityGovernanceInterceptor
-from openbox.activities import send_governance_event
+from openbox.activities import build_governance_activities
 from openbox.hook_governance import FAIL_OPEN, FAIL_CLOSED  # error policy constants
 
 # 1. Initialize SDK
@@ -511,14 +526,26 @@ activity_interceptor = ActivityGovernanceInterceptor(
     config=config,
 )
 
-# 6. Create worker
+# 6. Build the governance activity instance (credentials captured on `self`
+# so they never flow through workflow history).
+governance_activities = build_governance_activities(
+    api_url="http://localhost:8086",
+    api_key="obx_test_key_1",
+)
+
+# 7. Create worker
 from temporalio.worker import Worker
+from temporalio.contrib.opentelemetry import TracingInterceptor
 worker = Worker(
     client=client,
     task_queue="my-task-queue",
     workflows=[MyWorkflow],
-    activities=[my_activity, send_governance_event],
-    interceptors=[workflow_interceptor, activity_interceptor],
+    activities=[my_activity, governance_activities.send_governance_event],
+    interceptors=[
+        workflow_interceptor,
+        activity_interceptor,
+        TracingInterceptor(),  # W3C header propagation for OTel spans
+    ],
 )
 ```
 

{openbox_temporal_sdk_python-1.1.1.dist-info → openbox_temporal_sdk_python-1.1.2.dist-info}/RECORD

@@ -1,25 +1,25 @@
-openbox/__init__.py,sha256=-7RjQDWJfZNKWjl-1akKLtvjm-dj8I3kr-u-FvG_vUY,10451
-openbox/activities.py,sha256=g5Mz7WVoDmMwRS9bJcxb_Y2Qs_Q2CilqhtJoOETfqyk,7381
+openbox/__init__.py,sha256=uyGpMtLwx7em2lapvIvkiTtmGcf5Og-CBWyHiY0jztA,10451
+openbox/activities.py,sha256=mSOOQerWhF1KoRzw3jb24HBNZkAMeWjtvUUUmeUCK4M,10017
 openbox/activity_interceptor.py,sha256=WGpnREw_rxZe9pT_MfnD_snnpdXLA5WXG8SLdgPIueE,26181
 openbox/client.py,sha256=CKXhtZGmMeyIyZQpX1CTVGLj7iiGP_JcoOZ-0F1jEws,7135
 openbox/config.py,sha256=nUpKGV88LOsGcFThwBJM4rr79tecEmXZ0U7trf34hQo,11369
 openbox/context_propagation.py,sha256=hOEjqdKWgAw16ONppVI7B6YXD9SMufsdKP5ODmHCGCI,2105
-openbox/db_governance_hooks.py,sha256=qauqK9hqTOthmibeHBsTK_89Mz6y-7VY2vsxI90g8wU,31486
-openbox/errors.py,sha256=lZcXRtdEdtGBDAsCyXUU1WupCJ9w6gGXpL2J6xkVfi8,7731
+openbox/db_governance_hooks.py,sha256=4g3i0bibYyBkSWl0U0dic3oBMUypiZU2xIBTtfcJfRk,31702
+openbox/errors.py,sha256=je6Pp6Dim13cPfOphn4aJsSkHjoN_dzAlblPo_s-_mk,8676
 openbox/file_governance_hooks.py,sha256=i25n2CeENHsaYEwBnmxtZE8APoXo1gZFBMMzFOKPCFo,14221
 openbox/hitl.py,sha256=_sq_3DcvOOdFHi7uyNFG8FiN-q26YgkA9BEs9J8vyW4,4534
-openbox/hook_governance.py,sha256=GzZXPN_Z5jdeFZjb0DEKvit1DlZCgo2354xXOkVPOUo,14859
+openbox/hook_governance.py,sha256=GjUlVblO7KyMet-mU2FtKeHTTrcUYYU4s4bgC5aCHfQ,15430
 openbox/http_governance_hooks.py,sha256=lKryJk3xwqmeXvtWtzVzXhZ3oNGV7o6C1zD3lbQpoiE,31241
 openbox/otel_setup.py,sha256=T3MK6GqLfVC3kLJC88VSYUZNbbhmskuS11DigxLWgdc,16843
-openbox/plugin.py,sha256=iDFMMCLhWJpEWdOIMg87lAP2C5tNzjKcsc2N3VTSURc,6640
+openbox/plugin.py,sha256=WljrcJh_zuIxvgFTj_xcFjHoiarR6uXr4E2okMMu3Tw,7710
 openbox/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 openbox/span_processor.py,sha256=k_tAT0sWudyVYuw3MALLXCqyNDyXTPwtPl4KVG4CscI,11913
 openbox/tracing.py,sha256=mPaf2Q3Vrhv-GIVmT56iTDF25IECYrp3GbdtOxPaxJY,10148
 openbox/types.py,sha256=2XD9aGdS4uNRUO2NzxluR5wOReIkmxCwfXtXrVQOhT4,6729
 openbox/verdict_handler.py,sha256=rUeiq1Qjrkp4yXfOzoH9Au0YWSKIyEsjdF7aUvI4PbY,4017
-openbox/worker.py,sha256=n0_2oPJnkaRpFyjLzNr0J4tMpkNmcMmbYzNzbnaWJxU,10924
-openbox/workflow_interceptor.py,sha256=sD-KKANZI2OAxEf1u7NtCqCGAqIzmX3GItPVgHnPxq8,12502
-openbox_temporal_sdk_python-1.1.1.dist-info/METADATA,sha256=ihnxZsXTWguotoBmqHU68T_Ip0U1jfW7_DORfTIWYTQ,20845
-openbox_temporal_sdk_python-1.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-openbox_temporal_sdk_python-1.1.1.dist-info/licenses/LICENSE,sha256=J7UVgclAywF4uoxRJXhkMqYrPu0cjB_8ckiA_nMNpfI,1069
-openbox_temporal_sdk_python-1.1.1.dist-info/RECORD,,
+openbox/worker.py,sha256=dPWNL-V2SLPzN-LM6AFpda3fclR83KXYVeMzDdN3EUw,11511
+openbox/workflow_interceptor.py,sha256=cDeyAQhHREgll7l8ihJ2S3OszVo08DZyiNpeaJSpSKE,13985
+openbox_temporal_sdk_python-1.1.2.dist-info/METADATA,sha256=hJY6QCHzukThYG-9kYQ9BbealZJzNXIzu1ocGJ1nfjE,22132
+openbox_temporal_sdk_python-1.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+openbox_temporal_sdk_python-1.1.2.dist-info/licenses/LICENSE,sha256=J7UVgclAywF4uoxRJXhkMqYrPu0cjB_8ckiA_nMNpfI,1069
+openbox_temporal_sdk_python-1.1.2.dist-info/RECORD,,