ioa-observe-sdk 1.0.26__tar.gz → 1.0.28__tar.gz

{ioa_observe_sdk-1.0.26 → ioa_observe_sdk-1.0.28}/PKG-INFO

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

{ioa_observe_sdk-1.0.26 → ioa_observe_sdk-1.0.28}/ioa_observe/sdk/client/client.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import sys
+import threading
 
 from .http import HTTPClient
 from ioa_observe.sdk.version import __version__
@@ -51,21 +52,29 @@ class Client:
 class KVStore(object):
     """
     Key-Value Store for storing key-value pairs (Singleton).
+    Thread-safe implementation for concurrent access.
     """
 
     _instance = None
+    _instance_lock = threading.Lock()
 
     def __new__(cls):
         if cls._instance is None:
-            cls._instance = super(KVStore, cls).__new__(cls)
-            cls._instance.store = {}
+            with cls._instance_lock:
+                # Double-check locking pattern
+                if cls._instance is None:
+                    cls._instance = super(KVStore, cls).__new__(cls)
+                    cls._instance.store = {}
+                    cls._instance._lock = threading.Lock()
         return cls._instance
 
     def set(self, key: str, value: str):
-        self.store[key] = value
+        with self._lock:
+            self.store[key] = value
 
     def get(self, key: str):
-        return self.store.get(key)
+        with self._lock:
+            return self.store.get(key)
 
 
 kv_store = KVStore()

{ioa_observe_sdk-1.0.26 → ioa_observe_sdk-1.0.28}/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-1.0.26 → ioa_observe_sdk-1.0.28}/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-1.0.26 → ioa_observe_sdk-1.0.28}/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,10 @@ 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
+MAX_PROCESSED_SPANS_SIZE = 100000  # Maximum size before cleanup
+
 
 def determine_reliability_score(span):
     if "observe.entity.output" in span.attributes:
@@ -132,11 +137,16 @@ 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 = {}
+            obj._agent_execution_counts_lock = threading.Lock()
             # Track spans that have been processed to avoid duplicates
             obj._processed_spans = set()
+            obj._processed_spans_lock = threading.Lock()
             TracerWrapper.app_name = TracerWrapper.resource_attributes.get(
                 "service.name", "observe"
             )
@@ -270,12 +280,74 @@ 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]
+
+            # Periodic cleanup of processed spans to prevent unbounded memory growth
+            with self._processed_spans_lock:
+                if len(self._processed_spans) > MAX_PROCESSED_SPANS_SIZE:
+                    self._processed_spans.clear()
+
+            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()):
+                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):
@@ -355,12 +427,21 @@ class TracerWrapper(object):
         # Added for avoid duplicate on_ending with manual triggers
         # from decorators (@tool, @workflow) in base.py
         span_id = span.context.span_id
-        if span_id in self._processed_spans:
-            # This span was already processed, skip to avoid duplicates
-            return
-
-        # Mark this span as processed
-        self._processed_spans.add(span_id)
+        with self._processed_spans_lock:
+            if span_id in self._processed_spans:
+                # This span was already processed, skip to avoid duplicates
+                return
+
+            # Mark this span as processed
+            self._processed_spans.add(span_id)
+
+        # update last activity per session
+        # Skip session.end spans to avoid infinite loop - these are cleanup spans
+        # that should not re-register the session as active
+        session_id = span.attributes.get("session.id")
+        if session_id and span.name != "session.end":
+            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 +463,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")
@@ -500,21 +577,23 @@ class TracerWrapper(object):
         return self.__tracer_provider.get_tracer(TRACER_NAME)
 
     def record_agent_execution(self, agent_name: str, success: bool):
-        counts = self._agent_execution_counts.setdefault(agent_name, [0, 0])
-        if success:
-            counts[0] += 1  # success count
-        counts[1] += 1  # total count
+        with self._agent_execution_counts_lock:
+            counts = self._agent_execution_counts.setdefault(agent_name, [0, 0])
+            if success:
+                counts[0] += 1  # success count
+            counts[1] += 1  # total count
 
     def _observe_agent_execution_success_rate(self, observer):
         measurements = []
-        for agent_name, (
-            success_count,
-            total_count,
-        ) in self._agent_execution_counts.items():
-            rate = (success_count / total_count) if total_count > 0 else 0.0
-            measurements.append(
-                Observation(value=rate, attributes={"agent_name": agent_name})
-            )
+        with self._agent_execution_counts_lock:
+            for agent_name, (
+                success_count,
+                total_count,
+            ) in self._agent_execution_counts.items():
+                rate = (success_count / total_count) if total_count > 0 else 0.0
+                measurements.append(
+                    Observation(value=rate, attributes={"agent_name": agent_name})
+                )
         return measurements
 
 

{ioa_observe_sdk-1.0.26 → ioa_observe_sdk-1.0.28}/ioa_observe_sdk.egg-info/PKG-INFO

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

{ioa_observe_sdk-1.0.26 → ioa_observe_sdk-1.0.28}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ioa-observe-sdk"
-version = "1.0.26"
+version = "1.0.28"
 license = "Apache-2.0"
 description = "IOA Observability SDK"
 readme = "README.md"