tilebox-workflows 0.63.2__tar.gz → 0.65.0__tar.gz

{tilebox_workflows-0.63.2 → tilebox_workflows-0.65.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tilebox-workflows
-Version: 0.63.2
+Version: 0.65.0
 Summary: Workflow client and task runner for Tilebox
 Project-URL: Homepage, https://tilebox.com
 Project-URL: Documentation, https://docs.tilebox.com/workflows/introduction
@@ -25,11 +25,11 @@ Requires-Dist: google-auth[requests]>=2.29
 Requires-Dist: grpcio>=1.84.0
 Requires-Dist: msgspec>=0.19
 Requires-Dist: obstore>=0.8.2
-Requires-Dist: opentelemetry-api>=1.43.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.43.0
-Requires-Dist: opentelemetry-instrumentation-logging>=0.64b0
-Requires-Dist: opentelemetry-proto>=1.43.0
-Requires-Dist: opentelemetry-sdk>=1.43.0
+Requires-Dist: opentelemetry-api>=1.44.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.44.0
+Requires-Dist: opentelemetry-instrumentation-logging>=0.65b0
+Requires-Dist: opentelemetry-proto>=1.44.0
+Requires-Dist: opentelemetry-sdk>=1.44.0
 Requires-Dist: tenacity>=8
 Requires-Dist: tilebox-datasets>=0.56.0
 Requires-Dist: tilebox-grpc>=0.28.0

{tilebox_workflows-0.63.2 → tilebox_workflows-0.65.0}/pyproject.toml

@@ -27,14 +27,14 @@ dependencies = [
     "grpcio>=1.84.0",
     "google-auth[requests]>=2.29",
     "azure-identity>=1.23",
-    "opentelemetry-api>=1.43.0",
-    "opentelemetry-exporter-otlp-proto-http>=1.43.0",
-    "opentelemetry-sdk>=1.43.0",
+    "opentelemetry-api>=1.44.0",
+    "opentelemetry-exporter-otlp-proto-http>=1.44.0",
+    "opentelemetry-sdk>=1.44.0",
     "tenacity>=8",
     "boto3>=1.40.2",
     "obstore>=0.8.2",
-    "opentelemetry-proto>=1.43.0",
-    "opentelemetry-instrumentation-logging>=0.64b0",
+    "opentelemetry-proto>=1.44.0",
+    "opentelemetry-instrumentation-logging>=0.65b0",
     "msgspec>=0.19",
 ]
 

{tilebox_workflows-0.63.2 → tilebox_workflows-0.65.0}/tilebox/workflows/__init__.py

@@ -1,6 +1,9 @@
 import os
 from typing import TYPE_CHECKING, Any
 
+# Apply native logging defaults before any submodule can initialize gRPC.
+import _tilebox.grpc  # noqa: F401
+
 if TYPE_CHECKING:
     from tilebox.workflows.client import Client
     from tilebox.workflows.data import Job
@@ -48,8 +51,17 @@ def __dir__() -> list[str]:
 def _initialize_logging_from_environment() -> None:
     # Stage 1: current CLIs provide credentials before importing workflow code, so
     # even import-time logs reach the API. Ordinary SDK imports stay lightweight.
+    runtime_dir = os.environ.get("TILEBOX_RUNTIME_DIR")
+    runtime_token = os.environ.get("TILEBOX_RUNTIME_TOKEN")
+    if bool(runtime_dir) != bool(runtime_token):
+        raise RuntimeError("TILEBOX_RUNTIME_DIR and TILEBOX_RUNTIME_TOKEN must be set together")
+
     url = os.environ.get("TILEBOX_API_URL")
     token = os.environ.get("TILEBOX_API_KEY")
+    if runtime_dir and runtime_token:
+        # Importing installs the managed local stream before workflow modules can log.
+        from tilebox.workflows.observability import logging as _runtime_logging  # noqa: F401, PLC0415
+
     if not url or not token:
         return
 

{tilebox_workflows-0.63.2 → tilebox_workflows-0.65.0}/tilebox/workflows/automations/client.py

@@ -18,14 +18,6 @@ class AutomationClient:
     def __init__(self, service: AutomationService) -> None:
         self._service = service
 
-    def storage_locations(self) -> list[StorageLocation]:
-        """List all available storage locations that can potentially be used as storage event triggers.
-
-        Returns:
-            A list of all available storage locations.
-        """
-        return self._service.list_storage_locations()
-
     def all(self) -> list[AutomationPrototype]:
         """List all registered automations.
 

{tilebox_workflows-0.63.2 → tilebox_workflows-0.65.0}/tilebox/workflows/automations/service.py

@@ -9,39 +9,24 @@ from _tilebox.grpc.error import with_pythonic_errors
 from tilebox.datasets.uuid import uuid_to_uuid_message
 from tilebox.workflows.data import (
     AutomationPrototype,
-    StorageLocation,
 )
 from tilebox.workflows.workflows.v1.automation_pb2 import AutomationPrototype as AutomationPrototypeMessage
 from tilebox.workflows.workflows.v1.automation_pb2 import Automations, DeleteAutomationRequest
 from tilebox.workflows.workflows.v1.automation_pb2_grpc import AutomationServiceStub
-from tilebox.workflows.workflows.v1.storage_location_pb2 import StorageLocations
-from tilebox.workflows.workflows.v1.storage_location_pb2_grpc import StorageLocationServiceStub
 
 
 class AutomationService:
-    def __init__(self, channel: Channel | Any, storage_channel: Channel | Any = None) -> None:
+    def __init__(self, channel: Channel | Any) -> None:
         """
         A wrapper around the AutomationServiceStub that provides a more pythonic interface and converts the protobuf
         messages to and from the data classes used in the rest of the tilebox-workflows codebase.
 
         Args:
             channel: The gRPC channel to use for the service.
-            storage_channel: Optional separate storage-location client for the Connect transport.
         """
         self.service = (
             with_pythonic_errors(AutomationServiceStub(channel)) if hasattr(channel, "unary_unary") else channel
         )
-        if storage_channel is None:
-            storage_channel = channel
-        self.storage_service = (
-            with_pythonic_errors(StorageLocationServiceStub(storage_channel))
-            if hasattr(storage_channel, "unary_unary")
-            else storage_channel
-        )
-
-    def list_storage_locations(self) -> builtins.list[StorageLocation]:
-        response: StorageLocations = self.storage_service.ListStorageLocations(Empty())
-        return [StorageLocation.from_message(sl) for sl in response.locations]
 
     def list(self) -> builtins.list[AutomationPrototype]:
         response: Automations = self.service.ListAutomations(Empty())

{tilebox_workflows-0.63.2 → tilebox_workflows-0.65.0}/tilebox/workflows/automations/storage_event.py

@@ -13,7 +13,7 @@ from tilebox.workflows.workflows.v1.automation_pb2 import Automation as Automati
 from tilebox.workflows.workflows.v1.storage_location_pb2 import TriggeredStorageEvent as TriggeredStorageEventMessage
 
 _NOT_TRIGGERED = TriggeredStorageEvent(
-    StorageLocation(UUID(int=0), "", StorageType.FS),
+    StorageLocation(UUID(int=0), "", StorageType.LOCAL),
     StorageEventType.CREATED,
     "",
 )

{tilebox_workflows-0.63.2 → tilebox_workflows-0.65.0}/tilebox/workflows/client.py

@@ -23,6 +23,8 @@ from tilebox.workflows.observability.tracing import WorkflowTracer
 from tilebox.workflows.runner.executor import LazyStorageLocations
 from tilebox.workflows.runner.task_runner import TaskRunner, _LeaseRenewer
 from tilebox.workflows.runner.task_service import TaskService
+from tilebox.workflows.storage_locations.client import StorageLocationClient
+from tilebox.workflows.storage_locations.service import StorageLocationService
 from tilebox.workflows.task import Task
 from tilebox.workflows.workflows.client import WorkflowClient
 from tilebox.workflows.workflows.service import WorkflowService
@@ -207,7 +209,11 @@ class Client:
         Returns:
             A client for the automations service.
         """
-        return AutomationClient(AutomationService(self._automation_service, self._storage_location_service))
+        return AutomationClient(AutomationService(self._automation_service))
+
+    def storage_locations(self) -> StorageLocationClient:
+        """Get a client for storage locations."""
+        return StorageLocationClient(StorageLocationService(self._storage_location_service))
 
 
 def _token_from_env(url: str, token: str | None) -> str | None:

{tilebox_workflows-0.63.2 → tilebox_workflows-0.65.0}/tilebox/workflows/data.py

@@ -969,13 +969,67 @@ class QueryJobSpansResponse:
 
 
 class StorageType(Enum):
-    GCS = storage_pb.STORAGE_TYPE_GCS_BUCKET  # Google Cloud Storage
-    S3 = storage_pb.STORAGE_TYPE_AWS_S3_BUCKET  # Amazon Web Services S3
-    FS = storage_pb.STORAGE_TYPE_FILESYSTEM  # Local Filesystem
-    AZURE = storage_pb.STORAGE_TYPE_AZURE_BLOB  # Azure Blob Storage
+    GCS = storage_pb.STORAGE_TYPE_GCS  # Google Cloud Storage
+    AWS_S3 = storage_pb.STORAGE_TYPE_AWS_S3  # Amazon Web Services S3
+    LOCAL = storage_pb.STORAGE_TYPE_LOCAL  # Local Filesystem
+    AZURE_BLOB = storage_pb.STORAGE_TYPE_AZURE_BLOB  # Azure Blob Storage
 
 
-_STORAGE_TYPE_TO_ENUM = {storage_type.value: storage_type for storage_type in StorageType}
+@dataclass(frozen=True)
+class AWSS3BucketReference:
+    bucket: str
+    region: str = ""
+
+    def to_message(self) -> storage_pb.StorageLocationReference:
+        return storage_pb.StorageLocationReference(
+            type=storage_pb.STORAGE_TYPE_AWS_S3,
+            aws_s3_bucket=storage_pb.AWSS3BucketReference(bucket=self.bucket, region=self.region),
+        )
+
+
+@dataclass(frozen=True)
+class GCSBucketReference:
+    bucket: str
+    project_id: str = ""
+    location: str = ""
+
+    def to_message(self) -> storage_pb.StorageLocationReference:
+        return storage_pb.StorageLocationReference(
+            type=storage_pb.STORAGE_TYPE_GCS,
+            gcs_bucket=storage_pb.GCSBucketReference(
+                bucket=self.bucket, project_id=self.project_id, location=self.location
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class AzureBlobReference:
+    storage_account_resource_id: str
+    container: str
+    region: str = ""
+
+    def to_message(self) -> storage_pb.StorageLocationReference:
+        return storage_pb.StorageLocationReference(
+            type=storage_pb.STORAGE_TYPE_AZURE_BLOB,
+            azure_blob=storage_pb.AzureBlobReference(
+                storage_account_resource_id=self.storage_account_resource_id,
+                container=self.container,
+                region=self.region,
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class LocalReference:
+    path: str
+
+    def to_message(self) -> storage_pb.StorageLocationReference:
+        return storage_pb.StorageLocationReference(
+            type=storage_pb.STORAGE_TYPE_LOCAL, local=storage_pb.LocalReference(path=self.path)
+        )
+
+
+StorageLocationReference: TypeAlias = AWSS3BucketReference | GCSBucketReference | AzureBlobReference | LocalReference
 
 
 @total_ordering
@@ -985,53 +1039,81 @@ class StorageLocation:
     location: str
     type: StorageType
     runner_context: "RunnerContext | None" = None
+    name: str = field(default="", kw_only=True)
 
     def __lt__(self, other: object) -> bool:
         if not isinstance(other, StorageLocation):
             return NotImplemented
         return (self.id, self.location, self.type.value) < (other.id, other.location, other.type.value)
 
+    def __str__(self) -> str:
+        match self.type:
+            case StorageType.AWS_S3:
+                return f"s3://{self.location}"
+            case StorageType.GCS:
+                return f"gs://{self.location}"
+            case StorageType.LOCAL:
+                return self.location
+            case _:
+                return self.type.name.lower().replace("_", "-")
+
     @classmethod
     def from_message(cls, storage_location: storage_pb.StorageLocation) -> "StorageLocation":
         """Convert a StorageLocation protobuf message to a StorageLocation object."""
-        location = storage_location.location
-        storage_type = storage_location.type
-        if storage_location.HasField("reference"):
-            reference = storage_location.reference
-            storage_type = reference.type
-            match storage_type:
-                case storage_pb.STORAGE_TYPE_AZURE_BLOB:
-                    return AzureStorageLocation(
-                        id=uuid_message_to_uuid(storage_location.id),
-                        location=reference.azure_blob.container,
-                        type=StorageType.AZURE,
-                        storage_account_resource_id=reference.azure_blob.storage_account_resource_id,
-                    )
-                case storage_pb.STORAGE_TYPE_GCS_BUCKET:
-                    location = reference.gcs_bucket.bucket
-                case storage_pb.STORAGE_TYPE_AWS_S3_BUCKET:
-                    return S3StorageLocation(
-                        id=uuid_message_to_uuid(storage_location.id),
-                        location=reference.aws_s3_bucket.bucket,
-                        type=StorageType.S3,
-                        region=reference.aws_s3_bucket.region or None,
-                    )
-                case storage_pb.STORAGE_TYPE_FILESYSTEM:
-                    location = reference.filesystem.path
-        return cls(
-            id=uuid_message_to_uuid(storage_location.id),
-            location=location,
-            type=_STORAGE_TYPE_TO_ENUM[storage_type],
-        )
+        reference = storage_location.reference
+        match reference.type:
+            case storage_pb.STORAGE_TYPE_AZURE_BLOB:
+                return AzureBlobStorageLocation(
+                    id=uuid_message_to_uuid(storage_location.id),
+                    name=storage_location.name,
+                    location=reference.azure_blob.container,
+                    type=StorageType.AZURE_BLOB,
+                    storage_account_resource_id=reference.azure_blob.storage_account_resource_id,
+                    region=reference.azure_blob.region,
+                )
+            case storage_pb.STORAGE_TYPE_GCS:
+                return GCSStorageLocation(
+                    id=uuid_message_to_uuid(storage_location.id),
+                    name=storage_location.name,
+                    location=reference.gcs_bucket.bucket,
+                    type=StorageType.GCS,
+                    project_id=reference.gcs_bucket.project_id,
+                    bucket_location=reference.gcs_bucket.location,
+                )
+            case storage_pb.STORAGE_TYPE_AWS_S3:
+                return AWSS3StorageLocation(
+                    id=uuid_message_to_uuid(storage_location.id),
+                    name=storage_location.name,
+                    location=reference.aws_s3_bucket.bucket,
+                    type=StorageType.AWS_S3,
+                    region=reference.aws_s3_bucket.region or None,
+                )
+            case storage_pb.STORAGE_TYPE_LOCAL:
+                return cls(
+                    id=uuid_message_to_uuid(storage_location.id),
+                    name=storage_location.name,
+                    location=reference.local.path,
+                    type=StorageType.LOCAL,
+                )
+            case _:
+                raise ValueError(f"Unsupported storage reference type: {reference.type}")
 
     def _with_runner_context(self, runner_context: "RunnerContext") -> "StorageLocation":
         return replace(self, runner_context=runner_context)
 
     def to_message(self) -> storage_pb.StorageLocation:
         """Convert a StorageLocation object to a StorageLocation protobuf message."""
-        return storage_pb.StorageLocation(
-            id=uuid_to_uuid_message(self.id), location=self.location, type=self.type.value
-        )
+        reference = storage_pb.StorageLocationReference(type=self.type.value)
+        match self.type:
+            case StorageType.AWS_S3:
+                reference.aws_s3_bucket.bucket = self.location
+            case StorageType.GCS:
+                reference.gcs_bucket.bucket = self.location
+            case StorageType.AZURE_BLOB:
+                reference.azure_blob.container = self.location
+            case StorageType.LOCAL:
+                reference.local.path = self.location
+        return storage_pb.StorageLocation(id=uuid_to_uuid_message(self.id), name=self.name, reference=reference)
 
     def read(self, path: str) -> bytes:
         runner_context = self.runner_context or RunnerContext()
@@ -1042,21 +1124,26 @@ class StorageLocation:
                 case StorageType.GCS:
                     span.set_attribute("bucket", self.location)
                     store = runner_context.gcs_client(self.location)
-                case StorageType.S3:
+                case StorageType.AWS_S3:
                     span.set_attribute("bucket", self.location)
-                    if isinstance(self, S3StorageLocation) and self.region:
+                    if isinstance(self, AWSS3StorageLocation) and self.region:
                         store = runner_context.s3_client(self.location, region=self.region)
                     else:
                         store = runner_context.s3_client(self.location)
-                case StorageType.AZURE:
-                    if not isinstance(self, AzureStorageLocation) or not self.storage_account_resource_id:
+                case StorageType.AZURE_BLOB:
+                    if not isinstance(self, AzureBlobStorageLocation) or not self.storage_account_resource_id:
                         raise ValueError("Azure storage location is missing its storage account resource ID")
                     span.set_attribute("storage_account_resource_id", self.storage_account_resource_id)
                     span.set_attribute("container", self.location)
                     store = runner_context.azure_client(self.storage_account_resource_id, self.location)
-                case StorageType.FS:
+                case StorageType.LOCAL:
+                    from obstore.store import LocalStore  # noqa: PLC0415
+
                     span.set_attribute("root_directory", self.location)
-                    return Path(self.location).joinpath(path).read_bytes()
+                    root = runner_context.local_path(self.location)
+                    if not self.location or not root.is_dir():
+                        raise ValueError(f"Local storage location root is not available: {self.location!r}")
+                    store = LocalStore(root)
 
             import obstore  # noqa: PLC0415
 
@@ -1064,28 +1151,41 @@ class StorageLocation:
 
 
 @dataclass(frozen=True)
-class S3StorageLocation(StorageLocation):
+class AWSS3StorageLocation(StorageLocation):
     region: str | None = field(default=None, kw_only=True)
 
     def to_message(self) -> storage_pb.StorageLocation:
         """Include the S3 bucket and its region in the storage reference."""
         message = super().to_message()
-        message.reference.type = storage_pb.STORAGE_TYPE_AWS_S3_BUCKET
-        message.reference.aws_s3_bucket.bucket = self.location
         message.reference.aws_s3_bucket.region = self.region or ""
         return message
 
 
 @dataclass(frozen=True)
-class AzureStorageLocation(StorageLocation):
+class GCSStorageLocation(StorageLocation):
+    project_id: str = field(default="", kw_only=True)
+    bucket_location: str = field(default="", kw_only=True)
+
+    def to_message(self) -> storage_pb.StorageLocation:
+        message = super().to_message()
+        message.reference.gcs_bucket.project_id = self.project_id
+        message.reference.gcs_bucket.location = self.bucket_location
+        return message
+
+
+@dataclass(frozen=True)
+class AzureBlobStorageLocation(StorageLocation):
     storage_account_resource_id: str = field(kw_only=True)
+    region: str = field(default="", kw_only=True)
+
+    def __str__(self) -> str:
+        return f"{self.storage_account_resource_id}/containers/{self.location}"
 
     def to_message(self) -> storage_pb.StorageLocation:
         """Include the Azure account and container in the storage reference."""
         message = super().to_message()
-        message.reference.type = storage_pb.STORAGE_TYPE_AZURE_BLOB
         message.reference.azure_blob.storage_account_resource_id = self.storage_account_resource_id
-        message.reference.azure_blob.container = self.location
+        message.reference.azure_blob.region = self.region
         return message
 
 

tilebox_workflows-0.65.0/tilebox/workflows/observability/_log_stream.py

@@ -0,0 +1,172 @@
+"""Bounded OTLP log streaming for CLI-managed workflow runtimes."""
+
+import logging
+import os
+import threading
+import time
+import traceback
+from collections import deque
+from collections.abc import Callable, Iterator
+from typing import Any
+
+from opentelemetry.instrumentation.log_utils import std_to_otel
+from opentelemetry.proto.common.v1.common_pb2 import AnyValue, ArrayValue, KeyValue, KeyValueList
+from opentelemetry.proto.logs.v1.logs_pb2 import LogRecord, SeverityNumber
+from opentelemetry.semconv.attributes import exception_attributes
+
+from tilebox.workflows.observability._logging import _record_attributes
+
+_MAX_RECORD_SIZE = 1024 * 1024
+_MANAGED_RUNTIME = bool(os.environ.get("TILEBOX_RUNTIME_DIR") and os.environ.get("TILEBOX_RUNTIME_TOKEN"))
+
+
+def _any_value(value: Any) -> AnyValue:  # noqa: PLR0911 -- each protobuf union arm is clearest explicitly
+    """Convert an already-normalized JSON value to OTLP."""
+    if value is None:
+        return AnyValue()
+    if isinstance(value, bool):
+        return AnyValue(bool_value=value)
+    if isinstance(value, int):
+        if abs(value) > 2**63 - 1:
+            return AnyValue(string_value=str(value))
+        return AnyValue(int_value=value)
+    if isinstance(value, float):
+        return AnyValue(double_value=value)
+    if isinstance(value, dict):
+        return AnyValue(
+            kvlist_value=KeyValueList(values=[KeyValue(key=key, value=_any_value(item)) for key, item in value.items()])
+        )
+    if isinstance(value, list):
+        return AnyValue(array_value=ArrayValue(values=[_any_value(item) for item in value]))
+    return AnyValue(string_value=value)
+
+
+class _LogQueue:
+    """Non-blocking bounded queue with explicit sealed-and-empty termination."""
+
+    def __init__(self, capacity: int = 256, max_record_size: int = _MAX_RECORD_SIZE) -> None:
+        self._capacity = capacity
+        self._max_record_size = max_record_size
+        self._records: deque[LogRecord] = deque()
+        self._condition = threading.Condition()
+        self._subscriber = False
+        self._sealed = False
+        self._dropped = 0
+
+    def submit(self, record: LogRecord) -> None:
+        with self._condition:
+            if self._sealed:
+                return
+            if record.ByteSize() > self._max_record_size or len(self._records) >= self._capacity:
+                self._dropped += 1
+                self._condition.notify_all()
+                return
+            if self._dropped:
+                self._records.append(_drop_record(self._dropped))
+                self._dropped = 0
+            if len(self._records) >= self._capacity:
+                self._dropped += 1
+                self._condition.notify_all()
+                return
+            self._records.append(record)
+            self._condition.notify_all()
+
+    def subscribe(self, active: Callable[[], bool] = lambda: True) -> Iterator[LogRecord]:
+        with self._condition:
+            if self._subscriber:
+                raise RuntimeError("A log subscriber is already connected")
+            self._subscriber = True
+        try:
+            while active():
+                with self._condition:
+                    if self._records:
+                        record = self._records.popleft()
+                        self._condition.notify_all()
+                    elif self._dropped:
+                        record = _drop_record(self._dropped)
+                        self._dropped = 0
+                        self._condition.notify_all()
+                    elif self._sealed:
+                        return
+                    else:
+                        self._condition.wait(timeout=0.1)
+                        continue
+                yield record
+        finally:
+            with self._condition:
+                self._subscriber = False
+                self._condition.notify_all()
+
+    def seal(self) -> None:
+        with self._condition:
+            self._sealed = True
+            self._condition.notify_all()
+
+    def wait_empty(self, timeout: float) -> bool:
+        deadline = time.monotonic() + timeout
+        with self._condition:
+            while self._records or self._dropped:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    return False
+                self._condition.wait(timeout=remaining)
+            return True
+
+
+def _drop_record(count: int) -> LogRecord:
+    return LogRecord(
+        time_unix_nano=time.time_ns(),
+        severity_number=_severity_number(logging.WARNING),
+        severity_text="WARN",
+        body=AnyValue(string_value=f"Dropped {count} local log records"),
+    )
+
+
+class _OTLPQueueHandler(logging.Handler):
+    def __init__(self, records: _LogQueue) -> None:
+        super().__init__(logging.NOTSET)
+        self._records = records
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            attributes = dict(_record_attributes(record))
+            trace_id = _hex_id(attributes.pop("trace_id", ""), 16)
+            span_id = _hex_id(attributes.pop("span_id", ""), 8)
+            if record.exc_info:
+                exctype, value, tb = record.exc_info
+                if exctype is not None:
+                    attributes[exception_attributes.EXCEPTION_TYPE] = exctype.__name__
+                if value is not None:
+                    attributes[exception_attributes.EXCEPTION_MESSAGE] = str(value)
+                if tb is not None:
+                    attributes[exception_attributes.EXCEPTION_STACKTRACE] = "".join(
+                        traceback.format_exception(*record.exc_info)
+                    )
+            self._records.submit(
+                LogRecord(
+                    time_unix_nano=int(record.created * 1e9),
+                    severity_number=_severity_number(record.levelno),
+                    severity_text={"WARNING": "WARN", "CRITICAL": "FATAL"}.get(record.levelname, record.levelname),
+                    body=_any_value(record.getMessage()),
+                    attributes=[KeyValue(key=str(key), value=_any_value(value)) for key, value in attributes.items()],
+                    trace_id=trace_id,
+                    span_id=span_id,
+                )
+            )
+        except Exception:  # noqa: BLE001 -- logging must never break workflow execution
+            self.handleError(record)
+
+
+def _hex_id(value: Any, size: int) -> bytes:
+    try:
+        result = bytes.fromhex(value) if isinstance(value, str) else b""
+    except ValueError:
+        return b""
+    return result if len(result) == size else b""
+
+
+def _severity_number(level: int) -> SeverityNumber.ValueType:
+    return SeverityNumber.Value(f"SEVERITY_NUMBER_{std_to_otel(level).name}")
+
+
+managed_log_queue = _LogQueue() if _MANAGED_RUNTIME else None