netra-sdk 0.1.45__py3-none-any.whl → 0.1.46__py3-none-any.whl

netra/__init__.py

@@ -1,7 +1,7 @@
 import atexit
 import logging
 import threading
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Dict, List, Literal, Optional, Set
 
 from opentelemetry import context as context_api
 from opentelemetry import trace
@@ -14,7 +14,7 @@ from .config import Config
 # Instrumentor functions
 from .instrumentation import init_instrumentations
 from .session_manager import ConversationType, SessionManager
-from .span_wrapper import ActionModel, SpanWrapper, UsageModel
+from .span_wrapper import ActionModel, SpanType, SpanWrapper, UsageModel
 from .tracer import Tracer
 
 # Package-level logger. Attach NullHandler by default so library does not emit logs
@@ -263,11 +263,12 @@ class Netra:
         name: str,
         attributes: Optional[Dict[str, str]] = None,
         module_name: str = "combat_sdk",
+        as_type: Optional[SpanType] = SpanType.SPAN,
     ) -> SpanWrapper:
         """
         Start a new session.
         """
-        return SpanWrapper(name, attributes, module_name)
+        return SpanWrapper(name, attributes, module_name, as_type=as_type)
 
 
-__all__ = ["Netra", "UsageModel", "ActionModel"]
+__all__ = ["Netra", "UsageModel", "ActionModel", "SpanType"]

netra/config.py

@@ -30,7 +30,7 @@ class Config:
     # Maximum length for any attribute value (strings and bytes). Processors should honor this.
     ATTRIBUTE_MAX_LEN = 2000
     # Maximum length specifically for conversation entry content (strings or JSON when serialized)
