netra-sdk 0.1.45__py3-none-any.whl → 0.1.47__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
@@ -183,11 +183,12 @@ class Netra:
             session_id: Session identifier
         """
         if not isinstance(session_id, str):
-            raise TypeError(f"session_id must be a string, got {type(session_id)}")
+            logger.error(f"set_session_id: session_id must be a string, got {type(session_id)}")
+            return
         if session_id:
             SessionManager.set_session_context("session_id", session_id)
         else:
-            logger.warning("Session ID must be provided for setting session_id.")
+            logger.warning("set_session_id: Session ID must be provided for setting session_id.")
 
     @classmethod
     def set_user_id(cls, user_id: str) -> None:
@@ -198,11 +199,12 @@ class Netra:
             user_id: User identifier
         """
         if not isinstance(user_id, str):
-            raise TypeError(f"user_id must be a string, got {type(user_id)}")
+            logger.error(f"set_user_id: user_id must be a string, got {type(user_id)}")
+            return
         if user_id:
             SessionManager.set_session_context("user_id", user_id)
         else:
-            logger.warning("User ID must be provided for setting user_id.")
+            logger.warning("set_user_id: User ID must be provided for setting user_id.")
 
     @classmethod
     def set_tenant_id(cls, tenant_id: str) -> None:
@@ -213,11 +215,12 @@ class Netra:
             user_account_id: User account identifier
         """
         if not isinstance(tenant_id, str):
-            raise TypeError(f"tenant_id must be a string, got {type(tenant_id)}")
+            logger.error(f"set_tenant_id: tenant_id must be a string, got {type(tenant_id)}")
+            return
         if tenant_id:
             SessionManager.set_session_context("tenant_id", tenant_id)
         else:
-            logger.warning("Tenant ID must be provided for setting tenant_id.")
+            logger.warning("set_tenant_id: Tenant ID must be provided for setting tenant_id.")
 
     @classmethod
     def set_custom_attributes(cls, key: str, value: Any) -> None:
@@ -263,11 +266,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,15 @@ 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):
+                logger.error("Invalid span type: %s", as_type)
+                return
+            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 +342,15 @@ 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):
+                    logger.error("Invalid span type: %s", as_type)
+                    return
+                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 +394,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 +407,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 +445,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 +456,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,12 @@ 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:
+            logger.error("Invalid span type: %s", as_type)
+            return
+
     def __enter__(self) -> "SpanWrapper":
         """Start the span wrapper, begin time tracking, and create OpenTelemetry span."""
         self.start_time = time.time()

netra/tracer.py

@@ -5,10 +5,12 @@ including exporter setup and span processor configuration.
 """
 
 import logging
