agenta 0.27.0__py3-none-any.whl → 0.27.0a1__py3-none-any.whl

agenta/sdk/tracing/context.py

@@ -15,10 +15,7 @@ def tracing_context_manager():
     try:
         yield
     except Exception as e:
-        log.error("----------------------------------------------")
-        log.error("Agenta SDK - handling tracing exception below:")
-        log.error("----------------------------------------------")
-        log.error(format_exc().strip("\n"))
-        log.error("----------------------------------------------")
+        log.error(f"Error with tracing context: {_tracing_context}")
+        log.error(f"Exception: {format_exc()}")
     finally:
         tracing_context.reset(token)

agenta/sdk/tracing/conventions.py

@@ -1,7 +1,14 @@
+from opentelemetry.trace import SpanKind
+
 from enum import Enum
+
 from re import fullmatch
 
-from opentelemetry.trace import SpanKind
+_PATTERN = r"[A-Za-z0-9._-]+"
+
+
+def is_valid_attribute_key(string):
+    return bool(fullmatch(_PATTERN, string))
 
 
 class Reference(str, Enum):
@@ -19,15 +26,6 @@ class Reference(str, Enum):
     #
 
 
-_PATTERN = r"[A-Za-z0-9._-]+"
-
-
-def is_valid_attribute_key(
-    string: str,
-):
-    return bool(fullmatch(_PATTERN, string))
-
-
 def parse_span_kind(type: str) -> SpanKind:
     kind = SpanKind.INTERNAL
     if type in [

agenta/sdk/tracing/exporters.py

@@ -1,12 +1,14 @@
 from typing import Sequence, Dict, List
 
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk.trace.export import (
     ConsoleSpanExporter,
     SpanExporter,
     SpanExportResult,
     ReadableSpan,
 )
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+    OTLPSpanExporter,
+)
 
 from agenta.sdk.utils.exceptions import suppress
 
@@ -38,28 +40,17 @@ class InlineTraceExporter(SpanExporter):
     def force_flush(self, timeout_millis: int = 30000) -> bool:
         return True
 
-    def is_ready(
-        self,
-        trace_id: int,
-    ) -> bool:
-        is_ready = trace_id in self._registry
-
-        return is_ready
-
-    def fetch(
-        self,
-        trace_id: int,
-    ) -> List[ReadableSpan]:
+    def fetch(self, trace_id: int) -> List[ReadableSpan]:
         trace = self._registry.get(trace_id, [])
 
-        if trace_id in self._registry:
-            del self._registry[trace_id]
+        del self._registry[trace_id]
 
         return trace
 
 
 OTLPSpanExporter._MAX_RETRY_TIMEOUT = 2
 
+
 ConsoleExporter = ConsoleSpanExporter
 InlineExporter = InlineTraceExporter
 OTLPExporter = OTLPSpanExporter

agenta/sdk/tracing/inline.py

@@ -11,11 +11,82 @@ from enum import Enum
 from collections import OrderedDict
 
 
