ioa-observe-sdk 1.0.26__py3-none-any.whl → 1.0.27__py3-none-any.whl

ioa_observe/sdk/instrumentations/a2a.py

@@ -204,6 +204,122 @@ class A2AInstrumentor(BaseInstrumentor):
 
         # original_server_on_message_send = DefaultRequestHandler.on_message_send
 
+        # Instrumentation for slima2a
+        if importlib.util.find_spec("slima2a"):
+            from slima2a.client_transport import SRPCTransport
+
+            # send_message
+            original_srpc_transport_send_message = SRPCTransport.send_message
+
+            @functools.wraps(original_srpc_transport_send_message)
+            async def instrumented_srpc_transport_send_message(
+                self, request, *args, **kwargs
+            ):
+                # Put context into A2A message metadata instead of HTTP headers
+                with _global_tracer.start_as_current_span("slima2a.send_message"):
+                    traceparent = get_current_traceparent()
+                    session_id = None
+                    if traceparent:
+                        session_id = kv_store.get(f"execution.{traceparent}")
+                        if not session_id:
+                            session_id = get_value("session.id")
+                            if session_id:
+                                kv_store.set(f"execution.{traceparent}", session_id)
+
+                    # Ensure metadata dict exists
+                    try:
+                        md = getattr(request.params, "metadata", None)
+                    except AttributeError:
+                        md = None
+                    metadata = md if isinstance(md, dict) else {}
+
+                    observe_meta = dict(metadata.get("observe", {}))
+
+                    # Inject W3C trace context + baggage into observe_meta
+                    TraceContextTextMapPropagator().inject(carrier=observe_meta)
+                    W3CBaggagePropagator().inject(carrier=observe_meta)
+
+                    if traceparent:
+                        observe_meta["traceparent"] = traceparent
+                    if session_id:
+                        observe_meta["session_id"] = session_id
+                        baggage.set_baggage(f"execution.{traceparent}", session_id)
+
+                    metadata["observe"] = observe_meta
+
+                    # Write back metadata (pydantic models are mutable by default in v2)
+                    try:
+                        request.metadata = metadata
+                    except Exception:
+                        # Fallback
+                        request = request.model_copy(update={"metadata": metadata})
+
+                # Call through without transport-specific kwargs
+                return await original_srpc_transport_send_message(
+                    self, request, *args, **kwargs
+                )
+
+            SRPCTransport.send_message = instrumented_srpc_transport_send_message
+
+            # send_message_streaming
+            original_srpc_transport_send_message_streaming = (
+                SRPCTransport.send_message_streaming
+            )
+
+            @functools.wraps(original_srpc_transport_send_message_streaming)
+            async def instrumented_srpc_transport_send_message_streaming(
+                self, request, *args, **kwargs
+            ):
+                # Put context into A2A message metadata instead of HTTP headers
+                with _global_tracer.start_as_current_span(
+                    "slima2a.send_message_streaming"
+                ):
+                    traceparent = get_current_traceparent()
+                    session_id = None
+                    if traceparent:
+                        session_id = kv_store.get(f"execution.{traceparent}")
+                        if not session_id:
+                            session_id = get_value("session.id")
+                            if session_id:
+                                kv_store.set(f"execution.{traceparent}", session_id)
+
+                    # Ensure metadata dict exists
+                    try:
+                        md = getattr(request.params, "metadata", None)
+                    except AttributeError:
+                        md = None
+                    metadata = md if isinstance(md, dict) else {}
+
+                    observe_meta = dict(metadata.get("observe", {}))
+
+                    # Inject W3C trace context + baggage into observe_meta
+                    TraceContextTextMapPropagator().inject(carrier=observe_meta)
+                    W3CBaggagePropagator().inject(carrier=observe_meta)
+
+                    if traceparent:
+                        observe_meta["traceparent"] = traceparent
+                    if session_id:
+                        observe_meta["session_id"] = session_id
+                        baggage.set_baggage(f"execution.{traceparent}", session_id)
+
+                    metadata["observe"] = observe_meta
+
+                    # Write back metadata (pydantic models are mutable by default in v2)
+                    try:
+                        request.metadata = metadata
+                    except Exception:
+                        # Fallback
+                        request = request.model_copy(update={"metadata": metadata})
+
+                # Call through without transport-specific kwargs
+                return await original_srpc_transport_send_message_streaming(
+                    self, request, *args, **kwargs
+                )
+
+            SRPCTransport.send_message_streaming = (
+                instrumented_srpc_transport_send_message_streaming
+            )
+
     def _uninstrument(self, **kwargs):
         import importlib
 
