netra-sdk 0.1.43__tar.gz → 0.1.45__tar.gz

{netra_sdk-0.1.43 → netra_sdk-0.1.45}/PKG-INFO

@@ -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.45/netra/exporters/__init__.py

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

netra_sdk-0.1.45/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_sdk-0.1.43 → netra_sdk-0.1.45}/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_sdk-0.1.45/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_sdk-0.1.43 → netra_sdk-0.1.45}/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_sdk-0.1.45/netra/tracer.py

@@ -0,0 +1,121 @@
+"""Netra OpenTelemetry tracer configuration module.
+
+This module handles the initialization and configuration of OpenTelemetry tracing,
+including exporter setup and span processor configuration.
+"""
+
+import logging
+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 TracerProvider
+from opentelemetry.sdk.trace.export import (
+    BatchSpanProcessor,
+    ConsoleSpanExporter,
+    SimpleSpanProcessor,
+)
+
+from netra.config import Config
+from netra.exporters import FilteringSpanExporter
+
+logger = logging.getLogger(__name__)
+
+
+class Tracer:
+    """
+    Configures Netra's OpenTelemetry tracer with OTLP exporter (or Console exporter as fallback)
+    and appropriate span processor.
+    """
+
+    def __init__(self, cfg: Config) -> None:
+        """Initialize the Netra tracer with the provided configuration.
+
+        Args:
+            cfg: Configuration object with tracer settings
+        """
+        self.cfg = cfg
+        self._setup_tracer()
+
+    def _setup_tracer(self) -> None:
+        """Set up the OpenTelemetry tracer with appropriate exporters and processors.
+
+        Creates a resource with service name and custom attributes,
+        configures the appropriate exporter (OTLP or Console fallback),
+        and sets up either a batch or simple span processor based on configuration.
+        """
+        # Create Resource with service.name + custom attributes
+        resource_attrs: Dict[str, Any] = {
+            SERVICE_NAME: self.cfg.app_name,
+            DEPLOYMENT_ENVIRONMENT: self.cfg.environment,
+        }
+        if self.cfg.resource_attributes:
+            resource_attrs.update(self.cfg.resource_attributes)
+        resource = Resource(attributes=resource_attrs)
+
+        # Build TracerProvider
+        provider = TracerProvider(resource=resource)
+
+        # Configure exporter based on configuration
+        if not self.cfg.otlp_endpoint:
+            logger.warning("OTLP endpoint not provided, falling back to console exporter")
+            exporter = ConsoleSpanExporter()
+        else:
+            exporter = OTLPSpanExporter(
+                endpoint=self._format_endpoint(self.cfg.otlp_endpoint),
+                headers=self.cfg.headers,
+            )
+        # Wrap exporter with filtering to support both global and local (baggage-based) rules
+        try:
+            patterns = getattr(self.cfg, "blocked_spans", None) or []
+            exporter = FilteringSpanExporter(exporter, patterns)
+            if patterns:
+                logger.info("Enabled FilteringSpanExporter with %d global pattern(s)", len(patterns))
+            else:
+                logger.info("Enabled FilteringSpanExporter with local-only rules")
+        except Exception as e:
+            logger.warning("Failed to enable FilteringSpanExporter: %s", e)
+        # Add span processors: first instrumentation wrapper, then session processor
+        from netra.processors import (
+            InstrumentationSpanProcessor,
+            LocalFilteringSpanProcessor,
+            ScrubbingSpanProcessor,
+            SessionSpanProcessor,
+        )
+
+        # Apply local filtering propagation first so later processors and spans see attributes
+        provider.add_span_processor(LocalFilteringSpanProcessor())
+        provider.add_span_processor(InstrumentationSpanProcessor())
+        provider.add_span_processor(SessionSpanProcessor())
+
+        # Add scrubbing processor if enabled
+        if self.cfg.enable_scrubbing:
+            provider.add_span_processor(ScrubbingSpanProcessor())  # type: ignore[no-untyped-call]
+
+        # Install appropriate span processor
+        if self.cfg.disable_batch:
+            provider.add_span_processor(SimpleSpanProcessor(exporter))
+        else:
+            provider.add_span_processor(BatchSpanProcessor(exporter))
+
+        # Set global tracer provider
+        trace.set_tracer_provider(provider)
+        logger.info(
+            "Netra TracerProvider initialized: endpoint=%s, disable_batch=%s",
+            self.cfg.otlp_endpoint,
+            self.cfg.disable_batch,
+        )
+
+    def _format_endpoint(self, endpoint: str) -> str:
+        """Format the OTLP endpoint URL to ensure it ends with '/v1/traces'.
+
+        Args:
+            endpoint: Base OTLP endpoint URL
+
+        Returns:
+            Properly formatted endpoint URL
+        """
+        if not endpoint.endswith("/v1/traces"):
+            return endpoint.rstrip("/") + "/v1/traces"
+        return endpoint