-class ProjectScopeDTO(BaseModel):
+NOF_CHARS = 8
+
+
+def _p_id(id):
+    return repr(str(id)[:NOF_CHARS])
+
+
+def _p_osa(o):
+    elements = []
+
+    for i in OrderedDict(sorted(o.items())).items():
+        if not i[0].startswith("_"):
+            if i[1].__class__.__module__ != "builtins":
+                if repr(i[1]).startswith("<"):
+                    elements.append(f"{i[0]}: {i[1].name}")
+                elif repr(i[1]).startswith("UUID("):
+                    elements.append(f"{i[0]}: {_p_id(i[1])}")
+                else:
+                    elements.append(f"{i[0]}: {i[1].__str__()}")
+            else:
+                if isinstance(i[1], list):
+                    elements.append(
+                        f"{i[0]}: [" + ", ".join([el.__str__() for el in i[1]]) + "]"
+                    )
+                elif isinstance(i[1], dict):
+                    elements.append(f"{i[0]}: {{{_p_osa(i[1])}}}")
+                else:
+                    if i[1] is not None:
+                        if i[0] == "slug":
+                            elements.append(f"{i[0]}: {repr(i[1][:8])}")
+                        else:
+                            elements.append(f"{i[0]}: {repr(i[1])}")
+
+    return ", ".join(elements)
+
+
+def _p_ora(o, open="{", close="}", sep=": ", foo=repr):
+    if o.__class__.__module__ != "builtins":
+        if o.__class__.__name__ == "UUID":
+            return repr(o)
+        if isinstance(o, Enum):
+            return o
+        if isinstance(o, datetime):
+            return o.isoformat()
+        return f"{o.__class__.__name__}({_p_ora(o.__dict__, open='', close='', sep='=', foo=lambda x : x)})"
+    elif isinstance(o, list):
+        return f"[{', '.join([repr(el) for el in o])}]"
+    elif isinstance(o, dict):
+        o = OrderedDict(sorted(o.items()))
+        return f"{open}{', '.join([f'{foo(elk)}{sep}{_p_ora(elv)}' for elk, elv in o.items()])}{close}"
+    else:
+        if o is not None:
+            return repr(o)
+
+
+def _str(o):
+    return f"{{{_p_osa(o.__dict__)}}}"
+
+
+def _repr(o):
+    return _p_ora(o)
+
+
+class DisplayBase(BaseModel):
+    def __str__(self):
+        return _str(self)
+
+    def __repr__(self):
+        return _repr(self)
+
+
+class ProjectScopeDTO(DisplayBase):
     project_id: UUID
 
 
-class LifecycleDTO(BaseModel):
+class LifecycleDTO(DisplayBase):
     created_at: datetime
     updated_at: Optional[datetime] = None
 
@@ -31,14 +102,14 @@ class LifecycleDTO(BaseModel):
 ### services.observability.dtos ###
 ### --------------------------- ###
 
-from typing import List, Dict, Any, Union, Optional
+from typing import List, Dict, Any, Union, Optional, Sequence
 
 from enum import Enum
 from datetime import datetime
 from uuid import UUID
 
 
-class TimeDTO(BaseModel):
+class TimeDTO(DisplayBase):
     start: datetime
     end: datetime
     span: int
@@ -50,7 +121,7 @@ class StatusCode(Enum):
     ERROR = "ERROR"
 
 
-class StatusDTO(BaseModel):
+class StatusDTO(DisplayBase):
     code: StatusCode
     message: Optional[str] = None
     stacktrace: Optional[str] = None
@@ -84,16 +155,16 @@ class NodeType(Enum):
     # --- VARIANTS --- #
 
 
-class RootDTO(BaseModel):
+class RootDTO(DisplayBase):
     id: UUID
 
 
-class TreeDTO(BaseModel):
+class TreeDTO(DisplayBase):
     id: UUID
     type: Optional[TreeType] = None
 
 
-class NodeDTO(BaseModel):
+class NodeDTO(DisplayBase):
     id: UUID
     type: Optional[NodeType] = None
     name: str
@@ -106,13 +177,13 @@ Tags = Dict[str, str]
 Refs = Dict[str, str]
 
 
-class LinkDTO(BaseModel):
+class LinkDTO(DisplayBase):
     type: str
     id: UUID
     tree_id: Optional[UUID] = None
 
 
-class ParentDTO(BaseModel):
+class ParentDTO(DisplayBase):
     id: UUID
 
 
@@ -134,25 +205,25 @@ class OTelStatusCode(Enum):
     STATUS_CODE_UNSET = "STATUS_CODE_UNSET"
 
 
-class OTelContextDTO(BaseModel):
+class OTelContextDTO(DisplayBase):
     trace_id: str
     span_id: str
 
 
-class OTelEventDTO(BaseModel):
+class OTelEventDTO(DisplayBase):
     name: str
     timestamp: datetime
 
     attributes: Optional[Attributes] = None
 
 
-class OTelLinkDTO(BaseModel):
+class OTelLinkDTO(DisplayBase):
     context: OTelContextDTO
 
     attributes: Optional[Attributes] = None
 
 
-class OTelExtraDTO(BaseModel):
+class OTelExtraDTO(DisplayBase):
     kind: Optional[str] = None
 
     attributes: Optional[Attributes] = None
@@ -160,8 +231,8 @@ class OTelExtraDTO(BaseModel):
     links: Optional[List[OTelLinkDTO]] = None
 
 