-    CONVERSATION_CONTENT_MAX_LEN = 1000
+    CONVERSATION_CONTENT_MAX_LEN = 2000
 
     def __init__(
         self,

netra/decorators.py

@@ -33,6 +33,7 @@ from opentelemetry import trace
 
 from .config import Config
 from .session_manager import SessionManager
+from .span_wrapper import SpanType
 
 logger = logging.getLogger(__name__)
 
@@ -262,7 +263,12 @@ def _wrap_streaming_response_with_span(
     return resp
 
 
-def _create_function_wrapper(func: Callable[P, R], entity_type: str, name: Optional[str] = None) -> Callable[P, R]:
+def _create_function_wrapper(
+    func: Callable[P, R],
+    entity_type: str,
+    name: Optional[str] = None,
+    as_type: Optional[SpanType] = SpanType.SPAN,
+) -> Callable[P, R]:
     module_name = func.__name__
     is_async = inspect.iscoroutinefunction(func)
     span_name = name if name is not None else func.__name__
@@ -276,6 +282,14 @@ def _create_function_wrapper(func: Callable[P, R], entity_type: str, name: Optio
 
             tracer = trace.get_tracer(module_name)
             span = tracer.start_span(span_name)
+            # Set span type if provided
+
+            if not isinstance(as_type, SpanType):
+                raise ValueError(f"Invalid span type: {as_type}")
+            try:
+                span.set_attribute("netra.span.type", as_type.value)
+            except Exception:
+                pass
             # Register and activate span
             try:
                 SessionManager.register_span(span_name, span)
@@ -327,6 +341,14 @@ def _create_function_wrapper(func: Callable[P, R], entity_type: str, name: Optio
 
             tracer = trace.get_tracer(module_name)
             span = tracer.start_span(span_name)
+            # Set span type if provided
+            if as_type is not None:
+                if not isinstance(as_type, SpanType):
+                    raise ValueError(f"Invalid span type: {as_type}")
+                try:
+                    span.set_attribute("netra.span.type", as_type.value)
+                except Exception:
+                    pass
             # Register and activate span
             try:
                 SessionManager.register_span(span_name, span)
@@ -370,7 +392,12 @@ def _create_function_wrapper(func: Callable[P, R], entity_type: str, name: Optio
         return cast(Callable[P, R], sync_wrapper)
 
 
-def _wrap_class_methods(cls: C, entity_type: str, name: Optional[str] = None) -> C:
+def _wrap_class_methods(
+    cls: C,
+    entity_type: str,
+    name: Optional[str] = None,
+    as_type: Optional[SpanType] = SpanType.SPAN,
+) -> C:
     class_name = name if name is not None else cls.__name__
     for attr_name in cls.__dict__:
         attr = getattr(cls, attr_name)
@@ -378,7 +405,7 @@ def _wrap_class_methods(cls: C, entity_type: str, name: Optional[str] = None) ->
             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)
+            wrapped_method = _create_function_wrapper(attr, entity_type, method_span_name, as_type=as_type)
             setattr(cls, attr_name, wrapped_method)
     return cls
 
@@ -416,10 +443,10 @@ def task(
 ) -> 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)
+            return _wrap_class_methods(cast(C, obj), "task", name, as_type=SpanType.TOOL)
         else:
             # When obj is a function, it should be type Callable[P, R]
-            return _create_function_wrapper(cast(Callable[P, R], obj), "task", name)
+            return _create_function_wrapper(cast(Callable[P, R], obj), "task", name, as_type=SpanType.TOOL)
 
     if target is not None:
         return decorator(target)
@@ -427,14 +454,17 @@ def task(
 
 
 def span(
-    target: Union[Callable[P, R], C, None] = None, *, name: Optional[str] = None
+    target: Union[Callable[P, R], C, None] = None,
+    *,
+    name: Optional[str] = None,
+    as_type: Optional[SpanType] = SpanType.SPAN,
 ) -> 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)
+            return _wrap_class_methods(cast(C, obj), "span", name, as_type=as_type)
         else:
             # When obj is a function, it should be type Callable[P, R]
-            return _create_function_wrapper(cast(Callable[P, R], obj), "span", name)
+            return _create_function_wrapper(cast(Callable[P, R], obj), "span", name, as_type=as_type)
 
     if target is not None:
         return decorator(target)

netra/processors/instrumentation_span_processor.py

@@ -74,9 +74,6 @@ class InstrumentationSpanProcessor(SpanProcessor):  # type: ignore[misc]
                     truncated = self._truncate_value(value)
                     # Forward to original
                     original_set_attribute(key, truncated)
-                    # Special rule: if model key set, mark span as llm
-                    if key == "gen_ai.request.model":
-                        original_set_attribute(f"{Config.LIBRARY_NAME}.span.type", "llm")
                 except Exception:
                     # Best-effort; never break span
                     try:

netra/session_manager.py

@@ -275,20 +275,27 @@ class SessionManager:
 
         # Hard runtime validation of input types and values
         if not isinstance(conversation_type, ConversationType):
-            raise TypeError("conversation_type must be a ConversationType enum value (input, output, system)")
+            logger.error(
+                "add_conversation: conversation_type must be a ConversationType enum value (input, output, system)"
+            )
+            return
         normalized_type = conversation_type.value
 
         if not isinstance(role, str):
-            raise TypeError(f"role must be a string, got {type(role)}")
+            logger.error("add_conversation: role must be a string")
+            return
 
         if not isinstance(content, (str, dict)):
-            raise TypeError(f"content must be a string or dict, got {type(content)}")
+            logger.error("add_conversation: content must be a string or dict")
+            return
 
         if not role:
-            raise ValueError("role must be a non-empty string")
+            logger.error("add_conversation: role must be a non-empty string")
+            return
 
         if not content:
-            raise ValueError("content must not be empty")
+            logger.error("add_conversation: content must not be empty")
+            return
 
         try:
 

netra/span_wrapper.py

@@ -2,6 +2,7 @@ import json
 import logging
 import time
 from datetime import datetime
+from enum import Enum
 from typing import Any, Dict, List, Literal, Optional
 
 from opentelemetry import baggage
@@ -49,6 +50,13 @@ class ATTRIBUTE:
     ACTION = "action"
 
 
+class SpanType(str, Enum):
+    SPAN = "SPAN"
+    GENERATION = "GENERATION"
+    TOOL = "TOOL"
+    EMBEDDING = "EMBEDDING"
+
+
 class SpanWrapper:
     """
     Context manager for tracking observability data for external API calls.
@@ -63,9 +71,16 @@ class SpanWrapper:
             span.set_usage(usage_data)
     """
 
-    def __init__(self, name: str, attributes: Optional[Dict[str, str]] = None, module_name: str = "combat_sdk"):
+    def __init__(
+        self,
+        name: str,
+        attributes: Optional[Dict[str, str]] = None,
+        module_name: str = "combat_sdk",
+        as_type: Optional[SpanType] = SpanType.SPAN,
+    ):
         self.name = name
         self.attributes = attributes or {}
+
         self.start_time: Optional[float] = None
         self.end_time: Optional[float] = None
         self.status = "pending"
@@ -80,6 +95,11 @@ class SpanWrapper:
         # Token for locally attached baggage (if any)
         self._local_block_token: Optional[object] = None
 
+        if isinstance(as_type, SpanType):
+            self.attributes["netra.span.type"] = as_type.value
+        else:
+            raise ValueError(f"Invalid span type: {as_type}")
+
     def __enter__(self) -> "SpanWrapper":
         """Start the span wrapper, begin time tracking, and create OpenTelemetry span."""
         self.start_time = time.time()

netra/version.py

@@ -1 +1 @@
-__version__ = "0.1.45"
+__version__ = "0.1.46"

{netra_sdk-0.1.45.dist-info → netra_sdk-0.1.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netra-sdk
-Version: 0.1.45
+Version: 0.1.46
 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-Expression: Apache-2.0
 License-File: LICENCE

{netra_sdk-0.1.45.dist-info → netra_sdk-0.1.46.dist-info}/RECORD

@@ -1,10 +1,10 @@
-netra/__init__.py,sha256=-eEBq3ndX3JAWDo4_Ra0L19KrTfrJhNDjlAwChb3_IA,10353
+netra/__init__.py,sha256=tbj0UsUHKMG8RHJ58Y0tCvPVDS_XkGb7sF_xM1lxJEY,10454
 netra/anonymizer/__init__.py,sha256=KeGPPZqKVZbtkbirEKYTYhj6aZHlakjdQhD7QHqBRio,133
 netra/anonymizer/anonymizer.py,sha256=IcrYkdwWrFauGWUeAW-0RwrSUM8VSZCFNtoywZhvIqU,3778
 netra/anonymizer/base.py,sha256=ytPxHCUD2OXlEY6fNTuMmwImNdIjgj294I41FIgoXpU,5946
 netra/anonymizer/fp_anonymizer.py,sha256=_6svIYmE0eejdIMkhKBUWCNjGtGimtrGtbLvPSOp8W4,6493
-netra/config.py,sha256=MMSAKrX_HCZ7QECjTocs_jsNFgcOnbP8aAVfOdq9YEs,7032
-netra/decorators.py,sha256=qZFHrwdj10FsTFqggo3XjdGB12aMxsrrDMMmslDqZ-0,17424
+netra/config.py,sha256=RqLul2vlNHHKGU31OQIJTUpcKMSmVse9IlGFwImW6sE,7032
+netra/decorators.py,sha256=NHJZeZo3LEuOxCz-lfz3j74o6CS0jS8JBRw2LvoeeWE,18389
 netra/exceptions/__init__.py,sha256=uDgcBxmC4WhdS7HRYQk_TtJyxH1s1o6wZmcsnSHLAcM,174
 netra/exceptions/injection.py,sha256=ke4eUXRYUFJkMZgdSyPPkPt5PdxToTI6xLEBI0hTWUQ,1332
 netra/exceptions/pii.py,sha256=MT4p_x-zH3VtYudTSxw1Z9qQZADJDspq64WrYqSWlZc,2438
@@ -43,17 +43,17 @@ netra/instrumentation/weaviate/__init__.py,sha256=EOlpWxobOLHYKqo_kMct_7nu26x1hr
 netra/instrumentation/weaviate/version.py,sha256=PiCZHjonujPbnIn0KmD3Yl68hrjPRG_oKe5vJF3mmG8,24
 netra/pii.py,sha256=Rn4SjgTJW_aw9LcbjLuMqF3fKd9b1ndlYt1CaK51Ge0,33125
 netra/processors/__init__.py,sha256=56RO7xMoBx2aoVuESyQXll65o7IoO98nSHZ5KpR5iQk,471
-netra/processors/instrumentation_span_processor.py,sha256=VzurzwtGleFltxzKD_gjVkUQiRC6SGlb0oG4Nlpu85A,4365
+netra/processors/instrumentation_span_processor.py,sha256=7iDnJUSBXyiRcWxoxk3uStoh0r4Yxjh7PBTbFDVMjlA,4150
 netra/processors/local_filtering_span_processor.py,sha256=Vk_UP--ZxWwdrbJA7a95iRo853QfPCME2C5ChgjiHl8,6664
 netra/processors/scrubbing_span_processor.py,sha256=dJ86Ncmjvmrhm_uAdGTwcGvRpZbVVWqD9AOFwEMWHZY,6701
 netra/processors/session_span_processor.py,sha256=qcsBl-LnILWefsftI8NQhXDGb94OWPc8LvzhVA0JS_c,2432
 netra/scanner.py,sha256=kyDpeZiscCPb6pjuhS-sfsVj-dviBFRepdUWh0sLoEY,11554
-netra/session_manager.py,sha256=VzmSAiP63ODCuOWv-irsxyU2LvHoqjOBUuXtyxboBU0,13740
-netra/span_wrapper.py,sha256=3xzZs44s85KiB81WXjAJmfQcH_aPMxCuQ_1xjDVGtwE,9682
+netra/session_manager.py,sha256=jxA62zAgiTsuTyV_UuPkVb2W1Uieb7I5jWsYiJ6jSxk,13897
+netra/span_wrapper.py,sha256=80-0MkAw7AOQg0u7dj2YfXfnuUQDE8ymsGNzh6y6JtA,10102
 netra/tracer.py,sha256=IPVYMc4x74XZJeKvCfV6b0X9mUHGvsssUzLnRvFPV6M,4629
 netra/utils.py,sha256=FblSzI8qMTfEbusakGBKE9CNELW0GEBHl09mPPxgI-w,2521
-netra/version.py,sha256=G1Bw5SEeRoSlHVxmFKf6PIpK38SHTYTFhSFGm9d8YQM,23
-netra_sdk-0.1.45.dist-info/METADATA,sha256=UbtkH3HwIO59lD3lo1TACHzHWMFWTNXquAaRputrOV4,28208
-netra_sdk-0.1.45.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-netra_sdk-0.1.45.dist-info/licenses/LICENCE,sha256=8B_UoZ-BAl0AqiHAHUETCgd3I2B9yYJ1WEQtVb_qFMA,11359
-netra_sdk-0.1.45.dist-info/RECORD,,
+netra/version.py,sha256=X3e_85I7oZGwZD8nW9SBKEUbQU7-_3W9FXuicrfxHjc,23
+netra_sdk-0.1.46.dist-info/METADATA,sha256=QWfOewRPrRyNlamWqdvuS-1U01UocBvxcRZQ_H6Qmvw,28208
+netra_sdk-0.1.46.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+netra_sdk-0.1.46.dist-info/licenses/LICENCE,sha256=8B_UoZ-BAl0AqiHAHUETCgd3I2B9yYJ1WEQtVb_qFMA,11359
+netra_sdk-0.1.46.dist-info/RECORD,,