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

netra/exporters/__init__.py

@@ -0,0 +1,3 @@
+from netra.exporters.filtering_span_exporter import FilteringSpanExporter
+
+__all__ = ["FilteringSpanExporter"]

netra/exporters/filtering_span_exporter.py

@@ -0,0 +1,211 @@
+import logging
+from typing import Any, Dict, List, Sequence
+
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import (
+    SpanExporter,
+    SpanExportResult,
+)
+
+from netra.processors.local_filtering_span_processor import (
+    BLOCKED_LOCAL_PARENT_MAP,
+)
+
+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] = []
+        blocked_parent_map: Dict[Any, Any] = {}
+        for span in spans:
+            name = getattr(span, "name", None)
+            if name is None:
+                filtered.append(span)
+                continue
+
+            # Global blocking (configured patterns)
+            globally_blocked = self._is_blocked(name)
+
+            # Local per-span blocking via attribute set by LocalFilteringSpanProcessor
+            locally_blocked = False
+            try:
+                local_patterns = self._get_local_patterns(span)
+                if local_patterns:
+                    locally_blocked = self._matches_any_pattern(name, local_patterns)
+                # Fallback: if processor explicitly marked the span as locally blocked
+                if not locally_blocked and self._has_local_block_flag(span):
+                    locally_blocked = True
+            except Exception:
+                locally_blocked = False
+
+            if not (globally_blocked or locally_blocked):
+                filtered.append(span)
+                continue
+
+            # Collect mapping for reparenting children of the blocked span
+            span_context = getattr(span, "context", None)
+            span_id = getattr(span_context, "span_id", None) if span_context else None
+            if span_id is not None:
+                blocked_parent_map[span_id] = getattr(span, "parent", None)
+
+        # Merge with registry of locally blocked spans captured by processor to handle
+        # cases where children export before their blocked parent (SimpleSpanProcessor)
+        merged_map: Dict[Any, Any] = {}
+        try:
+            if BLOCKED_LOCAL_PARENT_MAP:
+                merged_map.update(BLOCKED_LOCAL_PARENT_MAP)
+        except Exception:
+            pass
+        merged_map.update(blocked_parent_map)
+
+        if merged_map:
+            self._reparent_blocked_children(filtered, merged_map)
+        if not filtered:
+            return SpanExportResult.SUCCESS
+        return self._exporter.export(filtered)
+
+    def _is_blocked(self, name: str) -> bool:
+        if name in self._exact:
+            return True
+        for pref in self._prefixes:
+            if name.startswith(pref):
+                return True
+        for suf in self._suffixes:
+            if name.endswith(suf):
+                return True
+        return False
+
+    def _get_local_patterns(self, span: ReadableSpan) -> List[str]:
+        """Fetch local-block patterns from span attributes set by LocalFilteringSpanProcessor."""
+        try:
+            attrs = getattr(span, "attributes", None)
+            if not attrs:
+                return []
+            value = None
+            # Prefer Mapping.get if available
+            try:
+                if hasattr(attrs, "get"):
+                    value = attrs.get("netra.local_blocked_spans")
+                else:
+                    value = attrs["netra.local_blocked_spans"]
+            except Exception:
+                value = None
+            if isinstance(value, (list, tuple)) and all(isinstance(v, str) for v in value):
+                return [v for v in value if v]
+        except Exception:
+            logger.debug("Failed reading local blocked patterns from span", exc_info=True)
+        return []
+
+    def _matches_any_pattern(self, name: str, patterns: Sequence[str]) -> bool:
+        for p in patterns:
+            if not p:
+                continue
+            if p.endswith("*") and not p.startswith("*"):
+                if name.startswith(p[:-1]):
+                    return True
+            elif p.startswith("*") and not p.endswith("*"):
+                if name.endswith(p[1:]):
+                    return True
+            else:
+                if name == p:
+                    return True
+        return False
+
+    def _has_local_block_flag(self, span: ReadableSpan) -> bool:
+        try:
+            attrs = getattr(span, "attributes", None)
+            if not attrs:
+                return False
+            try:
+                if hasattr(attrs, "get"):
+                    value = attrs.get("netra.local_blocked")
+                else:
+                    value = attrs["netra.local_blocked"]
+            except Exception:
+                value = None
+            return bool(value) is True
+        except Exception:
+            return False
+
+    def _reparent_blocked_children(
+        self,
+        spans: Sequence[ReadableSpan],
+        blocked_parent_map: Dict[Any, Any],
+    ) -> None:
+        if not blocked_parent_map:
+            return
+
+        for span in spans:
+            parent_context = getattr(span, "parent", None)
+            if parent_context is None:
+                continue
+
+            updated_parent = parent_context
+            visited: set[Any] = set()
+            changed = False
+
+            while updated_parent is not None:
+                parent_span_id = getattr(updated_parent, "span_id", None)
+                if parent_span_id not in blocked_parent_map or parent_span_id in visited:
+                    break
+                visited.add(parent_span_id)
+                updated_parent = blocked_parent_map[parent_span_id]
+                changed = True
+
+            if changed:
+                self._set_span_parent(span, updated_parent)
+
+    def _set_span_parent(self, span: ReadableSpan, parent: Any) -> None:
+        if hasattr(span, "_parent"):
+            try:
+                span._parent = parent
+                return
+            except Exception:
+                pass
+        try:
+            setattr(span, "parent", parent)
+        except Exception:
+            logger.debug("Failed to reparent span %s", getattr(span, "name", "<unknown>"), exc_info=True)
+
+    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