-class SpanDTO(BaseModel):
-    scope: Optional[ProjectScopeDTO] = None
+class SpanDTO(DisplayBase):
+    scope: ProjectScopeDTO
 
     lifecycle: Optional[LifecycleDTO] = None
 
@@ -187,7 +258,7 @@ class SpanDTO(BaseModel):
     nodes: Optional[Dict[str, Union["SpanDTO", List["SpanDTO"]]]] = None
 
 
-class OTelSpanDTO(BaseModel):
+class OTelSpanDTO(DisplayBase):
     context: OTelContextDTO
 
     name: str
@@ -412,12 +483,9 @@ def _connect_tree_dfs(
 ### apis.fastapi.observability.opentelemetry.semconv ###
 ### ------------------------------------------------ ###
 
-from json import loads
-
 VERSION = "0.4.1"
 
 V_0_4_1_ATTRIBUTES_EXACT = [
-    # OPENLLMETRY
     ("gen_ai.system", "ag.meta.system"),
     ("gen_ai.request.base_url", "ag.meta.request.base_url"),
     ("gen_ai.request.endpoint", "ag.meta.request.endpoint"),
@@ -442,35 +510,12 @@ V_0_4_1_ATTRIBUTES_EXACT = [
     ("db.vector.query.top_k", "ag.meta.request.top_k"),
     ("pinecone.query.top_k", "ag.meta.request.top_k"),
     ("traceloop.span.kind", "ag.type.node"),
-    ("traceloop.entity.name", "ag.node.name"),
-    # OPENINFERENCE
-    ("output.value", "ag.data.outputs"),
-    ("input.value", "ag.data.inputs"),
-    ("embedding.model_name", "ag.meta.request.model"),
-    ("llm.invocation_parameters", "ag.meta.request"),
-    ("llm.model_name", "ag.meta.request.model"),
-    ("llm.provider", "ag.meta.provider"),
-    ("llm.system", "ag.meta.system"),
 ]
 V_0_4_1_ATTRIBUTES_PREFIX = [
-    # OPENLLMETRY
     ("gen_ai.prompt", "ag.data.inputs.prompt"),
     ("gen_ai.completion", "ag.data.outputs.completion"),
-    ("llm.request.functions", "ag.data.inputs.functions"),
-    ("llm.request.tools", "ag.data.inputs.tools"),
-    # OPENINFERENCE
-    ("llm.token_count", "ag.metrics.unit.tokens"),
-    ("llm.input_messages", "ag.data.inputs.prompt"),
-    ("llm.output_messages", "ag.data.outputs.completion"),
 ]
 
-V_0_4_1_ATTRIBUTES_DYNAMIC = [
-    # OPENLLMETRY
-    ("traceloop.entity.input", lambda x: ("ag.data.inputs", loads(x).get("inputs"))),
-    ("traceloop.entity.output", lambda x: ("ag.data.outputs", loads(x).get("outputs"))),
-]
-
-
 V_0_4_1_MAPS = {
     "attributes": {
         "exact": {
@@ -481,9 +526,6 @@ V_0_4_1_MAPS = {
             "from": {otel: agenta for otel, agenta in V_0_4_1_ATTRIBUTES_PREFIX[::-1]},
             "to": {agenta: otel for otel, agenta in V_0_4_1_ATTRIBUTES_PREFIX[::-1]},
         },
-        "dynamic": {
-            "from": {otel: agenta for otel, agenta in V_0_4_1_ATTRIBUTES_DYNAMIC[::-1]}
-        },
     },
 }
 V_0_4_1_KEYS = {
@@ -496,9 +538,6 @@ V_0_4_1_KEYS = {
             "from": list(V_0_4_1_MAPS["attributes"]["prefix"]["from"].keys()),
             "to": list(V_0_4_1_MAPS["attributes"]["prefix"]["to"].keys()),
         },
-        "dynamic": {
-            "from": list(V_0_4_1_MAPS["attributes"]["dynamic"]["from"].keys()),
-        },
     },
 }
 
@@ -512,7 +551,6 @@ KEYS = {
 
 CODEX = {"maps": MAPS[VERSION], "keys": KEYS[VERSION]}
 
-
 ### ------------------------------------------------ ###
 ### apis.fastapi.observability.opentelemetry.semconv ###
 ########################################################
@@ -686,18 +724,6 @@ def _parse_from_semconv(
 
                     del attributes[old_key]
 
-            for dynamic_key in CODEX["keys"]["attributes"]["dynamic"]["from"]:
-                if old_key == dynamic_key:
-                    try:
-                        new_key, new_value = CODEX["maps"]["attributes"]["dynamic"][
-                            "from"
-                        ][dynamic_key](value)
-
-                        attributes[new_key] = new_value
-
-                    except:  # pylint: disable=bare-except
-                        pass
-
 
 def _parse_from_links(
     otel_span_dto: OTelSpanDTO,
@@ -800,8 +826,11 @@ def _parse_from_attributes(
 
 
 def parse_from_otel_span_dto(
+    project_id: str,
     otel_span_dto: OTelSpanDTO,
 ) -> SpanDTO:
+    scope = ProjectScopeDTO(project_id=UUID(project_id))
+
     lifecyle = LifecycleDTO(
         created_at=datetime.now(),
     )
@@ -821,15 +850,11 @@ def parse_from_otel_span_dto(
 
     node_id = UUID(tree_id.hex[16:] + otel_span_dto.context.span_id[2:])
 
-    node_type = NodeType.TASK
-    try:
-        node_type = NodeType(types.get("node", "").lower())
-    except:  # pylint: disable=bare-except
-        pass
+    node_type: str = types.get("node")
 
     node = NodeDTO(
         id=node_id,
-        type=node_type,
+        type=node_type.lower() if node_type else None,
         name=otel_span_dto.name,
     )
 
@@ -877,6 +902,7 @@ def parse_from_otel_span_dto(
     )
 
     span_dto = SpanDTO(
+        scope=scope,
         lifecycle=lifecyle,
         root=root,
         tree=tree,
@@ -947,6 +973,7 @@ from opentelemetry.sdk.trace import ReadableSpan
 
 
 def parse_inline_trace(
+    project_id: str,
     spans: Dict[str, ReadableSpan],
 ):
     otel_span_dtos = _parse_readable_spans(spans)
@@ -955,7 +982,8 @@ def parse_inline_trace(
     ### apis.fastapi.observability.api.otlp_collect_traces() ###
     ### ---------------------------------------------------- ###
     span_dtos = [
-        parse_from_otel_span_dto(otel_span_dto) for otel_span_dto in otel_span_dtos
+        parse_from_otel_span_dto(project_id, otel_span_dto)
+        for otel_span_dto in otel_span_dtos
     ]
     ### ---------------------------------------------------- ###
     ### apis.fastapi.observability.api.otlp_collect_traces() ###
@@ -1195,7 +1223,7 @@ def _parse_to_legacy_span(span: SpanDTO) -> CreateSpan:
         ),
         #
         app_id=(
-            span.refs.get("application", {}).get("id", "missing-app-id")
+            span.refs.get("application.id", "missing-app-id")
             if span.refs
             else "missing-app-id"
         ),

agenta/sdk/tracing/processors.py

@@ -1,4 +1,5 @@
-from typing import Optional, Dict, List
+from typing import Optional, Dict
+from traceback import format_exc
 
 from opentelemetry.context import Context
 from opentelemetry.sdk.trace import Span
@@ -6,8 +7,8 @@ from opentelemetry.sdk.trace.export import (
     SpanExporter,
     ReadableSpan,
     BatchSpanProcessor,
+    _DEFAULT_EXPORT_TIMEOUT_MILLIS,
     _DEFAULT_MAX_QUEUE_SIZE,
-    _DEFAULT_MAX_EXPORT_BATCH_SIZE,
 )
 
 from agenta.sdk.utils.logging import log
@@ -28,21 +29,16 @@ class TraceProcessor(BatchSpanProcessor):
         super().__init__(
             span_exporter,
             _DEFAULT_MAX_QUEUE_SIZE,
-            12 * 60 * 60 * 1000,  # 12 hours
-            _DEFAULT_MAX_EXPORT_BATCH_SIZE,
+            60 * 60 * 1000,  # 1 hour
+            _DEFAULT_MAX_QUEUE_SIZE,
             500,  # < 1 second (0.5 seconds)
         )
 
         self._registry = dict()
         self._exporter = span_exporter
         self.references = references or dict()
-        self.spans: Dict[int, List[ReadableSpan]] = dict()
 
-    def on_start(
-        self,
-        span: Span,
-        parent_context: Optional[Context] = None,
-    ) -> None:
+    def on_start(self, span: Span, parent_context: Optional[Context] = None) -> None:
         # ADD LINKS FROM CONTEXT, HERE
 
         for key in self.references.keys():
@@ -53,41 +49,15 @@ class TraceProcessor(BatchSpanProcessor):
 
         self._registry[span.context.trace_id][span.context.span_id] = True
 
-    def on_end(
-        self,
-        span: ReadableSpan,
-    ):
-        if self.done:
-            return
-
-        if span.context.trace_id not in self.spans:
-            self.spans[span.context.trace_id] = list()
-
-        self.spans[span.context.trace_id].append(span)
+    def on_end(self, span: ReadableSpan):
+        super().on_end(span)
 
         del self._registry[span.context.trace_id][span.context.span_id]
 
-        if len(self._registry[span.context.trace_id]) == 0:
-            self.export(span.context.trace_id)
-
-    def export(
-        self,
-        trace_id: int,
-    ):
-        spans = self.spans[trace_id]
-
-        for span in spans:
-            self.queue.appendleft(span)
-
-        with self.condition:
-            self.condition.notify()
-
-        del self.spans[trace_id]
+        if self.is_ready(span.get_span_context().trace_id):
+            self.force_flush()
 
-    def force_flush(
-        self,
-        timeout_millis: int = None,
-    ) -> bool:
+    def force_flush(self, timeout_millis: int = None) -> bool:
         ret = super().force_flush(timeout_millis)
 
         if not ret:
@@ -95,23 +65,12 @@ class TraceProcessor(BatchSpanProcessor):
             log.error("Agenta SDK - skipping export due to timeout.")
             log.error("--------------------------------------------")
 
-    def is_ready(
-        self,
-        trace_id: Optional[int] = None,
-    ) -> bool:
-        is_ready = True
-
-        try:
-            is_ready = self._exporter.is_ready(trace_id)
-        except:  # pylint: disable=bare-except
-            pass
+    def is_ready(self, trace_id: Optional[int] = None) -> bool:
+        is_ready = not len(self._registry.get(trace_id, {}))
 
         return is_ready
 
-    def fetch(
-        self,
-        trace_id: Optional[int] = None,
-    ) -> Dict[str, ReadableSpan]:
+    def fetch(self, trace_id: Optional[int] = None) -> Dict[str, ReadableSpan]:
         trace = self._exporter.fetch(trace_id)  # type: ignore
 
         return trace

agenta/sdk/tracing/spans.py

@@ -8,10 +8,7 @@ from agenta.sdk.tracing.attributes import serialize
 
 
 class CustomSpan(Span):  # INHERITANCE FOR TYPING ONLY
-    def __init__(
-        self,
-        span: Span,
-    ) -> None:
+    def __init__(self, span: Span) -> None:
         super().__init__(  # INHERITANCE FOR TYPING ONLY
             name=span.name,
             context=span.context,
@@ -41,10 +38,7 @@ class CustomSpan(Span):  # INHERITANCE FOR TYPING ONLY
     def is_recording(self) -> bool:
         return self._span.is_recording()
 
-    def update_name(
-        self,
-        name: str,
-    ) -> None:
+    def update_name(self, name: str) -> None:
         self._span.update_name(name)
 
     def set_status(
@@ -52,10 +46,7 @@ class CustomSpan(Span):  # INHERITANCE FOR TYPING ONLY
         status: Union[Status, StatusCode],
         description: Optional[str] = None,
     ) -> None:
-        self._span.set_status(
-            status=status,
-            description=description,
-        )
+        self._span.set_status(status=status, description=description)
 
     def end(self) -> None:
         self._span.end()
@@ -82,10 +73,7 @@ class CustomSpan(Span):  # INHERITANCE FOR TYPING ONLY
         value: Any,
         namespace: Optional[str] = None,
     ) -> None:
-        self.set_attributes(
-            attributes={key: value},
-            namespace=namespace,
-        )
+        self.set_attributes({key: value}, namespace)
 
     def add_event(
         self,