ioa-observe-sdk 1.0.12__py3-none-any.whl → 1.0.13__py3-none-any.whl

ioa_observe/sdk/decorators/base.py

@@ -10,13 +10,20 @@ import types
 from typing import Optional, TypeVar, Callable, Awaitable, Any, cast, Union
 import inspect
 
+from ioa_observe.sdk.decorators.helpers import (
+    _is_async_method,
+    _get_original_function_name,
+    _is_async_generator,
+)
+
+
 from langgraph.graph.state import CompiledStateGraph
 from opentelemetry import trace
 from opentelemetry import context as context_api
 from pydantic_core import PydanticSerializationError
 from typing_extensions import ParamSpec
 
-from ioa_observe.sdk.decorators.util import determine_workflow_type
+from ioa_observe.sdk.decorators.util import determine_workflow_type, _serialize_object
 from ioa_observe.sdk.metrics.agents.availability import agent_availability
 from ioa_observe.sdk.metrics.agents.recovery_tracker import agent_recovery_tracker
 from ioa_observe.sdk.metrics.agents.tool_call_tracker import tool_call_tracker
@@ -79,14 +86,6 @@ def _should_send_prompts():
     ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
 
 
-# Unified Decorators : handles both sync and async operations
-
-
-def _is_async_method(fn):
-    # check if co-routine function or async generator( example : using async & yield)
-    return inspect.iscoroutinefunction(fn) or inspect.isasyncgenfunction(fn)
-
-
 def _setup_span(
     entity_name,
     tlp_span_kind: Optional[ObserveSpanKindValues] = None,
@@ -164,24 +163,24 @@ def _handle_span_input(span, args, kwargs, cls=None):
             # Safely convert args
             for arg in args:
                 try:
-                    # Test if the object can be JSON serialized
+                    # Check if the object can be JSON serialized directly
                     json.dumps(arg)
                     safe_args.append(arg)
                 except (TypeError, ValueError, PydanticSerializationError):
-                    # If it can't be serialized, use string representation
-                    safe_args.append(str(arg))
+                    # Use intelligent serialization
+                    safe_args.append(_serialize_object(arg))
 
             # Safely convert kwargs
             for key, value in kwargs.items():
                 try:
-                    # Test if the object can be JSON serialized
+                    # Test if the object can be JSON serialized directly
                     json.dumps(value)
                     safe_kwargs[key] = value
                 except (TypeError, ValueError, PydanticSerializationError):
-                    # If it can't be serialized, use string representation
-                    safe_kwargs[key] = str(value)
+                    # Use intelligent serialization
+                    safe_kwargs[key] = _serialize_object(value)
 
-            # Create the JSON without custom encoder to avoid recursion
+            # Create the JSON
             json_input = json.dumps({"args": safe_args, "kwargs": safe_kwargs})
 
             if _is_json_size_valid(json_input):
@@ -212,62 +211,55 @@ def _handle_span_output(span, tlp_span_kind, res, cls=None):
                     # end_span.end()  # end the span immediately
                     set_agent_id_event("")  # reset the agent id event
                 # Add agent interpretation scoring
-            if (
-                tlp_span_kind == ObserveSpanKindValues.AGENT
-                or tlp_span_kind == ObserveSpanKindValues.WORKFLOW
-            ):
-                current_agent = span.attributes.get("agent_id", "unknown")
-
-                # Determine next agent from response (if Command object with goto)
-                next_agent = None
-                if isinstance(res, dict) and "goto" in res:
-                    next_agent = res["goto"]
-                    # Check if there's an error flag in the response
-                    success = not (
-                        res.get("error", False) or res.get("goto") == "__end__"
+        if (
+            tlp_span_kind == ObserveSpanKindValues.AGENT
+            or tlp_span_kind == ObserveSpanKindValues.WORKFLOW
+        ):
+            current_agent = span.attributes.get("agent_id", "unknown")
+
+            # Determine next agent from response (if Command object with goto)
+            next_agent = None
+            if isinstance(res, dict) and "goto" in res:
+                next_agent = res["goto"]
+                # Check if there's an error flag in the response
+                success = not (res.get("error", False) or res.get("goto") == "__end__")
+
+                # If we have a chain of communication, compute interpretation score
+                if next_agent and next_agent != "__end__":
+                    score = compute_agent_interpretation_score(
+                        sender_agent=current_agent,
+                        receiver_agent=next_agent,
+                        data=res,
+                    )
+                    span.set_attribute("gen_ai.ioa.agent.interpretation_score", score)
+                    reliability = connection_tracker.record_connection(
+                        sender=current_agent, receiver=next_agent, success=success
+                    )
+                    span.set_attribute(
+                        "gen_ai.ioa.agent.connection_reliability", reliability
                     )
 
-                    # If we have a chain of communication, compute interpretation score
-                    if next_agent and next_agent != "__end__":
-                        score = compute_agent_interpretation_score(
-                            sender_agent=current_agent,
-                            receiver_agent=next_agent,
-                            data=res,
-                        )
-                        span.set_attribute(
-                            "gen_ai.ioa.agent.interpretation_score", score
-                        )
-                        reliability = connection_tracker.record_connection(
-                            sender=current_agent, receiver=next_agent, success=success
-                        )
-                        span.set_attribute(
-                            "gen_ai.ioa.agent.connection_reliability", reliability
-                        )
-
-            if _should_send_prompts():
+        if _should_send_prompts():
+            try:
+                # Try direct JSON serialization first
+                json_output = json.dumps(res)
+            except (TypeError, PydanticSerializationError, ValueError):
+                # Use intelligent serialization for complex objects
                 try:
-                    # Try direct JSON serialization first (without custom encoder)
-                    json_output = json.dumps(res)
-                except (TypeError, PydanticSerializationError, ValueError):
-                    # Fallback for objects that can't be directly serialized
-                    try:
-                        # Try to serialize a string representation
-                        safe_output = str(res)
-                        json_output = json.dumps(
-                            {"__str_representation__": safe_output}
-                        )
-                    except Exception:
-                        # If all serialization fails, skip output attribute
-                        json_output = None
+                    serialized_res = _serialize_object(res)
+                    json_output = json.dumps(serialized_res)
+                except Exception:
+                    # If all serialization fails, skip output attribute
+                    json_output = None
 
-                if json_output and _is_json_size_valid(json_output):
-                    span.set_attribute(
-                        OBSERVE_ENTITY_OUTPUT,
-                        json_output,
-                    )
-                    TracerWrapper().span_processor_on_ending(
-                        span
-                    )  # record the response latency
+            if json_output and _is_json_size_valid(json_output):
+                span.set_attribute(
+                    OBSERVE_ENTITY_OUTPUT,
+                    json_output,
+                )
+                TracerWrapper().span_processor_on_ending(
+                    span
+                )  # record the response latency
     except Exception as e:
         print(f"Warning: Failed to serialize output for span: {e}")
         Telemetry().log_exception(e)
@@ -301,9 +293,9 @@ def entity_method(
 ) -> Callable[[F], F]:
     def decorate(fn: F) -> F:
         is_async = _is_async_method(fn)
-        entity_name = name or fn.__qualname__
+        entity_name = name or _get_original_function_name(fn)
         if is_async:
-            if inspect.isasyncgenfunction(fn):
+            if _is_async_generator(fn):
 
                 @wraps(fn)
                 async def async_gen_wrap(*args: Any, **kwargs: Any) -> Any:

ioa_observe/sdk/decorators/helpers.py

@@ -0,0 +1,66 @@
+# Copyright AGNTCY Contributors (https://github.com/agntcy)
+# SPDX-License-Identifier: Apache-2.0
+
+import inspect
+
+
+def _is_async_method(fn):
+    # check if co-routine function or async generator( example : using async & yield)
+    if inspect.iscoroutinefunction(fn) or inspect.isasyncgenfunction(fn):
+        return True
+
+    # Check if this is a wrapped function that might hide the original async nature
+    # Look for common wrapper attributes that might contain the original function
+    for attr_name in ["__wrapped__", "func", "_func", "function"]:
+        if hasattr(fn, attr_name):
+            wrapped_fn = getattr(fn, attr_name)
+            if wrapped_fn and callable(wrapped_fn):
+                if inspect.iscoroutinefunction(
+                    wrapped_fn
+                ) or inspect.isasyncgenfunction(wrapped_fn):
+                    return True
+                # Recursively check in case of multiple levels of wrapping
+                if _is_async_method(wrapped_fn):
+                    return True
+
+    return False
+
+
+def _is_async_generator(fn):
+    """Check if function is an async generator, looking through wrapped functions"""
+    if inspect.isasyncgenfunction(fn):
+        return True
+
+    # Check if this is a wrapped function that might hide the original async generator nature
+    for attr_name in ["__wrapped__", "func", "_func", "function"]:
+        if hasattr(fn, attr_name):
+            wrapped_fn = getattr(fn, attr_name)
+            if wrapped_fn and callable(wrapped_fn):
+                if inspect.isasyncgenfunction(wrapped_fn):
+                    return True
+                # Recursively check in case of multiple levels of wrapping
+                if _is_async_generator(wrapped_fn):
+                    return True
+
+    return False
+
+
+def _get_original_function_name(fn):
+    """Extract the original function name from potentially wrapped functions"""
+    if hasattr(fn, "__qualname__") and fn.__qualname__:
+        return fn.__qualname__
+
+    # Look for the original function in common wrapper attributes
+    for attr_name in ["__wrapped__", "func", "_func", "function"]:
+        if hasattr(fn, attr_name):
+            wrapped_fn = getattr(fn, attr_name)
+            if wrapped_fn and callable(wrapped_fn):
+                if hasattr(wrapped_fn, "__qualname__") and wrapped_fn.__qualname__:
+                    return wrapped_fn.__qualname__
+                # Recursively check in case of multiple levels of wrapping
+                result = _get_original_function_name(wrapped_fn)
+                if result:
+                    return result
+
+    # Fallback to function name if qualname is not available
+    return getattr(fn, "__name__", "unknown_function")

ioa_observe/sdk/decorators/util.py

@@ -13,6 +13,129 @@ from llama_index.core.workflow.utils import (
 )
 
 
+def _serialize_object(obj, max_depth=5, current_depth=0):
+    """
+    Intelligently serialize an object to a more meaningful representation
+    """
+    if current_depth > max_depth:
+        return f"<{type(obj).__name__}:max_depth_reached>"
+
+    # Handle basic JSON-serializable types
+    if obj is None or isinstance(obj, (bool, int, float, str)):
+        return obj
+
+    # Handle lists and tuples
+    if isinstance(obj, (list, tuple)):
+        try:
+            return [
+                _serialize_object(item, max_depth, current_depth + 1)
+                for item in obj[:10]
+            ]  # Limit to first 10 items
+        except Exception:
+            return f"<{type(obj).__name__}:length={len(obj)}>"
+
+    # Handle dictionaries
+    if isinstance(obj, dict):
+        try:
+            serialized = {}
+            for key, value in list(obj.items())[:10]:  # Limit to first 10 items
+                serialized[str(key)] = _serialize_object(
+                    value, max_depth, current_depth + 1
+                )
+            return serialized
+        except Exception:
+            return f"<dict:keys={len(obj)}>"
+
+    # Handle common object types with meaningful attributes
+    try:
+        # Check class attributes first
+        class_attrs = {}
+        for attr_name in dir(type(obj)):
+            if (
+                not attr_name.startswith("_")
+                and not callable(getattr(type(obj), attr_name, None))
+                and hasattr(obj, attr_name)
+            ):
+                try:
+                    attr_value = getattr(obj, attr_name)
+                    if not callable(attr_value):
+                        class_attrs[attr_name] = _serialize_object(
+                            attr_value, max_depth, current_depth + 1
+                        )
+                        if len(class_attrs) >= 5:  # Limit attributes
+                            break
+                except Exception:
+                    continue
+
+        # Check if object has a __dict__ with interesting attributes
+        instance_attrs = {}
+        if hasattr(obj, "__dict__"):
+            obj_dict = obj.__dict__
+            if obj_dict:
+                # Extract meaningful attributes (skip private ones and callables)
+                for key, value in obj_dict.items():
+                    if not key.startswith("_") and not callable(value):
+                        try:
+                            instance_attrs[key] = _serialize_object(
+                                value, max_depth, current_depth + 1
+                            )
+                            if len(instance_attrs) >= 5:  # Limit attributes
+                                break
+                        except Exception:
+                            continue
+
+        # Combine class and instance attributes
+        all_attrs = {**class_attrs, **instance_attrs}
+
+        if all_attrs:
+            return {
+                "__class__": type(obj).__name__,
+                "__module__": getattr(type(obj), "__module__", "unknown"),
+                "attributes": all_attrs,
+            }
+
+        # Special handling for specific types
+        if hasattr(obj, "message") and hasattr(obj.message, "parts"):
+            # Handle RequestContext-like objects
+            try:
+                parts_content = []
+                for part in obj.message.parts:
+                    if hasattr(part, "root") and hasattr(part.root, "text"):
+                        parts_content.append(part.root.text)
+                return {
+                    "__class__": type(obj).__name__,
+                    "message_content": parts_content,
+                }
+            except Exception:
+                pass
+
+        # Check for common readable attributes
+        for attr in ["name", "id", "type", "value", "content", "text", "data"]:
+            if hasattr(obj, attr):
+                try:
+                    attr_value = getattr(obj, attr)
+                    if not callable(attr_value):
+                        return {
+                            "__class__": type(obj).__name__,
+                            attr: _serialize_object(
+                                attr_value, max_depth, current_depth + 1
+                            ),
+                        }
+                except Exception:
+                    continue
+
+        # Fallback to class information
+        return {
+            "__class__": type(obj).__name__,
+            "__module__": getattr(type(obj), "__module__", "unknown"),
+            "__repr__": str(obj)[:100] + ("..." if len(str(obj)) > 100 else ""),
+        }
+
+    except Exception:
+        # Final fallback
+        return f"<{type(obj).__name__}:serialization_failed>"
+
+
 def determine_workflow_type(workflow_obj: Any) -> Union[None, dict]:
     """Determines the workflow type and generates appropriate topology."""
     # Check if it's a dict mapping agent roles to agent names

{ioa_observe_sdk-1.0.12.dist-info → ioa_observe_sdk-1.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ioa-observe-sdk
-Version: 1.0.12
+Version: 1.0.13
 Summary: IOA Observability SDK
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{ioa_observe_sdk-1.0.12.dist-info → ioa_observe_sdk-1.0.13.dist-info}/RECORD

@@ -10,8 +10,9 @@ ioa_observe/sdk/config/__init__.py,sha256=8aVNaw0yRNLFPxlf97iOZLlJVcV81ivSDnudH2
 ioa_observe/sdk/connectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ioa_observe/sdk/connectors/slim.py,sha256=NwbKEV7d5NIOqmG8zKqtgGigSJl7kf3QJ65z2gxpsY8,8498
 ioa_observe/sdk/decorators/__init__.py,sha256=Lv5EbouBazvWaYB0N82v26pqKtj2FAqlwfLKEh5e8Q0,3251
-ioa_observe/sdk/decorators/base.py,sha256=kR_0KWMMbOdJ_t9m5EZ9ZUj3pmKWEgkj0-E1F3c-nIE,29969
-ioa_observe/sdk/decorators/util.py,sha256=WMkzmwD7Js0g1BbId9_qR4pwhnaIJdW588zVc5dpqdQ,25399
+ioa_observe/sdk/decorators/base.py,sha256=wdllPcsb_vtq8Kbu1oF7eg2Z5e-Rgv8XUu1Shsk1Fp4,29395
+ioa_observe/sdk/decorators/helpers.py,sha256=I9HXMBivkZpGDtPe9Ad_UU35p_m_wEPate4r_fU0oOA,2705
+ioa_observe/sdk/decorators/util.py,sha256=v0dBY-ynyiLFHwQSteBfoCZ-rxwPUTgfczokKlevSKM,30068
 ioa_observe/sdk/instrumentations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ioa_observe/sdk/instrumentations/a2a.py,sha256=ov_9ckkymf_qFXG0iXVWfxlW-3kFcP-knrM_t-Cf72w,4414
 ioa_observe/sdk/instrumentations/slim.py,sha256=J5e6XeshH55xXaUiT9_j4R_n6VQELzBjgRAU-AgZGOg,11435
@@ -38,8 +39,8 @@ ioa_observe/sdk/utils/const.py,sha256=GwbHakKPjBL4wLqAVkDrSoKB-8p18EUrbaqPuRuV_x
 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.12.dist-info/licenses/LICENSE.md,sha256=55VjUfgjWOS4vv3Cf55gfq-RxjPgRIO2vlgYPUuC5lA,11362
-ioa_observe_sdk-1.0.12.dist-info/METADATA,sha256=3owAgvI_xgARwMohc3ticBRqKwju2w-poBOu1SILHC4,6109
-ioa_observe_sdk-1.0.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ioa_observe_sdk-1.0.12.dist-info/top_level.txt,sha256=Yt-6Y1olZEDqCs2REeqI30WjYx0pLGQSVqzYmDd67N8,12
-ioa_observe_sdk-1.0.12.dist-info/RECORD,,
+ioa_observe_sdk-1.0.13.dist-info/licenses/LICENSE.md,sha256=55VjUfgjWOS4vv3Cf55gfq-RxjPgRIO2vlgYPUuC5lA,11362
+ioa_observe_sdk-1.0.13.dist-info/METADATA,sha256=h0RjY4epTI6SNW15L-Lxlv0OjN9L0UrfQyQJYGk6lCg,6109
+ioa_observe_sdk-1.0.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ioa_observe_sdk-1.0.13.dist-info/top_level.txt,sha256=Yt-6Y1olZEDqCs2REeqI30WjYx0pLGQSVqzYmDd67N8,12
+ioa_observe_sdk-1.0.13.dist-info/RECORD,,