netra/processors/__init__.py

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

netra/processors/local_filtering_span_processor.py

@@ -0,0 +1,155 @@
+import json
+import logging
+from contextlib import contextmanager
+from typing import List, Optional, Sequence
+
+from opentelemetry import baggage
+from opentelemetry import context as otel_context
+from opentelemetry import trace
+from opentelemetry.sdk.trace import SpanProcessor
+
+logger = logging.getLogger(__name__)
+
+# Baggage key to carry local blocked span patterns in the active context
+_LOCAL_BLOCKED_SPANS_BAGGAGE_KEY = "netra.local_blocked_spans"
+# Attribute key to copy resolved local blocked patterns onto each span
+_LOCAL_BLOCKED_SPANS_ATTR_KEY = "netra.local_blocked_spans"
+
+# Registry of locally blocked spans: span_id -> parent_context
+# This lets exporters reparent children reliably even when children export before parents
+BLOCKED_LOCAL_PARENT_MAP: dict[object, object] = {}
+
+
+class LocalFilteringSpanProcessor(SpanProcessor):  # type: ignore[misc]
+    """Propagates local blocked span patterns from baggage to span attributes.
+
+    - On span start, reads patterns from baggage key `_LOCAL_BLOCKED_SPANS_BAGGAGE_KEY` on the provided
+      `parent_context` and, if present, sets them on the span attribute `_LOCAL_BLOCKED_SPANS_ATTR_KEY`.
+    - This enables exporters (e.g., `FilteringSpanExporter`) to decide per-span blocking based on the
+      active context in which the span was created.
+    """
+
+    def on_start(self, span: trace.Span, parent_context: Optional[otel_context.Context] = None) -> None:
+        try:
+            # Use provided parent_context if available, otherwise fall back to current context
+            ctx_to_read = parent_context if parent_context is not None else otel_context.get_current()
+            raw = baggage.get_baggage(_LOCAL_BLOCKED_SPANS_BAGGAGE_KEY, context=ctx_to_read)
+            if not raw:
+                return
+            patterns: Optional[List[str]] = _decode_patterns(raw)
+            if patterns:
+                try:
+                    span.set_attribute(_LOCAL_BLOCKED_SPANS_ATTR_KEY, patterns)
+                except Exception:
+                    # Best-effort: never break span start
+                    logger.debug("Failed setting local blocked patterns on span", exc_info=True)
+                # If this span matches the local patterns, record it as locally blocked for reparenting
+                try:
+                    name = getattr(span, "name", None)
+                    if isinstance(name, str) and name and _matches_any_pattern(name, patterns):
+                        ctx = getattr(span, "context", None)
+                        span_id = getattr(ctx, "span_id", None) if ctx else None
+                        # Determine the parent SpanContext of this blocked span from the context
+                        parent_span = trace.get_current_span(ctx_to_read)
+                        parent_span_context = (
+                            parent_span.get_span_context() if hasattr(parent_span, "get_span_context") else None
+                        )
+                        if span_id is not None and parent_span_context is not None:
+                            BLOCKED_LOCAL_PARENT_MAP[span_id] = parent_span_context
+                            # Mark on the span for visibility/debugging
+                            try:
+                                span.set_attribute("netra.local_blocked", True)
+                            except Exception:
+                                pass
+                except Exception:
+                    logger.debug("Failed to precompute locally blocked mapping on start", exc_info=True)
+        except Exception:
+            # Never break tracing pipeline
+            logger.debug("LocalFilteringSpanProcessor.on_start failed", exc_info=True)
+
+    # No-ops required by interface
+    def on_end(self, span: trace.Span) -> None:  # noqa: D401
+        # Cleanup registry entry to avoid leaks
+        try:
+            ctx = getattr(span, "context", None)
+            span_id = getattr(ctx, "span_id", None) if ctx else None
+            if span_id is not None:
+                BLOCKED_LOCAL_PARENT_MAP.pop(span_id, None)
+        except Exception:
+            pass
+        return
+
+    def shutdown(self) -> None:  # noqa: D401
+        return
+
+    def force_flush(self, timeout_millis: int = 30000) -> None:  # noqa: D401
+        return
+
+
+def _decode_patterns(raw: str) -> Optional[List[str]]:
+    """Decode patterns stored in baggage.
+
+    We store JSON-encoded list[str] in baggage (must be a string). This safely handles complex
+    characters and is robust to commas in patterns.
+    """
+    try:
+        parsed = json.loads(raw)
+        if isinstance(parsed, list) and all(isinstance(p, str) for p in parsed):
+            return [p for p in parsed if p]
+    except Exception:
+        logger.debug("Failed to decode local blocked patterns from baggage", exc_info=True)
+    return None
+
+
+def _matches_any_pattern(name: str, patterns: Sequence[str]) -> bool:
+    """Return True if name matches any pattern (exact, prefix*, *suffix)."""
+    try:
+        for p in patterns:
+            if not p:
+                continue
+            if p.endswith("*") and not p.startswith("*"):
+                if name.startswith(p[:-1]):
+                    return True
+            elif p.startswith("*") and not p.endswith("*"):
+                if name.endswith(p[1:]):
+                    return True
+            else:
+                if name == p:
+                    return True
+    except Exception:
+        # Be conservative: on error, treat as no match
+        return False
+    return False
+
+
+@contextmanager
+def block_spans_local(patterns: Sequence[str]):  # type: ignore[no-untyped-def]
+    """Context manager to locally block spans by name patterns.
+
+    Usage:
+        with block_spans_local(["openai.*", "*.internal"]):
+            # Spans created in this context will inherit these local rules
+            ...
+
+    Patterns follow the same rules as global blocking in the exporter:
+      - Exact match: "Foo"
+      - Prefix: "CloudSpanner.*"
+      - Suffix: "*.Query"
+    """
+    # Normalize incoming sequence to a compact list of non-empty strings
+    normalized: List[str] = [p for p in patterns if isinstance(p, str) and p]
+    # Encode as JSON string for baggage
+    payload = json.dumps(normalized)
+
+    # Attach to current context
+    token = otel_context.attach(
+        baggage.set_baggage(_LOCAL_BLOCKED_SPANS_BAGGAGE_KEY, payload, context=otel_context.get_current())
+    )
+    try:
+        yield
+    finally:
+        try:
+            otel_context.detach(token)
+        except Exception:
+            # If context changed unexpectedly, avoid crashing user code
+            logger.debug("Failed to detach local blocking context token", exc_info=True)

