raindrop-ai 0.0.29__py3-none-any.whl → 0.0.31__py3-none-any.whl

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,
@@ -38,6 +48,26 @@ from traceloop.sdk.decorators import (
     F,
 )
 
+__all__ = [
+    # Configuration functions
+    "set_debug_logs",
+    "set_redact_pii",
+    "init",
+    "identify",
+    "track_ai",
+    "track_signal",
+    "begin",
+    "resume_interaction",
+    "interaction",
+    "task",
+    "tool",
+    "task_span",
+    "tool_span",
+    "set_span_properties",
+    "flush",
+    "shutdown",
+]
+
 
 # Configure logging
 logging.basicConfig(
@@ -293,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"]
 
@@ -552,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/version.py

@@ -1 +1 @@
-VERSION = "0.0.29"
+VERSION = "0.0.31"

{raindrop_ai-0.0.29.dist-info → raindrop_ai-0.0.31.dist-info}/METADATA

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

{raindrop_ai-0.0.29.dist-info → raindrop_ai-0.0.31.dist-info}/RECORD

@@ -1,10 +1,10 @@
 raindrop/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-raindrop/analytics.py,sha256=L6CrwfngxGJOw-05FPPytC3sANaHccmlw82j8ajrf6c,19240
+raindrop/analytics.py,sha256=XHCXHM-S92ZAgsigPrDovUDTSlHiLLfuIHHEq9wnpTY,24354
 raindrop/interaction.py,sha256=1gYFj2-oEobLtG56RZw5de3RjYr0pCXg_NqYDGx32Uc,1896
 raindrop/models.py,sha256=dEhwTtBEgwOOW_qaPEYugCLeOqvDXuBpEfi7vUANVK0,5361
 raindrop/redact.py,sha256=rMNUoI90KxOY3d_zcHAr0TFD2yQ_CDgpDz-1XJLVmHs,7658
-raindrop/version.py,sha256=ZIBhRcpTwwJfP6TpTO4noMPlluF8zyhxOYd3p_p0zNI,19
+raindrop/version.py,sha256=g9PK7-EZQg9Xj85paKedV-EguQ1hpWMe5uKllKCG_QI,19
 raindrop/well-known-names.json,sha256=9giJF6u6W1R0APW-Pf1dvNUU32OXQEoQ9CBQXSnA3ks,144403
-raindrop_ai-0.0.29.dist-info/METADATA,sha256=YHcFiEkQETKv7xi5imYLYF5MmLi5lFCXsQQisxfswao,1269
-raindrop_ai-0.0.29.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-raindrop_ai-0.0.29.dist-info/RECORD,,
+raindrop_ai-0.0.31.dist-info/METADATA,sha256=1ChjDAUZRU0R2kjK9RpwveWVefChGoRwm-bhdn1cctg,1269
+raindrop_ai-0.0.31.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+raindrop_ai-0.0.31.dist-info/RECORD,,