@@ -227,3 +343,20 @@ class A2AInstrumentor(BaseInstrumentor):
         DefaultRequestHandler.on_message_send = (
             DefaultRequestHandler.on_message_send.__wrapped__
         )
+
+        # handle slima2a
+        if importlib.util.find_spec("slima2a"):
+            from slima2a.client_transport import SRPCTransport
+
+            # Uninstrument `send_message`
+            if hasattr(SRPCTransport, "send_message") and hasattr(
+                SRPCTransport.send_message, "__wrapped__"
+            ):
+                SRPCTransport.send_message = SRPCTransport.send_message.__wrapped__
+
+            if hasattr(SRPCTransport, "send_message_streaming") and hasattr(
+                SRPCTransport.send_message_streaming, "__wrapped__"
+            ):
+                SRPCTransport.send_message_streaming = (
+                    SRPCTransport.send_message.__wrapped__
+                )

ioa_observe/sdk/instrumentations/slim.py

@@ -531,7 +531,15 @@ class SLIMInstrumentor(BaseInstrumentor):
             if timeout is not None:
                 kwargs["timeout"] = timeout
 
-            result = await original_get_message(self, **kwargs)
+            if _global_tracer:
+                with _global_tracer.start_as_current_span(
+                    "session.get_message"
+                ) as span:
+                    if hasattr(self, "id"):
+                        span.set_attribute("slim.session.id", str(self.id))
+                    result = await original_get_message(self, **kwargs)
+            else:
+                result = await original_get_message(self, **kwargs)
 
             # Handle different return types from get_message
             if result is None:

ioa_observe/sdk/tracing/tracing.py

@@ -7,6 +7,7 @@ import json
 import logging
 import os
 import re
+import threading
 import time
 import uuid
 
@@ -64,6 +65,9 @@ from typing import Callable, Dict, Optional, Set
 TRACER_NAME = "ioa.observe.tracer"
 APP_NAME = ""
 
+SESSION_IDLE_TIMEOUT_SECONDS = 300  # e.g. 5 minutes
+SESSION_WATCHER_INTERVAL_SECONDS = 30
+
 
 def determine_reliability_score(span):
     if "observe.entity.output" in span.attributes:
@@ -132,6 +136,9 @@ class TracerWrapper(object):
             if not TracerWrapper.endpoint:
                 return obj
 
+            # session activity tracking
+            obj._session_last_activity: dict[str, float] = {}
+            obj._session_lock = threading.Lock()
             obj.__image_uploader = image_uploader
             # {(agent_name): [success_count, total_count]}
             obj._agent_execution_counts = {}
@@ -270,12 +277,70 @@ class TracerWrapper(object):
 
             obj.__content_allow_list = ContentAllowList()
 
+            # start background watcher for session end
+            obj._start_session_watcher()
+
             # Force flushes for debug environments (e.g. local development)
             atexit.register(obj.exit_handler)
 
         return cls.instance
 
+    def _start_session_watcher(self) -> None:
+        t = threading.Thread(
+            target=self._session_watcher_loop,
+            name="ioa-session-watcher",
+            daemon=True,
+        )
+        t.start()
+
+    def _session_watcher_loop(self) -> None:
+        while True:
+            time.sleep(SESSION_WATCHER_INTERVAL_SECONDS)
+            now = time.time()
+            expired: dict[str, float] = {}
+
+            # Find idle sessions and remove them from _session_last_activity
+            with self._session_lock:
+                for session_id, last_ts in list(self._session_last_activity.items()):
+                    if now - last_ts > SESSION_IDLE_TIMEOUT_SECONDS:
+                        expired[session_id] = last_ts
+                        del self._session_last_activity[session_id]
+
+            if not expired:
+                continue
+
+            tracer = self.get_tracer()
+
+            # Iterate over a snapshot and do *not* modify `expired` in the loop
+            for session_id, _last_ts in list(expired.items()):
+                print("ending session", session_id)
+                with tracer.start_as_current_span("session.end") as span:
+                    span.set_attribute("session.id", session_id)
+                    workflow_name = get_value("workflow_name")
+                    if workflow_name:
+                        span.set_attribute(OBSERVE_WORKFLOW_NAME, workflow_name)
+                    span.set_attribute("session.ended_at", _last_ts)
+
+            # ensure end spans are exported reasonably fast
+            self.flush()
+
     def exit_handler(self):