+import threading
 from typing import Any, Dict
 
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk import trace as sdk_trace
 from opentelemetry.sdk.resources import DEPLOYMENT_ENVIRONMENT, SERVICE_NAME, Resource
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import (
@@ -22,6 +24,8 @@ from netra.exporters import FilteringSpanExporter
 
 logger = logging.getLogger(__name__)
 
+_provider_install_lock = threading.Lock()
+
 
 class Tracer:
     """
@@ -55,57 +59,66 @@ class Tracer:
         resource = Resource(attributes=resource_attrs)
 
         # Build TracerProvider
-        provider = TracerProvider(resource=resource)
-
-        # Configure exporter based on configuration
-        if not self.cfg.otlp_endpoint:
-            logger.warning("OTLP endpoint not provided, falling back to console exporter")
-            exporter = ConsoleSpanExporter()
+        current_provider = trace.get_tracer_provider()
+        if isinstance(current_provider, sdk_trace.TracerProvider):
+            provider = current_provider
+            logger.info("Reusing existing TracerProvider. Possible loss of Resource attributes")
         else:
-            exporter = OTLPSpanExporter(
-                endpoint=self._format_endpoint(self.cfg.otlp_endpoint),
-                headers=self.cfg.headers,
+            provider = TracerProvider(resource=resource)
+            trace.set_tracer_provider(provider)
+            logger.info("Using Netra TracerProvider")
+
+        with _provider_install_lock:
+            if getattr(provider, "_netra_processors_installed", False):
+                logger.info("Netra processors already installed on provider; skipping setup")
+                return
+
+            if not self.cfg.otlp_endpoint:
+                logger.warning("OTLP endpoint not provided, falling back to console exporter")
+                exporter = ConsoleSpanExporter()
+            else:
+                exporter = OTLPSpanExporter(
+                    endpoint=self._format_endpoint(self.cfg.otlp_endpoint),
+                    headers=self.cfg.headers,
+                )
+            original_exporter = exporter
+            try:
+                patterns = getattr(self.cfg, "blocked_spans", None) or []
+                exporter = FilteringSpanExporter(exporter, patterns)
+                if patterns:
+                    logger.info("Enabled FilteringSpanExporter with %d global pattern(s)", len(patterns))
+                else:
+                    logger.info("Enabled FilteringSpanExporter with local-only rules")
+            except (ValueError, TypeError) as e:
+                logger.warning("Failed to enable FilteringSpanExporter: %s; using unwrapped exporter", e)
+                exporter = original_exporter
+
+            from netra.processors import (
+                InstrumentationSpanProcessor,
+                LocalFilteringSpanProcessor,
+                ScrubbingSpanProcessor,
+                SessionSpanProcessor,
             )
-        # Wrap exporter with filtering to support both global and local (baggage-based) rules
-        try:
-            patterns = getattr(self.cfg, "blocked_spans", None) or []
-            exporter = FilteringSpanExporter(exporter, patterns)
-            if patterns:
-                logger.info("Enabled FilteringSpanExporter with %d global pattern(s)", len(patterns))
+
+            provider.add_span_processor(LocalFilteringSpanProcessor())
+            provider.add_span_processor(InstrumentationSpanProcessor())
+            provider.add_span_processor(SessionSpanProcessor())
+
+            if self.cfg.enable_scrubbing:
+                provider.add_span_processor(ScrubbingSpanProcessor())  # type: ignore[no-untyped-call]
+
+            if self.cfg.disable_batch:
+                provider.add_span_processor(SimpleSpanProcessor(exporter))
             else:
-                logger.info("Enabled FilteringSpanExporter with local-only rules")
-        except Exception as e:
-            logger.warning("Failed to enable FilteringSpanExporter: %s", e)
-        # Add span processors: first instrumentation wrapper, then session processor
-        from netra.processors import (
-            InstrumentationSpanProcessor,
-            LocalFilteringSpanProcessor,
-            ScrubbingSpanProcessor,
-            SessionSpanProcessor,
-        )
-
-        # Apply local filtering propagation first so later processors and spans see attributes
-        provider.add_span_processor(LocalFilteringSpanProcessor())
-        provider.add_span_processor(InstrumentationSpanProcessor())
-        provider.add_span_processor(SessionSpanProcessor())
-
-        # Add scrubbing processor if enabled
-        if self.cfg.enable_scrubbing:
-            provider.add_span_processor(ScrubbingSpanProcessor())  # type: ignore[no-untyped-call]
-
-        # Install appropriate span processor
-        if self.cfg.disable_batch:
-            provider.add_span_processor(SimpleSpanProcessor(exporter))
-        else:
-            provider.add_span_processor(BatchSpanProcessor(exporter))
-
-        # Set global tracer provider
-        trace.set_tracer_provider(provider)
-        logger.info(
-            "Netra TracerProvider initialized: endpoint=%s, disable_batch=%s",
-            self.cfg.otlp_endpoint,
-            self.cfg.disable_batch,
-        )
+                provider.add_span_processor(BatchSpanProcessor(exporter))
+
+            setattr(provider, "_netra_processors_installed", True)
+
+            logger.info(
+                "Netra initialized: endpoint=%s, disable_batch=%s",
+                self.cfg.otlp_endpoint,
+                self.cfg.disable_batch,
+            )
 
     def _format_endpoint(self, endpoint: str) -> str:
         """Format the OTLP endpoint URL to ensure it ends with '/v1/traces'.

netra/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netra-sdk
-Version: 0.1.45
+Version: 0.1.47
 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.47.dist-info}/RECORD

@@ -1,10 +1,10 @@
-netra/__init__.py,sha256=-eEBq3ndX3JAWDo4_Ra0L19KrTfrJhNDjlAwChb3_IA,10353
+netra/__init__.py,sha256=vH9J2iPKtx8j9-dWhDroUqRq10qfqHaBurMl11c4g6Q,10590
 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=b6cNRJVUvroGv97NVE-psMZzL-Upl0X2m63_l_-VBdQ,18433
 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/tracer.py,sha256=IPVYMc4x74XZJeKvCfV6b0X9mUHGvsssUzLnRvFPV6M,4629
+netra/session_manager.py,sha256=jxA62zAgiTsuTyV_UuPkVb2W1Uieb7I5jWsYiJ6jSxk,13897
+netra/span_wrapper.py,sha256=x5ejtMwD40eMRbeYOfsE2GQGrqZcjZz_sZOuLIeZ__8,10118
+netra/tracer.py,sha256=BXlEEOQ7ou5zd2Bf5cUFp6vLoMJLgBywtxfUBr9Di-Q,5175
 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=BqdH88p7_x5NtwJCtqUPLKt1fAJF1mVKUoKH7vlX5dQ,23
+netra_sdk-0.1.47.dist-info/METADATA,sha256=JbzzZzE-IzVy2h8fNa0QT5doUkjgpvJXHgnxf44zj0Y,28208
+netra_sdk-0.1.47.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+netra_sdk-0.1.47.dist-info/licenses/LICENCE,sha256=8B_UoZ-BAl0AqiHAHUETCgd3I2B9yYJ1WEQtVb_qFMA,11359
+netra_sdk-0.1.47.dist-info/RECORD,,