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

netra/__init__.py

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

netra/config.py

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

netra/decorators.py

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

netra/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/instrumentation_span_processor.py

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

netra/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/session_manager.py

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

netra/span_wrapper.py

@@ -2,8 +2,11 @@ import json
 import logging
 import time
 from datetime import datetime
+from enum import Enum
 from typing import Any, Dict, List, Literal, Optional
 
+from opentelemetry import baggage
+from opentelemetry import context as otel_context
 from opentelemetry import trace
 from opentelemetry.trace import SpanKind, Status, StatusCode
 from pydantic import BaseModel
@@ -15,6 +18,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))
@@ -44,6 +50,13 @@ class ATTRIBUTE:
     ACTION = "action"
 
 
+class SpanType(str, Enum):
+    SPAN = "SPAN"
+    GENERATION = "GENERATION"
+    TOOL = "TOOL"
+    EMBEDDING = "EMBEDDING"
+
+
 class SpanWrapper:
     """
     Context manager for tracking observability data for external API calls.
@@ -58,9 +71,16 @@ class SpanWrapper:
             span.set_usage(usage_data)
     """
 
-    def __init__(self, name: str, attributes: Optional[Dict[str, str]] = None, module_name: str = "combat_sdk"):
+    def __init__(
+        self,
+        name: str,
+        attributes: Optional[Dict[str, str]] = None,
+        module_name: str = "combat_sdk",
+        as_type: Optional[SpanType] = SpanType.SPAN,
+    ):
         self.name = name
         self.attributes = attributes or {}
+
         self.start_time: Optional[float] = None
         self.end_time: Optional[float] = None
         self.status = "pending"
@@ -72,11 +92,34 @@ 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
+
+        if isinstance(as_type, SpanType):
+            self.attributes["netra.span.type"] = as_type.value
+        else:
+            raise ValueError(f"Invalid span type: {as_type}")
 
     def __enter__(self) -> "SpanWrapper":
         """Start the span wrapper, begin time tracking, and create OpenTelemetry span."""
         self.start_time = time.time()
 
