netra-sdk 0.1.42__tar.gz → 0.1.44__tar.gz

{netra_sdk-0.1.42 → netra_sdk-0.1.44}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: netra-sdk
-Version: 0.1.42
+Version: 0.1.44
 Summary: A Python SDK for AI application observability that provides OpenTelemetry-based monitoring, tracing, and PII protection for LLM and vector database applications. Enables easy instrumentation, session tracking, and privacy-focused data collection for AI systems in production environments.
-License: Apache-2.0
+License-Expression: Apache-2.0
+License-File: LICENCE
 Keywords: netra,tracing,observability,sdk,ai,llm,vector,database
 Author: Sooraj Thomas
 Author-email: sooraj@keyvalue.systems
@@ -19,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 Provides-Extra: llm-guard
 Provides-Extra: presidio
+Requires-Dist: json-repair (==0.44.1)
 Requires-Dist: llm-guard (==0.3.16) ; extra == "llm-guard"
 Requires-Dist: opentelemetry-api (>=1.34.0,<2.0.0)
 Requires-Dist: opentelemetry-instrumentation-aio-pika (>=0.55b1,<1.0.0)

{netra_sdk-0.1.42 → netra_sdk-0.1.44}/netra/config.py

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

{netra_sdk-0.1.42 → netra_sdk-0.1.44}/netra/session_manager.py

@@ -13,6 +13,7 @@ from opentelemetry import context as otel_context
 from opentelemetry import trace
 
 from netra.config import Config
+from netra.utils import process_content_for_max_len
 
 logger = logging.getLogger(__name__)
 
@@ -279,6 +280,10 @@ class SessionManager:
 
         if not isinstance(role, str):
             raise TypeError(f"role must be a string, got {type(role)}")
+
+        if not isinstance(content, (str, dict)):
+            raise TypeError(f"content must be a string or dict, got {type(content)}")
+
         if not role:
             raise ValueError("role must be a non-empty string")
 
@@ -286,11 +291,14 @@ class SessionManager:
             raise ValueError("content must not be empty")
 
         try:
+
+            # Get active recording span
             span = trace.get_current_span()
             if not (span and getattr(span, "is_recording", lambda: False)()):
                 logger.warning("No active span to add conversation attribute.")
                 return
 
+            # Load existing conversation (JSON string -> list)
             existing: List[Dict[str, Any]] = []
             raw_data = None
 
@@ -300,10 +308,12 @@ class SessionManager:
                     raw_data = attrs.get("conversation")
             except Exception:
                 logger.exception("Failed to retrieve conversation attribute")
+
             if raw_data:
                 try:
                     import json
 
+                    parsed: Any = None
                     if isinstance(raw_data, str):
                         parsed = json.loads(raw_data)
                     if isinstance(parsed, list):
@@ -311,16 +321,30 @@ class SessionManager:
                 except Exception:
                     existing = []
 
-            # Append new entry
-            entry: Dict[str, Any] = {"type": normalized_type, "role": role, "content": content}
-            # Add value_type and media_type based on value type for backend parsing
-            if isinstance(content, str):
+            # Enforce per-entry content length limit without breaking the entire conversation structure
+            max_len = Config.CONVERSATION_CONTENT_MAX_LEN
+            processed_content = process_content_for_max_len(content, max_len)
+
+            # Create a conversation entry
+            entry: Dict[str, Any] = {"type": normalized_type, "role": role, "content": processed_content}
+
+            # Add format based on processed value type for backend parsing
+            if isinstance(processed_content, str):
                 entry["format"] = "text"
-            elif isinstance(content, dict):
+            elif isinstance(processed_content, dict):
                 entry["format"] = "json"
             existing.append(entry)
 
-            SessionManager.set_attribute_on_active_span("conversation", existing)
+            # Bypass global attribute value truncation by writing directly to the span's
+            # private attribute store. We intentionally avoid span.set_attribute here.
+            try:
+                import json
+
+                payload = json.dumps(existing, default=str)
+                attrs = getattr(span, "_attributes", None)
+                attrs["conversation"] = payload  # type: ignore[index]
+            except Exception:
+                logger.exception("Failed to set conversation attribute directly on span")
         except Exception as e:
             logger.exception("Failed to add conversation attribute: %s", e)
 

{netra_sdk-0.1.42 → netra_sdk-0.1.44}/netra/tracer.py

@@ -57,50 +57,74 @@ class FilteringSpanExporter(SpanExporter):  # type: ignore[misc]
 
     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)
+        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
-            # 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)
+
+            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()

netra_sdk-0.1.44/netra/utils.py

@@ -0,0 +1,81 @@
+"""General utility helpers for Netra SDK.
+
+This module centralizes common helpers that can be reused across the codebase.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def truncate_string(value: str, max_len: int) -> str:
+    """Truncate a string to max_len characters.
+
+    If value is not a string, it is returned unchanged.
+    """
+    try:
+        if not isinstance(value, str):
+            return value
+        return value if len(value) <= max_len else value[:max_len]
+    except Exception:
+        return value
+
+
+def truncate_and_repair_json(content: Any, max_len: int) -> Any:
+    """Truncate a dict/list by JSON-serializing and hard-cutting, then attempt repair.
+
+    The function will:
+    - json.dumps(content, default=str)
+    - hard-cut the string to max_len
+    - try to repair using `json-repair` (optional dependency)
+    - parse back with json.loads
+
+    On failure, returns a minimal safe container with a preview of the truncated text.
+    """
+    try:
+        import json
+
+        json_str = json.dumps(content, default=str)
+        if len(json_str) <= max_len:
+            return content
+
+        truncated = json_str[:max_len]
+
+        # Try json_repair if available
+        repaired_obj: Any = None
+        try:
+            try:
+                from json_repair import repair_json as _repair_json
+            except Exception:  # pragma: no cover - optional dependency not installed
+                _repair_json = None
+
+            if _repair_json is not None:
+                repaired_str = _repair_json(truncated)
+                repaired_obj = json.loads(repaired_str)
+        except Exception:
+            repaired_obj = None
+
+        if repaired_obj is not None:
+            return repaired_obj
+
+        # Fallback: safe container preserving a preview
+        return {"__truncated__": True, "preview": truncated}
+    except Exception:
+        # If anything goes wrong, return original content as-is
+        return content
+
+
+def process_content_for_max_len(content: Any, max_len: int) -> Any:
+    """Ensure the content fits within max_len when serialized.
+
+    - If content is a string: truncate to max_len.
+    - If content is a dict or list: attempt truncate+repair to keep it valid JSON.
+    """
+    try:
+        if isinstance(content, str):
+            return truncate_string(content, max_len)
+        if isinstance(content, (dict, list)):
+            return truncate_and_repair_json(content, max_len)
+        return content
+    except Exception:
+        return content

netra_sdk-0.1.44/netra/version.py

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

{netra_sdk-0.1.42 → netra_sdk-0.1.44}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "netra-sdk"
-version = "0.1.42"
+version = "0.1.44"
 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"}
@@ -77,6 +77,7 @@ dependencies = [
     "opentelemetry-instrumentation-tortoiseorm>=0.55b1,<1.0.0",
     "opentelemetry-instrumentation-urllib>=0.55b1,<1.0.0",
     "opentelemetry-instrumentation-urllib3>=0.55b1,<1.0.0",
+    "json-repair==0.44.1",
 ]
 
 [project.urls]

netra_sdk-0.1.42/netra/version.py

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