netra/span_wrapper.py

@@ -4,6 +4,8 @@ import time
 from datetime import datetime
 from typing import Any, Dict, List, Literal, Optional
 
+from opentelemetry import baggage
+from opentelemetry import context as otel_context
 from opentelemetry import trace
 from opentelemetry.trace import SpanKind, Status, StatusCode
 from pydantic import BaseModel
@@ -15,6 +17,9 @@ from netra.session_manager import SessionManager
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# Baggage key for local-only blocked spans patterns
+_LOCAL_BLOCKED_SPANS_BAGGAGE_KEY = "netra.local_blocked_spans"
+
 
 class ActionModel(BaseModel):  # type: ignore[misc]
     start_time: str = str((datetime.now().timestamp() * 1_000_000_000))
@@ -72,11 +77,29 @@ class SpanWrapper:
         self.span: Optional[trace.Span] = None
         # Internal context manager to manage current-span scope safely
         self._span_cm: Optional[Any] = None
+        # Token for locally attached baggage (if any)
+        self._local_block_token: Optional[object] = None
 
     def __enter__(self) -> "SpanWrapper":
         """Start the span wrapper, begin time tracking, and create OpenTelemetry span."""
         self.start_time = time.time()
 
+        # If user provided local blocked patterns in attributes, attach them as baggage
+        try:
+            patterns = None
+            # Accept either explicit key or short key for convenience
+            if isinstance(self.attributes.get("netra.local_blocked_spans"), list):
+                patterns = [p for p in self.attributes.get("netra.local_blocked_spans", []) if isinstance(p, str) and p]
+            elif isinstance(self.attributes.get("blocked_spans"), list):
+                patterns = [p for p in self.attributes.get("blocked_spans", []) if isinstance(p, str) and p]
+            if patterns:
+                payload = json.dumps(patterns)
+                self._local_block_token = otel_context.attach(
+                    baggage.set_baggage(_LOCAL_BLOCKED_SPANS_BAGGAGE_KEY, payload, context=otel_context.get_current())
+                )
+        except Exception:
+            logger.debug("Failed to attach local blocked spans baggage on span start", exc_info=True)
+
         # 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(
