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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: netra-sdk
-Version: 0.1.30
+Version: 0.1.33
 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
@@ -72,7 +72,7 @@ Requires-Dist: presidio-anonymizer (==2.2.358) ; extra == "presidio"
 Requires-Dist: stanza (>=1.10.1,<2.0.0) ; extra == "presidio"
 Requires-Dist: traceloop-sdk (>=0.40.7,<0.43.0)
 Requires-Dist: transformers (==4.51.3) ; extra == "presidio"
-Project-URL: Bug Tracker, https://github.com/KeyValueSoftwareSystems/netra-sdk-py/issues
+Project-URL: Changelog, https://github.com/KeyValueSoftwareSystems/netra-sdk-py/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://github.com/KeyValueSoftwareSystems/netra-sdk-py/blob/main/README.md
 Project-URL: Homepage, https://github.com/KeyValueSoftwareSystems/netra-sdk-py
 Project-URL: Repository, https://github.com/KeyValueSoftwareSystems/netra-sdk-py
@@ -303,6 +303,7 @@ async def async_span(data):
 - **CrewAI** - Multi-agent AI systems
 - **Pydantic AI** - AI model communication standard
 - **MCP (Model Context Protocol)** - AI model communication standard
+- **LiteLLM** - LLM provider agnostic client
 
 ## 🛡️ Privacy Protection & Security
 

{netra_sdk-0.1.30 → netra_sdk-0.1.33}/README.md

@@ -223,6 +223,7 @@ async def async_span(data):
 - **CrewAI** - Multi-agent AI systems
 - **Pydantic AI** - AI model communication standard
 - **MCP (Model Context Protocol)** - AI model communication standard
+- **LiteLLM** - LLM provider agnostic client
 
 ## 🛡️ Privacy Protection & Security
 

{netra_sdk-0.1.30 → netra_sdk-0.1.33}/netra/__init__.py

@@ -1,7 +1,7 @@
 import atexit
 import logging
 import threading
-from typing import Any, Dict, Optional, Set
+from typing import Any, Dict, List, Optional, Set
 
 from opentelemetry import context as context_api
 from opentelemetry import trace
@@ -56,6 +56,8 @@ class Netra:
         enable_root_span: Optional[bool] = None,
         resource_attributes: Optional[Dict[str, Any]] = None,
         environment: Optional[str] = None,
+        enable_scrubbing: Optional[bool] = None,
+        blocked_spans: Optional[List[str]] = None,
         instruments: Optional[Set[NetraInstruments]] = None,
         block_instruments: Optional[Set[NetraInstruments]] = None,
     ) -> None:
@@ -77,6 +79,8 @@ class Netra:
                 enable_root_span=enable_root_span,
                 resource_attributes=resource_attributes,
                 environment=environment,
+                enable_scrubbing=enable_scrubbing,
+                blocked_spans=blocked_spans,
             )
 
             # Configure package logging based on debug mode

{netra_sdk-0.1.30 → netra_sdk-0.1.33}/netra/config.py

@@ -1,6 +1,6 @@
 import json
 import os
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from opentelemetry.util.re import parse_env_headers
 
@@ -19,6 +19,8 @@ class Config:
       - debug_mode:              Whether to enable SDK logging; default False (bool)
       - enable_root_span:        Whether to create a process root span; default False (bool)
       - resource_attributes:     Custom resource attributes dict (e.g., {'env': 'prod', 'version': '1.0.0'})