+        # emit end spans for any sessions that never went idle
+        now = time.time()
+        tracer = self.get_tracer()
+
+        with self._session_lock:
+            remaining_ids = list(self._session_last_activity.keys())
+            self._session_last_activity.clear()
+
+        for session_id in remaining_ids:
+            with tracer.start_as_current_span("session.end") as span:
+                span.set_attribute("session.id", session_id)
+                workflow_name = get_value("workflow_name")
+                if workflow_name:
+                    span.set_attribute(OBSERVE_WORKFLOW_NAME, workflow_name)
+                span.set_attribute("session.ended_at", now)
+
         self.flush()
 
     def _span_processor_on_start(self, span, parent_context):
@@ -362,6 +427,12 @@ class TracerWrapper(object):
         # Mark this span as processed
         self._processed_spans.add(span_id)
 
+        # update last activity per session
+        session_id = span.attributes.get("session.id")
+        if session_id:
+            with self._session_lock:
+                self._session_last_activity[session_id] = time.time()
+
         determine_reliability_score(span)
         # start_time = span.attributes.get("ioa_start_time")
 
@@ -382,10 +453,6 @@ class TracerWrapper(object):
                 except Exception as e:
                     logging.error(f"Error applying span transformation: {e}")
 
-        # if start_time is not None:
-        #     latency = (time.time() - start_time) * 1000
-        #     self.response_latency_histogram.record(latency, attributes=span.attributes)
-
         # Call original on_end method if it exists
         if (
             hasattr(self, "_TracerWrapper__spans_processor_original_on_end")

{ioa_observe_sdk-1.0.26.dist-info → ioa_observe_sdk-1.0.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ioa-observe-sdk
-Version: 1.0.26
+Version: 1.0.27
 Summary: IOA Observability SDK
 License-Expression: Apache-2.0
 Requires-Python: >=3.10

{ioa_observe_sdk-1.0.26.dist-info → ioa_observe_sdk-1.0.27.dist-info}/RECORD

@@ -14,10 +14,10 @@ ioa_observe/sdk/decorators/base.py,sha256=gezoLMLOo-CWsxzsXbQMsj5HxmchUEmlhTspbq
 ioa_observe/sdk/decorators/helpers.py,sha256=I9HXMBivkZpGDtPe9Ad_UU35p_m_wEPate4r_fU0oOA,2705
 ioa_observe/sdk/decorators/util.py,sha256=IebvH9gwZN1en3LblYJUh4bAV2STl6xmp8WpZzBDH2g,30068
 ioa_observe/sdk/instrumentations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ioa_observe/sdk/instrumentations/a2a.py,sha256=U6VbhgEMJVbMXugq0Ap07EFSvBPjvS0rX80-KIAKi4w,9356
+ioa_observe/sdk/instrumentations/a2a.py,sha256=LHvvQUluPtmvbRNuoqf-EkWlZJa_NicerTpM3t1UZws,15299
 ioa_observe/sdk/instrumentations/mcp.py,sha256=UG82fWitFT-K-ecnkTKZa-uFTDAs-j2HymvhUwCBRLY,18721
 ioa_observe/sdk/instrumentations/nats.py,sha256=MEYCFqHyRK5HtkjrbGVV5qIWplZ1ZjJjFCB8vtQl6qE,14736
-ioa_observe/sdk/instrumentations/slim.py,sha256=1zVPqInz7SOZ54fwy9V6aR9Lb8KpiGsXIxV_0ou14LE,45339
+ioa_observe/sdk/instrumentations/slim.py,sha256=c_Q1cb6pdjZLOw1MbclUf1eRFrc_sUEe9pQJvAyoD1Y,45712
 ioa_observe/sdk/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ioa_observe/sdk/logging/logging.py,sha256=HZxW9s8Due7jgiNkdI38cIjv5rC9D-Flta3RQMOnpow,2891
 ioa_observe/sdk/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -35,15 +35,15 @@ ioa_observe/sdk/tracing/content_allow_list.py,sha256=1fAkpIwUQ7vDwCTkIVrqeltWQtr
 ioa_observe/sdk/tracing/context_manager.py,sha256=O0JEXYa9h8anhW78R8KKBuqS0j4by1E1KXxNIMPnLr8,400
 ioa_observe/sdk/tracing/context_utils.py,sha256=-sYS9vPLI87davV9ubneq5xqbV583CC_c0SmOQS1TAs,2933
 ioa_observe/sdk/tracing/manual.py,sha256=KS6WN-zw9vAACzXYmnMoJm9d1fenYMfvzeK1GrGDPDE,1937
-ioa_observe/sdk/tracing/tracing.py,sha256=lX3Mh7NH2Rxtj3Bs6Oofxedd8YC_Y4gg3gMl0puFfSI,47357
+ioa_observe/sdk/tracing/tracing.py,sha256=7eJAEqaAEBZ2gjIXrdb7SyUidA8P10GnpBLzr8InLKI,50007
 ioa_observe/sdk/tracing/transform_span.py,sha256=XTApi_gJxum7ynvhtcoCfDyK8VVOj91Q1DT6hAeLHA8,8419
 ioa_observe/sdk/utils/__init__.py,sha256=UPn182U-UblF_XwXaFpx8F-TmQTbm1LYf9y89uSp5Hw,704
 ioa_observe/sdk/utils/const.py,sha256=d67dUTAH9UpWvUV9GLBUqn1Sc2knJ55dy-e6YoLrvSo,1318
 ioa_observe/sdk/utils/in_memory_span_exporter.py,sha256=H_4TRaThMO1H6vUQ0OpQvzJk_fZH0OOsRAM1iZQXsR8,2112
 ioa_observe/sdk/utils/json_encoder.py,sha256=g4NQ0tTqgWssY6I1D7r4zo0G6PiUo61jhofTAw5-jno,639
 ioa_observe/sdk/utils/package_check.py,sha256=1d1MjxhwoEZIx9dumirT2pRsEWgn-m-SI4npDeEalew,576
-ioa_observe_sdk-1.0.26.dist-info/licenses/LICENSE.md,sha256=55VjUfgjWOS4vv3Cf55gfq-RxjPgRIO2vlgYPUuC5lA,11362
-ioa_observe_sdk-1.0.26.dist-info/METADATA,sha256=xpBRssD4PqtdIIlXpIvS_joVzQvA8XsUUx_GrF31xa8,7997
-ioa_observe_sdk-1.0.26.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-ioa_observe_sdk-1.0.26.dist-info/top_level.txt,sha256=Yt-6Y1olZEDqCs2REeqI30WjYx0pLGQSVqzYmDd67N8,12
-ioa_observe_sdk-1.0.26.dist-info/RECORD,,
+ioa_observe_sdk-1.0.27.dist-info/licenses/LICENSE.md,sha256=55VjUfgjWOS4vv3Cf55gfq-RxjPgRIO2vlgYPUuC5lA,11362
+ioa_observe_sdk-1.0.27.dist-info/METADATA,sha256=OrhfkqzR0Qj2qwSGXtSmL9rYjS1OMk-IYmTU5wHMHdE,7997
+ioa_observe_sdk-1.0.27.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ioa_observe_sdk-1.0.27.dist-info/top_level.txt,sha256=Yt-6Y1olZEDqCs2REeqI30WjYx0pLGQSVqzYmDd67N8,12
+ioa_observe_sdk-1.0.27.dist-info/RECORD,,

{ioa_observe_sdk-1.0.26.dist-info → ioa_observe_sdk-1.0.27.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any