netra-sdk 0.1.6__py3-none-any.whl → 0.1.9__py3-none-any.whl

netra/{session.py → span_wrapper.py}

@@ -16,10 +16,18 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
+class ActionModel(BaseModel):  # type: ignore[misc]
+    action: str
+    action_type: str
+    success: bool
+    affected_records: Optional[List[Dict[str, str]]] = None
+    metadata: Optional[Dict[str, str]] = None
+
+
 class UsageModel(BaseModel):  # type: ignore[misc]
     model: str
-    type: str
-    unit_used: Optional[int] = None
+    usage_type: str
+    units_used: Optional[int] = None
     cost_in_usd: Optional[float] = None
 
 
@@ -28,27 +36,25 @@ class ATTRIBUTE:
     MODEL = "model"
     PROMPT = "prompt"
     NEGATIVE_PROMPT = "negative_prompt"
-    HEIGHT = "height"
-    WIDTH = "width"
-    OUTPUT_TYPE = "output_type"
     USAGE = "usage"
     STATUS = "status"
     DURATION_MS = "duration_ms"
     ERROR_MESSAGE = "error_message"
+    ACTION = "action"
 
 
-class Session:
+class SpanWrapper:
     """
     Context manager for tracking observability data for external API calls.
 
     Usage:
-        with combat.start_session("video_gen_task") as session:
-            session.set_prompt("A cat playing piano").set_image_height("1024")
+        with combat.start_span("video_gen_task") as span:
+            span.set_prompt("A cat playing piano").set_image_height("1024")
 
             # External API call
             result = external_api.generate_video(...)
 
-            session.set_usage(usage_data)
+            span.set_usage(usage_data)
     """
 
     def __init__(self, name: str, attributes: Optional[Dict[str, str]] = None, module_name: str = "combat_sdk"):
@@ -65,8 +71,8 @@ class Session:
         self.span: Optional[trace.Span] = None
         self.context_token: Optional[Any] = None
 
-    def __enter__(self) -> "Session":
-        """Start the session, begin time tracking, and create OpenTelemetry span."""
+    def __enter__(self) -> "SpanWrapper":
+        """Start the span wrapper, begin time tracking, and create OpenTelemetry span."""
         self.start_time = time.time()
 
         # Create OpenTelemetry span
@@ -76,11 +82,11 @@ class Session:
         ctx = set_span_in_context(self.span)
         self.context_token = context_api.attach(ctx)
 
-        logger.info(f"Started session: {self.name}")
+        logger.info(f"Started span wrapper: {self.name}")
         return self
 
     def __exit__(self, exc_type: Optional[type], exc_val: Optional[Exception], exc_tb: Any) -> Literal[False]:
-        """End the session, calculate duration, handle errors, and close OpenTelemetry span."""
+        """End the span wrapper, calculate duration, handle errors, and close OpenTelemetry span."""
         self.end_time = time.time()
         duration_ms = (self.end_time - self.start_time) * 1000 if self.start_time is not None else None
 
@@ -101,7 +107,7 @@ class Session:
                 self.span.set_status(Status(StatusCode.ERROR, self.error_message))
                 if exc_val is not None:
                     self.span.record_exception(exc_val)
-            logger.error(f"Session {self.name} failed: {self.error_message}")
+            logger.error(f"Span wrapper {self.name} failed: {self.error_message}")
 
         self.set_attribute(f"{Config.LIBRARY_NAME}.{ATTRIBUTE.STATUS}", self.status)
 
@@ -117,15 +123,15 @@ class Session:
             context_api.detach(self.context_token)
 
         logger.info(
-            f"Ended session: {self.name} (Status: {self.status}, Duration: {duration_ms:.2f}ms)"
+            f"Ended span wrapper: {self.name} (Status: {self.status}, Duration: {duration_ms:.2f}ms)"
             if duration_ms is not None
-            else f"Ended session: {self.name} (Status: {self.status})"
+            else f"Ended span wrapper: {self.name} (Status: {self.status})"
         )
 
         # Don't suppress exceptions
         return False
 
