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

agenta/sdk/tracing/attributes.py

@@ -93,19 +93,14 @@ def _marshal(
     return marshalled
 
 
-def _encode_key(
-    namespace: Optional[str] = None,
-    key: str = "",
-) -> str:
+def _encode_key(namespace: Optional[str] = None, key: str = "") -> str:
     if namespace is None:
         return key
 
     return f"ag.{namespace}.{key}"
 
 
-def _encode_value(
-    value: Any,
-) -> Optional[Attribute]:
+def _encode_value(value: Any) -> Optional[Attribute]:
     if value is None:
         return None
 
@@ -139,3 +134,48 @@ def serialize(
     }
 
     return _attributes
+
+
+"""
+def _decode_key(namespace: Optional[str] = None, key: str = "") -> str:
+    if namespace is None:
+        return key
+
+    return key.replace(f"ag.{namespace}.", "")
+"""
+
+"""
+def _decode_value(value: Attribute) -> Any:
+    if isinstance(value, (int, float, bool, bytes)):
+        return value
+
+    if isinstance(value, str):
+        if value == "@ag.type=none:":
+            return None
+
+        if value.startswith("@ag.type=json:"):
+            encoded = value[len("@ag.type=json:") :]
+            value = loads(encoded)
+            return value
+
+        return value
+
+    return value
+"""
+
+"""
+def deserialize(
+    *,
+    namespace: str,
+    attributes: Dict[str, Any],
+    max_depth: Optional[int] = None,
+) -> Dict[str, Any]:
+    if not isinstance(attributes, dict):
+        return {}
+
+    return {
+        _decode_key(namespace, key): _decode_value(value)
+        for key, value in attributes
+        if key != _decode_key(namespace, key)
+    }
+"""

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,31 +1,25 @@
-from enum import Enum
-from re import fullmatch
+from typing import Literal
 
 from opentelemetry.trace import SpanKind
 
-
-class Reference(str, Enum):
-    #
-    VARIANT_ID = "variant.id"
-    VARIANT_SLUG = "variant.slug"
-    VARIANT_VERSION = "variant.version"
-    #
-    ENVIRONMENT_ID = "environment.id"
-    ENVIRONMENT_SLUG = "environment.slug"
-    ENVIRONMENT_VERSION = "environment.version"
-    #
-    APPLICATION_ID = "application.id"
-    APPLICATION_SLUG = "application.slug"
-    #
-
-
-_PATTERN = r"[A-Za-z0-9._-]+"
-
-
-def is_valid_attribute_key(
-    string: str,
-):
-    return bool(fullmatch(_PATTERN, string))
+Namespace = Literal[
+    "data.inputs",
+    "data.internals",
+    "data.outputs",
+    "metrics.scores",
+    "metrics.unit.costs",
+    "metrics.unit.tokens",
+    "meta.configuration",
+    "meta.version",
+    "tags",
+    "refs",
+]
+
+Code = Literal[
+    "OK",
+    "UNSET",
+    "ERROR",
+]
 
 
 def parse_span_kind(type: str) -> SpanKind:

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,14 @@ 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
@@ -60,6 +131,14 @@ AttributeValueType = Any
 Attributes = Dict[str, AttributeValueType]
 
 
+class AttributesDTO(DisplayBase):
+    data: Optional[Attributes] = None
+    metrics: Optional[Attributes] = None
+    meta: Optional[Attributes] = None
+    tags: Optional[Attributes] = None
+    semconv: Optional[Attributes] = None
+
+
 class TreeType(Enum):
     # --- VARIANTS --- #
     INVOCATION = "invocation"
@@ -84,16 +163,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 +185,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 +213,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,10 +239,10 @@ class OTelExtraDTO(BaseModel):
     links: Optional[List[OTelLinkDTO]] = None
 
 
-class SpanDTO(BaseModel):
-    scope: Optional[ProjectScopeDTO] = None
+class SpanDTO(DisplayBase):
+    scope: ProjectScopeDTO
 
-    lifecycle: Optional[LifecycleDTO] = None
+    lifecycle: LifecycleDTO
 
     root: RootDTO
     tree: TreeDTO
@@ -187,7 +266,30 @@ class SpanDTO(BaseModel):
     nodes: Optional[Dict[str, Union["SpanDTO", List["SpanDTO"]]]] = None
 
 
-class OTelSpanDTO(BaseModel):
+class SpanCreateDTO(DisplayBase):
+    scope: ProjectScopeDTO
+
+    root: RootDTO
+    tree: TreeDTO
+    node: NodeDTO
+
+    parent: Optional[ParentDTO] = None
+
+    time: TimeDTO
+    status: StatusDTO
+
+    data: Optional[Data] = None
+    metrics: Optional[Metrics] = None
+    meta: Optional[Metadata] = None
+    tags: Optional[Tags] = None
+    refs: Optional[Refs] = None
+
+    links: Optional[List[LinkDTO]] = None
+
+    otel: Optional[OTelExtraDTO] = None
+
+
+class OTelSpanDTO(DisplayBase):
     context: OTelContextDTO
 
     name: str
@@ -219,20 +321,20 @@ from typing import List, Dict, OrderedDict
 
 
 def parse_span_dtos_to_span_idx(
-    span_dtos: List[SpanDTO],
-) -> Dict[str, SpanDTO]:
+    span_dtos: List[SpanCreateDTO],
+) -> Dict[str, SpanCreateDTO]:
     span_idx = {span_dto.node.id: span_dto for span_dto in span_dtos}
 
     return span_idx
 
 
 def parse_span_idx_to_span_id_tree(
-    span_idx: Dict[str, SpanDTO],
+    span_idx: Dict[str, SpanCreateDTO],
 ) -> OrderedDict:
     span_id_tree = OrderedDict()
     index = {}
 
