netra-sdk 0.1.30__py3-none-any.whl → 0.1.33__py3-none-any.whl

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/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/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/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/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

netra/instrumentation/litellm/version.py

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

netra/instrumentation/litellm/wrappers.py

@@ -0,0 +1,557 @@
+import logging
+import time
+from collections.abc import Awaitable
+from typing import Any, AsyncIterator, Callable, Dict, Iterator, Tuple
+
+from opentelemetry import context as context_api
+from opentelemetry.instrumentation.utils import _SUPPRESS_INSTRUMENTATION_KEY
+from opentelemetry.semconv_ai import (
+    SpanAttributes,
+)
+from opentelemetry.trace import Span, SpanKind, Tracer
+from opentelemetry.trace.status import Status, StatusCode
+from wrapt import ObjectProxy
+
+logger = logging.getLogger(__name__)
+
+COMPLETION_SPAN_NAME = "litellm.completion"
+EMBEDDING_SPAN_NAME = "litellm.embedding"
+IMAGE_GENERATION_SPAN_NAME = "litellm.image_generation"
+
+
+def should_suppress_instrumentation() -> bool:
+    """Check if instrumentation should be suppressed"""
+    return context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY) is True
+
+
+def is_streaming_response(response: Any) -> bool:
+    """Check if response is a streaming response"""
+    return hasattr(response, "__iter__") and not isinstance(response, (str, bytes, dict))
+
+
+def model_as_dict(obj: Any) -> Dict[str, Any]:
+    """Convert LiteLLM model object to dictionary"""
+    if hasattr(obj, "model_dump"):
+        result = obj.model_dump()
+        return result if isinstance(result, dict) else {}
+    elif hasattr(obj, "to_dict"):
+        result = obj.to_dict()
+        return result if isinstance(result, dict) else {}
+    elif isinstance(obj, dict):
+        return obj
+    else:
+        return {}
+
+
+def set_request_attributes(span: Span, kwargs: Dict[str, Any], operation_type: str) -> None:
+    """Set request attributes on span"""
+    if not span.is_recording():
+        return
+
+    # Set operation type
+    span.set_attribute(f"{SpanAttributes.LLM_REQUEST_TYPE}", operation_type)
+    span.set_attribute(f"{SpanAttributes.LLM_SYSTEM}", "LiteLLM")
+
+    # Common attributes
+    if kwargs.get("model"):
+        span.set_attribute(f"{SpanAttributes.LLM_REQUEST_MODEL}", kwargs["model"])
+
+    if kwargs.get("temperature") is not None:
+        span.set_attribute(f"{SpanAttributes.LLM_REQUEST_TEMPERATURE}", kwargs["temperature"])
+
+    if kwargs.get("max_tokens") is not None:
+        span.set_attribute(f"{SpanAttributes.LLM_REQUEST_MAX_TOKENS}", kwargs["max_tokens"])
+
+    if kwargs.get("stream") is not None:
+        span.set_attribute("gen_ai.stream", kwargs["stream"])
+
+    # Chat completion specific attributes
+    if operation_type == "chat" and kwargs.get("messages"):
+        messages = kwargs["messages"]
+        if isinstance(messages, list) and len(messages) > 0:
+            for index, message in enumerate(messages):
+                if isinstance(message, dict):
+                    span.set_attribute(f"{SpanAttributes.LLM_PROMPTS}.{index}.role", message.get("role", "user"))
+                    span.set_attribute(f"{SpanAttributes.LLM_PROMPTS}.{index}.content", str(message.get("content", "")))
+
+    # Embedding specific attributes
+    if operation_type == "embedding" and kwargs.get("input"):
+        input_data = kwargs["input"]
+        if isinstance(input_data, str):
+            span.set_attribute(f"{SpanAttributes.LLM_PROMPTS}.0.content", input_data)
+        elif isinstance(input_data, list):
+            for index, text in enumerate(input_data):
+                if isinstance(text, str):
+                    span.set_attribute(f"{SpanAttributes.LLM_PROMPTS}.{index}.content", text)
+
+    # Image generation specific attributes
+    if operation_type == "image_generation":
+        if kwargs.get("prompt"):
+            span.set_attribute("gen_ai.prompt", kwargs["prompt"])
+        if kwargs.get("n"):
+            span.set_attribute("gen_ai.request.n", kwargs["n"])
+        if kwargs.get("size"):
+            span.set_attribute("gen_ai.request.size", kwargs["size"])
+        if kwargs.get("quality"):
+            span.set_attribute("gen_ai.request.quality", kwargs["quality"])
+        if kwargs.get("style"):
+            span.set_attribute("gen_ai.request.style", kwargs["style"])
+
+
+def set_response_attributes(span: Span, response_dict: Dict[str, Any], operation_type: str) -> None:
+    """Set response attributes on span"""
+    if not span.is_recording():
+        return
+
+    if response_dict.get("model"):
+        span.set_attribute(f"{SpanAttributes.LLM_RESPONSE_MODEL}", response_dict["model"])
+
+    if response_dict.get("id"):
+        span.set_attribute("gen_ai.response.id", response_dict["id"])
+
+    # Usage information
+    usage = response_dict.get("usage", {})
+    if usage:
+        if usage.get("prompt_tokens"):
+            span.set_attribute(f"{SpanAttributes.LLM_USAGE_PROMPT_TOKENS}", usage["prompt_tokens"])
+        if usage.get("completion_tokens"):
+            span.set_attribute(f"{SpanAttributes.LLM_USAGE_COMPLETION_TOKENS}", usage["completion_tokens"])
+        if usage.get("cache_read_input_tokens"):
+            span.set_attribute(f"{SpanAttributes.LLM_USAGE_CACHE_READ_INPUT_TOKENS}", usage["cache_read_input_tokens"])
+        if usage.get("cache_creation_input_tokens"):
+            span.set_attribute("gen_ai.usage.cache_creation_input_tokens", usage["cache_creation_input_tokens"])
+        if usage.get("total_tokens"):
+            span.set_attribute(f"{SpanAttributes.LLM_USAGE_TOTAL_TOKENS}", usage["total_tokens"])
+
+    # Chat completion response content
+    if operation_type == "chat":
+        choices = response_dict.get("choices", [])
+        for index, choice in enumerate(choices):
+            if choice.get("message", {}).get("role"):
+                span.set_attribute(f"{SpanAttributes.LLM_COMPLETIONS}.{index}.role", choice["message"]["role"])
+            if choice.get("message", {}).get("content"):
+                span.set_attribute(f"{SpanAttributes.LLM_COMPLETIONS}.{index}.content", choice["message"]["content"])
+            if choice.get("finish_reason"):
+                span.set_attribute(f"{SpanAttributes.LLM_COMPLETIONS}.{index}.finish_reason", choice["finish_reason"])
+
+    # Embedding response content
+    elif operation_type == "embedding":
+        data = response_dict.get("data", [])
+        for index, embedding_data in enumerate(data):
+            if embedding_data.get("index") is not None:
+                span.set_attribute(f"gen_ai.response.embeddings.{index}.index", embedding_data["index"])
+            if embedding_data.get("embedding"):
+                # Don't log the actual embedding vector, just its dimensions
+                embedding_vector = embedding_data["embedding"]
+                if isinstance(embedding_vector, list):
+                    span.set_attribute(f"gen_ai.response.embeddings.{index}.dimensions", len(embedding_vector))
+
+    # Image generation response content
+    elif operation_type == "image_generation":
+        data = response_dict.get("data", [])
+        for index, image_data in enumerate(data):
+            if image_data.get("url"):
+                span.set_attribute(f"gen_ai.response.images.{index}.url", image_data["url"])
+            if image_data.get("b64_json"):
+                span.set_attribute(f"gen_ai.response.images.{index}.has_b64_json", True)
+            if image_data.get("revised_prompt"):
+                span.set_attribute(f"gen_ai.response.images.{index}.revised_prompt", image_data["revised_prompt"])
+
+
+def completion_wrapper(tracer: Tracer) -> Callable[..., Any]:
+    """Wrapper for LiteLLM completion function"""
+
+    def wrapper(wrapped: Callable[..., Any], instance: Any, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Any:
+        logger.debug(f"LiteLLM completion wrapper called with model: {kwargs.get('model')}")
+
+        if should_suppress_instrumentation():
+            logger.debug("LiteLLM instrumentation suppressed")
+            return wrapped(*args, **kwargs)
+
+        # Check if streaming
+        is_streaming = kwargs.get("stream", False)
+
+        if is_streaming:
+            # Use start_span for streaming - returns span directly
+            span = tracer.start_span(
+                COMPLETION_SPAN_NAME, kind=SpanKind.CLIENT, attributes={"llm.request.type": "chat"}
+            )
+
+            set_request_attributes(span, kwargs, "chat")
+
+            try:
+                start_time = time.time()
+                response = wrapped(*args, **kwargs)
+
+                return StreamingWrapper(span=span, response=response, start_time=start_time, request_kwargs=kwargs)
+            except Exception as e:
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                span.record_exception(e)
+                span.end()
+                raise
+        else:
+            # Use start_as_current_span for non-streaming - returns context manager
+            with tracer.start_as_current_span(
+                COMPLETION_SPAN_NAME, kind=SpanKind.CLIENT, attributes={"llm.request.type": "chat"}
+            ) as span:
+                set_request_attributes(span, kwargs, "chat")
+
+                try:
+                    start_time = time.time()
+                    response = wrapped(*args, **kwargs)
+                    end_time = time.time()
+
+                    response_dict = model_as_dict(response)
+                    set_response_attributes(span, response_dict, "chat")
+
+                    span.set_attribute("llm.response.duration", end_time - start_time)
+                    span.set_status(Status(StatusCode.OK))
+
+                    return response
+                except Exception as e:
+                    span.set_status(Status(StatusCode.ERROR, str(e)))
+                    raise
+
+    return wrapper
+
+
+def acompletion_wrapper(tracer: Tracer) -> Callable[..., Awaitable[Any]]:
+    """Async wrapper for LiteLLM acompletion function"""
+
+    async def wrapper(
+        wrapped: Callable[..., Awaitable[Any]], instance: Any, args: Tuple[Any, ...], kwargs: Dict[str, Any]
+    ) -> Any:
+        if should_suppress_instrumentation():
+            return await wrapped(*args, **kwargs)
+
+        # Check if streaming
+        is_streaming = kwargs.get("stream", False)
+
+        if is_streaming:
+            # Use start_span for streaming - returns span directly
+            span = tracer.start_span(
+                COMPLETION_SPAN_NAME, kind=SpanKind.CLIENT, attributes={"llm.request.type": "chat"}
+            )
+
+            set_request_attributes(span, kwargs, "chat")
+
+            try:
+                start_time = time.time()
+                response = await wrapped(*args, **kwargs)
+
+                return AsyncStreamingWrapper(span=span, response=response, start_time=start_time, request_kwargs=kwargs)
+            except Exception as e:
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                span.record_exception(e)
+                span.end()
+                raise
+        else:
+            # Use start_as_current_span for non-streaming - returns context manager
+            with tracer.start_as_current_span(
+                COMPLETION_SPAN_NAME, kind=SpanKind.CLIENT, attributes={"llm.request.type": "chat"}
+            ) as span:
+                set_request_attributes(span, kwargs, "chat")
+
+                try:
+                    start_time = time.time()
+                    response = await wrapped(*args, **kwargs)
+                    end_time = time.time()
+
+                    response_dict = model_as_dict(response)
+                    set_response_attributes(span, response_dict, "chat")
+
+                    span.set_attribute("llm.response.duration", end_time - start_time)
+                    span.set_status(Status(StatusCode.OK))
+
+                    return response
+                except Exception as e:
+                    span.set_status(Status(StatusCode.ERROR, str(e)))
+                    raise
+
+    return wrapper
+
+
+def embedding_wrapper(tracer: Tracer) -> Callable[..., Any]:
+    """Wrapper for LiteLLM embedding function"""
+
+    def wrapper(wrapped: Callable[..., Any], instance: Any, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Any:
+        if should_suppress_instrumentation():
+            return wrapped(*args, **kwargs)
+
+        # Embeddings are never streaming, always use start_as_current_span
+        with tracer.start_as_current_span(
+            EMBEDDING_SPAN_NAME, kind=SpanKind.CLIENT, attributes={"llm.request.type": "embedding"}
+        ) as span:
+            set_request_attributes(span, kwargs, "embedding")
+
+            try:
+                start_time = time.time()
+                response = wrapped(*args, **kwargs)
+                end_time = time.time()
+
+                response_dict = model_as_dict(response)
+                set_response_attributes(span, response_dict, "embedding")
+
+                span.set_attribute("llm.response.duration", end_time - start_time)
+                span.set_status(Status(StatusCode.OK))
+
+                return response
+            except Exception as e:
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                raise
+
+    return wrapper
+
+
+def aembedding_wrapper(tracer: Tracer) -> Callable[..., Awaitable[Any]]:
+    """Async wrapper for LiteLLM aembedding function"""
+
+    async def wrapper(
+        wrapped: Callable[..., Awaitable[Any]], instance: Any, args: Tuple[Any, ...], kwargs: Dict[str, Any]
+    ) -> Any:
+        if should_suppress_instrumentation():
+            return await wrapped(*args, **kwargs)
+
+        # Embeddings are never streaming, always use start_as_current_span
+        with tracer.start_as_current_span(
+            EMBEDDING_SPAN_NAME, kind=SpanKind.CLIENT, attributes={"llm.request.type": "embedding"}
+        ) as span:
+            set_request_attributes(span, kwargs, "embedding")
+
+            try:
+                start_time = time.time()
+                response = await wrapped(*args, **kwargs)
+                end_time = time.time()
+
+                response_dict = model_as_dict(response)
+                set_response_attributes(span, response_dict, "embedding")
+
+                span.set_attribute("llm.response.duration", end_time - start_time)
+                span.set_status(Status(StatusCode.OK))
+
+                return response
+            except Exception as e:
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                raise
+
+    return wrapper
+
+
+def image_generation_wrapper(tracer: Tracer) -> Callable[..., Any]:
+    """Wrapper for LiteLLM image_generation function"""
+
+    def wrapper(wrapped: Callable[..., Any], instance: Any, args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Any:
+        if should_suppress_instrumentation():
+            return wrapped(*args, **kwargs)
+
+        # Image generation is never streaming, always use start_as_current_span
+        with tracer.start_as_current_span(
+            IMAGE_GENERATION_SPAN_NAME, kind=SpanKind.CLIENT, attributes={"llm.request.type": "image_generation"}
+        ) as span:
+            set_request_attributes(span, kwargs, "image_generation")
+
+            try:
+                start_time = time.time()
+                response = wrapped(*args, **kwargs)
+                end_time = time.time()
+
+                response_dict = model_as_dict(response)
+                set_response_attributes(span, response_dict, "image_generation")
+
+                span.set_attribute("llm.response.duration", end_time - start_time)
+                span.set_status(Status(StatusCode.OK))
+
+                return response
+            except Exception as e:
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                raise
+
+    return wrapper
+
+
+def aimage_generation_wrapper(tracer: Tracer) -> Callable[..., Awaitable[Any]]:
+    """Async wrapper for LiteLLM aimage_generation function"""
+
+    async def wrapper(
+        wrapped: Callable[..., Awaitable[Any]], instance: Any, args: Tuple[Any, ...], kwargs: Dict[str, Any]
+    ) -> Any:
+        if should_suppress_instrumentation():
+            return await wrapped(*args, **kwargs)
+
+        # Image generation is never streaming, always use start_as_current_span
+        with tracer.start_as_current_span(
+            IMAGE_GENERATION_SPAN_NAME, kind=SpanKind.CLIENT, attributes={"llm.request.type": "image_generation"}
+        ) as span:
+            set_request_attributes(span, kwargs, "image_generation")
+
+            try:
+                start_time = time.time()
+                response = await wrapped(*args, **kwargs)
+                end_time = time.time()
+
+                response_dict = model_as_dict(response)
+                set_response_attributes(span, response_dict, "image_generation")
+
+                span.set_attribute("llm.response.duration", end_time - start_time)
+                span.set_status(Status(StatusCode.OK))
+
+                return response
+            except Exception as e:
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                raise
+
+    return wrapper
+
+
+class StreamingWrapper(ObjectProxy):  # type: ignore[misc]
+    """Wrapper for streaming responses"""
+
+    def __init__(self, span: Span, response: Iterator[Any], start_time: float, request_kwargs: Dict[str, Any]) -> None:
+        super().__init__(response)
+        self._span = span
+        self._start_time = start_time
+        self._request_kwargs = request_kwargs
+        self._complete_response: Dict[str, Any] = {"choices": [], "model": ""}
+        self._content_parts: list[str] = []
+
+    def __iter__(self) -> Iterator[Any]:
+        return self
+
+    def __next__(self) -> Any:
+        try:
+            chunk = self.__wrapped__.__next__()
+            self._process_chunk(chunk)
+            return chunk
+        except StopIteration:
+            self._finalize_span()
+            raise
+
+    def _process_chunk(self, chunk: Any) -> None:
+        """Process streaming chunk"""
+        chunk_dict = model_as_dict(chunk)
+
+        # Accumulate response data
+        if chunk_dict.get("model"):
+            self._complete_response["model"] = chunk_dict["model"]
+
+        # Accumulate usage information from chunks
+        if chunk_dict.get("usage"):
+            self._complete_response["usage"] = chunk_dict["usage"]
+
+        # Collect content from delta
+        choices = chunk_dict.get("choices", [])
+        for choice in choices:
+            delta = choice.get("delta", {})
+            if delta.get("content"):
+                self._content_parts.append(delta["content"])
+
+            # Collect finish_reason from choices
+            if choice.get("finish_reason"):
+                if "choices" not in self._complete_response:
+                    self._complete_response["choices"] = []
+                # Ensure we have enough choice entries
+                while len(self._complete_response["choices"]) <= len(choices) - 1:
+                    self._complete_response["choices"].append(
+                        {"message": {"role": "assistant", "content": ""}, "finish_reason": None}
+                    )
+
+                choice_index = choice.get("index", 0)
+                if choice_index < len(self._complete_response["choices"]):
+                    self._complete_response["choices"][choice_index]["finish_reason"] = choice["finish_reason"]
+
+        # Add chunk event
+        self._span.add_event("llm.content.completion.chunk")
+
+    def _finalize_span(self) -> None:
+        """Finalize span when streaming is complete"""
+        end_time = time.time()
+        duration = end_time - self._start_time
+
+        # Set accumulated content
+        if self._content_parts:
+            full_content = "".join(self._content_parts)
+            self._span.set_attribute(f"{SpanAttributes.LLM_COMPLETIONS}.0.content", full_content)
+            self._span.set_attribute(f"{SpanAttributes.LLM_COMPLETIONS}.0.role", "assistant")
+
+        set_response_attributes(self._span, self._complete_response, "chat")
+        self._span.set_attribute("llm.response.duration", duration)
+        self._span.set_status(Status(StatusCode.OK))
+        self._span.end()
+
+
+class AsyncStreamingWrapper(ObjectProxy):  # type: ignore[misc]
+    """Async wrapper for streaming responses"""
+
+    def __init__(
+        self, span: Span, response: AsyncIterator[Any], start_time: float, request_kwargs: Dict[str, Any]
+    ) -> None:
+        super().__init__(response)
+        self._span = span
+        self._start_time = start_time
+        self._request_kwargs = request_kwargs
+        self._complete_response: Dict[str, Any] = {"choices": [], "model": ""}
+        self._content_parts: list[str] = []
+
+    def __aiter__(self) -> AsyncIterator[Any]:
+        return self
+
+    async def __anext__(self) -> Any:
+        try:
+            chunk = await self.__wrapped__.__anext__()
+            self._process_chunk(chunk)
+            return chunk
+        except StopAsyncIteration:
+            self._finalize_span()
+            raise
+
+    def _process_chunk(self, chunk: Any) -> None:
+        """Process streaming chunk"""
+        chunk_dict = model_as_dict(chunk)
+
+        # Accumulate response data
+        if chunk_dict.get("model"):
+            self._complete_response["model"] = chunk_dict["model"]
+
+        # Accumulate usage information from chunks
+        if chunk_dict.get("usage"):
+            self._complete_response["usage"] = chunk_dict["usage"]
+
+        # Collect content from delta
+        choices = chunk_dict.get("choices", [])
+        for choice in choices:
+            delta = choice.get("delta", {})
+            if delta.get("content"):
+                self._content_parts.append(delta["content"])
+
+            # Collect finish_reason from choices
+            if choice.get("finish_reason"):
+                if "choices" not in self._complete_response:
+                    self._complete_response["choices"] = []
+                # Ensure we have enough choice entries
+                while len(self._complete_response["choices"]) <= len(choices) - 1:
+                    self._complete_response["choices"].append(
+                        {"message": {"role": "assistant", "content": ""}, "finish_reason": None}
+                    )
+
+                choice_index = choice.get("index", 0)
+                if choice_index < len(self._complete_response["choices"]):
+                    self._complete_response["choices"][choice_index]["finish_reason"] = choice["finish_reason"]
+
+        # Add chunk event
+        self._span.add_event("llm.content.completion.chunk")
+
+    def _finalize_span(self) -> None:
+        """Finalize span when streaming is complete"""
+        end_time = time.time()
+        duration = end_time - self._start_time
+
+        # Set accumulated content
+        if self._content_parts:
+            full_content = "".join(self._content_parts)
+            self._span.set_attribute(f"{SpanAttributes.LLM_COMPLETIONS}.0.content", full_content)
+            self._span.set_attribute(f"{SpanAttributes.LLM_COMPLETIONS}.0.role", "assistant")
+
+        set_response_attributes(self._span, self._complete_response, "chat")
+        self._span.set_attribute("llm.response.duration", duration)
+        self._span.set_status(Status(StatusCode.OK))
+        self._span.end()

netra/processors/__init__.py

@@ -1,4 +1,5 @@
 from netra.processors.instrumentation_span_processor import InstrumentationSpanProcessor
+from netra.processors.scrubbing_span_processor import ScrubbingSpanProcessor
 from netra.processors.session_span_processor import SessionSpanProcessor
 
-__all__ = ["SessionSpanProcessor", "InstrumentationSpanProcessor"]
+__all__ = ["SessionSpanProcessor", "InstrumentationSpanProcessor", "ScrubbingSpanProcessor"]

netra/processors/scrubbing_span_processor.py

@@ -0,0 +1,178 @@
+import logging
+import re
+from typing import Any, Dict, Optional, Union
+
+from opentelemetry import context as otel_context
+from opentelemetry import trace
+from opentelemetry.sdk.trace import SpanProcessor
+
+logger = logging.getLogger(__name__)
+
+
+class ScrubbingSpanProcessor(SpanProcessor):  # type: ignore[misc]
+    """OpenTelemetry span processor that scrubs sensitive data from span attributes using pydantic logfire patterns."""
+
+    # Common patterns for sensitive data detection (based on pydantic logfire scrubbing)
+    SENSITIVE_PATTERNS = {
+        # API keys first to avoid other patterns interfering
+        "api_key": re.compile(
+            r"(?:Token:\s*\S{32,})"  # scrub entire "Token: <value>" where value is 32+ non-space
+            r"|(?:sk-[A-Za-z0-9]{16,})"  # scrub only the sk-... token (keep labels like "API Key:")
+        ),
+        "email": re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b", re.IGNORECASE),
+        "phone": re.compile(r"(?:\+?1[-.\s]?)?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}"),
+        # Run credit card BEFORE SSN to avoid SSN partially matching inside card numbers
+        "credit_card": re.compile(r"(?<!\d)(?:4\d{15}|5[1-5]\d{14}|3[47]\d{13}|6(?:011|5\d{2})\d{12})(?!\d)"),
+        "ssn": re.compile(r"\b\d{3}-?\d{2}-?\d{4}\b"),
+        "password": re.compile(r"(?i)(?:password|passwd|pwd|secret|token)\s*[:=]\s*\S+"),
+        "bearer_token": re.compile(r"(?i)(?:authorization:\s*)?bearer\s+[A-Za-z0-9\-._~+/]+=*"),
+        "authorization": re.compile(r"(?i)authorization\s*:\s*\S+"),
+    }
+
+    # Sensitive attribute keys that should be scrubbed
+    SENSITIVE_KEYS = {
+        "password",
+        "passwd",
+        "pwd",
+        "secret",
+        "token",
+        "key",
+        "api_key",
+        "auth",
+        "authorization",
+        "bearer",
+        "credential",
+        "private_key",
+        "access_token",
+        "refresh_token",
+        "session_token",
+        "x-api-key",
+        "x-auth-token",
+        "cookie",
+        "set-cookie",
+    }
+
+    def __init__(self):  # type: ignore[no-untyped-def]
+        """Initialize the scrubbing span processor."""
+        self.scrub_replacement = "[SCRUBBED]"
+
+    def on_start(self, span: trace.Span, parent_context: Optional[otel_context.Context] = None) -> None:
+        """Process span when it starts - no scrubbing needed here."""
+
+    def on_end(self, span: trace.Span) -> None:
+        """Scrub sensitive data from span attributes when span ends."""
+        try:
+            # Get span attributes
+            if hasattr(span, "_attributes") and span._attributes:
+                scrubbed_attributes = {}
+                for key, value in span._attributes.items():
+                    scrubbed_key, scrubbed_value = self._scrub_key_value(key, value)
+                    scrubbed_attributes[scrubbed_key] = scrubbed_value
+
+                # Replace the attributes with scrubbed versions
+                span._attributes = scrubbed_attributes
+
+        except Exception as e:
+            logger.exception(f"Error scrubbing span attributes: {e}")
+
+    def _scrub_key_value(self, key: str, value: Any) -> tuple[str, Any]:
+        """Scrub sensitive data from a key-value pair.
+
+        Args:
+            key: The attribute key
+            value: The attribute value
+
+        Returns:
+            Tuple of (scrubbed_key, scrubbed_value)
+        """
+        # Check if key itself is sensitive and value is a simple type (string, number, etc.)
+        if self._is_sensitive_key(key) and not isinstance(value, (dict, list, tuple)):
+            return key, self.scrub_replacement
+
+        # Scrub value based on its type
+        if isinstance(value, str):
+            scrubbed_value = self._scrub_string_value(value)
+            return key, scrubbed_value
+        elif isinstance(value, dict):
+            return key, self._scrub_dict_value(value)
+        elif isinstance(value, (list, tuple)):
+            return key, self._scrub_list_value(value)
+
+        return key, value
+
+    def _is_sensitive_key(self, key: str) -> bool:
+        """Check if a key is considered sensitive.
+
+        Args:
+            key: The key to check
+
+        Returns:
+            True if the key is sensitive, False otherwise
+        """
+        key_lower = key.lower()
+        return any(sensitive_key in key_lower for sensitive_key in self.SENSITIVE_KEYS)
+
+    def _scrub_string_value(self, value: str) -> str:
+        """Scrub sensitive patterns from a string value.
+
+        Args:
+            value: The string value to scrub
+
+        Returns:
+            The scrubbed string value
+        """
+        scrubbed_value = value
+
+        # Early catch-all for contiguous 13-19 digit sequences (credit/debit cards)
+        scrubbed_value = re.sub(r"(?<!\d)\d{13,19}(?!\d)", self.scrub_replacement, scrubbed_value)
+
+        for pattern_name, pattern in self.SENSITIVE_PATTERNS.items():
+            if pattern.search(scrubbed_value):
+                scrubbed_value = pattern.sub(self.scrub_replacement, scrubbed_value)
+
+        # No extra fallback required now that we pre-scrub 13-19 digit sequences
+
+        return scrubbed_value
+
+    def _scrub_dict_value(self, value: Dict[str, Any]) -> Dict[str, Any]:
+        """Recursively scrub sensitive data from a dictionary value.
+
+        Args:
+            value: The dictionary value to scrub
+
+        Returns:
+            The scrubbed dictionary value
+        """
+        scrubbed_dict = {}
+        for k, v in value.items():
+            scrubbed_k, scrubbed_v = self._scrub_key_value(k, v)
+            scrubbed_dict[scrubbed_k] = scrubbed_v
+        return scrubbed_dict
+
+    def _scrub_list_value(self, value: Union[list, tuple]) -> Union[list, tuple] | None:  # type: ignore[type-arg]
+        """Recursively scrub sensitive data from a list/tuple value.
+
+        Args:
+            value: The list/tuple value to scrub
+
+        Returns:
+            The scrubbed list/tuple value
+        """
+        scrubbed_items = []
+        for item in value:
+            if isinstance(item, str):
+                scrubbed_items.append(self._scrub_string_value(item))
+            elif isinstance(item, dict):
+                scrubbed_items.append(self._scrub_dict_value(item))  # type: ignore[arg-type]
+            elif isinstance(item, (list, tuple)):
+                scrubbed_items.append(self._scrub_list_value(item))  # type: ignore[arg-type]
+            else:
+                scrubbed_items.append(item)
+
+        return type(value)(scrubbed_items)
+
+    def force_flush(self, timeout_millis: int = 30000) -> None:
+        """Force flush - no-op for scrubbing processor."""
+
+    def shutdown(self) -> None:
+        """Shutdown - no-op for scrubbing processor."""

netra/span_wrapper.py

@@ -4,10 +4,8 @@ import time
 from datetime import datetime
 from typing import Any, Dict, List, Literal, Optional
 
-from opentelemetry import context as context_api
 from opentelemetry import trace
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.trace.propagation import set_span_in_context
 from pydantic import BaseModel
 
 from netra.config import Config
@@ -72,18 +70,19 @@ class SpanWrapper:
         # OpenTelemetry span management
         self.tracer = trace.get_tracer(module_name)
         self.span: Optional[trace.Span] = None
-        self.context_token: Optional[Any] = None
+        # Internal context manager to manage current-span scope safely
+        self._span_cm: Optional[Any] = None
 
     def __enter__(self) -> "SpanWrapper":
         """Start the span wrapper, begin time tracking, and create OpenTelemetry span."""
         self.start_time = time.time()
 
-        # Create OpenTelemetry span
-        self.span = self.tracer.start_span(name=self.name, kind=SpanKind.CLIENT, attributes=self.attributes)
-
-        # Set span in context
-        ctx = set_span_in_context(self.span)
-        self.context_token = context_api.attach(ctx)
+        # Create OpenTelemetry span and make it current using OTel's context manager
+        # Store the context manager so we can close it in __exit__
+        self._span_cm = self.tracer.start_as_current_span(
+            name=self.name, kind=SpanKind.CLIENT, attributes=self.attributes
+        )
+        self.span = self._span_cm.__enter__()
 
         # Register with SessionManager for name-based lookup
         try:
@@ -93,7 +92,6 @@ class SpanWrapper:
         except Exception:
             logger.exception("Failed to register span '%s' with SessionManager", self.name)
 
-        logger.info(f"Started span wrapper: {self.name}")
         return self
 
     def __exit__(self, exc_type: Optional[type], exc_val: Optional[Exception], exc_tb: Any) -> Literal[False]:
@@ -127,22 +125,19 @@ class SpanWrapper:
             for key, value in self.attributes.items():
                 self.span.set_attribute(key, value)
 
-        # End OpenTelemetry span and detach context
+        # End OpenTelemetry span via the context manager (also clears current context)
         if self.span:
             # Unregister from SessionManager before ending span
             try:
                 SessionManager.unregister_span(self.name, self.span)
             except Exception:
                 logger.exception("Failed to unregister span '%s' from SessionManager", self.name)
-            self.span.end()
-        if self.context_token:
-            context_api.detach(self.context_token)
-
-        logger.info(
-            f"Ended span wrapper: {self.name} (Status: {self.status}, Duration: {duration_ms:.2f}ms)"
-            if duration_ms is not None
-            else f"Ended span wrapper: {self.name} (Status: {self.status})"
-        )
+        if self._span_cm is not None:
+            try:
+                # Delegate to OTel CM to properly end span and restore context
+                self._span_cm.__exit__(exc_type, exc_val, exc_tb)
+            finally:
+                self._span_cm = None
 
         # Don't suppress exceptions
         return False

netra/tracer.py

@@ -5,16 +5,18 @@ including exporter setup and span processor configuration.
 """
 
 import logging
-from typing import Any, Dict
+from typing import Any, Dict, List, Sequence
 
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk.resources import DEPLOYMENT_ENVIRONMENT, SERVICE_NAME, Resource
-from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace import ReadableSpan, TracerProvider
 from opentelemetry.sdk.trace.export import (
     BatchSpanProcessor,
     ConsoleSpanExporter,
     SimpleSpanProcessor,
+    SpanExporter,
+    SpanExportResult,
 )
 
 from netra.config import Config
@@ -22,6 +24,75 @@ from netra.config import Config
 logger = logging.getLogger(__name__)
 
 
+class FilteringSpanExporter(SpanExporter):  # type: ignore[misc]
+    """
+    SpanExporter wrapper that filters out spans by name.
+
+    Matching rules:
+    - Exact match: pattern "Foo" blocks span.name == "Foo".
+    - Prefix match: pattern ending with '*' (e.g., "CloudSpanner.*") blocks spans whose
+      names start with the prefix before '*', e.g., "CloudSpanner.", "CloudSpanner.Query".
+    - Suffix match: pattern starting with '*' (e.g., "*.Query") blocks spans whose
+      names end with the suffix after '*', e.g., "DB.Query", "Search.Query".
+    """
+
+    def __init__(self, exporter: SpanExporter, patterns: Sequence[str]) -> None:
+        self._exporter = exporter
+        # Normalize once for efficient checks
+        exact: List[str] = []
+        prefixes: List[str] = []
+        suffixes: List[str] = []
+        for p in patterns:
+            if not p:
+                continue
+            if p.endswith("*") and not p.startswith("*"):
+                prefixes.append(p[:-1])
+            elif p.startswith("*") and not p.endswith("*"):
+                suffixes.append(p[1:])
+            else:
+                exact.append(p)
+        self._exact = set(exact)
+        self._prefixes = prefixes
+        self._suffixes = suffixes
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        filtered: List[ReadableSpan] = []
+        for s in spans:
+            name = getattr(s, "name", None)
+            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):
+                        blocked = True
+                        break
+            if not blocked:
+                filtered.append(s)
+        if not filtered:
+            return SpanExportResult.SUCCESS
+        return self._exporter.export(filtered)
+
+    def shutdown(self) -> None:
+        try:
+            self._exporter.shutdown()
+        except Exception:
+            pass
+
+    def force_flush(self, timeout_millis: int = 30000) -> Any:
+        try:
+            return self._exporter.force_flush(timeout_millis)
+        except Exception:
+            return True
+
+
 class Tracer:
     """
     Configures Netra's OpenTelemetry tracer with OTLP exporter (or Console exporter as fallback)
@@ -65,12 +136,24 @@ class Tracer:
                 endpoint=self._format_endpoint(self.cfg.otlp_endpoint),
                 headers=self.cfg.headers,
             )
+        # Wrap exporter with filtering if blocked span patterns are provided
+        try:
+            patterns = getattr(self.cfg, "blocked_spans", None)
+            if patterns:
+                exporter = FilteringSpanExporter(exporter, patterns)
+                logger.info("Enabled FilteringSpanExporter with %d pattern(s)", len(patterns))
+        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, SessionSpanProcessor
+        from netra.processors import InstrumentationSpanProcessor, ScrubbingSpanProcessor, SessionSpanProcessor
 
         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))