netra_sdk-0.1.45/netra/version.py

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

{netra_sdk-0.1.43 → netra_sdk-0.1.45}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "netra-sdk"
-version = "0.1.43"
+version = "0.1.45"
 description = "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."
 authors = [
     {name = "Sooraj Thomas",email = "sooraj@keyvalue.systems"}

netra_sdk-0.1.43/netra/tracer.py

@@ -1,203 +0,0 @@
-"""Netra OpenTelemetry tracer configuration module.
-
-This module handles the initialization and configuration of OpenTelemetry tracing,
-including exporter setup and span processor configuration.
-"""
-
-import logging
-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 ReadableSpan, TracerProvider
-from opentelemetry.sdk.trace.export import (
-    BatchSpanProcessor,
-    ConsoleSpanExporter,
-    SimpleSpanProcessor,
-    SpanExporter,
-    SpanExportResult,
-)
-
-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
-            # 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)
-    and appropriate span processor.
-    """
-
-    def __init__(self, cfg: Config) -> None:
-        """Initialize the Netra tracer with the provided configuration.
-
-        Args:
-            cfg: Configuration object with tracer settings
-        """
-        self.cfg = cfg
-        self._setup_tracer()
-
-    def _setup_tracer(self) -> None:
-        """Set up the OpenTelemetry tracer with appropriate exporters and processors.
-
-        Creates a resource with service name and custom attributes,
-        configures the appropriate exporter (OTLP or Console fallback),
-        and sets up either a batch or simple span processor based on configuration.
-        """
-        # Create Resource with service.name + custom attributes
-        resource_attrs: Dict[str, Any] = {
-            SERVICE_NAME: self.cfg.app_name,
-            DEPLOYMENT_ENVIRONMENT: self.cfg.environment,
-        }
-        if self.cfg.resource_attributes:
-            resource_attrs.update(self.cfg.resource_attributes)
-        resource = Resource(attributes=resource_attrs)
-
-        # Build TracerProvider
-        provider = TracerProvider(resource=resource)
-
-        # Configure exporter based on configuration
-        if not self.cfg.otlp_endpoint:
-            logger.warning("OTLP endpoint not provided, falling back to console exporter")
-            exporter = ConsoleSpanExporter()
-        else:
-            exporter = OTLPSpanExporter(
-                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, 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))
-        else:
-            provider.add_span_processor(BatchSpanProcessor(exporter))
-
-        # Set global tracer provider
-        trace.set_tracer_provider(provider)
-        logger.info(
-            "Netra TracerProvider initialized: endpoint=%s, disable_batch=%s",
-            self.cfg.otlp_endpoint,
-            self.cfg.disable_batch,
-        )
-
-    def _format_endpoint(self, endpoint: str) -> str:
-        """Format the OTLP endpoint URL to ensure it ends with '/v1/traces'.
-
-        Args:
-            endpoint: Base OTLP endpoint URL
-
-        Returns:
-            Properly formatted endpoint URL
-        """
-        if not endpoint.endswith("/v1/traces"):
-            return endpoint.rstrip("/") + "/v1/traces"
-        return endpoint

netra_sdk-0.1.43/netra/version.py

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