-    def push(span_dto: SpanDTO) -> None:
+    def push(span_dto: SpanCreateDTO) -> None:
         if span_dto.parent is None:
             span_id_tree[span_dto.node.id] = OrderedDict()
             index[span_dto.node.id] = span_id_tree[span_dto.node.id]
@@ -248,15 +350,15 @@ def parse_span_idx_to_span_id_tree(
 
 def cumulate_costs(
     spans_id_tree: OrderedDict,
-    spans_idx: Dict[str, SpanDTO],
+    spans_idx: Dict[str, SpanCreateDTO],
 ) -> None:
-    def _get_unit(span: SpanDTO):
+    def _get_unit(span: SpanCreateDTO):
         if span.metrics is not None:
             return span.metrics.get("unit.costs.total", 0.0)
 
         return 0.0
 
-    def _get_acc(span: SpanDTO):
+    def _get_acc(span: SpanCreateDTO):
         if span.metrics is not None:
             return span.metrics.get("acc.costs.total", 0.0)
 
@@ -265,7 +367,7 @@ def cumulate_costs(
     def _acc(a: float, b: float):
         return a + b
 
-    def _set(span: SpanDTO, cost: float):
+    def _set(span: SpanCreateDTO, cost: float):
         if span.metrics is None:
             span.metrics = {}
 
@@ -279,7 +381,7 @@ def cumulate_tokens(
     spans_id_tree: OrderedDict,
     spans_idx: Dict[str, dict],
 ) -> None:
-    def _get_unit(span: SpanDTO):
+    def _get_unit(span: SpanCreateDTO):
         _tokens = {
             "prompt": 0.0,
             "completion": 0.0,
@@ -295,7 +397,7 @@ def cumulate_tokens(
 
         return _tokens
 
-    def _get_acc(span: SpanDTO):
+    def _get_acc(span: SpanCreateDTO):
         _tokens = {
             "prompt": 0.0,
             "completion": 0.0,
@@ -318,7 +420,7 @@ def cumulate_tokens(
             "total": a.get("total", 0.0) + b.get("total", 0.0),
         }
 
-    def _set(span: SpanDTO, tokens: dict):
+    def _set(span: SpanCreateDTO, tokens: dict):
         if span.metrics is None:
             span.metrics = {}
 
@@ -340,7 +442,7 @@ def cumulate_tokens(
 
 def _cumulate_tree_dfs(
     spans_id_tree: OrderedDict,
-    spans_idx: Dict[str, SpanDTO],
+    spans_idx: Dict[str, SpanCreateDTO],
     get_unit_metric,
     get_acc_metric,
     accumulate_metric,
@@ -412,12 +514,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 +541,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 +557,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 +569,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 +582,6 @@ KEYS = {
 
 CODEX = {"maps": MAPS[VERSION], "keys": KEYS[VERSION]}
 
-
 ### ------------------------------------------------ ###
 ### apis.fastapi.observability.opentelemetry.semconv ###
 ########################################################
@@ -686,18 +755,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 +857,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 +881,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 +933,7 @@ def parse_from_otel_span_dto(
     )
 
     span_dto = SpanDTO(
+        scope=scope,
         lifecycle=lifecyle,
         root=root,
         tree=tree,
@@ -947,6 +1004,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 +1013,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() ###
@@ -973,7 +1032,7 @@ def parse_inline_trace(
     ###############################################
     ### services.observability.service.ingest() ###
     ### --------------------------------------- ###
-    calculate_costs(span_idx)
+    calculate_cost(span_idx)
     cumulate_costs(span_id_tree, span_idx)
     cumulate_tokens(span_id_tree, span_idx)
     ### --------------------------------------- ###
@@ -1195,7 +1254,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"
         ),
@@ -1212,7 +1271,7 @@ def _parse_to_legacy_span(span: SpanDTO) -> CreateSpan:
     return legacy_span
 
 
-TYPES_WITH_COSTS = [
+PAYING_TYPES = [
     "embedding",
     "query",
     "completion",
@@ -1221,14 +1280,9 @@ TYPES_WITH_COSTS = [
 ]
 
 
-def calculate_costs(span_idx: Dict[str, SpanDTO]):
+def calculate_cost(span_idx: Dict[str, SpanCreateDTO]):
     for span in span_idx.values():
-        if (
-            span.node.type
-            and span.node.type.name.lower() in TYPES_WITH_COSTS
-            and span.meta
-            and span.metrics
-        ):
+        if span.node.type.name.lower() in PAYING_TYPES and span.meta and span.metrics:
             try:
                 costs = cost_calculator.cost_per_token(
                     model=span.meta.get("response.model"),