netra/version.py

@@ -1 +1 @@
-__version__ = "0.1.30"
+__version__ = "0.1.33"

{netra_sdk-0.1.30.dist-info → netra_sdk-0.1.33.dist-info}/METADATA

@@ -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.dist-info → netra_sdk-0.1.33.dist-info}/RECORD

@@ -1,15 +1,15 @@
-netra/__init__.py,sha256=4eqBwPZP86tsxnUJC-Q7dEVpFAIoZcp5vgmOyKwQslo,10740
+netra/__init__.py,sha256=bBnv8InguoqBleHuA5KNU145eozdPOooxQrIMaKgJ5c,10942
 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=-_2iXoMP92pifMFLOt1rjpRvEnqHWc3O9usFIGhxnwA,6075
+netra/config.py,sha256=51m8R0NoOrw58gMV7arOniEuFdJ7EIu3PNdFtIQ5xfg,6893
 netra/decorators.py,sha256=yuQP02sdvTRIYkv-myNcP8q7dmPq3ME1AJZxJtryayI,8720
 netra/exceptions/__init__.py,sha256=uDgcBxmC4WhdS7HRYQk_TtJyxH1s1o6wZmcsnSHLAcM,174
 netra/exceptions/injection.py,sha256=ke4eUXRYUFJkMZgdSyPPkPt5PdxToTI6xLEBI0hTWUQ,1332
 netra/exceptions/pii.py,sha256=MT4p_x-zH3VtYudTSxw1Z9qQZADJDspq64WrYqSWlZc,2438
 netra/input_scanner.py,sha256=At6N9gNY8cR0O6S8x3K6swWBV3P1a_9O-XBNM_pcKz4,5348