@@ -139,6 +162,15 @@ class SpanWrapper:
             finally:
                 self._span_cm = None
 
+        # Detach local blocking baggage if we attached it
+        if self._local_block_token is not None:
+            try:
+                otel_context.detach(self._local_block_token)
+            except Exception:
+                logger.debug("Failed to detach local blocked spans baggage token", exc_info=True)
+            finally:
+                self._local_block_token = None
+
         # Don't suppress exceptions
         return False
 

netra/tracer.py

@@ -5,115 +5,24 @@ including exporter setup and span processor configuration.
 """
 
 import logging
-from typing import Any, Dict, List, Sequence
+from typing import Any, Dict
 
 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 ReadableSpan, TracerProvider
+from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import (
     BatchSpanProcessor,
     ConsoleSpanExporter,
     SimpleSpanProcessor,
-    SpanExporter,
-    SpanExportResult,
 )
 
 from netra.config import Config
+from netra.exporters import FilteringSpanExporter
 
 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
-            # Only apply blocked span patterns to root-level spans (no valid parent)
-            parent = getattr(s, "parent", None)
-            # Determine if the span has a valid parent. SpanContext.is_valid may be a property or method.
-            has_valid_parent = False
-            if parent is not None:
-                is_valid_attr = getattr(parent, "is_valid", None)
-                if callable(is_valid_attr):
-                    try:
-                        has_valid_parent = bool(is_valid_attr())
-                    except Exception:
-                        has_valid_parent = False
-                else:
-                    has_valid_parent = bool(is_valid_attr)
-
-            is_root_span = parent is None or not has_valid_parent
-
-            if is_root_span:
-                # Apply name-based blocking only for root spans
-                if name in self._exact:
-                    continue
-                blocked = False
-                for pref in self._prefixes:
-                    if name.startswith(pref):
-                        blocked = True
-                        break
-                if not blocked and self._suffixes:
-                    for suf in self._suffixes:
-                        if name.endswith(suf):
-                            blocked = True
-                            break
-                if not blocked:
-                    filtered.append(s)
-            else:
-                # Do not block child spans based on name
-                filtered.append(s)
-        if not filtered:
-            return SpanExportResult.SUCCESS
-        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)
@@ -157,17 +66,26 @@ class Tracer:
                 endpoint=self._format_endpoint(self.cfg.otlp_endpoint),
                 headers=self.cfg.headers,
             )
-        # Wrap exporter with filtering if blocked span patterns are provided
+        # Wrap exporter with filtering to support both global and local (baggage-based) rules
         try:
-            patterns = getattr(self.cfg, "blocked_spans", None)
+            patterns = getattr(self.cfg, "blocked_spans", None) or []
+            exporter = FilteringSpanExporter(exporter, patterns)
             if patterns:
-                exporter = FilteringSpanExporter(exporter, patterns)
-                logger.info("Enabled FilteringSpanExporter with %d pattern(s)", len(patterns))
+                logger.info("Enabled FilteringSpanExporter with %d global pattern(s)", len(patterns))
+            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, ScrubbingSpanProcessor, SessionSpanProcessor
+        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())
 

netra/version.py

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

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

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

@@ -8,6 +8,8 @@ netra/decorators.py,sha256=qZFHrwdj10FsTFqggo3XjdGB12aMxsrrDMMmslDqZ-0,17424
 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/exporters/__init__.py,sha256=8KFjTVKbTzoH2X0Yu1Cll6_CvCguD7dX9dHjFJqrM4M,111
+netra/exporters/filtering_span_exporter.py,sha256=rWTGL8ja9v9hVhm9nuJCZGmQ6zw59F0Oh1hahhFJwU8,7649
 netra/input_scanner.py,sha256=At6N9gNY8cR0O6S8x3K6swWBV3P1a_9O-XBNM_pcKz4,5348
 netra/instrumentation/__init__.py,sha256=HdG3n5TxPRUNlOxsqjlvwDmBcnm3UtYx1OecLhnLeQM,41578
 netra/instrumentation/aiohttp/__init__.py,sha256=M1kuF0R3gKY5rlbhEC1AR13UWHelmfokluL2yFysKWc,14398
@@ -40,17 +42,18 @@ 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=TLVBKk4Bli7MOyHTy_F-4NSm0thzIcJcZAVVNoq6gK8,333
+netra/processors/__init__.py,sha256=56RO7xMoBx2aoVuESyQXll65o7IoO98nSHZ5KpR5iQk,471
 netra/processors/instrumentation_span_processor.py,sha256=VzurzwtGleFltxzKD_gjVkUQiRC6SGlb0oG4Nlpu85A,4365
+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=IygQX78xQRlL_Z1MfKfUbv0okihx92qNClnRlYFtRNc,8004
-netra/tracer.py,sha256=FJO8Cine-WL9K_4wn6RVjQOgX6c1JCp_8QowUbRSVHk,7718
+netra/span_wrapper.py,sha256=3xzZs44s85KiB81WXjAJmfQcH_aPMxCuQ_1xjDVGtwE,9682
+netra/tracer.py,sha256=IPVYMc4x74XZJeKvCfV6b0X9mUHGvsssUzLnRvFPV6M,4629
 netra/utils.py,sha256=FblSzI8qMTfEbusakGBKE9CNELW0GEBHl09mPPxgI-w,2521
-netra/version.py,sha256=PwEipAcIgfEks4UpVgOERoR8Az-FCfCGocVnb0rkncM,23
-netra_sdk-0.1.43.dist-info/METADATA,sha256=3IMsH-b9Wcy9tMvG62MgOa3Zj76kidZbt1biWT3jyj0,28208
-netra_sdk-0.1.43.dist-info/WHEEL,sha256=M5asmiAlL6HEcOq52Yi5mmk9KmTVjY2RDPtO4p9DMrc,88
-netra_sdk-0.1.43.dist-info/licenses/LICENCE,sha256=8B_UoZ-BAl0AqiHAHUETCgd3I2B9yYJ1WEQtVb_qFMA,11359
-netra_sdk-0.1.43.dist-info/RECORD,,
+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_sdk-0.1.43.dist-info → netra_sdk-0.1.45.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.0
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any