trodo-python 2.3.1__tar.gz → 2.4.1__tar.gz

{trodo_python-2.3.1/trodo_python.egg-info → trodo_python-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trodo-python
-Version: 2.3.1
+Version: 2.4.1
 Summary: Trodo Analytics SDK for Python — server-side event tracking
 License: ISC
 Keywords: analytics,tracking,trodo,server-side
@@ -19,6 +19,10 @@ Description-Content-Type: text/markdown
 Requires-Dist: requests>=2.28.0
 Provides-Extra: async
 Requires-Dist: httpx>=0.27.0; extra == "async"
+Provides-Extra: otlp
+Requires-Dist: opentelemetry-api>=1.20.0; extra == "otlp"
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == "otlp"
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0; extra == "otlp"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -37,6 +41,39 @@ pip install trodo-python
 
 Requires Python 3.8+.
 
+## OpenTelemetry / OTLP path (NEW in 2.4.0)
+
+Already running OTel? Skip the Trodo SDK install entirely and point your existing pipeline at Trodo. Two env vars:
+
+```bash
+export OTEL_EXPORTER_OTLP_ENDPOINT=https://sdkapi.trodo.ai
+export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer ${TRODO_SITE_ID}"
+```
+
+The Bearer token is your **site_id** — same value you'd pass to `trodo.init(site_id=...)`. Get it from the [Integration Manager](https://app.trodo.ai/dashboard/integrations).
+
+Use this when **you already run OTel** (Datadog, Jaeger, Honeycomb) and want Trodo as an additional destination. Install `trodo-python` and call `trodo.register_otel(site_id=..., mode='otlp')` to attach our OTLP exporter without replacing your existing setup. `wrap_agent` then routes through OTel so auto-instrumented children share the same trace.
+
+```python
+# At app startup (after your existing OTel provider is registered)
+import os, trodo
+
+trodo.register_otel(
+    site_id=os.environ['TRODO_SITE_ID'],
+    mode='otlp',
+)
+```
+
+`mode='otlp'` requires the optional `[otlp]` extras:
+
+```bash
+pip install 'trodo-python[otlp]'
+```
+
+The SDK raises a friendly install hint if you call `mode='otlp'` without them.
+
+For richer Trodo features on top (`wrap_agent`, `feedback`, `track_mcp`), continue with the SDK quick start below.
+
 ## Quick Start
 
 ```python

trodo_python-2.3.1/PKG-INFO → trodo_python-2.4.1/README.md

@@ -1,30 +1,3 @@
-Metadata-Version: 2.4
-Name: trodo-python
-Version: 2.3.1
-Summary: Trodo Analytics SDK for Python — server-side event tracking
-License: ISC
-Keywords: analytics,tracking,trodo,server-side
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: ISC License (ISCL)
-Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: requests>=2.28.0
-Provides-Extra: async
-Requires-Dist: httpx>=0.27.0; extra == "async"
-Provides-Extra: dev
-Requires-Dist: pytest>=7.0; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: responses>=0.25.0; extra == "dev"
-Requires-Dist: httpx>=0.27.0; extra == "dev"
-
 # trodo-python
 
 Server-side Python SDK for [Trodo Analytics](https://trodo.ai). Track backend events, identify users, manage people/groups, and instrument AI agents — all unified with your frontend data under the same `site_id`.
@@ -37,6 +10,39 @@ pip install trodo-python
 
 Requires Python 3.8+.
 
+## OpenTelemetry / OTLP path (NEW in 2.4.0)
+
+Already running OTel? Skip the Trodo SDK install entirely and point your existing pipeline at Trodo. Two env vars:
+
+```bash
+export OTEL_EXPORTER_OTLP_ENDPOINT=https://sdkapi.trodo.ai
+export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer ${TRODO_SITE_ID}"
+```
+
+The Bearer token is your **site_id** — same value you'd pass to `trodo.init(site_id=...)`. Get it from the [Integration Manager](https://app.trodo.ai/dashboard/integrations).
+
+Use this when **you already run OTel** (Datadog, Jaeger, Honeycomb) and want Trodo as an additional destination. Install `trodo-python` and call `trodo.register_otel(site_id=..., mode='otlp')` to attach our OTLP exporter without replacing your existing setup. `wrap_agent` then routes through OTel so auto-instrumented children share the same trace.
+
+```python
+# At app startup (after your existing OTel provider is registered)
+import os, trodo
+
+trodo.register_otel(
+    site_id=os.environ['TRODO_SITE_ID'],
+    mode='otlp',
+)
+```
+
+`mode='otlp'` requires the optional `[otlp]` extras:
+
+```bash
+pip install 'trodo-python[otlp]'
+```
+
+The SDK raises a friendly install hint if you call `mode='otlp'` without them.
+
+For richer Trodo features on top (`wrap_agent`, `feedback`, `track_mcp`), continue with the SDK quick start below.
+
 ## Quick Start
 
 ```python

{trodo_python-2.3.1 → trodo_python-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trodo-python"
-version = "2.3.1"
+version = "2.4.1"
 description = "Trodo Analytics SDK for Python — server-side event tracking"
 readme = "README.md"
 license = { text = "ISC" }
@@ -28,6 +28,13 @@ classifiers = [
 
 [project.optional-dependencies]
 async = ["httpx>=0.27.0"]
+# OTLP-mode dependencies for register_otel(mode='otlp'). Install with:
+#   pip install 'trodo-python[otlp]'
+otlp = [
+    "opentelemetry-api>=1.20.0",
+    "opentelemetry-sdk>=1.20.0",
+    "opentelemetry-exporter-otlp-proto-http>=1.20.0",
+]
 dev = [
     "pytest>=7.0",
     "pytest-cov",

trodo_python-2.4.1/tests/test_auto_instrument_fixes.py

@@ -0,0 +1,111 @@
+"""Mirror of trodo-node 2.4.3 bridge fixes for the Python SDK.
+
+Covers:
+  1. duration_ms is rounded to an integer.
+  2. Active run is recovered from on_start-stamped attributes when
+     contextvars are empty at on_end (httpx async-context loss).
+  3. Internal trodo.* attributes are stripped from the persisted span.
+"""
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+from trodo.otel.auto_instrument import _OtelAdapter, otel_span_to_trodo_span
+from trodo.otel.context import (
+    ActiveSpanContext,
+    get_active_context,
+    run_with_context,
+)
+
+
+RUN_ID = "11111111-1111-1111-1111-111111111111"
+ROOT_SPAN_ID = "22222222-2222-2222-2222-222222222222"
+
+
+def _fake_otel_span(start_ns=None, end_ns=None, attrs=None, span_id_int=0xABCD1234ABCD1234, parent_span_id_int=None):
+    span_context = SimpleNamespace(span_id=span_id_int)
+    parent = SimpleNamespace(span_id=parent_span_id_int) if parent_span_id_int else None
+    return SimpleNamespace(
+        name="anthropic.messages.create",
+        get_span_context=lambda: span_context,
+        attributes=attrs or {},
+        start_time=start_ns,
+        end_time=end_ns,
+        status=None,
+        parent=parent,
+    )
+
+
+def _ctx():
+    return ActiveSpanContext(
+        run_id=RUN_ID,
+        span_id=ROOT_SPAN_ID,
+        parent_span_id=None,
+        team_site_id="site-1",
+        processor=None,  # type: ignore[arg-type]
+    )
+
+
+class TestDurationRounding:
+    def test_fractional_ns_delta_rounds_to_integer(self):
+        # 1000ms + 0.999888 fractional ms via nanos delta
+        otel = _fake_otel_span(start_ns=1_000_000_000, end_ns=2_000_999_888)
+        with run_with_context(_ctx()):
+            span = otel_span_to_trodo_span(otel)
+        assert span is not None
+        assert isinstance(span.duration_ms, int)
+        assert span.duration_ms == 1001
+
+    def test_missing_times_leaves_duration_none(self):
+        otel = _fake_otel_span(start_ns=None, end_ns=None)
+        with run_with_context(_ctx()):
+            span = otel_span_to_trodo_span(otel)
+        assert span.duration_ms is None
+
+
+class TestOnStartStamping:
+    def test_on_start_stamps_run_id_when_context_is_alive(self):
+        adapter = _OtelAdapter(processor=MagicMock())
+        live_span = MagicMock()
+        with run_with_context(_ctx()):
+            adapter.on_start(live_span, None)
+        live_span.set_attribute.assert_any_call("trodo.run_id", RUN_ID)
+        live_span.set_attribute.assert_any_call("trodo.parent_span_id", ROOT_SPAN_ID)
+
+    def test_recovers_run_from_stamped_attrs_when_contextvars_empty(self):
+        # Simulate the failure mode: span fires on_end outside any wrap_agent.
+        assert get_active_context() is None
+        otel = _fake_otel_span(
+            start_ns=1_000_000_000,
+            end_ns=2_000_000_000,
+            attrs={
+                "trodo.run_id": RUN_ID,
+                "trodo.parent_span_id": ROOT_SPAN_ID,
+                "gen_ai.request.model": "claude-3-7",
+            },
+        )
+        span = otel_span_to_trodo_span(otel)
+        assert span is not None
+        assert span.run_id == RUN_ID
+        assert span.parent_span_id == ROOT_SPAN_ID
+
+    def test_strips_trodo_attrs_from_persisted_span(self):
+        otel = _fake_otel_span(
+            start_ns=1_000_000_000,
+            end_ns=2_000_000_000,
+            attrs={
+                "trodo.run_id": RUN_ID,
+                "trodo.parent_span_id": ROOT_SPAN_ID,
+                "gen_ai.request.model": "gpt-4",
+            },
+        )
+        span = otel_span_to_trodo_span(otel)
+        assert "trodo.run_id" not in (span.attributes or {})
+        assert "trodo.parent_span_id" not in (span.attributes or {})
+        assert (span.attributes or {}).get("gen_ai.request.model") == "gpt-4"
+
+    def test_drops_span_when_no_run_id_anywhere(self):
+        otel = _fake_otel_span(start_ns=1, end_ns=2, attrs={})
+        assert otel_span_to_trodo_span(otel) is None

trodo_python-2.4.1/tests/test_register_otel.py

@@ -0,0 +1,183 @@
+"""Tests for register_otel + transport dispatch (Python parity with the TS SDK)."""
+from __future__ import annotations
+
+import pytest
+
+from trodo.otel.register import register_otel, _reset_for_tests
+from trodo.otel.transport import (
+    get_transport_mode,
+    get_otel_tracer,
+    set_otel_transport,
+    _reset_transport_for_tests,
+)
+from trodo.otel.processor import TrodoSpanProcessor
+from trodo.otel.wrap_agent import wrap_agent
+
+
+@pytest.fixture(autouse=True)
+def reset_state():
+    _reset_for_tests()
+    yield
+    _reset_for_tests()
+
+
+# ---------------------------------------------------------------------------
+# register_otel — argument validation + idempotency
+# ---------------------------------------------------------------------------
+
+
+def test_raises_when_site_id_missing(processor):
+    with pytest.raises(ValueError, match="site_id"):
+        register_otel(site_id="", processor=processor)
+
+
+def test_raises_when_processor_missing():
+    with pytest.raises(ValueError, match="processor"):
+        register_otel(site_id="site_x", processor=None)  # type: ignore[arg-type]
+
+
+def test_idempotency_warns_on_second_call(processor):
+    first = register_otel(site_id="site_x", processor=processor, mode="trodo")
+    assert first.mode == "trodo"
+    assert first.fresh is True
+
+    with pytest.warns(UserWarning, match="already called"):
+        second = register_otel(site_id="site_x", processor=processor, mode="trodo")
+    assert second is first
+
+
+def test_unknown_mode_raises(processor):
+    with pytest.raises(ValueError, match="unknown mode"):
+        register_otel(site_id="site_x", processor=processor, mode="bogus")
+
+
+# ---------------------------------------------------------------------------
+# Mode dispatch — 'trodo' default, 'otlp' raises if peer deps missing
+# ---------------------------------------------------------------------------
+
+
+def test_trodo_mode_succeeds_without_otlp_peer_deps(processor):
+    result = register_otel(site_id="site_x", processor=processor, mode="trodo")
+    assert result.mode == "trodo"
+    # active_instrumentations is best-effort; just confirm it's a list.
+    assert isinstance(result.active_instrumentations, list)
+
+
+def test_otlp_mode_emits_install_hint_when_peer_deps_missing(processor, monkeypatch):
+    # Ensure opentelemetry imports fail to simulate a fresh install without
+    # the 'otlp' extras. We do this by replacing opentelemetry.sdk.trace's
+    # spec in sys.modules with None, mimicking ImportError at import time.
+    import sys
+
+    sentinel = "opentelemetry.exporter.otlp.proto.http.trace_exporter"
+    monkeypatch.setitem(sys.modules, sentinel, None)
+
+    with pytest.raises(RuntimeError, match=r"register_otel\(mode='otlp'\) requires"):
+        register_otel(site_id="site_x", processor=processor, mode="otlp")
+
+
+# ---------------------------------------------------------------------------
+# Transport dispatch — wrap_agent in 'otlp' mode goes through the OTel tracer
+# ---------------------------------------------------------------------------
+
+
+class RecordedSpan:
+    def __init__(self, name: str, trace_id: int, span_id: int):
+        self.name = name
+        self.trace_id = trace_id
+        self.span_id = span_id
+        self.attrs = {}
+        self.ended = False
+        self.exception = None
+        self.status = None
+
+    def set_attribute(self, key, value):
+        self.attrs[key] = value
+
+    def record_exception(self, e):
+        self.exception = e
+
+    def set_status(self, s):
+        self.status = s
+
+    def end(self):
+        self.ended = True
+
+    def get_span_context(self):
+        class C:
+            pass
+        c = C()
+        c.trace_id = self.trace_id
+        c.span_id = self.span_id
+        return c
+
+
+class MockTracer:
+    def __init__(self):
+        self.spans: list = []
+        self._next_id = 1
+
+    def start_span(self, name):
+        span = RecordedSpan(name, self._next_id, self._next_id + 1000)
+        self._next_id += 1
+        self.spans.append(span)
+        return span
+
+
+def test_wrap_agent_dispatches_to_otel_when_transport_set(processor):
+    """wrap_agent in 'otlp' transport routes through tracer.start_span and
+    sets Trodo attributes the backend OTLP controller understands."""
+    tracer = MockTracer()
+
+    class _NoopCM:
+        def __enter__(self):
+            return None
+
+        def __exit__(self, *a):
+            return None
+
+    def fake_use_span(span, end_on_exit=False):
+        return _NoopCM()
+
+    set_otel_transport(tracer, use_span=fake_use_span)
+
+    with wrap_agent(
+        processor=processor,
+        team_site_id="site-x",
+        agent_name="support-bot",
+        distinct_id="user-1",
+        conversation_id="conv-1",
+        metadata={"experimentId": "v3", "tier": "enterprise"},
+    ) as run:
+        run.set_input({"q": "hello"})
+        run.set_output({"a": "world"})
+
+    assert len(tracer.spans) == 1
+    span = tracer.spans[0]
+    assert span.name == "support-bot"
+    assert span.ended is True
+    assert span.attrs["trodo.agent_name"] == "support-bot"
+    assert span.attrs["trodo.distinct_id"] == "user-1"
+    assert span.attrs["trodo.conversation_id"] == "conv-1"
+    assert span.attrs["trodo.metadata.experimentId"] == "v3"
+    assert span.attrs["trodo.metadata.tier"] == "enterprise"
+    assert "ai.prompt" in span.attrs
+    assert "ai.response.text" in span.attrs
+
+
+def test_wrap_agent_legacy_path_when_no_transport(processor, http):
+    """No register_otel call → transport mode stays 'trodo' → wrap_agent
+    uses TrodoSpanProcessor + HTTP API as in 2.3.x."""
+    assert get_transport_mode() == "trodo"
+    assert get_otel_tracer() is None
+
+    with wrap_agent(
+        processor=processor,
+        team_site_id="site-x",
+        agent_name="legacy-agent",
+    ) as run:
+        run.set_output("done")
+
+    # Trodo HTTP API path used as in 2.3.x.
+    assert len(http.run_ingest) == 1
+    assert http.run_ingest[0]["run"]["agent_name"] == "legacy-agent"

{trodo_python-2.3.1 → trodo_python-2.4.1}/trodo/__init__.py

@@ -40,7 +40,7 @@ Downstream microservice (join the caller's run instead of making a new one):
 
 from __future__ import annotations
 
-__version__ = "2.3.1"
+__version__ = "2.4.0"
 
 from typing import Any, Callable, Dict, List, Optional, Union
 
@@ -67,6 +67,7 @@ __all__ = [
     "SpanHandle",
     "FeedbackProps",
     "init",
+    "register_otel",
     "for_user",
     "track",
     "identify",
@@ -129,6 +130,7 @@ def init(
     on_error: Optional[Any] = None,
     debug: bool = False,
     auto_instrument: bool = True,
+    otel_mode: str = "trodo",
 ) -> TrodoClient:
     """Initialise the singleton SDK instance.
 
@@ -150,10 +152,53 @@ def init(
         on_error=on_error,
         debug=debug,
         auto_instrument=auto_instrument,
+        otel_mode=otel_mode,
     )
     return _client
 
 
+def register_otel(
+    *,
+    site_id: Optional[str] = None,
+    mode: str = "trodo",
+    endpoint: Optional[str] = None,
+    service_name: str = "trodo-agent",
+) -> Any:
+    """Configure the OTel pipeline with one call.
+
+    Auto-creates the singleton TrodoClient if init() hasn't been called yet,
+    so this can replace init() for OTel-first deployments.
+
+    Modes:
+      - 'trodo' (default): bridges OTel auto-instrumentations into
+        TrodoSpanProcessor (HTTP API path). Same as init() with default config.
+      - 'otlp': registers an OTel TracerProvider with an OTLP/protobuf
+        exporter pointed at Trodo's /v1/traces. Use alongside Datadog/Jaeger
+        or for vanilla OTel-native setups.
+
+    Example:
+        import trodo
+        trodo.register_otel(site_id=os.environ['TRODO_SITE_ID'], mode='otlp')
+    """
+    global _client
+    from .otel.register import register_otel as _impl
+    if _client is None:
+        if not site_id:
+            raise ValueError(
+                "register_otel: pass site_id, or call trodo.init(site_id=...) first."
+            )
+        # Suppress legacy auto_instrument inside the constructor — register_otel
+        # below is what wires the pipeline.
+        _client = TrodoClient(site_id=site_id, auto_instrument=False)
+    return _impl(
+        site_id=site_id or _client.site_id,
+        processor=_client._get_span_processor(),
+        mode=mode,
+        endpoint=endpoint,
+        service_name=service_name,
+    )
+
+
 def for_user(
     distinct_id: str,
     session_id: Optional[str] = None,

{trodo_python-2.3.1 → trodo_python-2.4.1}/trodo/client.py

@@ -23,6 +23,7 @@ from .otel.wrap_agent import (
     current_span_id as _current_span_id,
 )
 from .otel.auto_instrument import enable_auto_instrument
+from .otel.register import register_otel as _register_otel
 from .otel.helpers import (
     tool as tool_decorator,
     track_llm_call as track_llm_call_fn,
@@ -52,11 +53,13 @@ class TrodoClient:
         on_error: Optional[Any] = None,
         debug: bool = False,
         auto_instrument: bool = True,
+        otel_mode: str = "trodo",
     ) -> None:
         if not site_id:
             raise ValueError("trodo-python: site_id is required")
 
         self.site_id = site_id
+        self._api_base = api_base
 
         self._http = HttpClient(
             api_base=api_base,
@@ -90,7 +93,22 @@ class TrodoClient:
 
         self._span_processor = TrodoSpanProcessor(http_client=self._http)
         if auto_instrument:
-            enable_auto_instrument(self._span_processor)
+            import os
+            if os.environ.get("TRODO_LEGACY_INIT") == "1":
+                # Pre-2.4 escape hatch for one minor version.
+                enable_auto_instrument(self._span_processor)
+            else:
+                _register_otel(
+                    site_id=site_id,
+                    processor=self._span_processor,
+                    mode=otel_mode,
+                    endpoint=api_base,
+                )
+
+    def _get_span_processor(self) -> TrodoSpanProcessor:
+        """Internal: expose the span processor to register_otel. Not part of
+        the public surface; subject to change between minors."""
+        return self._span_processor
 
     # --------------------------------------------------------------------------
     # Primary pattern: for_user()

{trodo_python-2.3.1 → trodo_python-2.4.1}/trodo/otel/auto_instrument.py

@@ -34,11 +34,17 @@ def _infer_kind(attrs: Dict[str, Any]) -> str:
     return "generic"
 
 
+_ATTR_TRODO_RUN_ID = "trodo.run_id"
+_ATTR_TRODO_PARENT_SPAN_ID = "trodo.parent_span_id"
+
+
 def otel_span_to_trodo_span(otel_span: Any) -> Optional[TrodoSpan]:
-    """Translate an OTel ReadableSpan to our TrodoSpan using GenAI semconv."""
-    ctx = get_active_context()
-    if ctx is None:
-        return None  # span emitted outside of wrap_agent — drop
+    """Translate an OTel ReadableSpan to our TrodoSpan using GenAI semconv.
+
+    Recovers the active run from on_start-stamped attributes when contextvars
+    have been clobbered by httpx/asyncio context loss at span end. Mirrors
+    the trodo-node 2.4.3 bridge behaviour.
+    """
     try:
         span_ctx = (
             otel_span.get_span_context()
@@ -53,15 +59,36 @@ def otel_span_to_trodo_span(otel_span: Any) -> Optional[TrodoSpan]:
         return None
     span_id = f"{span_id_int:016x}" if isinstance(span_id_int, int) else str(span_id_int)
 
+    attrs = dict(getattr(otel_span, "attributes", {}) or {})
+
+    # Prefer on_start-stamped run/parent so async-context loss can't drop
+    # auto-instrumented LLM spans.
+    stamped_run_id = attrs.get(_ATTR_TRODO_RUN_ID)
+    stamped_parent_span_id = attrs.get(_ATTR_TRODO_PARENT_SPAN_ID)
+
+    ctx = get_active_context()
+    run_id = stamped_run_id if isinstance(stamped_run_id, str) else (ctx.run_id if ctx else None)
+    if not run_id:
+        return None  # emitted outside any wrap_agent — drop
+
     parent = getattr(otel_span, "parent", None)
-    parent_span_id: Optional[str] = None
+    otel_parent_span_id: Optional[str] = None
     if parent is not None:
         pid = getattr(parent, "span_id", None)
-        parent_span_id = f"{pid:016x}" if isinstance(pid, int) else str(pid) if pid else None
-    if parent_span_id is None:
-        parent_span_id = ctx.span_id
+        otel_parent_span_id = (
+            f"{pid:016x}" if isinstance(pid, int) else str(pid) if pid else None
+        )
 
-    attrs = dict(getattr(otel_span, "attributes", {}) or {})
+    if isinstance(stamped_parent_span_id, str):
+        parent_span_id: Optional[str] = stamped_parent_span_id
+    elif otel_parent_span_id:
+        parent_span_id = otel_parent_span_id
+    else:
+        parent_span_id = ctx.span_id if ctx else None
+
+    # Strip the internal attrs so they don't leak into the persisted span.
+    attrs.pop(_ATTR_TRODO_RUN_ID, None)
+    attrs.pop(_ATTR_TRODO_PARENT_SPAN_ID, None)
     kind = _infer_kind(attrs)
 
     start_time = getattr(otel_span, "start_time", None)
@@ -70,7 +97,9 @@ def otel_span_to_trodo_span(otel_span: Any) -> Optional[TrodoSpan]:
     ended_at = _hr_to_iso(end_time)
     duration_ms = None
     if start_time and end_time:
-        duration_ms = max(0, int((end_time - start_time) / 1e6))
+        # round-half-to-even semantics are fine here; the constraint is
+        # "integer ms" matching the agent_spans.duration_ms column.
+        duration_ms = max(0, round((end_time - start_time) / 1e6))
 
     status = getattr(otel_span, "status", None)
     status_code = getattr(status, "status_code", None)
@@ -104,7 +133,7 @@ def otel_span_to_trodo_span(otel_span: Any) -> Optional[TrodoSpan]:
 
     return TrodoSpan(
         span_id=span_id,
-        run_id=ctx.run_id,
+        run_id=run_id,
         parent_span_id=parent_span_id,
         kind=kind,
         name=getattr(otel_span, "name", kind),
@@ -131,7 +160,20 @@ class _OtelAdapter:
         self._processor = processor
 
     def on_start(self, span: Any, parent_context: Any = None) -> None:
-        pass
+        # Stamp active run/parent ids while contextvars are still alive.
+        # See otel_span_to_trodo_span() docstring for the failure mode this
+        # guards against (async-context loss across httpx await boundaries).
+        ctx = get_active_context()
+        if ctx is None:
+            return
+        try:
+            set_attr = getattr(span, "set_attribute", None)
+            if callable(set_attr):
+                set_attr(_ATTR_TRODO_RUN_ID, ctx.run_id)
+                if ctx.span_id:
+                    set_attr(_ATTR_TRODO_PARENT_SPAN_ID, ctx.span_id)
+        except Exception:
+            pass  # never break user code
 
     def on_end(self, span: Any) -> None:
         trodo_span = otel_span_to_trodo_span(span)