+      - enable_scrubbing:        Whether to enable pydantic logfire scrubbing; default False (bool)
+      - blocked_spans:           List of span names (prefix/suffix patterns) to block from being exported to the tracing backend
     """
 
     # SDK Constants
@@ -38,6 +40,8 @@ class Config:
         enable_root_span: Optional[bool] = None,
         resource_attributes: Optional[Dict[str, Any]] = None,
         environment: Optional[str] = None,
+        enable_scrubbing: Optional[bool] = None,
+        blocked_spans: Optional[List[str]] = None,
     ):
         # Application name: from param, else env
         self.app_name = (
@@ -134,3 +138,14 @@ class Config:
                     self.resource_attributes = {}
             else:
                 self.resource_attributes = {}
+
+        # Enable scrubbing with pydantic logfire? Default False.
+        if enable_scrubbing is not None:
+            self.enable_scrubbing = enable_scrubbing
+        else:
+            env_scrub = os.getenv("NETRA_ENABLE_SCRUBBING")
+            self.enable_scrubbing = True if (env_scrub is not None and env_scrub.lower() in ("1", "true")) else False
+
+        # Blocked span names/prefix patterns
+        if blocked_spans is not None:
+            self.blocked_spans = blocked_spans

{netra_sdk-0.1.30 → netra_sdk-0.1.33}/netra/instrumentation/__init__.py

@@ -93,6 +93,10 @@ def init_instrumentations(
     if CustomInstruments.MISTRALAI in netra_custom_instruments:
         init_mistral_instrumentor()
 
+    # Initialize LiteLLM instrumentation.
+    if CustomInstruments.LITELLM in netra_custom_instruments:
+        init_litellm_instrumentation()
+
     # Initialize OpenAI instrumentation.
     if CustomInstruments.OPENAI in netra_custom_instruments:
         init_openai_instrumentation()
@@ -435,6 +439,26 @@ def init_mistral_instrumentor() -> bool:
         return False
 
 
+def init_litellm_instrumentation() -> bool:
+    """Initialize LiteLLM instrumentation.
+
+    Returns:
+        bool: True if initialization was successful, False otherwise.
+    """
+    try:
+        if is_package_installed("litellm"):
+            from netra.instrumentation.litellm import LiteLLMInstrumentor
+
+            instrumentor = LiteLLMInstrumentor()
+            if not instrumentor.is_instrumented_by_opentelemetry:
+                instrumentor.instrument()
+        return True
+    except Exception as e:
+        logging.error(f"Error initializing LiteLLM instrumentor: {e}")
+        Telemetry().log_exception(e)
+        return False
+
+
 def init_openai_instrumentation() -> bool:
     """Initialize OpenAI instrumentation.
 

{netra_sdk-0.1.30 → netra_sdk-0.1.33}/netra/instrumentation/instruments.py

@@ -8,6 +8,7 @@ class CustomInstruments(Enum):
     AIOHTTP = "aiohttp"
     COHEREAI = "cohere_ai"
     HTTPX = "httpx"
+    LITELLM = "litellm"
     MISTRALAI = "mistral_ai"
     OPENAI = "openai"
     PYDANTIC_AI = "pydantic_ai"
@@ -127,6 +128,7 @@ class InstrumentSet(Enum):
     KAFKA_PYTHON = "kafka_python"
     LANCEDB = "lancedb"
     LANGCHAIN = "langchain"
+    LITELLM = "litellm"
     LLAMA_INDEX = "llama_index"
     LOGGING = "logging"
     MARQO = "marqo"

netra_sdk-0.1.33/netra/instrumentation/litellm/__init__.py