+        # 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 +182,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,139 +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] = []
-        blocked_parent_map: Dict[Any, Any] = {}
-        for span in spans:
-            name = getattr(span, "name", None)
-            if name is None or not self._is_blocked(name):
-                filtered.append(span)
-                continue
-
-            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)
-        if blocked_parent_map:
-            self._reparent_blocked_children(filtered, blocked_parent_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 _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
-
-
 class Tracer:
     """
     Configures Netra's OpenTelemetry tracer with OTLP exporter (or Console exporter as fallback)
@@ -181,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.44"
+__version__ = "0.1.46"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netra-sdk
-Version: 0.1.44
+Version: 0.1.46
 Summary: A Python SDK for AI application observability that provides OpenTelemetry-based monitoring, tracing, and PII protection for LLM and vector database applications. Enables easy instrumentation, session tracking, and privacy-focused data collection for AI systems in production environments.
 License-Expression: Apache-2.0
 License-File: LICENCE

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

@@ -1,13 +1,15 @@
-netra/__init__.py,sha256=-eEBq3ndX3JAWDo4_Ra0L19KrTfrJhNDjlAwChb3_IA,10353
+netra/__init__.py,sha256=tbj0UsUHKMG8RHJ58Y0tCvPVDS_XkGb7sF_xM1lxJEY,10454
 netra/anonymizer/__init__.py,sha256=KeGPPZqKVZbtkbirEKYTYhj6aZHlakjdQhD7QHqBRio,133
 netra/anonymizer/anonymizer.py,sha256=IcrYkdwWrFauGWUeAW-0RwrSUM8VSZCFNtoywZhvIqU,3778
 netra/anonymizer/base.py,sha256=ytPxHCUD2OXlEY6fNTuMmwImNdIjgj294I41FIgoXpU,5946
 netra/anonymizer/fp_anonymizer.py,sha256=_6svIYmE0eejdIMkhKBUWCNjGtGimtrGtbLvPSOp8W4,6493
-netra/config.py,sha256=MMSAKrX_HCZ7QECjTocs_jsNFgcOnbP8aAVfOdq9YEs,7032
-netra/decorators.py,sha256=qZFHrwdj10FsTFqggo3XjdGB12aMxsrrDMMmslDqZ-0,17424
+netra/config.py,sha256=RqLul2vlNHHKGU31OQIJTUpcKMSmVse9IlGFwImW6sE,7032
+netra/decorators.py,sha256=NHJZeZo3LEuOxCz-lfz3j74o6CS0jS8JBRw2LvoeeWE,18389
 netra/exceptions/__init__.py,sha256=uDgcBxmC4WhdS7HRYQk_TtJyxH1s1o6wZmcsnSHLAcM,174
 netra/exceptions/injection.py,sha256=ke4eUXRYUFJkMZgdSyPPkPt5PdxToTI6xLEBI0hTWUQ,1332
 netra/exceptions/pii.py,sha256=MT4p_x-zH3VtYudTSxw1Z9qQZADJDspq64WrYqSWlZc,2438
+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/instrumentation_span_processor.py,sha256=VzurzwtGleFltxzKD_gjVkUQiRC6SGlb0oG4Nlpu85A,4365
+netra/processors/__init__.py,sha256=56RO7xMoBx2aoVuESyQXll65o7IoO98nSHZ5KpR5iQk,471
+netra/processors/instrumentation_span_processor.py,sha256=7iDnJUSBXyiRcWxoxk3uStoh0r4Yxjh7PBTbFDVMjlA,4150
+netra/processors/local_filtering_span_processor.py,sha256=Vk_UP--ZxWwdrbJA7a95iRo853QfPCME2C5ChgjiHl8,6664
 netra/processors/scrubbing_span_processor.py,sha256=dJ86Ncmjvmrhm_uAdGTwcGvRpZbVVWqD9AOFwEMWHZY,6701
 netra/processors/session_span_processor.py,sha256=qcsBl-LnILWefsftI8NQhXDGb94OWPc8LvzhVA0JS_c,2432
 netra/scanner.py,sha256=kyDpeZiscCPb6pjuhS-sfsVj-dviBFRepdUWh0sLoEY,11554
-netra/session_manager.py,sha256=VzmSAiP63ODCuOWv-irsxyU2LvHoqjOBUuXtyxboBU0,13740
-netra/span_wrapper.py,sha256=IygQX78xQRlL_Z1MfKfUbv0okihx92qNClnRlYFtRNc,8004
-netra/tracer.py,sha256=3s_ZAHgpfeegcnA43KVEinEPVyo3kGi_0bvSrQcKljk,8348
+netra/session_manager.py,sha256=jxA62zAgiTsuTyV_UuPkVb2W1Uieb7I5jWsYiJ6jSxk,13897
+netra/span_wrapper.py,sha256=80-0MkAw7AOQg0u7dj2YfXfnuUQDE8ymsGNzh6y6JtA,10102
+netra/tracer.py,sha256=IPVYMc4x74XZJeKvCfV6b0X9mUHGvsssUzLnRvFPV6M,4629
 netra/utils.py,sha256=FblSzI8qMTfEbusakGBKE9CNELW0GEBHl09mPPxgI-w,2521
-netra/version.py,sha256=AoJtnEXXv6E20uj57ChQUsGoLfKG8mvSQpdz97tcyis,23
-netra_sdk-0.1.44.dist-info/METADATA,sha256=f7QrKDQQtQyaaAzIzGFF44KOpHpNW00wrZ3KIPt0zvA,28208
-netra_sdk-0.1.44.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-netra_sdk-0.1.44.dist-info/licenses/LICENCE,sha256=8B_UoZ-BAl0AqiHAHUETCgd3I2B9yYJ1WEQtVb_qFMA,11359
-netra_sdk-0.1.44.dist-info/RECORD,,
+netra/version.py,sha256=X3e_85I7oZGwZD8nW9SBKEUbQU7-_3W9FXuicrfxHjc,23
+netra_sdk-0.1.46.dist-info/METADATA,sha256=QWfOewRPrRyNlamWqdvuS-1U01UocBvxcRZQ_H6Qmvw,28208
+netra_sdk-0.1.46.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+netra_sdk-0.1.46.dist-info/licenses/LICENCE,sha256=8B_UoZ-BAl0AqiHAHUETCgd3I2B9yYJ1WEQtVb_qFMA,11359
+netra_sdk-0.1.46.dist-info/RECORD,,