-netra/instrumentation/__init__.py,sha256=pJOkAO1h7rdM_VwvZ_FZZ-zq8PCmLOzW4jvr_CwWYCI,40792
+netra/instrumentation/__init__.py,sha256=HdG3n5TxPRUNlOxsqjlvwDmBcnm3UtYx1OecLhnLeQM,41578
 netra/instrumentation/aiohttp/__init__.py,sha256=M1kuF0R3gKY5rlbhEC1AR13UWHelmfokluL2yFysKWc,14398
 netra/instrumentation/aiohttp/version.py,sha256=Zy-0Aukx-HS_Mo3NKPWg-hlUoWKDzS0w58gLoVtJec8,24
 netra/instrumentation/cohere/__init__.py,sha256=3XwmCAZwZiMkHdNN3YvcBOLsNCx80ymbU31TyMzv1IY,17685
@@ -22,7 +22,10 @@ netra/instrumentation/google_genai/utils.py,sha256=2OeSN5jUaMKF4x5zWiW65R1LB_a44
 netra/instrumentation/google_genai/version.py,sha256=Hww1duZrC8kYK7ThBSQVyz0HNOb0ys_o8Pln-wVQ1hI,23
 netra/instrumentation/httpx/__init__.py,sha256=w1su_eQP_w5ZJHq0Lf-4miF5zM4OOW0ItmRp0wi85Ew,19388
 netra/instrumentation/httpx/version.py,sha256=ZRQKbgDaGz_yuLk-cUKuk6ZBKCSRKZC8nQd041NRNXk,23