@@ -0,0 +1,161 @@
+import logging
+import time
+from typing import Any, Collection, Dict, Optional
+
+from opentelemetry import context as context_api
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY, unwrap
+from opentelemetry.trace import SpanKind, Tracer, get_tracer
+from opentelemetry.trace.status import Status, StatusCode
+from wrapt import wrap_function_wrapper
+
+from netra.instrumentation.litellm.version import __version__
+from netra.instrumentation.litellm.wrappers import (
+    acompletion_wrapper,
+    aembedding_wrapper,
+    aimage_generation_wrapper,
+    completion_wrapper,
+    embedding_wrapper,
+    image_generation_wrapper,
+)
+
+logger = logging.getLogger(__name__)
+
+_instruments = ("litellm >= 1.0.0",)
+
+
+class LiteLLMInstrumentor(BaseInstrumentor):  # type: ignore[misc]
+    """
+    Custom LiteLLM instrumentor for Netra SDK with enhanced support for:
+    - completion() and acompletion() methods
+    - embedding() and aembedding() methods
+    - image_generation() and aimage_generation() methods
+    - Proper streaming/non-streaming span handling
+    - Integration with Netra tracing
+    """
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):  # type: ignore[no-untyped-def]
+        """Instrument LiteLLM methods"""
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, __version__, tracer_provider)
+
+        logger.debug("Starting LiteLLM instrumentation...")
+
+        # Force import litellm to ensure it's available for wrapping
+        try:
+            import litellm
+        except ImportError as e:
+            logger.error(f"Failed to import litellm: {e}")
+            return
+
+        # Store original functions for uninstrumentation
+        self._original_completion = getattr(litellm, "completion", None)
+        self._original_acompletion = getattr(litellm, "acompletion", None)
+        self._original_embedding = getattr(litellm, "embedding", None)
+        self._original_aembedding = getattr(litellm, "aembedding", None)
+        self._original_image_generation = getattr(litellm, "image_generation", None)
+        self._original_aimage_generation = getattr(litellm, "aimage_generation", None)
+
+        # Chat completions - use direct monkey patching with proper function wrapping
+        if self._original_completion:
+            try:
+
+                def instrumented_completion(*args, **kwargs):  # type: ignore[no-untyped-def]
+                    wrapper = completion_wrapper(tracer)
+                    return wrapper(self._original_completion, None, args, kwargs)
+
+                litellm.completion = instrumented_completion
+            except Exception as e:
+                logger.error(f"Failed to monkey-patch litellm.completion: {e}")
+
+        if self._original_acompletion:
+            try:
+
+                async def instrumented_acompletion(*args, **kwargs):  # type: ignore[no-untyped-def]
+                    wrapper = acompletion_wrapper(tracer)
+                    return await wrapper(self._original_acompletion, None, args, kwargs)
+
+                litellm.acompletion = instrumented_acompletion
+            except Exception as e:
+                logger.error(f"Failed to monkey-patch litellm.acompletion: {e}")
+
+        # Embeddings
+        if self._original_embedding:
+            try:
+
+                def instrumented_embedding(*args, **kwargs):  # type: ignore[no-untyped-def]
+                    wrapper = embedding_wrapper(tracer)
+                    return wrapper(self._original_embedding, None, args, kwargs)
+
+                litellm.embedding = instrumented_embedding
+            except Exception as e:
+                logger.error(f"Failed to monkey-patch litellm.embedding: {e}")
+
+        if self._original_aembedding:
+            try:
+
+                async def instrumented_aembedding(*args, **kwargs):  # type: ignore[no-untyped-def]
+                    wrapper = aembedding_wrapper(tracer)
+                    return await wrapper(self._original_aembedding, None, args, kwargs)
+
+                litellm.aembedding = instrumented_aembedding
+            except Exception as e:
+                logger.error(f"Failed to monkey-patch litellm.aembedding: {e}")
+
+        # Image generation
+        if self._original_image_generation:
+            try:
+
+                def instrumented_image_generation(*args, **kwargs):  # type: ignore[no-untyped-def]
+                    wrapper = image_generation_wrapper(tracer)
+                    return wrapper(self._original_image_generation, None, args, kwargs)
+
+                litellm.image_generation = instrumented_image_generation
+            except Exception as e:
+                logger.error(f"Failed to monkey-patch litellm.image_generation: {e}")
+
+        if self._original_aimage_generation:
+            try:
+
+                async def instrumented_aimage_generation(*args, **kwargs):  # type: ignore[no-untyped-def]
+                    wrapper = aimage_generation_wrapper(tracer)
+                    return await wrapper(self._original_aimage_generation, None, args, kwargs)
+
+                litellm.aimage_generation = instrumented_aimage_generation
+            except Exception as e:
+                logger.error(f"Failed to monkey-patch litellm.aimage_generation: {e}")
+
+    def _uninstrument(self, **kwargs):  # type: ignore[no-untyped-def]
+        """Uninstrument LiteLLM methods"""
+        try:
+            import litellm
+
+            # Restore original functions
+            if hasattr(self, "_original_completion") and self._original_completion:
+                litellm.completion = self._original_completion
+
+            if hasattr(self, "_original_acompletion") and self._original_acompletion:
+                litellm.acompletion = self._original_acompletion
+
+            if hasattr(self, "_original_embedding") and self._original_embedding:
+                litellm.embedding = self._original_embedding
+
+            if hasattr(self, "_original_aembedding") and self._original_aembedding:
+                litellm.aembedding = self._original_aembedding
+
+            if hasattr(self, "_original_image_generation") and self._original_image_generation:
+                litellm.image_generation = self._original_image_generation
+
+            if hasattr(self, "_original_aimage_generation") and self._original_aimage_generation:
+                litellm.aimage_generation = self._original_aimage_generation
+
+        except ImportError:
+            pass
+
+
+def should_suppress_instrumentation() -> bool:
+    """Check if instrumentation should be suppressed"""
+    return context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY) is True