-    def set_attribute(self, key: str, value: str) -> "Session":
+    def set_attribute(self, key: str, value: str) -> "SpanWrapper":
         """Set a single attribute and return self for method chaining."""
         self.attributes[key] = value
         # Also set on the span if it exists
@@ -133,41 +139,35 @@ class Session:
             self.span.set_attribute(key, value)
         return self
 
-    def set_prompt(self, prompt: str) -> "Session":
+    def set_prompt(self, prompt: str) -> "SpanWrapper":
         """Set the input prompt."""
         return self.set_attribute(f"{Config.LIBRARY_NAME}.{ATTRIBUTE.PROMPT}", prompt)
 
-    def set_negative_prompt(self, negative_prompt: str) -> "Session":
+    def set_negative_prompt(self, negative_prompt: str) -> "SpanWrapper":
         """Set the negative prompt."""
         return self.set_attribute(f"{Config.LIBRARY_NAME}.{ATTRIBUTE.NEGATIVE_PROMPT}", negative_prompt)
 
-    def set_height(self, height: str) -> "Session":
-        """Set the height."""
-        return self.set_attribute(f"{Config.LIBRARY_NAME}.{ATTRIBUTE.HEIGHT}", height)
-
-    def set_width(self, width: str) -> "Session":
-        """Set the width."""
-        return self.set_attribute(f"{Config.LIBRARY_NAME}.{ATTRIBUTE.WIDTH}", width)
-
-    def set_output_type(self, output_type: str) -> "Session":
-        """Set the output type."""
-        return self.set_attribute(f"{Config.LIBRARY_NAME}.{ATTRIBUTE.OUTPUT_TYPE}", output_type)
-
-    def set_usage(self, usage: List[UsageModel]) -> "Session":
+    def set_usage(self, usage: List[UsageModel]) -> "SpanWrapper":
         """Set the usage data as a JSON string."""
         usage_dict = [u.model_dump() for u in usage]
         usage_json = json.dumps(usage_dict)
         return self.set_attribute(f"{Config.LIBRARY_NAME}.{ATTRIBUTE.USAGE}", usage_json)
 
-    def set_model(self, model: str) -> "Session":
+    def set_action(self, action: List[ActionModel]) -> "SpanWrapper":
+        """Set the action data as a JSON string."""
+        action_dict = [a.model_dump() for a in action]
+        action_json = json.dumps(action_dict)
+        return self.set_attribute(f"{Config.LIBRARY_NAME}.{ATTRIBUTE.ACTION}", action_json)
+
+    def set_model(self, model: str) -> "SpanWrapper":
         """Set the model used."""
         return self.set_attribute(f"{Config.LIBRARY_NAME}.{ATTRIBUTE.MODEL}", model)
 
-    def set_llm_system(self, system: str) -> "Session":
+    def set_llm_system(self, system: str) -> "SpanWrapper":
         """Set the LLM system used."""
         return self.set_attribute(f"{Config.LIBRARY_NAME}.{ATTRIBUTE.LLM_SYSTEM}", system)
 
-    def set_error(self, error_message: str) -> "Session":
+    def set_error(self, error_message: str) -> "SpanWrapper":
         """Manually set an error message."""
         self.status = "error"
         self.error_message = error_message
@@ -175,14 +175,14 @@ class Session:
             self.span.set_status(Status(StatusCode.ERROR, error_message))
         return self.set_attribute(f"{Config.LIBRARY_NAME}.{ATTRIBUTE.ERROR_MESSAGE}", error_message)
 
-    def set_success(self) -> "Session":
-        """Manually mark the session as successful."""
+    def set_success(self) -> "SpanWrapper":
+        """Manually mark the span wrapper as successful."""
         self.status = "success"
         if self.span:
             self.span.set_status(Status(StatusCode.OK))
         return self
 
-    def add_event(self, name: str, attributes: Optional[Dict[str, str]] = None) -> "Session":
+    def add_event(self, name: str, attributes: Optional[Dict[str, str]] = None) -> "SpanWrapper":
         """Add an event to the span."""
         if self.span:
             self.span.add_event(name, attributes or {})

netra/tracer.py

@@ -66,10 +66,9 @@ class Tracer:
                 headers=self.cfg.headers,
             )
         # Add span processors for session span processing and data aggregation processing