-netra/instrumentation/instruments.py,sha256=JJF8J2O2Xd3w3k33ZYxpFNrwWgl_veRNxV6QUFCsFn0,4301
+netra/instrumentation/instruments.py,sha256=O6MI_BO-5EBkVqI-dr5eqhYnk8mP5QEpI0RWJ7Fe3FQ,4349
+netra/instrumentation/litellm/__init__.py,sha256=H9FsdEq-CL39zbl_dLm8D43-D1vAjoNqFTBpbmZsVXs,6740
+netra/instrumentation/litellm/version.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+netra/instrumentation/litellm/wrappers.py,sha256=H_UG0et6PUmj6CQagvNzbs_WodNTMruzzGOHhedmTko,22840
 netra/instrumentation/mistralai/__init__.py,sha256=RE0b-rS6iXdoynJMFKHL9s97eYo5HghrJa013fR4ZhI,18910
 netra/instrumentation/mistralai/config.py,sha256=XCyo3mk30qkvqyCqeTrKwROahu0gcOEwmbDLOo53J5k,121
 netra/instrumentation/mistralai/utils.py,sha256=nhdIer5gJFxuGwg8FCT222hggDHeMQDhJctnDSwLqcc,894
@@ -37,15 +40,16 @@ netra/instrumentation/pydantic_ai/wrappers.py,sha256=6cfIRvELBS4d9G9TttNYcHGueNI
 netra/instrumentation/weaviate/__init__.py,sha256=EOlpWxobOLHYKqo_kMct_7nu26x1hr8qkeG5_h99wtg,4330
 netra/instrumentation/weaviate/version.py,sha256=PiCZHjonujPbnIn0KmD3Yl68hrjPRG_oKe5vJF3mmG8,24
 netra/pii.py,sha256=Rn4SjgTJW_aw9LcbjLuMqF3fKd9b1ndlYt1CaK51Ge0,33125
