raindrop-ai 0.0.30__tar.gz → 0.0.32__tar.gz

{raindrop_ai-0.0.30 → raindrop_ai-0.0.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: raindrop-ai
-Version: 0.0.30
+Version: 0.0.32
 Summary: Raindrop AI (Python SDK)
 License: MIT
 Author: Raindrop AI

{raindrop_ai-0.0.30 → raindrop_ai-0.0.32}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "raindrop-ai"
-version = "0.0.30"
+version = "0.0.32"
 description = "Raindrop AI (Python SDK)"
 authors = ["Raindrop AI <sdk@raindrop.ai>"]
 license = "MIT"

{raindrop_ai-0.0.30 → raindrop_ai-0.0.32}/raindrop/analytics.py

@@ -29,8 +29,18 @@ import weakref
 import urllib.parse
 
 from traceloop.sdk import Traceloop
-from traceloop.sdk.tracing.tracing import TracerWrapper
+from traceloop.sdk.tracing.tracing import (
+    TracerWrapper,
+    get_chained_entity_path,
+    set_entity_path,
+)
 from opentelemetry.trace import get_current_span
+from opentelemetry import trace
+from opentelemetry import context as context_api
+from opentelemetry.semconv_ai import SpanAttributes
+from opentelemetry.trace.status import Status, StatusCode
+from traceloop.sdk.utils.json_encoder import JSONEncoder
+from traceloop.sdk.tracing.context_manager import get_tracer
 from traceloop.sdk.decorators import (
     task as tlp_task,
     workflow as tlp_workflow,
@@ -41,20 +51,19 @@ from traceloop.sdk.decorators import (
 __all__ = [
     # Configuration functions
     "set_debug_logs",
-    "set_redact_pii", 
+    "set_redact_pii",
     "init",
-    
     "identify",
     "track_ai",
     "track_signal",
     "begin",
     "resume_interaction",
-    
     "interaction",
-    "task", 
+    "task",
     "tool",
+    "task_span",
+    "tool_span",
     "set_span_properties",
-    
     "flush",
     "shutdown",
 ]
@@ -314,6 +323,28 @@ def _get_size(event: dict[str, any]) -> int:
         return 0
 
 
+def _truncate_json_if_needed(json_str: str) -> str:
+    """
+    Truncate JSON string if it exceeds OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+    truncation may yield an invalid JSON string, which is expected for logging purposes.
+    """
+    limit_str = os.getenv("OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT")
+    if limit_str:
+        try:
+            limit = int(limit_str)
+            if limit > 0 and len(json_str) > limit:
+                return json_str[:limit]
+        except ValueError:
+            pass
+    return json_str
+
+
+def _should_send_prompts():
+    return (
+        os.getenv("TRACELOOP_TRACE_CONTENT") or "true"
+    ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
+
+
 # Signal types - This is now defined in models.py
 # SignalType = Literal["default", "feedback", "edit"]
 
@@ -573,6 +604,110 @@ def set_span_properties(properties: Dict[str, Any]) -> None:
     Traceloop.set_association_properties(properties)
 
 
+class TraceEntitySpan:
+    def __init__(self, span):
+        self._span = span
+
+    def record_input(self, data: Any) -> None:
+        if self._span and _should_send_prompts():
+            try:
+                json_input = json.dumps({"args": [data]}, cls=JSONEncoder)
+                truncated = _truncate_json_if_needed(json_input)
+                self._span.set_attribute(
+                    SpanAttributes.TRACELOOP_ENTITY_INPUT, truncated
+                )
+            except TypeError as e:
+                logger.debug(f"[raindrop] Could not serialize input for span: {e}")
+
+    def record_output(self, data: Any) -> None:
+        if self._span and _should_send_prompts():
+            try:
+                json_output = json.dumps(data, cls=JSONEncoder)
+                truncated = _truncate_json_if_needed(json_output)
+                self._span.set_attribute(
+                    SpanAttributes.TRACELOOP_ENTITY_OUTPUT, truncated
+                )
+            except TypeError as e:
+                logger.debug(f"[raindrop] Could not serialize output for span: {e}")
+
+    def set_properties(self, props: Dict[str, Any]) -> None:
+        if _tracing_enabled and props:
+            Traceloop.set_association_properties(props)
+
+
+class _EntitySpanContext:
+    def __init__(self, kind: Literal["task", "tool"], name: str, version: int | None):
+        self._kind = kind
+        self._name = name
+        self._version = version
+        self._span = None
+        self._ctx_token = None
+        self._span_cm = None
+        self._helper = TraceEntitySpan(None)
+
+    # internal start/finish
+    def _start(self) -> None:
+        if not _tracing_enabled or not TracerWrapper.verify_initialized():
+            return
+        tlp_kind = (
+            TraceloopSpanKindValues.TASK
+            if self._kind == "task"
+            else TraceloopSpanKindValues.TOOL
+        )
+        span_name = f"{self._name}.{tlp_kind.value}"
+        with get_tracer() as tracer:
+            self._span_cm = tracer.start_as_current_span(span_name)
+            span = self._span_cm.__enter__()
+
+        if tlp_kind in [TraceloopSpanKindValues.TASK, TraceloopSpanKindValues.TOOL]:
+            entity_path = get_chained_entity_path(self._name)
+            set_entity_path(entity_path)
+
+        span.set_attribute(SpanAttributes.TRACELOOP_SPAN_KIND, tlp_kind.value)
+        span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_NAME, self._name)
+        if self._version is not None:
+            span.set_attribute(SpanAttributes.TRACELOOP_ENTITY_VERSION, self._version)
+
+        self._span = span
+        self._helper = TraceEntitySpan(span)
+
+    def _end(self, exc_type, exc, tb) -> bool:
+        if not self._span:
+            return False
+        try:
+            if exc is not None:
+                self._span.set_status(Status(StatusCode.ERROR, str(exc)))
+                self._span.record_exception(exc)
+            return False
+        finally:
+            if self._span_cm is not None:
+                self._span_cm.__exit__(exc_type, exc, tb)
+
+    # sync
+    def __enter__(self) -> TraceEntitySpan:
+        self._start()
+        return self._helper
+
+    def __exit__(self, exc_type, exc, tb) -> bool:
+        return self._end(exc_type, exc, tb)
+
+    # async
+    async def __aenter__(self) -> TraceEntitySpan:
+        self._start()
+        return self._helper
+
+    async def __aexit__(self, exc_type, exc, tb) -> bool:
+        return self._end(exc_type, exc, tb)
+
+
+def task_span(name: str, version: int | None = None) -> _EntitySpanContext:
+    return _EntitySpanContext("task", name, version)
+
+
+def tool_span(name: str, version: int | None = None) -> _EntitySpanContext:
+    return _EntitySpanContext("tool", name, version)
+
+
 def resume_interaction(event_id: str | None = None) -> Interaction:
     """Return an Interaction associated with the current trace or given event_id."""
 

{raindrop_ai-0.0.30 → raindrop_ai-0.0.32}/raindrop/models.py

@@ -16,10 +16,10 @@ class Attachment(BaseModel):
     language: Optional[str] = None  # for code snippets
 
     @model_validator(mode="after")
-    def _require_value(cls, values):
-        if not values.value:
+    def _require_value(self):
+        if not self.value:
             raise ValueError("value must be non-empty.")
-        return values
+        return self
 
 
 class AIData(_Base):
@@ -29,10 +29,10 @@ class AIData(_Base):
     convo_id: Optional[str]
 
     @model_validator(mode="after")
-    def _require_input_or_output(cls, values):
-        if not (values.input or values.output):
+    def _require_input_or_output(self):
+        if not (self.input or self.output):
             raise ValueError("Either 'input' or 'output' must be non-empty.")
-        return values
+        return self
 
 
 class TrackAIEvent(_Base):
@@ -94,10 +94,9 @@ class FeedbackSignal(BaseSignal):
     signal_type: Literal["feedback"]
 
     @model_validator(mode="after")
-    def _check_comment_in_properties(cls, values):
+    def _check_comment_in_properties(self):
         # Check properties safely after potential initialization
-        # Use getattr to safely access properties, returning None if not present
-        props = getattr(values, "properties", None)
+        props = self.properties
         if not isinstance(props, dict):
             raise ValueError("'properties' must be a dictionary for feedback signals.")
         comment = props.get("comment")
@@ -105,7 +104,7 @@ class FeedbackSignal(BaseSignal):
             raise ValueError(
                 "'properties' must contain a non-empty string 'comment' for feedback signals."
             )
-        return values
+        return self
 
 
 class EditSignal(BaseSignal):
@@ -114,9 +113,9 @@ class EditSignal(BaseSignal):
     signal_type: Literal["edit"]
 
     @model_validator(mode="after")
-    def _check_after_in_properties(cls, values):
+    def _check_after_in_properties(self):
         # Check properties safely after potential initialization
-        props = getattr(values, "properties", None)
+        props = self.properties
         if not isinstance(props, dict):
             raise ValueError("'properties' must be a dictionary for edit signals.")
         after = props.get("after")
@@ -124,7 +123,7 @@ class EditSignal(BaseSignal):
             raise ValueError(
                 "'properties' must contain a non-empty string 'after' for edit signals."
             )
-        return values
+        return self
 
 
 # Discriminated Union for Signal Events

raindrop_ai-0.0.32/raindrop/version.py

@@ -0,0 +1 @@
+VERSION = "0.0.32"

raindrop_ai-0.0.30/raindrop/version.py

@@ -1 +0,0 @@
-VERSION = "0.0.30"