by-framework 0.2.2.dev1__py3-none-any.whl → 0.2.2.dev2__py3-none-any.whl

by_framework/client/client.py

@@ -43,11 +43,7 @@ from by_framework.core.protocol.responses import (
 )
 from by_framework.core.registry import WorkerRegistry
 from by_framework.errors import WorkerRegistryNotSetError
-from by_framework.observability.span_recorder import (
-    SpanRecorder,
-    TraceSpan,
-    str_to_uint64,
-)
+from by_framework.trace.span_recorder import (SpanRecorder, TraceSpan, str_to_uint64)
 
 if TYPE_CHECKING:
     pass
@@ -688,7 +684,7 @@ class GatewayClient:
                     )
                 )
                 try:
-                    from by_framework.observability.metrics import record_availability_metrics
+                    from by_framework.metrics import record_availability_metrics
 
                     record_availability_metrics(
                         agent_type=params["target_agent_type"],

by_framework/{observability/metrics.py → metrics/__init__.py}

@@ -4,7 +4,12 @@ from __future__ import annotations
 
 from typing import Any, Optional
 
-from by_framework.observability.snapshot import _escape_label
+from by_framework.metrics.read_client import (
+    MetricsDiagnostic,
+    MetricsReadClient,
+    MetricsReadResult,
+    MetricsWindow,
+)
 
 try:
     from prometheus_client import REGISTRY, Counter, Histogram  # type: ignore
@@ -39,6 +44,10 @@ class DummyMetric:
         del value
 
 
+def _escape_label(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
+
+
 def get_registry() -> Any:
     """Get the active Prometheus collector registry."""
     return REGISTRY
@@ -193,3 +202,17 @@ def build_observability_diagnostics_metrics(diagnostics: dict[str, Any]) -> str:
             f'{{exporter="{_escape_label(str(exporter))}"}} {int(count)}'
         )
     return "\n".join(lines) + "\n"
+
+
+__all__ = [
+    "MetricsDiagnostic",
+    "MetricsReadClient",
+    "MetricsReadResult",
+    "MetricsWindow",
+    "PROMETHEUS_AVAILABLE",
+    "build_observability_diagnostics_metrics",
+    "generate_latest_metrics",
+    "get_registry",
+    "record_availability_metrics",
+    "record_execution_metrics",
+]

by_framework/metrics/read_client.py

@@ -0,0 +1,257 @@
+"""Read SDK for correlating metrics history with trace time windows."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from typing import Any, Optional
+
+from by_framework.common.redis_client import Redis, get_redis
+from by_framework.metrics.snapshot import (
+    REDIS_HISTORY_KEY,
+    build_history_point,
+    build_observability_snapshot,
+    load_history_from_redis,
+)
+
+
+@dataclass(frozen=True)
+class MetricsDiagnostic:
+    """A metrics read diagnostic."""
+
+    code: str
+    message: str
+    severity: str = "info"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            key: value for key, value in asdict(self).items() if value not in ("", None)
+        }
+
+
+@dataclass(frozen=True)
+class MetricsWindow:
+    """A time window used to correlate metrics with trace spans."""
+
+    start_ts: int
+    end_ts: int
+    buffer_ms: int = 0
+
+    def expanded(self) -> "MetricsWindow":
+        """Return this window with buffer applied on both sides."""
+        return MetricsWindow(
+            start_ts=max(0, self.start_ts - self.buffer_ms),
+            end_ts=max(self.start_ts, self.end_ts + self.buffer_ms),
+            buffer_ms=self.buffer_ms,
+        )
+
+    def to_dict(self) -> dict[str, int]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class MetricsReadResult:
+    """Metrics samples and compact summary for a time window."""
+
+    window: MetricsWindow
+    samples: list[dict[str, int]] = field(default_factory=list)
+    summary: dict[str, Any] = field(default_factory=dict)
+    diagnostics: list[MetricsDiagnostic] = field(default_factory=list)
+    status: str = "ok"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "window": self.window.to_dict(),
+            "samples": self.samples,
+            "summary": self.summary,
+            "diagnostics": [diagnostic.to_dict() for diagnostic in self.diagnostics],
+            "status": self.status,
+        }
+
+
+class MetricsReadClient:
+    """Read metrics snapshots and history from by-framework Redis storage."""
+
+    def __init__(self, redis_client: Optional[Redis] = None) -> None:
+        self.redis = redis_client or get_redis()
+
+    async def get_snapshot(self) -> dict[str, Any]:
+        """Return the current observability snapshot."""
+        return await build_observability_snapshot(self.redis)
+
+    async def get_history(
+        self,
+        *,
+        start_ts: int,
+        end_ts: int,
+        limit: int = 120,
+    ) -> list[dict[str, int]]:
+        """Return compact metrics history points that overlap a time window."""
+        window = MetricsWindow(start_ts=start_ts, end_ts=end_ts).expanded()
+        if window.end_ts <= 0:
+            return []
+        samples = await self._load_history_between(
+            window.start_ts,
+            window.end_ts,
+            limit=max(1, limit),
+        )
+        return sorted(samples, key=lambda item: int(item.get("generated_at", 0) or 0))
+
+    async def explain_window(
+        self,
+        *,
+        start_ts: int,
+        end_ts: int,
+        buffer_ms: int = 5_000,
+        limit: int = 120,
+    ) -> MetricsReadResult:
+        """Summarize metrics conditions around a trace/span time window."""
+        window = MetricsWindow(
+            start_ts=int(start_ts or 0),
+            end_ts=max(int(start_ts or 0), int(end_ts or 0)),
+            buffer_ms=max(0, int(buffer_ms or 0)),
+        ).expanded()
+        diagnostics: list[MetricsDiagnostic] = []
+        samples = await self.get_history(
+            start_ts=window.start_ts,
+            end_ts=window.end_ts,
+            limit=limit,
+        )
+        if not samples:
+            diagnostics.append(
+                MetricsDiagnostic(
+                    code="metrics_history_missing",
+                    message="No metrics history points were found for this window.",
+                    severity="warning",
+                )
+            )
+            try:
+                current_point = build_history_point(await self.get_snapshot())
+                if self._point_in_window(current_point, window):
+                    samples = [current_point]
+                    diagnostics.append(
+                        MetricsDiagnostic(
+                            code="metrics_current_snapshot_used",
+                            message="Current metrics snapshot was used as fallback.",
+                        )
+                    )
+            except Exception as err:  # pylint: disable=broad-exception-caught
+                diagnostics.append(
+                    MetricsDiagnostic(
+                        code="metrics_snapshot_failed",
+                        message=f"Current metrics snapshot fallback failed: {err}",
+                        severity="warning",
+                    )
+                )
+        summary = self._summarize(samples)
+        diagnostics.extend(self._diagnose_summary(summary))
+        status = "partial" if diagnostics else "ok"
+        return MetricsReadResult(
+            window=window,
+            samples=samples,
+            summary=summary,
+            diagnostics=diagnostics,
+            status=status,
+        )
+
+    async def _load_history_between(
+        self,
+        start_ts: int,
+        end_ts: int,
+        *,
+        limit: int,
+    ) -> list[dict[str, int]]:
+        zrangebyscore = getattr(self.redis, "zrangebyscore", None)
+        if callable(zrangebyscore):
+            try:
+                raw_entries = await zrangebyscore(
+                    REDIS_HISTORY_KEY,
+                    start_ts,
+                    end_ts,
+                    start=0,
+                    num=limit,
+                )
+                return [
+                    point for point in map(self._decode_point, raw_entries) if point
+                ]
+            except TypeError:
+                pass
+        points = await load_history_from_redis(self.redis, limit=limit)
+        return [
+            point
+            for point in points
+            if start_ts <= int(point.get("generated_at", 0) or 0) <= end_ts
+        ]
+
+    @staticmethod
+    def _decode_point(raw: Any) -> dict[str, int]:
+        if isinstance(raw, bytes):
+            raw = raw.decode("utf-8")
+        if isinstance(raw, str):
+            try:
+                raw = json.loads(raw)
+            except json.JSONDecodeError:
+                return {}
+        return raw if isinstance(raw, dict) else {}
+
+    @staticmethod
+    def _point_in_window(point: dict[str, int], window: MetricsWindow) -> bool:
+        generated_at = int(point.get("generated_at", 0) or 0)
+        return window.start_ts <= generated_at <= window.end_ts
+
+    @staticmethod
+    def _summarize(samples: list[dict[str, int]]) -> dict[str, Any]:
+        if not samples:
+            return {"sample_count": 0}
+        fields = (
+            "workers_online",
+            "active_executions",
+            "queued_executions",
+            "failed_executions",
+            "queue_depth_total",
+            "consumer_pending_total",
+            "alert_count",
+            "latency_p95_ms",
+            "queue_latency_p95_ms",
+            "total_latency_p95_ms",
+        )
+        summary: dict[str, Any] = {"sample_count": len(samples)}
+        for field_name in fields:
+            values = [int(sample.get(field_name, 0) or 0) for sample in samples]
+            summary[field_name] = {
+                "min": min(values),
+                "max": max(values),
+                "last": values[-1],
+            }
+        return summary
+
+    @staticmethod
+    def _diagnose_summary(summary: dict[str, Any]) -> list[MetricsDiagnostic]:
+        diagnostics: list[MetricsDiagnostic] = []
+        if not summary or int(summary.get("sample_count", 0) or 0) <= 0:
+            return diagnostics
+        checks = (
+            ("queue_depth_total", "metrics_queue_backlog", "Queue depth was non-zero."),
+            (
+                "consumer_pending_total",
+                "metrics_consumer_pending",
+                "Consumer pending messages were non-zero.",
+            ),
+            ("alert_count", "metrics_alerts_present", "System alerts were present."),
+            (
+                "failed_executions",
+                "metrics_failures_present",
+                "Failed executions were present.",
+            ),
+        )
+        for field_name, code, message in checks:
+            max_value = int(summary.get(field_name, {}).get("max", 0) or 0)
+            if max_value > 0:
+                diagnostics.append(
+                    MetricsDiagnostic(
+                        code=code,
+                        message=message,
+                        severity="warning",
+                    )
+                )
+        return diagnostics

by_framework/{observability → metrics}/snapshot.py

@@ -523,12 +523,12 @@ def build_prometheus_metrics(snapshot: dict[str, Any]) -> str:
             )
             lines.append(
                 "by_framework_stream_pending_messages"
-                f"{{{labels}}} {int(group.get("pending", 0) or 0)}"
+                f"{{{labels}}} {int(group.get('pending', 0) or 0)}"
             )
             lag = group.get("lag")
             if lag is not None:
                 lines.append(
-                    "by_framework_stream_consumer_lag" f"{{{labels}}} {int(lag or 0)}"
+                    f"by_framework_stream_consumer_lag{{{labels}}} {int(lag or 0)}"
                 )
 
     lines.extend(
@@ -1424,7 +1424,7 @@ def _build_queue_alerts(
                     "code": "QUEUE_BACKLOG",
                     "severity": "warning",
                     "message": (
-                        f"{length} messages queued for agent type " f"{agent_type}."
+                        f"{length} messages queued for agent type {agent_type}."
                     ),
                     "value": length,
                     "threshold": policy.queue_backlog_threshold,

by_framework/trace/__init__.py

@@ -0,0 +1,55 @@
+"""Trace helpers, context propagation, and write-side observability APIs."""
+
+from .external_trace import (
+    ExternalTraceContext,
+    build_langfuse_trace_context,
+    build_otel_parent_context,
+    extract_external_trace_context,
+    start_langfuse_observation,
+    to_langfuse_trace_id,
+)
+from .span_recorder import (
+    LiveSpanHandle,
+    ObservabilityConfig,
+    SpanRecorder,
+    TraceSpan,
+    build_observability_config,
+    get_observability_diagnostics,
+    live_execution_otel_span,
+    reset_observability_diagnostics,
+)
+from .trace_schema import (
+    EventRecord,
+    ExecutionRecord,
+    SpanNode,
+    SpanRecord,
+    TraceDiagnostic,
+    TraceReadResult,
+    TraceRecord,
+)
+from .trace_writer import TraceWriteClient
+
+__all__ = [
+    "ExternalTraceContext",
+    "EventRecord",
+    "ExecutionRecord",
+    "LiveSpanHandle",
+    "ObservabilityConfig",
+    "SpanNode",
+    "SpanRecord",
+    "SpanRecorder",
+    "TraceDiagnostic",
+    "TraceReadResult",
+    "TraceRecord",
+    "TraceSpan",
+    "TraceWriteClient",
+    "build_langfuse_trace_context",
+    "build_observability_config",
+    "build_otel_parent_context",
+    "extract_external_trace_context",
+    "get_observability_diagnostics",
+    "live_execution_otel_span",
+    "reset_observability_diagnostics",
+    "start_langfuse_observation",
+    "to_langfuse_trace_id",
+]

by_framework/{observability → trace}/external_trace.py

@@ -7,7 +7,7 @@ from typing import Any
 
 from by_framework.core.protocol.commands import BaseCommand
 from by_framework.core.protocol.message_header import MessageHeader
-from by_framework.observability.span_recorder import str_to_uint128
+from by_framework.trace.span_recorder import str_to_uint128
 
 
 @dataclass(frozen=True)

by_framework/{observability → trace}/span_recorder.py

@@ -6,6 +6,7 @@ import contextvars
 import hashlib
 import json
 import os
+import threading
 import time
 from contextlib import asynccontextmanager
 from dataclasses import asdict, dataclass, field, replace
@@ -77,7 +78,27 @@ try:
 except ImportError:
 
     class ContextIdGenerator:  # type: ignore
-        pass
+        """Fallback ID generator used when OpenTelemetry is not installed."""
+
+        def generate_trace_id(self) -> int:
+            """Return a context-provided or random 128-bit trace id."""
+            val = current_trace_id_var.get()
+            if val is not None:
+                return val
+            import secrets
+
+            val_rand = secrets.randbits(128)
+            return val_rand if val_rand != 0 else 1
+
+        def generate_span_id(self) -> int:
+            """Return a context-provided or random 64-bit span id."""
+            val = current_span_id_var.get()
+            if val is not None:
+                return val
+            import secrets
+
+            val_rand = secrets.randbits(64)
+            return val_rand if val_rand != 0 else 1
 
 
 def configure_otel_id_generator() -> None:
@@ -125,6 +146,9 @@ _OBSERVABILITY_DIAGNOSTICS: dict[str, Any] = {
     "export_failures_total": 0,
     "export_failures_by_exporter": {},
 }
+_OBSERVABILITY_DIAGNOSTICS_LOCK = threading.Lock()
+_LANGFUSE_PROCESSOR_PROVIDER_IDS: set[int] = set()
+_LANGFUSE_PROCESSOR_LOCK = threading.Lock()
 
 
 @dataclass(frozen=True)
@@ -171,38 +195,44 @@ def build_observability_config() -> ObservabilityConfig:
 
 def get_observability_diagnostics() -> dict[str, Any]:
     """Return trace exporter self-diagnostics."""
-    return {
-        "dropped_spans_total": int(_OBSERVABILITY_DIAGNOSTICS["dropped_spans_total"]),
-        "dropped_spans_by_reason": dict(
-            _OBSERVABILITY_DIAGNOSTICS["dropped_spans_by_reason"]
-        ),
-        "export_failures_total": int(
-            _OBSERVABILITY_DIAGNOSTICS["export_failures_total"]
-        ),
-        "export_failures_by_exporter": dict(
-            _OBSERVABILITY_DIAGNOSTICS["export_failures_by_exporter"]
-        ),
-    }
+    with _OBSERVABILITY_DIAGNOSTICS_LOCK:
+        return {
+            "dropped_spans_total": int(
+                _OBSERVABILITY_DIAGNOSTICS["dropped_spans_total"]
+            ),
+            "dropped_spans_by_reason": dict(
+                _OBSERVABILITY_DIAGNOSTICS["dropped_spans_by_reason"]
+            ),
+            "export_failures_total": int(
+                _OBSERVABILITY_DIAGNOSTICS["export_failures_total"]
+            ),
+            "export_failures_by_exporter": dict(
+                _OBSERVABILITY_DIAGNOSTICS["export_failures_by_exporter"]
+            ),
+        }
 
 
 def reset_observability_diagnostics() -> None:
     """Reset trace exporter self-diagnostics for tests."""
-    _OBSERVABILITY_DIAGNOSTICS["dropped_spans_total"] = 0
-    _OBSERVABILITY_DIAGNOSTICS["dropped_spans_by_reason"] = {}
-    _OBSERVABILITY_DIAGNOSTICS["export_failures_total"] = 0
-    _OBSERVABILITY_DIAGNOSTICS["export_failures_by_exporter"] = {}
+    with _OBSERVABILITY_DIAGNOSTICS_LOCK:
+        _OBSERVABILITY_DIAGNOSTICS["dropped_spans_total"] = 0
+        _OBSERVABILITY_DIAGNOSTICS["dropped_spans_by_reason"] = {}
+        _OBSERVABILITY_DIAGNOSTICS["export_failures_total"] = 0
+        _OBSERVABILITY_DIAGNOSTICS["export_failures_by_exporter"] = {}
 
 
 def _record_drop(reason: str) -> None:
-    _OBSERVABILITY_DIAGNOSTICS["dropped_spans_total"] += 1
-    by_reason = _OBSERVABILITY_DIAGNOSTICS["dropped_spans_by_reason"]
-    by_reason[reason] = int(by_reason.get(reason, 0)) + 1
+    with _OBSERVABILITY_DIAGNOSTICS_LOCK:
+        _OBSERVABILITY_DIAGNOSTICS["dropped_spans_total"] += 1
+        by_reason = _OBSERVABILITY_DIAGNOSTICS["dropped_spans_by_reason"]
+        by_reason[reason] = int(by_reason.get(reason, 0)) + 1
 
 
 def _record_export_failure(exporter_name: str) -> None:
-    _OBSERVABILITY_DIAGNOSTICS["export_failures_total"] += 1
-    by_exporter = _OBSERVABILITY_DIAGNOSTICS["export_failures_by_exporter"]
-    by_exporter[exporter_name] = int(by_exporter.get(exporter_name, 0)) + 1
+    with _OBSERVABILITY_DIAGNOSTICS_LOCK:
+        _OBSERVABILITY_DIAGNOSTICS["export_failures_total"] += 1
+        by_exporter = _OBSERVABILITY_DIAGNOSTICS["export_failures_by_exporter"]
+        by_exporter[exporter_name] = int(by_exporter.get(exporter_name, 0)) + 1
 
 
 def _clean_env(value: str | None) -> str:
@@ -287,6 +317,13 @@ class TraceSpan:
     start_ts: int
     end_ts: int
     status: str
+    name: str = ""
+    kind: str = ""
+    source: str = "redis"
+    input: Any = None
+    output: Any = None
+    tokens: dict[str, Any] = field(default_factory=dict)
+    cost: dict[str, Any] = field(default_factory=dict)
     session_id: str = ""
     execution_id: str = ""
     message_id: str = ""
@@ -312,17 +349,14 @@ class TraceSpan:
         payload["start_ts"] = int(self.start_ts or 0)
         payload["end_ts"] = max(payload["start_ts"], int(self.end_ts or 0))
         payload["duration_ms"] = max(0, payload["end_ts"] - payload["start_ts"])
+        payload["name"] = self.name or self.operation
         if payload.get("error_message"):
             payload["error_message"] = _sanitize_value(
                 "error_message", payload["error_message"]
             )
         if payload.get("metadata"):
             payload["metadata"] = _sanitize_value("metadata", payload["metadata"])
-        return {
-            key: value
-            for key, value in payload.items()
-            if value not in ("", None) and value is not False
-        }
+        return {key: value for key, value in payload.items() if value not in ("", None)}
 
 
 @runtime_checkable
@@ -351,8 +385,17 @@ class RedisSpanExporter:
         payload = span.to_payload()
         trace_id = str(payload["trace_id"])
         start_ts = int(payload.get("start_ts", 0) or 0)
+        end_ts = int(payload.get("end_ts", start_ts) or start_ts)
         meta_key = RedisKeys.trace_meta(trace_id)
         spans_key = RedisKeys.trace_spans(trace_id)
+        existing_start_ts = await self._read_hash_int(meta_key, "start_ts")
+        existing_updated_at = await self._read_hash_int(meta_key, "updated_at")
+        trace_start_ts = (
+            min(value for value in (existing_start_ts, start_ts) if value > 0)
+            if existing_start_ts or start_ts
+            else 0
+        )
+        updated_at = max(existing_updated_at, end_ts)
         pipe = self.redis.pipeline()
         if isawaitable(pipe):
             pipe = await pipe
@@ -363,14 +406,29 @@ class RedisSpanExporter:
         await self._call_pipeline(
             pipe, "hset", meta_key, "status", str(payload.get("status", ""))
         )
-        await self._call_pipeline(pipe, "hset", meta_key, "start_ts", start_ts)
-        await self._call_pipeline(
-            pipe,
-            "hset",
-            meta_key,
-            "updated_at",
-            int(payload.get("end_ts", start_ts) or start_ts),
-        )
+        operation = str(payload.get("operation", ""))
+        if payload.get("name") and operation.startswith("client.dispatch"):
+            await self._call_pipeline(
+                pipe, "hset", meta_key, "name", str(payload.get("name", ""))
+            )
+        if payload.get("target_agent_type") and operation.startswith("client.dispatch"):
+            await self._call_pipeline(
+                pipe,
+                "hset",
+                meta_key,
+                "root_agent_type",
+                str(payload.get("target_agent_type", "")),
+            )
+        if payload.get("message_id") and operation.startswith("client.dispatch"):
+            await self._call_pipeline(
+                pipe,
+                "hset",
+                meta_key,
+                "root_message_id",
+                str(payload.get("message_id", "")),
+            )
+        await self._call_pipeline(pipe, "hset", meta_key, "start_ts", trace_start_ts)
+        await self._call_pipeline(pipe, "hset", meta_key, "updated_at", updated_at)
         await self._call_pipeline(
             pipe, "rpush", spans_key, json.dumps(payload, ensure_ascii=False)
         )
@@ -413,6 +471,20 @@ class RedisSpanExporter:
         if isawaitable(result):
             await result
 
+    async def _read_hash_int(self, name: str, field_name: str) -> int:
+        hget = getattr(self.redis, "hget", None)
+        if not callable(hget):
+            return 0
+        try:
+            value = hget(name, field_name)  # pylint: disable=not-callable
+            if isawaitable(value):
+                value = await value
+            if isinstance(value, bytes):
+                value = value.decode("utf-8")
+            return int(value or 0)
+        except (TypeError, ValueError):
+            return 0
+
 
 class OTelSpanExporter:
     """Export TraceSpan objects into OpenTelemetry's global tracer."""
@@ -667,30 +739,18 @@ def register_langfuse_span_processor() -> None:
         if secret_key and public_key and base_url:
             # 1. Ensure the global TracerProvider exists and patch the ID generator.
             provider = trace.get_tracer_provider()
-            if hasattr(provider, "_delegate") and provider._delegate is not None:
-                provider = provider._delegate
-
             if not isinstance(provider, TracerProvider):
                 provider = TracerProvider()
                 trace.set_tracer_provider(provider)
                 configure_otel_id_generator()
 
-            # 2. Avoid registering duplicate LangfuseSpanProcessor instances.
-            has_processor = False
-            active_processor = getattr(provider, "_active_span_processor", None)
-            if active_processor is not None:
-                processors = []
-                if hasattr(active_processor, "_span_processors"):
-                    processors = active_processor._span_processors
-                else:
-                    processors = [active_processor]
-
-                for p in processors:
-                    if p.__class__.__name__ == "LangfuseSpanProcessor":
-                        has_processor = True
-                        break
-
-            if not has_processor:
+            # 2. Avoid duplicate registration from this integration without
+            # relying on OpenTelemetry SDK private provider internals.
+            provider_id = id(provider)
+            with _LANGFUSE_PROCESSOR_LOCK:
+                if provider_id in _LANGFUSE_PROCESSOR_PROVIDER_IDS:
+                    return
+
                 # 3. Dynamically import and attach LangfuseSpanProcessor.
                 langfuse_processor_mod = import_module(
                     "langfuse._client.span_processor"
@@ -725,6 +785,7 @@ def register_langfuse_span_processor() -> None:
                     should_export_span=should_export_span,
                 )
                 provider.add_span_processor(processor)
+                _LANGFUSE_PROCESSOR_PROVIDER_IDS.add(provider_id)
                 logger.info(
                     "LangfuseSpanProcessor registered successfully to global OTel "
                     "TracerProvider. Base URL: %s",