-netra/processors/__init__.py,sha256=2E18QGVwVl8nEpT-EViEZqGLdVVejMTEH1wZNugDmYU,230
+netra/processors/__init__.py,sha256=TLVBKk4Bli7MOyHTy_F-4NSm0thzIcJcZAVVNoq6gK8,333
 netra/processors/instrumentation_span_processor.py,sha256=Ef5FTr8O5FLHcIkBAW3ueU1nlkV2DuOi-y5iIwHzldQ,4252
+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=AoQa-k4dFcq7PeOD8G8DNzhLzL1JrHUW6b_y8mRyTQo,10255
-netra/span_wrapper.py,sha256=lGuV1F4Q5I_swIoIof5myzOQCFmGFdtrpgfQt7dTTus,8105
-netra/tracer.py,sha256=YiuijB_5DBOLVgE39Lj3thWVmUqHLcqbdFVB0HGovW0,3543
-netra/version.py,sha256=2GUJJyX8g8EAXKUqyj7DGVzG-jNXOGaqVSWilvGYuX8,23
-netra_sdk-0.1.30.dist-info/LICENCE,sha256=8B_UoZ-BAl0AqiHAHUETCgd3I2B9yYJ1WEQtVb_qFMA,11359
-netra_sdk-0.1.30.dist-info/METADATA,sha256=9quLP0B1XfOdcQWU4vsIY44Gf2CwWiF_er2-Wa6wKvM,28151
-netra_sdk-0.1.30.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-netra_sdk-0.1.30.dist-info/RECORD,,
+netra/span_wrapper.py,sha256=IygQX78xQRlL_Z1MfKfUbv0okihx92qNClnRlYFtRNc,8004
+netra/tracer.py,sha256=8stV4UUAiwsViGOgjKnv0MXse16ByWguYFZ4SGZJS_c,6712
+netra/version.py,sha256=gzg6nU6x2Uud0fXG6Kts9v4UFjYEjLGQu5DaW7kU0qc,23
+netra_sdk-0.1.33.dist-info/LICENCE,sha256=8B_UoZ-BAl0AqiHAHUETCgd3I2B9yYJ1WEQtVb_qFMA,11359
+netra_sdk-0.1.33.dist-info/METADATA,sha256=Wa0rozvrmQQyzLtouKrO8V6HzniurPfK8FLm7qB6l3U,28210
+netra_sdk-0.1.33.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+netra_sdk-0.1.33.dist-info/RECORD,,