netra-sdk 0.1.6__tar.gz → 0.1.7__tar.gz

{netra_sdk-0.1.6 → netra_sdk-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: netra-sdk
-Version: 0.1.6
+Version: 0.1.7
 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,44 @@ 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"})
 
-# Session automatically captures duration, status, and any errors
+    # Get the current active open telemetry span
+    current_span = span.get_current_span()
 ```
 
 ## 🔧 Advanced Configuration

{netra_sdk-0.1.6 → netra_sdk-0.1.7}/README.md

@@ -326,46 +326,44 @@ 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"})
 
-# Session automatically captures duration, status, and any errors
+    # Get the current active open telemetry span
+    current_span = span.get_current_span()
 ```
 
 ## 🔧 Advanced Configuration

{netra_sdk-0.1.6 → netra_sdk-0.1.7}/netra/__init__.py

@@ -8,8 +8,8 @@ from .config import Config
 
 # Instrumentor functions
 from .instrumentation import init_instrumentations
-from .session import Session
 from .session_manager import SessionManager
+from .span_wrapper import SpanWrapper, UsageModel
 from .tracer import Tracer
 
 logger = logging.getLogger(__name__)
@@ -133,16 +133,16 @@ class Netra:
         SessionManager.set_custom_event(event_name, attributes)
 
     @classmethod
-    def start_session(
+    def start_span(
         cls,
         name: str,
         attributes: Optional[Dict[str, str]] = None,
         module_name: str = "combat_sdk",
-    ) -> Session:
+    ) -> SpanWrapper:
         """
         Start a new session.
         """
-        return Session(name, attributes, module_name)
+        return SpanWrapper(name, attributes, module_name)
 
 
-__all__ = ["Netra"]
+__all__ = ["Netra", "UsageModel"]

{netra_sdk-0.1.6 → netra_sdk-0.1.7}/netra/config.py

@@ -86,6 +86,11 @@ class Config:
             env_tc = os.getenv("NETRA_TRACE_CONTENT")
             self.trace_content = False if (env_tc is not None and env_tc.lower() in ("0", "false")) else True
 
+        if not self.trace_content:
+            os.environ["TRACELOOP_TRACE_CONTENT"] = "false"
+        else:
+            os.environ["TRACELOOP_TRACE_CONTENT"] = "true"
+
         # 7. Environment: param override, else env
         if environment is not None:
             self.environment = environment

netra_sdk-0.1.6/netra/session.py → netra_sdk-0.1.7/netra/span_wrapper.py

@@ -18,8 +18,8 @@ logger = logging.getLogger(__name__)
 
 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 +28,24 @@ 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"
 
 
-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 +62,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 +73,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 +98,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 +114,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 +130,29 @@ 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_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 +160,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_sdk-0.1.7/netra/version.py

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

{netra_sdk-0.1.6 → netra_sdk-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "netra-sdk"
-version = "0.1.6"
+version = "0.1.7"
 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.6/netra/version.py

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