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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tilebox-workflows
-Version: 0.63.2
+Version: 0.64.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.64.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.64.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.64.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

{tilebox_workflows-0.63.2 → tilebox_workflows-0.64.0}/tilebox/workflows/observability/logging.py

@@ -1,5 +1,4 @@
 # allow the logging module name which shadows the builtin:
-import atexit
 import contextlib
 import logging
 import os
@@ -8,18 +7,20 @@ import re
 import sys
 import threading
 import traceback
+from contextvars import ContextVar
 from datetime import timedelta
 from importlib.metadata import PackageNotFoundError, version
 from typing import Any, ClassVar, TextIO
 from uuid import UUID, uuid4
 
 import msgspec
+from opentelemetry._logs import LogRecord, get_logger_provider
+from opentelemetry._logs import get_logger as get_otel_logger
 from opentelemetry.exporter.otlp.proto.http._log_exporter import (
     DEFAULT_LOGS_EXPORT_PATH,
     OTLPLogExporter,
-    _append_logs_path,
 )
-from opentelemetry.instrumentation.logging.handler import LoggingHandler
+from opentelemetry.instrumentation.log_utils import std_to_otel
 from opentelemetry.sdk._logs import LoggerProvider
 from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
 from opentelemetry.sdk.resources import (
@@ -34,10 +35,9 @@ from opentelemetry.sdk.resources import (
     Resource,
 )
 from opentelemetry.semconv.attributes import exception_attributes
-from opentelemetry.util.types import _ExtendedAttributes
 
 from tilebox.workflows._serialization import normalize_log_value
-from tilebox.workflows.observability._log_pipe import _PipeWriter, _StructuredHandler
+from tilebox.workflows.observability._log_stream import _OTLPQueueHandler, managed_log_queue
 from tilebox.workflows.observability._logging import (
     StructuredLogger as StructuredLogger,  # noqa: PLC0414 -- public compatibility alias
 )
@@ -64,13 +64,7 @@ _instance_id = str(UUID(_instance_id))
 
 
 def _get_default_resource(service: str | Resource | None = None) -> Resource:
-    if isinstance(service, Resource):  # already a resource object
-        service_name = service.attributes.get(SERVICE_NAME)
-        if service_name is not None and service_name != "unknown_service":
-            # default value of SERVICE_NAME is "unknown_service", so if we have anything other than that we
-            # know it's already configured
-            return service
-
+    """Build Tilebox defaults, then apply explicitly configured resource attributes."""
     service_name = service if isinstance(service, str) else _DEFAULT_SERVICE_NAME
 
     workflows_version = "dev"
@@ -78,7 +72,7 @@ def _get_default_resource(service: str | Resource | None = None) -> Resource:
         workflows_version = version("tilebox-workflows")
 
     uname = platform.uname()
-    return Resource.create(
+    resource = Resource.create(
         attributes={
             SERVICE_NAMESPACE: "tilebox.workflows",
             SERVICE_NAME: service_name,
@@ -90,6 +84,7 @@ def _get_default_resource(service: str | Resource | None = None) -> Resource:
             OS_TYPE: uname.system.lower(),
         }
     )
+    return resource.merge(service) if isinstance(service, Resource) else resource
 
 
 def _sanitize_otel_attribute_value(
@@ -110,15 +105,43 @@ def _sanitize_otel_attributes(attributes: dict[str, Any]) -> dict[str, Any]:
     return {str(key): _sanitize_otel_attribute_value(value) for key, value in attributes.items()}
 
 
-class OTELLoggingHandler(LoggingHandler):
-    def _get_attributes(self, record: logging.LogRecord) -> _ExtendedAttributes:
+class OTELLoggingHandler(logging.Handler):
+    def __init__(self, level: int = logging.NOTSET, logger_provider: LoggerProvider | None = None) -> None:
+        super().__init__(level)
+        self._logger_provider = logger_provider or get_logger_provider()
+        self._emitting = ContextVar("tilebox_otel_emitting", default=False)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        # Export processors can log themselves; do not recursively export those records.
+        if self._emitting.get():
+            return
+        token = self._emitting.set(True)
+        try:
+            get_otel_logger(record.name, logger_provider=self._logger_provider).emit(
+                LogRecord(
+                    timestamp=int(record.created * 1e9),
+                    severity_number=std_to_otel(record.levelno),
+                    severity_text={"WARNING": "WARN", "CRITICAL": "FATAL"}.get(record.levelname, record.levelname),
+                    body=self.format(record) if self.formatter else record.getMessage(),
+                    attributes=self._get_attributes(record),
+                )
+            )
+        finally:
+            self._emitting.reset(token)
+
+    def flush(self) -> None:
+        if callable(force_flush := getattr(self._logger_provider, "force_flush", None)):
+            # Match OTEL's handler: flushing under the logging lock can deadlock.
+            # Do not prolong process exit after a runtime's bounded final flush.
+            threading.Thread(target=force_flush, daemon=True).start()
+
+    def _get_attributes(self, record: logging.LogRecord) -> dict[str, Any]:
         cached = getattr(record, "_tilebox_otel_attributes", None)
         if cached is not None:
             return cached
         attributes = _sanitize_otel_attributes(_record_attributes(record))
 
-        # the default implementation returns attributes for the filepath, lineno and function of the log record
-        # we don't want that by default, so we override it to return an empty dict
+        # Export only task context and exception details, not stdlib logging metadata.
         if record.exc_info:
             exctype, value, tb = record.exc_info
             if exctype is not None:
@@ -138,10 +161,12 @@ class OTELLoggingHandler(LoggingHandler):
 
 _api_handler: OTELLoggingHandler | None = None
 _initialization_lock = threading.Lock()
-_writer: _PipeWriter | None = None
 _console_handlers: list[logging.Handler] = []
 _console_configured = False
 
+if managed_log_queue is not None:
+    root_logger.addHandler(_OTLPQueueHandler(managed_log_queue))
+
 
 def _remove_console_handlers() -> None:
     for handler in _console_handlers:
@@ -158,27 +183,13 @@ def _add_console_handler(level: int, stream: TextIO, formatter: logging.Formatte
     _console_handlers.append(handler)
 
 
-def _configure_runtime_logging() -> _PipeWriter | None:
-    """Install the required CLI pipe, or an optional default console for direct runners.
-
-    The CLI pipe is runtime-owned: public configuration can add outputs but cannot
-    disable or replace it. Console opt-out applies only to console handlers.
-    """
-    global _writer  # noqa: PLW0603 -- process-owned CLI pipe
+def _configure_runtime_logging() -> None:
+    """Add an optional default console when logs aren't streamed to a managed CLI."""
     with _initialization_lock:
-        fd_value = os.environ.get("TILEBOX_LOG_FD")
-        if fd_value is not None:
-            if _writer is None:
-                _writer = _PipeWriter(int(fd_value))
-                root_logger.addHandler(_StructuredHandler(_writer))
-                atexit.register(_writer.close)
-            if not _console_configured:
-                _remove_console_handlers()
-        elif not _console_configured and not _console_handlers:
+        if managed_log_queue is None and not _console_configured and not _console_handlers:
             _add_console_handler(
                 logging.NOTSET, sys.stdout, logging.Formatter("%(process)d: %(levelname)s: %(message)s")
             )
-        return _writer
 
 
 def configure_log_level(level: int = logging.INFO, *, tilebox_debug: bool = False) -> None:
@@ -191,7 +202,7 @@ def configure_log_level(level: int = logging.INFO, *, tilebox_debug: bool = Fals
     filtered out by the logger.
 
     Every call overrides both startup settings: omitting tilebox_debug disables internal
-    DEBUG logging even if TILEBOX_DEBUG was enabled. Existing API exports, the CLI pipe,
+    DEBUG logging even if TILEBOX_DEBUG was enabled. Existing API exports, the CLI stream,
     and console handlers are unchanged and retain their own output thresholds.
 
     Args:
@@ -215,7 +226,12 @@ def initialize_logging(url: str, token: str | None, service: str | None = None)
         if _api_handler is not None:
             return
 
-        provider = LoggerProvider(resource=_get_default_resource(service))
+        # CLI runtimes own the final, bounded flush. An additional OTEL atexit
+        # shutdown could wait indefinitely on an exporter after that deadline.
+        provider = LoggerProvider(
+            resource=_get_default_resource(service),
+            shutdown_on_exit=not bool(os.environ.get("TILEBOX_WORKER_ADDRESS")),
+        )
         processor = _otel_log_exporter(endpoint=url, headers={"Authorization": f"Bearer {token}"} if token else None)
         provider.add_log_record_processor(processor)
         handler = OTELLoggingHandler(level=logging.NOTSET, logger_provider=provider)
@@ -223,6 +239,20 @@ def initialize_logging(url: str, token: str | None, service: str | None = None)
         _api_handler = handler
 
 
+def flush_api_logging(timeout_millis: int = 1000) -> None:
+    """Flush the managed API exporter without waiting indefinitely."""
+    handler = _api_handler
+    if handler is None:
+        return
+    force_flush = getattr(handler._logger_provider, "force_flush", None)  # noqa: SLF001
+    if callable(force_flush):
+        # BatchLogRecordProcessor currently ignores its timeout argument.
+        # Bound our wait without making the export thread block process exit.
+        flush = threading.Thread(target=force_flush, kwargs={"timeout_millis": timeout_millis}, daemon=True)
+        flush.start()
+        flush.join(timeout=timeout_millis / 1000)
+
+
 def _otel_log_exporter(
     endpoint: str | None = None,
     headers: dict[str, str] | None = None,
@@ -237,7 +267,7 @@ def _otel_log_exporter(
         )
 
     if not endpoint.endswith(DEFAULT_LOGS_EXPORT_PATH):
-        endpoint = _append_logs_path(endpoint)
+        endpoint = f"{endpoint.rstrip('/')}/{DEFAULT_LOGS_EXPORT_PATH}"
 
     if export_interval is None:
         export_interval_env = os.environ.get(_OTEL_EXPORT_INTERVAL_ENV_VAR, None)
@@ -266,14 +296,12 @@ def configure_otel_logging(
     This will configure a logging handler that will send log messages to an OTLP compatible endpoint using the
     open telemetry protocol for exporting logs. The logging handler will be attached to the root tilebox logger.
     All loggers created using `get_logger()` will therefore inherit this handler configuration.
-    Each call adds an export; Tilebox's API export, the CLI pipe, and console outputs remain installed.
+    Each call adds an export; Tilebox's API export, the CLI stream, and console outputs remain installed.
 
     Args:
-        service: A string or a resource object to include in all traces. Used to identify the service being traced.
-            If a string is provided, it will be used as the service name. If a resource object is provided, it will be
-            used as the resource. Defaults to a resource with the service name set to "tilebox.workflows-{process_id}",
-            the version set to the version of the package, and the service instance id set to a combination
-            of hostname and process id.
+        service: A service name or resource whose attributes override the Tilebox defaults.
+            Defaults to service name "tilebox-python", namespace "tilebox.workflows", the installed package version,
+            and the CLI runtime ID or a process-local UUID shared by logs and traces.
         level: The logging level to use for the OTEL handler. Only log messages with a level higher or equal to
             this will be sent to the endpoint. Defaults to logging.DEBUG. It is typically recommended to keep this at a
             lower level, since actual filtering of log messages to higher levels is typically done by the logger itself.
@@ -313,11 +341,9 @@ def configure_otel_logging_axiom(
     configuration.
 
     Args:
-        service: A string or a resource object to include in all traces. Used to identify the service being traced.
-            If a string is provided, it will be used as the service name. If a resource object is provided, it will be
-            used as the resource. Defaults to a resource with the service name set to "tilebox.workflows-{process_id}",
-            the version set to the version of the package, and the service instance id set to a combination
-            of hostname and process id.
+        service: A service name or resource whose attributes override the Tilebox defaults.
+            Defaults to service name "tilebox-python", namespace "tilebox.workflows", the installed package version,
+            and the CLI runtime ID or a process-local UUID shared by logs and traces.
         level: The logging level to use for the Axiom log handler. Only log messages with a level higher or equal to
             this will be sent to the endpoint. Defaults to logging.DEBUG. It is typically recommended to keep this at a
             lower level, since actual filtering of log messages to higher levels is typically done by the logger itself.
@@ -397,7 +423,7 @@ def configure_console_logging(
             configured console logging handlers will be removed. If False, the existing handlers will be kept. Useful
             if you want to log to multiple consoles.
         enabled: If False, remove Tilebox-managed console handlers and disable automatic console output, even if
-            called before runner startup. API exports, the CLI log pipe, and user-installed handlers are unaffected.
+            called before runner startup. API exports, the CLI log stream, and user-installed handlers are unaffected.
     """
     global _console_configured  # noqa: PLW0603 -- explicit process-wide console policy
     with _initialization_lock:

{tilebox_workflows-0.63.2 → tilebox_workflows-0.64.0}/tilebox/workflows/observability/tracing.py

@@ -8,7 +8,6 @@ from typing import Any, Protocol, cast
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
     DEFAULT_TRACES_EXPORT_PATH,
     OTLPSpanExporter,
-    _append_trace_path,
 )
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -46,7 +45,7 @@ _OTEL_EXPORT_INTERVAL_ENV_VAR = "OTEL_EXPORT_INTERVAL"
 # to extract trace_ids and spans, in case other runners / workflow clients have tracing configured.
 # So instead we use a tracer provider without any exporters, which will still create traces and spans,
 # but will not send them anywhere.
-_tilebox_tracer_provider = TracerProvider()
+_tilebox_tracer_provider = TracerProvider(resource=_get_default_resource())
 _workflow_tracers = []
 
 
@@ -159,7 +158,7 @@ def _otel_span_exporter(
         )
 
     if not endpoint.endswith(DEFAULT_TRACES_EXPORT_PATH):
-        endpoint = _append_trace_path(endpoint)
+        endpoint = f"{endpoint.rstrip('/')}/{DEFAULT_TRACES_EXPORT_PATH}"
 
     if export_interval is None:
         export_interval_env = os.environ.get(_OTEL_EXPORT_INTERVAL_ENV_VAR, None)
@@ -232,11 +231,9 @@ def configure_otel_tracing(
     Additionally, this will also configure a logging handler that will add log messages to active spans as span events.
 
     Args:
-        service: A string or a resource object to include in all traces. Used to identify the service being traced.
-            If a string is provided, it will be used as the service name. If a resource object is provided, it will be
-            used as the resource. Defaults to a resource with the service name set to "tilebox.workflows-{process_id}",
-            the version set to the version of the package, and the service instance id set to a combination
-            of hostname and process id.
+        service: A service name or resource whose attributes override the Tilebox defaults.
+            Defaults to service name "tilebox-python", namespace "tilebox.workflows", the installed package version,
+            and the CLI runtime ID or a process-local UUID shared by logs and traces.
         endpoint: The URL of the OTLP compatible endpoint to send traces and spans to. If not provided, the environment
             variable OTEL_TRACES_ENDPOINT will be used. If that is not set either, an error will be raised.
             OTLP compatible endpoints typically have the path name "/v1/traces". If the specified endpoint does not
@@ -280,11 +277,9 @@ def configure_otel_tracing_axiom(
     send traces and spans to Axiom.
 
     Args:
-        service: A string or a resource object to include in all traces. Used to identify the service being traced.
-            If a string is provided, it will be used as the service name. If a resource object is provided, it will be
-            used as the resource. Defaults to a resource with the service name set to "tilebox.workflows-{process_id}",
-            the version set to the version of the package, and the service instance id set to a combination
-            of hostname and process id.
+        service: A service name or resource whose attributes override the Tilebox defaults.
+            Defaults to service name "tilebox-python", namespace "tilebox.workflows", the installed package version,
+            and the CLI runtime ID or a process-local UUID shared by logs and traces.
         dataset: The name of the Axiom dataset to ingest traces into. If not provided, the environment variable
             AXIOM_TRACES_DATASET will be used. If that is not set either, an error will be raised.
         api_key: The API key to use for authentication. If not provided, the environment variable AXIOM_API_KEY will be

{tilebox_workflows-0.63.2 → tilebox_workflows-0.64.0}/tilebox/workflows/runner/__main__.py

@@ -6,7 +6,7 @@ from typing import Any
 
 from tilebox.workflows.observability._logging import logger
 from tilebox.workflows.runner.runner import Runner
-from tilebox.workflows.runner.worker_server import serve_runner
+from tilebox.workflows.runner.worker_server import WorkerServer
 
 
 def main(argv: Sequence[str] | None = None) -> int:
@@ -17,10 +17,15 @@ def main(argv: Sequence[str] | None = None) -> int:
     parser.add_argument("runner", help="Runner object import path, for example 'my_workflow.runner:runner'.")
     args = parser.parse_args(argv)
 
-    logger.debug(f"Starting Tilebox workflow runtime for runner {args.runner!r}")
-    runner = _import_runner(args.runner)
-    logger.debug(f"Imported runner {args.runner!r}; starting worker server")
-    serve_runner(runner)
+    server = WorkerServer()
+    server.start()
+    try:
+        runner = _import_runner(args.runner)
+        server.set_runner(runner)
+        server.wait()
+    finally:
+        server.shutdown()
+        server.wait()
     return 0