-        from netra.processors import ErrorDetectionProcessor, SessionSpanProcessor
+        from netra.processors import SessionSpanProcessor
 
         provider.add_span_processor(SessionSpanProcessor())
-        provider.add_span_processor(ErrorDetectionProcessor())
 
         # Install appropriate span processor
         if self.cfg.disable_batch:

netra/version.py

@@ -1 +1,2 @@
-__version__ = "0.1.6"
+__version__ = "0.1.9"
+

{netra_sdk-0.1.6.dist-info → netra_sdk-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: netra-sdk
-Version: 0.1.6
+Version: 0.1.9
 Summary: A Python SDK for AI application observability that provides OpenTelemetry-based monitoring, tracing, and PII protection for LLM and vector database applications. Enables easy instrumentation, session tracking, and privacy-focused data collection for AI systems in production environments.
 License: Apache-2.0
 Keywords: netra,tracing,observability,sdk,ai,llm,vector,database
@@ -402,46 +402,96 @@ Netra.set_custom_event(event_name="conversion", attributes={
     "value": 99.99
 })
 ```
-## 🔄 Custom Session Tracking
+## 🔄 Custom Span Tracking
 
-Use the custom session tracking utility to track external API calls with detailed observability:
+Use the custom span tracking utility to track external API calls with detailed observability:
 
 ```python
-from netra import Netra, Session
-from netra.session import UsageModel
-
-# Start a new session
-with Netra.start_session("image_generation") as session:
-    # Set session attributes
-    session.set_prompt("A beautiful sunset over mountains")
-    session.set_negative_prompt("blurry, low quality")
-    session.set_height("1024")
-    session.set_width("1024")
-    session.set_model("dall-e-3")
-    session.set_llm_system("openai")
+from netra import Netra, UsageModel
+
+# Start a new span
+with Netra.start_span("image_generation") as span:
+    # Set span attributes
+    span.set_prompt("A beautiful sunset over mountains")
+    span.set_negative_prompt("blurry, low quality")
+    span.set_model("dall-e-3")
+    span.set_llm_system("openai")
 
     # Set usage data with UsageModel
     usage_data = [
         UsageModel(
             model="dall-e-3",
-            type="image_generation",
-            unit_used=1,
+            usage_type="image_generation",
+            units_used=1,
             cost_in_usd=0.02
         )
     ]
-    session.set_usage(usage_data)
+    span.set_usage(usage_data)
 
     # Your API calls here
     # ...
 
     # Set custom attributes
-    session.set_attribute("custom_key", "custom_value")
+    span.set_attribute("custom_key", "custom_value")
 
     # Add events
-    session.add_event("generation_started", {"step": 1, "status": "processing"})
-    session.add_event("processing_completed", {"step": "rendering"})
+    span.add_event("generation_started", {"step": "1", "status": "processing"})
+    span.add_event("processing_completed", {"step": "rendering"})
+
+    # Get the current active open telemetry span
+    current_span = span.get_current_span()
+
+    # Track database operations and other actions
+    action = ActionModel(
+        action="DB",
+        action_type="INSERT",
+        affected_records=[
+            {"record_id": "user_123", "record_type": "user"},
+            {"record_id": "profile_456", "record_type": "profile"}
+        ],
+        metadata={
+            "table": "users",
+            "operation_id": "tx_789",
+            "duration_ms": "45"
+        },
+        success=True
+    )
+    span.set_action([action])
+
+    # Record API calls
+    api_action = ActionModel(
+        action="API",
+        action_type="CALL",
+        metadata={
+            "endpoint": "/api/v1/process",
+            "method": "POST",
+            "status_code": 200,
+            "duration_ms": "120"
+        },
+        success=True
+    )
+    span.set_action([api_action])
+```
+
+### Action Tracking Schema
+
+Action tracking follows this schema:
 
-# Session automatically captures duration, status, and any errors
+```python
+[
+    {
+        "action": str,                # Type of action (e.g., "DB", "API", "CACHE")
+        "action_type": str,           # Action subtype (e.g., "INSERT", "SELECT", "CALL")
+        "affected_records": [         # Optional: List of records affected
+            {
+                "record_id": str,     # ID of the affected record
+                "record_type": str    # Type of the record
+            }
+        ],
+        "metadata": Dict[str, str],   # Additional metadata as key-value pairs
+        "success": bool              # Whether the action succeeded
+    }
+]
 ```
 
 ## 🔧 Advanced Configuration

{netra_sdk-0.1.6.dist-info → netra_sdk-0.1.9.dist-info}/RECORD

@@ -1,42 +1,46 @@
-netra/__init__.py,sha256=0qOHztSxtkSdA6-6gOT8BAqEMUnFOpFAhz9Sk2hTKRE,4665
+netra/__init__.py,sha256=0w42KiANH31q0sXFL2hLxRjueepfo_jbx2oMDc5miFo,4733
 netra/anonymizer/__init__.py,sha256=KeGPPZqKVZbtkbirEKYTYhj6aZHlakjdQhD7QHqBRio,133
 netra/anonymizer/anonymizer.py,sha256=1VeYAsFpF_tYDlqJF-Q82-ZXGOR4YWBqrKUsRw3qOrA,3539
 netra/anonymizer/base.py,sha256=ytPxHCUD2OXlEY6fNTuMmwImNdIjgj294I41FIgoXpU,5946
 netra/anonymizer/fp_anonymizer.py,sha256=_6svIYmE0eejdIMkhKBUWCNjGtGimtrGtbLvPSOp8W4,6493
-netra/config.py,sha256=6aUG-BWWDOyptnTlEjOpB41n9xLmuo-XBAgs5GE5Tbg,4761
+netra/config.py,sha256=S9GsCvwtakrmryAaV-AhyVB_wAQ6tjwPLLZQemLgXko,5006
 netra/decorators.py,sha256=V_WpZ2IgW2Y7B_WnSXmKUGGhkM5Cra2TwONddmJpPaI,6837
 netra/exceptions/__init__.py,sha256=uDgcBxmC4WhdS7HRYQk_TtJyxH1s1o6wZmcsnSHLAcM,174
 netra/exceptions/injection.py,sha256=ke4eUXRYUFJkMZgdSyPPkPt5PdxToTI6xLEBI0hTWUQ,1332
 netra/exceptions/pii.py,sha256=MT4p_x-zH3VtYudTSxw1Z9qQZADJDspq64WrYqSWlZc,2438
 netra/input_scanner.py,sha256=bzP3s7YudGHQrIbUgQGrcIBEJ6CmOewzuYNSu75cVXM,4988
-netra/instrumentation/__init__.py,sha256=s-sXykQZ4CKUHLqHRR7buOrkN9hXGTZpNALRZkdIHB0,38757
+netra/instrumentation/__init__.py,sha256=Mz7BlRp4zgKAD3oLBGfBzh5naVVgAP0sLw4ISDydhLw,39567
 netra/instrumentation/aiohttp/__init__.py,sha256=M1kuF0R3gKY5rlbhEC1AR13UWHelmfokluL2yFysKWc,14398
 netra/instrumentation/aiohttp/version.py,sha256=Zy-0Aukx-HS_Mo3NKPWg-hlUoWKDzS0w58gLoVtJec8,24
 netra/instrumentation/cohere/__init__.py,sha256=3XwmCAZwZiMkHdNN3YvcBOLsNCx80ymbU31TyMzv1IY,17685
 netra/instrumentation/cohere/version.py,sha256=eFXRvO5AgP2DDj5tMt7hkuzi30NOLEqZ9dJpPaHFZLs,23
+netra/instrumentation/fastapi/__init__.py,sha256=v955lLezcI-3toA60RVkTYqlstu-QjMOAbLkM9uHHU4,16611
+netra/instrumentation/fastapi/version.py,sha256=FX3pdiCFGDsISNiq2rT0sQFwNLZ5IGKhiVknXkSE3O0,24
 netra/instrumentation/google_genai/__init__.py,sha256=470x3o5_NDQHRNT4o-IWnSZw1JjPnAoFSZ-mpaWvAuE,17894
 netra/instrumentation/google_genai/config.py,sha256=XCyo3mk30qkvqyCqeTrKwROahu0gcOEwmbDLOo53J5k,121
 netra/instrumentation/google_genai/utils.py,sha256=2OeSN5jUaMKF4x5zWiW65R1LB_a44Roi00isv2vxFME,921
 netra/instrumentation/google_genai/version.py,sha256=Hww1duZrC8kYK7ThBSQVyz0HNOb0ys_o8Pln-wVQ1hI,23
 netra/instrumentation/httpx/__init__.py,sha256=w1su_eQP_w5ZJHq0Lf-4miF5zM4OOW0ItmRp0wi85Ew,19388
 netra/instrumentation/httpx/version.py,sha256=ZRQKbgDaGz_yuLk-cUKuk6ZBKCSRKZC8nQd041NRNXk,23
-netra/instrumentation/instruments.py,sha256=M_-4N1YML-Lc1Jb2dIzoHF9sCmsFz4euUvm8a-VKROM,4247
+netra/instrumentation/instruments.py,sha256=_25TCDiBsgqP_fzL4OgwWx2UKD8EnzvLn0WA8t3lB_U,4269
 netra/instrumentation/mistralai/__init__.py,sha256=RE0b-rS6iXdoynJMFKHL9s97eYo5HghrJa013fR4ZhI,18910
 netra/instrumentation/mistralai/config.py,sha256=XCyo3mk30qkvqyCqeTrKwROahu0gcOEwmbDLOo53J5k,121
 netra/instrumentation/mistralai/utils.py,sha256=nhdIer5gJFxuGwg8FCT222hggDHeMQDhJctnDSwLqcc,894
 netra/instrumentation/mistralai/version.py,sha256=d6593s-XBNvVxri9lr2qLUDZQ3Zk3-VXHEwdb4pj8qA,22
+netra/instrumentation/openai/__init__.py,sha256=HztqLMw8Tf30-Ydqr4N7FcvAwj-5cnGZNqI-S3wIZ_4,5143
+netra/instrumentation/openai/version.py,sha256=_J-N1qG50GykJDM356BSQf0E8LoLbB8AaC3RKho494A,23
+netra/instrumentation/openai/wrappers.py,sha256=hXUgWKAs2_LCKIBnScoIJt_AkHhdQKnZWk7D94UjPGU,20685
 netra/instrumentation/weaviate/__init__.py,sha256=EOlpWxobOLHYKqo_kMct_7nu26x1hr8qkeG5_h99wtg,4330
 netra/instrumentation/weaviate/version.py,sha256=PiCZHjonujPbnIn0KmD3Yl68hrjPRG_oKe5vJF3mmG8,24
 netra/pii.py,sha256=S7GnVzoNJEzKiUWnqN9bOCKPeNLsriztgB2E6Rx-yJU,27023
-netra/processors/__init__.py,sha256=G16VumYTpgV4jsWrKNFSgm6xMQAsZ2Rrux25UVeo5YQ,215
-netra/processors/error_detection_processor.py,sha256=TtSZoJ7BCMHlVaXWYfqLHSZ6uIx43tdqYb7AFXpt0BA,2898
+netra/processors/__init__.py,sha256=wfnSskRBtMT90hO7LqFJoEW374LgoH_gnTxhynqtByI,109
 netra/processors/session_span_processor.py,sha256=qcsBl-LnILWefsftI8NQhXDGb94OWPc8LvzhVA0JS_c,2432
 netra/scanner.py,sha256=wqjMZnEbVvrGMiUSI352grUyHpkk94oBfHfMiXPhpGU,3866
-netra/session.py,sha256=o1wXrPzMauqj_3P-iNBHVlcIR7zcKcbsmkrcHjQMKuY,7263
 netra/session_manager.py,sha256=EVcnWcSj4NdkH--HmqHx0mmzivQiM4GCyFLu6lwi33M,6252
-netra/tracer.py,sha256=9jAKdIHXbaZ6WV_p8I1syQiMdqXVCXMhpEhCBsbbci8,3538
-netra/version.py,sha256=n3oM6B_EMz93NsTI18NNZd-jKFcUPzUkbIKj5VFK5ok,22
-netra_sdk-0.1.6.dist-info/LICENCE,sha256=8B_UoZ-BAl0AqiHAHUETCgd3I2B9yYJ1WEQtVb_qFMA,11359
-netra_sdk-0.1.6.dist-info/METADATA,sha256=5iMVB2PTJpnGBVB-JSsBF9AS5OzGUT2heIdfRoOXR1s,23730
-netra_sdk-0.1.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-netra_sdk-0.1.6.dist-info/RECORD,,
+netra/span_wrapper.py,sha256=MMFuQTqEmQ33pj6qUeIx7EbJJoEz_hzW-4dt1Y2N7s8,7286
+netra/tracer.py,sha256=In5QPVLz_6BxrolWpav9EuR9_hirD2UUIlyY75QUaKk,3450
+netra/version.py,sha256=_sUAMIoa3JJyDFRRMIhTB30E34m3PK89cv561Stxyb4,23
+netra_sdk-0.1.9.dist-info/LICENCE,sha256=8B_UoZ-BAl0AqiHAHUETCgd3I2B9yYJ1WEQtVb_qFMA,11359
+netra_sdk-0.1.9.dist-info/METADATA,sha256=jTsIP9rcBdVgL0x4sBtmEQL4NLWxnl5yHwteWhdiUdQ,25100
+netra_sdk-0.1.9.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+netra_sdk-0.1.9.dist-info/RECORD,,

netra/processors/error_detection_processor.py

@@ -1,84 +0,0 @@
-import logging
-from typing import Any, Optional, Union
-
-import httpx
-from opentelemetry.sdk.trace import SpanProcessor
-from opentelemetry.trace import Context, Span, Status, StatusCode
-
-from netra import Netra
-
-logger = logging.getLogger(__name__)
-
-
-class ErrorDetectionProcessor(SpanProcessor):  # type: ignore[misc]
-    """
-    OpenTelemetry span processor that monitors for error attributes in spans and creates custom events.
-    """
-
-    def __init__(self) -> None:
-        pass
-
-    def on_start(self, span: Span, parent_context: Optional[Context] = None) -> None:
-        """Called when a span starts."""
-        span_id = self._get_span_id(span)
-        if not span_id:
-            return
-
-        # Wrap span methods to capture data
-        self._wrap_span_methods(span, span_id)
-
-    def on_end(self, span: Span) -> None:
-        """Called when a span ends."""
-
-    def force_flush(self, timeout_millis: int = 30000) -> bool:
-        """Force flush any pending data."""
-        return True
-
-    def shutdown(self) -> bool:
-        """Shutdown the processor."""
-        return True
-
-    def _get_span_id(self, span: Span) -> Optional[str]:
-        """Get a unique identifier for the span."""
-        try:
-            span_context = span.get_span_context()
-            return f"{span_context.trace_id:032x}-{span_context.span_id:016x}"
-        except Exception:
-            return None
-
-    def _status_code_processing(self, status_code: int) -> None:
-        if httpx.codes.is_error(status_code):
-            event_attributes = {"has_error": True, "status_code": status_code}
-            Netra.set_custom_event(event_name="error_detected", attributes=event_attributes)
-
-    def _wrap_span_methods(self, span: Span, span_id: str) -> Any:
-        """Wrap span methods to capture attributes and events."""
-        # Wrap set_attribute
-        original_set_attribute = span.set_attribute
-
-        def wrapped_set_attribute(key: str, value: Any) -> Any:
-            # Status code processing
-            if key == "http.status_code":
-                self._status_code_processing(value)
-
-            return original_set_attribute(key, value)
-
-        # Wrap set_status
-        original_set_status = span.set_status
-
-        def wrapped_set_status(status: Union[Status, StatusCode]) -> Any:
-            # Check if status code is ERROR
-            if isinstance(status, Status):
-                status_code = status.status_code
-            elif isinstance(status, StatusCode):
-                status_code = status
-            if status_code == StatusCode.ERROR:
-                event_attributes = {
-                    "has_error": True,
-                }
-                Netra.set_custom_event(event_name="error_detected", attributes=event_attributes)
-
-            return original_set_status(status)
-
-        span.set_attribute = wrapped_set_attribute
-        span.set_status = wrapped_set_status