netra-sdk 0.1.33__tar.gz → 0.1.35__tar.gz

{netra_sdk-0.1.33 → netra_sdk-0.1.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: netra-sdk
-Version: 0.1.33
+Version: 0.1.35
 Summary: A Python SDK for AI application observability that provides OpenTelemetry-based monitoring, tracing, and PII protection for LLM and vector database applications. Enables easy instrumentation, session tracking, and privacy-focused data collection for AI systems in production environments.
 License: Apache-2.0
 Keywords: netra,tracing,observability,sdk,ai,llm,vector,database

netra_sdk-0.1.35/netra/decorators.py

@@ -0,0 +1,441 @@
+"""Netra decorator utilities.
+
+This module provides decorators for common patterns in Netra SDK.
+Decorators can be applied to both functions and classes.
+"""
+
+import functools
+import inspect
+import json
+import logging
+from typing import (
+    Any,
+    AsyncGenerator,
+    Awaitable,
+    Callable,
+    Dict,
+    Generator,
+    Optional,
+    ParamSpec,
+    Tuple,
+    TypeVar,
+    Union,
+    cast,
+)
+
+try:
+    # Optional import: only present in FastAPI/Starlette environments
+    from starlette.responses import StreamingResponse
+except Exception:  # pragma: no cover - starlette may not be installed in some environments
+    StreamingResponse = None
+
+from opentelemetry import trace
+
+from .config import Config
+from .session_manager import SessionManager
+
+logger = logging.getLogger(__name__)
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+F_Callable = TypeVar("F_Callable", bound=Callable[..., Any])
+C = TypeVar("C", bound=type)
+
+
+def _serialize_value(value: Any) -> str:
+    """Safely serialize a value to string for span attributes."""
+    try:
+        if isinstance(value, (str, int, float, bool, type(None))):
+            return str(value)
+        elif isinstance(value, (list, dict, tuple)):
+            return json.dumps(value, default=str)[:1000]  # Limit size
+        else:
+            return str(value)[:1000]  # Limit size
+    except Exception:
+        return str(type(value).__name__)
+
+
+def _add_span_attributes(
+    span: trace.Span, func: Callable[..., Any], args: Tuple[Any, ...], kwargs: Dict[str, Any], entity_type: str
+) -> None:
+    """Helper function to add span attributes from function parameters."""
+    span.set_attribute(f"{Config.LIBRARY_NAME}.entity.type", entity_type)
+
+    try:
+        sig = inspect.signature(func)
+        param_names = list(sig.parameters.keys())
+        input_data = {}
+
+        for i, arg in enumerate(args):
+            if i < len(param_names):
+                param_name = param_names[i]
+                if param_name not in ("self", "cls"):
+                    input_data[param_name] = _serialize_value(arg)
+
+        for key, value in kwargs.items():
+            input_data[key] = _serialize_value(value)
+
+        if input_data:
+            span.set_attribute(f"{Config.LIBRARY_NAME}.entity.input", json.dumps(input_data))
+
+    except Exception as e:
+        span.set_attribute(f"{Config.LIBRARY_NAME}.input_error", str(e))
+
+
+def _add_output_attributes(span: trace.Span, result: Any) -> None:
+    """Helper function to add output attributes to span."""
+    try:
+        serialized_output = _serialize_value(result)
+        span.set_attribute(f"{Config.LIBRARY_NAME}.entity.output", serialized_output)
+    except Exception as e:
+        span.set_attribute(f"{Config.LIBRARY_NAME}.entity.output_error", str(e))
+
+
+def _is_streaming_response(obj: Any) -> bool:
+    """Return True if obj is a Starlette StreamingResponse instance."""
+    if StreamingResponse is None:
+        return False
+    try:
+        return isinstance(obj, StreamingResponse)
+    except Exception:
+        return False
+
+
+def _is_async_generator(obj: Any) -> bool:
+    return inspect.isasyncgen(obj)
+
+
+def _is_sync_generator(obj: Any) -> bool:
+    return inspect.isgenerator(obj)
+
+
+def _wrap_async_generator_with_span(
+    span: trace.Span,
+    agen: AsyncGenerator[Any, None],
+    span_name: str,
+    entity_type: str,
+) -> AsyncGenerator[Any, None]:
+    """Wrap an async generator so the span remains current for the full iteration and ends afterwards."""
+
+    async def _wrapped() -> AsyncGenerator[Any, None]:
+        # Activate span for the entire iteration
+        with trace.use_span(span, end_on_exit=False):
+            try:
+                async for item in agen:
+                    yield item
+            except Exception as e:
+                try:
+                    span.set_attribute(f"{Config.LIBRARY_NAME}.entity.error", str(e))
+                    span.record_exception(e)
+                finally:
+                    span.end()
+                    # De-register and pop entity at the very end for streaming lifecycle
+                    try:
+                        SessionManager.unregister_span(span_name, span)
+                    except Exception:
+                        logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+                    SessionManager.pop_entity(entity_type)
+                raise
+            else:
+                # Normal completion
+                span.end()
+                try:
+                    SessionManager.unregister_span(span_name, span)
+                except Exception:
+                    logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+                SessionManager.pop_entity(entity_type)
+
+    return _wrapped()
+
+
+def _wrap_sync_generator_with_span(
+    span: trace.Span,
+    gen: Generator[Any, None, None],
+    span_name: str,
+    entity_type: str,
+) -> Generator[Any, None, None]:
+    """Wrap a sync generator so the span remains current for the full iteration and ends afterwards."""
+
+    def _wrapped() -> Generator[Any, None, None]:
+        with trace.use_span(span, end_on_exit=False):
+            try:
+                for item in gen:
+                    yield item
+            except Exception as e:
+                try:
+                    span.set_attribute(f"{Config.LIBRARY_NAME}.entity.error", str(e))
+                    span.record_exception(e)
+                finally:
+                    span.end()
+                    try:
+                        SessionManager.unregister_span(span_name, span)
+                    except Exception:
+                        logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+                    SessionManager.pop_entity(entity_type)
+                raise
+            else:
+                span.end()
+                try:
+                    SessionManager.unregister_span(span_name, span)
+                except Exception:
+                    logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+                SessionManager.pop_entity(entity_type)
+
+    return _wrapped()
+
+
+def _wrap_streaming_response_with_span(
+    span: trace.Span,
+    resp: Any,
+    span_name: str,
+    entity_type: str,
+) -> Any:
+    """Wrap StreamingResponse.body_iterator with a generator that keeps span current and ends it afterwards."""
+    try:
+        body_iter = getattr(resp, "body_iterator", None)
+        if body_iter is None:
+            return resp
+        # Async iterator
+        if inspect.isasyncgen(body_iter) or hasattr(body_iter, "__aiter__"):
+
+            async def _aiter_wrapper():  # type: ignore[no-untyped-def]
+                with trace.use_span(span, end_on_exit=False):
+                    try:
+                        async for chunk in body_iter:
+                            yield chunk
+                    except Exception as e:
+                        try:
+                            span.set_attribute(f"{Config.LIBRARY_NAME}.entity.error", str(e))
+                            span.record_exception(e)
+                        finally:
+                            span.end()
+                            try:
+                                SessionManager.unregister_span(span_name, span)
+                            except Exception:
+                                logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+                            SessionManager.pop_entity(entity_type)
+                        raise
+                    else:
+                        span.end()
+                        try:
+                            SessionManager.unregister_span(span_name, span)
+                        except Exception:
+                            logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+                        SessionManager.pop_entity(entity_type)
+
+            resp.body_iterator = _aiter_wrapper()  # type: ignore[no-untyped-call]
+            return resp
+
+        # Sync iterator
+        if inspect.isgenerator(body_iter) or hasattr(body_iter, "__iter__"):
+
+            def _iter_wrapper():  # type: ignore[no-untyped-def]
+                with trace.use_span(span, end_on_exit=False):
+                    try:
+                        for chunk in body_iter:
+                            yield chunk
+                    except Exception as e:
+                        try:
+                            span.set_attribute(f"{Config.LIBRARY_NAME}.entity.error", str(e))
+                            span.record_exception(e)
+                        finally:
+                            span.end()
+                            try:
+                                SessionManager.unregister_span(span_name, span)
+                            except Exception:
+                                logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+                            SessionManager.pop_entity(entity_type)
+                        raise
+                    else:
+                        span.end()
+                        try:
+                            SessionManager.unregister_span(span_name, span)
+                        except Exception:
+                            logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+                        SessionManager.pop_entity(entity_type)
+
+            resp.body_iterator = _iter_wrapper()  # type: ignore[no-untyped-call]
+            return resp
+    except Exception:
+        logger.exception("Failed to wrap StreamingResponse with span '%s'", span_name)
+    return resp
+
+
+def _create_function_wrapper(func: Callable[P, R], entity_type: str, name: Optional[str] = None) -> Callable[P, R]:
+    module_name = func.__name__
+    is_async = inspect.iscoroutinefunction(func)
+    span_name = name if name is not None else func.__name__
+
+    if is_async:
+
+        @functools.wraps(func)
+        async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+            # Push entity before span starts so processors can capture it
+            SessionManager.push_entity(entity_type, span_name)
+
+            tracer = trace.get_tracer(module_name)
+            span = tracer.start_span(span_name)
+            # Register and activate span
+            try:
+                SessionManager.register_span(span_name, span)
+                SessionManager.set_current_span(span)
+            except Exception:
+                logger.exception("Failed to register span '%s' with SessionManager", span_name)
+
+            with trace.use_span(span, end_on_exit=False):
+                _add_span_attributes(span, func, args, kwargs, entity_type)
+                try:
+                    result = await cast(Awaitable[Any], func(*args, **kwargs))
+                except Exception as e:
+                    span.set_attribute(f"{Config.LIBRARY_NAME}.entity.error", str(e))
+                    span.record_exception(e)
+                    span.end()
+                    try:
+                        SessionManager.unregister_span(span_name, span)
+                    except Exception:
+                        logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+                    SessionManager.pop_entity(entity_type)
+                    raise
+
+            # If result is streaming, defer span end to when stream completes
+            if _is_streaming_response(result):
+                return _wrap_streaming_response_with_span(span, result, span_name, entity_type)
+            if _is_async_generator(result):
+                return _wrap_async_generator_with_span(span, result, span_name, entity_type)
+            if _is_sync_generator(result):
+                return _wrap_sync_generator_with_span(span, result, span_name, entity_type)
+
+            # Non-streaming: finalize now
+            _add_output_attributes(span, result)
+            span.end()
+            try:
+                SessionManager.unregister_span(span_name, span)
+            except Exception:
+                logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+            SessionManager.pop_entity(entity_type)
+            return result
+
+        return cast(Callable[P, R], async_wrapper)
+
+    else:
+
+        @functools.wraps(func)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+            # Push entity before span starts so processors can capture it
+            SessionManager.push_entity(entity_type, span_name)
+
+            tracer = trace.get_tracer(module_name)
+            span = tracer.start_span(span_name)
+            # Register and activate span
+            try:
+                SessionManager.register_span(span_name, span)
+                SessionManager.set_current_span(span)
+            except Exception:
+                logger.exception("Failed to register span '%s' with SessionManager", span_name)
+
+            with trace.use_span(span, end_on_exit=False):
+                _add_span_attributes(span, func, args, kwargs, entity_type)
+                try:
+                    result = func(*args, **kwargs)
+                except Exception as e:
+                    span.set_attribute(f"{Config.LIBRARY_NAME}.entity.error", str(e))
+                    span.record_exception(e)
+                    span.end()
+                    try:
+                        SessionManager.unregister_span(span_name, span)
+                    except Exception:
+                        logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+                    SessionManager.pop_entity(entity_type)
+                    raise
+
+            # If result is streaming, defer span end to when stream completes
+            if _is_streaming_response(result):
+                return _wrap_streaming_response_with_span(span, result, span_name, entity_type)
+            if _is_async_generator(result):
+                return _wrap_async_generator_with_span(span, result, span_name, entity_type)  # type: ignore[arg-type]
+            if _is_sync_generator(result):
+                return _wrap_sync_generator_with_span(span, result, span_name, entity_type)  # type: ignore[arg-type]
+
+            # Non-streaming: finalize now
+            _add_output_attributes(span, result)
+            span.end()
+            try:
+                SessionManager.unregister_span(span_name, span)
+            except Exception:
+                logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
+            SessionManager.pop_entity(entity_type)
+            return result
+
+        return cast(Callable[P, R], sync_wrapper)
+
+
+def _wrap_class_methods(cls: C, entity_type: str, name: Optional[str] = None) -> C:
+    class_name = name if name is not None else cls.__name__
+    for attr_name in cls.__dict__:
+        attr = getattr(cls, attr_name)
+        if attr_name.startswith("_"):
+            continue
+        if callable(attr) and inspect.isfunction(attr):
+            method_span_name = f"{class_name}.{attr_name}"
+            wrapped_method = _create_function_wrapper(attr, entity_type, method_span_name)
+            setattr(cls, attr_name, wrapped_method)
+    return cls
+
+
+def workflow(
+    target: Union[Callable[P, R], C, None] = None, *, name: Optional[str] = None
+) -> Union[Callable[P, R], C, Callable[[Callable[P, R]], Callable[P, R]]]:
+    def decorator(obj: Union[Callable[P, R], C]) -> Union[Callable[P, R], C]:
+        if inspect.isclass(obj):
+            return _wrap_class_methods(cast(C, obj), "workflow", name)
+        else:
+            return _create_function_wrapper(cast(Callable[P, R], obj), "workflow", name)
+
+    if target is not None:
+        return decorator(target)
+    return decorator
+
+
+def agent(
+    target: Union[Callable[P, R], C, None] = None, *, name: Optional[str] = None
+) -> Union[Callable[P, R], C, Callable[[Callable[P, R]], Callable[P, R]]]:
+    def decorator(obj: Union[Callable[P, R], C]) -> Union[Callable[P, R], C]:
+        if inspect.isclass(obj):
+            return _wrap_class_methods(cast(C, obj), "agent", name)
+        else:
+            return _create_function_wrapper(cast(Callable[P, R], obj), "agent", name)
+
+    if target is not None:
+        return decorator(target)
+    return decorator
+
+
+def task(
+    target: Union[Callable[P, R], C, None] = None, *, name: Optional[str] = None
+) -> Union[Callable[P, R], C, Callable[[Callable[P, R]], Callable[P, R]]]:
+    def decorator(obj: Union[Callable[P, R], C]) -> Union[Callable[P, R], C]:
+        if inspect.isclass(obj):
+            return _wrap_class_methods(cast(C, obj), "task", name)
+        else:
+            # When obj is a function, it should be type Callable[P, R]
+            return _create_function_wrapper(cast(Callable[P, R], obj), "task", name)
+
+    if target is not None:
+        return decorator(target)
+    return decorator
+
+
+def span(
+    target: Union[Callable[P, R], C, None] = None, *, name: Optional[str] = None
+) -> Union[Callable[P, R], C, Callable[[Callable[P, R]], Callable[P, R]]]:
+    def decorator(obj: Union[Callable[P, R], C]) -> Union[Callable[P, R], C]:
+        if inspect.isclass(obj):
+            return _wrap_class_methods(cast(C, obj), "span", name)
+        else:
+            # When obj is a function, it should be type Callable[P, R]
+            return _create_function_wrapper(cast(Callable[P, R], obj), "span", name)
+
+    if target is not None:
+        return decorator(target)
+    return decorator

{netra_sdk-0.1.33 → netra_sdk-0.1.35}/netra/session_manager.py

@@ -31,6 +31,10 @@ class SessionManager:
     # Span registry: name -> stack of spans (most-recent last)
     _spans_by_name: Dict[str, List[trace.Span]] = {}
 
+    # Global stack of active spans in creation order (oldest first, newest last)
+    # Maintained for spans registered via SessionManager (e.g., SpanWrapper)
+    _active_spans: List[trace.Span] = []
+
     @classmethod
     def set_current_span(cls, span: Optional[trace.Span]) -> None:
         """
@@ -62,6 +66,8 @@ class SessionManager:
                 cls._spans_by_name[name] = [span]
             else:
                 stack.append(span)
+            # Track globally as active
+            cls._active_spans.append(span)
         except Exception:
             logger.exception("Failed to register span '%s'", name)
 
@@ -81,6 +87,11 @@ class SessionManager:
                     break
             if not stack:
                 cls._spans_by_name.pop(name, None)
+            # Also remove from global active list (remove last matching instance)
+            for i in range(len(cls._active_spans) - 1, -1, -1):
+                if cls._active_spans[i] is span:
+                    cls._active_spans.pop(i)
+                    break
         except Exception:
             logger.exception("Failed to unregister span '%s'", name)
 
@@ -240,12 +251,13 @@ class SessionManager:
     @classmethod
     def set_attribute_on_target_span(cls, attr_key: str, attr_value: Any, span_name: Optional[str] = None) -> None:
         """
-        Best-effort setter to annotate the active span with the provided attribute.
+        Best-effort setter to annotate a target span with the provided attribute.
 
-        If span_name is provided, we look up that span via SessionManager's registry and set
-        the attribute on that span explicitly. Otherwise, we annotate the active span.
-        We first try the OpenTelemetry current span; if that's invalid, we fall back to
-        the SDK-managed current span from `SessionManager`.
+        Behavior:
+        - If span_name is provided, set the attribute on the span registered with that name.
+        - If no span_name is provided, attempt to set the attribute on the SDK root span
+          (created when Netra.init(enable_root_span=True)). If the root span is unavailable,
+          fall back to the currently active span (OTel current span or SDK-managed current span).
         """
         try:
             # Convert attribute value to a JSON-safe string representation
@@ -268,10 +280,41 @@ class SessionManager:
                 target.set_attribute(attr_key, attr_str)
                 return
 
-            # Otherwise annotate the active span
+            # Otherwise, attempt to set on the root-most span in the current trace
+            candidate = None
+
+            # Determine current trace_id from the active/current span
             current_span = trace.get_current_span()
             has_valid_current = getattr(current_span, "is_recording", None) is not None and current_span.is_recording()
-            candidate = current_span if has_valid_current else cls.get_current_span()
+            base_span = current_span if has_valid_current else cls.get_current_span()
+            trace_id: Optional[int] = None
+            try:
+                if base_span is not None and hasattr(base_span, "get_span_context"):
+                    sc = base_span.get_span_context()
+                    trace_id = getattr(sc, "trace_id", None)
+            except Exception:
+                trace_id = None
+
+            # Find the earliest active span in this process that belongs to the same trace
+            if trace_id is not None:
+                try:
+                    for s in cls._active_spans:
+                        if s is None:
+                            continue
+                        if not getattr(s, "is_recording", lambda: False)():
+                            continue
+                        sc = getattr(s, "get_span_context", lambda: None)()
+                        if sc is None:
+                            continue
+                        if getattr(sc, "trace_id", None) == trace_id:
+                            candidate = s
+                            break
+                except Exception:
+                    candidate = None
+
+            # Fallback to the current active span if no root-most could be found
+            if candidate is None:
+                candidate = base_span
             if candidate is None:
                 logger.debug("No active span found to set attribute %s", attr_key)
                 return

{netra_sdk-0.1.33 → netra_sdk-0.1.35}/netra/tracer.py

@@ -62,19 +62,40 @@ class FilteringSpanExporter(SpanExporter):  # type: ignore[misc]
             if name is None:
                 filtered.append(s)
                 continue
-            if name in self._exact:
-                continue
-            blocked = False
-            for pref in self._prefixes:
-                if name.startswith(pref):
-                    blocked = True
-                    break
-            if not blocked and self._suffixes:
-                for suf in self._suffixes:
-                    if name.endswith(suf):
+            # Only apply blocked span patterns to root-level spans (no valid parent)
+            parent = getattr(s, "parent", None)
+            # Determine if the span has a valid parent. SpanContext.is_valid may be a property or method.
+            has_valid_parent = False
+            if parent is not None:
+                is_valid_attr = getattr(parent, "is_valid", None)
+                if callable(is_valid_attr):
+                    try:
+                        has_valid_parent = bool(is_valid_attr())
+                    except Exception:
+                        has_valid_parent = False
+                else:
+                    has_valid_parent = bool(is_valid_attr)
+
+            is_root_span = parent is None or not has_valid_parent
+
+            if is_root_span:
+                # Apply name-based blocking only for root spans
+                if name in self._exact:
+                    continue
+                blocked = False
+                for pref in self._prefixes:
+                    if name.startswith(pref):
                         blocked = True
                         break
-            if not blocked:
+                if not blocked and self._suffixes:
+                    for suf in self._suffixes:
+                        if name.endswith(suf):
+                            blocked = True
+                            break
+                if not blocked:
+                    filtered.append(s)
+            else:
+                # Do not block child spans based on name
                 filtered.append(s)
         if not filtered:
             return SpanExportResult.SUCCESS

netra_sdk-0.1.35/netra/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.35"

{netra_sdk-0.1.33 → netra_sdk-0.1.35}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "netra-sdk"
-version = "0.1.33"
+version = "0.1.35"
 description = "A Python SDK for AI application observability that provides OpenTelemetry-based monitoring, tracing, and PII protection for LLM and vector database applications. Enables easy instrumentation, session tracking, and privacy-focused data collection for AI systems in production environments."
 authors = [
     {name = "Sooraj Thomas",email = "sooraj@keyvalue.systems"}

netra_sdk-0.1.33/netra/decorators.py

@@ -1,218 +0,0 @@
-"""Netra decorator utilities.
-
-This module provides decorators for common patterns in Netra SDK.
-Decorators can be applied to both functions and classes.
-"""
-
-import functools
-import inspect
-import json
-import logging
-from typing import Any, Awaitable, Callable, Dict, Optional, ParamSpec, Tuple, TypeVar, Union, cast
-
-from opentelemetry import trace
-
-from .config import Config
-from .session_manager import SessionManager
-
-logger = logging.getLogger(__name__)
-
-P = ParamSpec("P")
-R = TypeVar("R")
-
-F_Callable = TypeVar("F_Callable", bound=Callable[..., Any])
-C = TypeVar("C", bound=type)
-
-
-def _serialize_value(value: Any) -> str:
-    """Safely serialize a value to string for span attributes."""
-    try:
-        if isinstance(value, (str, int, float, bool, type(None))):
-            return str(value)
-        elif isinstance(value, (list, dict, tuple)):
-            return json.dumps(value, default=str)[:1000]  # Limit size
-        else:
-            return str(value)[:1000]  # Limit size
-    except Exception:
-        return str(type(value).__name__)
-
-
-def _add_span_attributes(
-    span: trace.Span, func: Callable[..., Any], args: Tuple[Any, ...], kwargs: Dict[str, Any], entity_type: str
-) -> None:
-    """Helper function to add span attributes from function parameters."""
-    span.set_attribute(f"{Config.LIBRARY_NAME}.entity.type", entity_type)
-
-    try:
-        sig = inspect.signature(func)
-        param_names = list(sig.parameters.keys())
-        input_data = {}
-
-        for i, arg in enumerate(args):
-            if i < len(param_names):
-                param_name = param_names[i]
-                if param_name not in ("self", "cls"):
-                    input_data[param_name] = _serialize_value(arg)
-
-        for key, value in kwargs.items():
-            input_data[key] = _serialize_value(value)
-
-        if input_data:
-            span.set_attribute(f"{Config.LIBRARY_NAME}.entity.input", json.dumps(input_data))
-
-    except Exception as e:
-        span.set_attribute(f"{Config.LIBRARY_NAME}.input_error", str(e))
-
-
-def _add_output_attributes(span: trace.Span, result: Any) -> None:
-    """Helper function to add output attributes to span."""
-    try:
-        serialized_output = _serialize_value(result)
-        span.set_attribute(f"{Config.LIBRARY_NAME}.entity.output", serialized_output)
-    except Exception as e:
-        span.set_attribute(f"{Config.LIBRARY_NAME}.entity.output_error", str(e))
-
-
-def _create_function_wrapper(func: Callable[P, R], entity_type: str, name: Optional[str] = None) -> Callable[P, R]:
-    module_name = func.__name__
-    is_async = inspect.iscoroutinefunction(func)
-    span_name = name if name is not None else func.__name__
-
-    if is_async:
-
-        @functools.wraps(func)
-        async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
-            # Push entity to stack before span starts so SessionSpanProcessor can capture it
-            SessionManager.push_entity(entity_type, span_name)
-
-            tracer = trace.get_tracer(module_name)
-            with tracer.start_as_current_span(span_name) as span:
-                # Register the span by name for cross-context attribute setting
-                try:
-                    SessionManager.register_span(span_name, span)
-                    SessionManager.set_current_span(span)
-                except Exception:
-                    logger.exception("Failed to register span '%s' with SessionManager", span_name)
-
-                _add_span_attributes(span, func, args, kwargs, entity_type)
-                try:
-                    result = await cast(Awaitable[Any], func(*args, **kwargs))
-                    _add_output_attributes(span, result)
-                    return result
-                except Exception as e:
-                    span.set_attribute(f"{Config.LIBRARY_NAME}.entity.error", str(e))
-                    raise
-                finally:
-                    # Unregister and pop entity from stack after function call is done
-                    try:
-                        SessionManager.unregister_span(span_name, span)
-                    except Exception:
-                        logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
-                    SessionManager.pop_entity(entity_type)
-
-        return cast(Callable[P, R], async_wrapper)
-
-    else:
-
-        @functools.wraps(func)
-        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
-            # Push entity to stack before span starts so SessionSpanProcessor can capture it
-            SessionManager.push_entity(entity_type, span_name)
-
-            tracer = trace.get_tracer(module_name)
-            with tracer.start_as_current_span(span_name) as span:
-                # Register the span by name for cross-context attribute setting
-                try:
-                    SessionManager.register_span(span_name, span)
-                    SessionManager.set_current_span(span)
-                except Exception:
-                    logger.exception("Failed to register span '%s' with SessionManager", span_name)
-
-                _add_span_attributes(span, func, args, kwargs, entity_type)
-                try:
-                    result = func(*args, **kwargs)
-                    _add_output_attributes(span, result)
-                    return result
-                except Exception as e:
-                    span.set_attribute(f"{Config.LIBRARY_NAME}.entity.error", str(e))
-                    raise
-                finally:
-                    # Unregister and pop entity from stack after function call is done
-                    try:
-                        SessionManager.unregister_span(span_name, span)
-                    except Exception:
-                        logger.exception("Failed to unregister span '%s' from SessionManager", span_name)
-                    SessionManager.pop_entity(entity_type)
-
-        return cast(Callable[P, R], sync_wrapper)
-
-
-def _wrap_class_methods(cls: C, entity_type: str, name: Optional[str] = None) -> C:
-    class_name = name if name is not None else cls.__name__
-    for attr_name in cls.__dict__:
-        attr = getattr(cls, attr_name)
-        if attr_name.startswith("_"):
-            continue
-        if callable(attr) and inspect.isfunction(attr):
-            method_span_name = f"{class_name}.{attr_name}"
-            wrapped_method = _create_function_wrapper(attr, entity_type, method_span_name)
-            setattr(cls, attr_name, wrapped_method)
-    return cls
-
-
-def workflow(
-    target: Union[Callable[P, R], C, None] = None, *, name: Optional[str] = None
-) -> Union[Callable[P, R], C, Callable[[Callable[P, R]], Callable[P, R]]]:
-    def decorator(obj: Union[Callable[P, R], C]) -> Union[Callable[P, R], C]:
-        if inspect.isclass(obj):
-            return _wrap_class_methods(cast(C, obj), "workflow", name)
-        else:
-            return _create_function_wrapper(cast(Callable[P, R], obj), "workflow", name)
-
-    if target is not None:
-        return decorator(target)
-    return decorator
-
-
-def agent(
-    target: Union[Callable[P, R], C, None] = None, *, name: Optional[str] = None
-) -> Union[Callable[P, R], C, Callable[[Callable[P, R]], Callable[P, R]]]:
-    def decorator(obj: Union[Callable[P, R], C]) -> Union[Callable[P, R], C]:
-        if inspect.isclass(obj):
-            return _wrap_class_methods(cast(C, obj), "agent", name)
-        else:
-            return _create_function_wrapper(cast(Callable[P, R], obj), "agent", name)
-
-    if target is not None:
-        return decorator(target)
-    return decorator
-
-
-def task(
-    target: Union[Callable[P, R], C, None] = None, *, name: Optional[str] = None
-) -> Union[Callable[P, R], C, Callable[[Callable[P, R]], Callable[P, R]]]:
-    def decorator(obj: Union[Callable[P, R], C]) -> Union[Callable[P, R], C]:
-        if inspect.isclass(obj):
-            return _wrap_class_methods(cast(C, obj), "task", name)
-        else:
-            # When obj is a function, it should be type Callable[P, R]
-            return _create_function_wrapper(cast(Callable[P, R], obj), "task", name)
-
-    if target is not None:
-        return decorator(target)
-    return decorator
-
-
-def span(
-    target: Union[Callable[P, R], C, None] = None, *, name: Optional[str] = None
-) -> Union[Callable[P, R], C, Callable[[Callable[P, R]], Callable[P, R]]]:
-    def decorator(obj: Union[Callable[P, R], C]) -> Union[Callable[P, R], C]:
-        if inspect.isclass(obj):
-            return _wrap_class_methods(cast(C, obj), "span", name)
-        else:
-            # When obj is a function, it should be type Callable[P, R]
-            return _create_function_wrapper(cast(Callable[P, R], obj), "span", name)
-
-    if target is not None:
-        return decorator(target)
-    return decorator

netra_sdk-0.1.33/netra/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.33"