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

agenta/sdk/tracing/processors.py

@@ -1,4 +1,4 @@
-from typing import Optional, Dict, List
+from typing import Optional, Any, Dict
 
 from opentelemetry.context import Context
 from opentelemetry.sdk.trace import Span
@@ -6,12 +6,10 @@ 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
-
 # LOAD CONTEXT, HERE
 
 
@@ -28,21 +26,16 @@ class TraceProcessor(BatchSpanProcessor):
         super().__init__(
             span_exporter,
             _DEFAULT_MAX_QUEUE_SIZE,
-            12 * 60 * 60 * 1000,  # 12 hours
-            _DEFAULT_MAX_EXPORT_BATCH_SIZE,
-            500,  # < 1 second (0.5 seconds)
+            60 * 60 * 1000,  # 1 hour
+            _DEFAULT_MAX_QUEUE_SIZE,
+            _DEFAULT_EXPORT_TIMEOUT_MILLIS,
         )
 
         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,65 +46,20 @@ 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]
+        if self.is_ready(span.get_span_context().trace_id):
+            self.force_flush()
 
-        for span in spans:
-            self.queue.appendleft(span)
-
-        with self.condition:
-            self.condition.notify()
-
-        del self.spans[trace_id]
-
-    def force_flush(
-        self,
-        timeout_millis: int = None,
-    ) -> bool:
-        ret = super().force_flush(timeout_millis)
-
-        if not ret:
-            log.error("--------------------------------------------")
-            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,

agenta/sdk/tracing/tracing.py

@@ -1,5 +1,4 @@
 from typing import Optional, Any, Dict
-from enum import Enum
 
 from httpx import get as check
 
@@ -14,13 +13,14 @@ from opentelemetry.sdk.trace import Span, Tracer, TracerProvider
 from opentelemetry.sdk.resources import Resource
 
 from agenta.sdk.utils.singleton import Singleton
-from agenta.sdk.utils.exceptions import suppress
+from agenta.sdk.utils.exceptions import suppress  # USE IT !
 from agenta.sdk.utils.logging import log
+
 from agenta.sdk.tracing.processors import TraceProcessor
-from agenta.sdk.tracing.exporters import InlineExporter, OTLPExporter
+from agenta.sdk.tracing.exporters import ConsoleExporter, InlineExporter, OTLPExporter
 from agenta.sdk.tracing.spans import CustomSpan
+from agenta.sdk.tracing.context import tracing_context
 from agenta.sdk.tracing.inline import parse_inline_trace
-from agenta.sdk.tracing.conventions import Reference, is_valid_attribute_key
 
 
 class Tracing(metaclass=Singleton):
@@ -35,6 +35,10 @@ class Tracing(metaclass=Singleton):
     ) -> None:
         # ENDPOINT (OTLP)
         self.otlp_url = url
+        # AUTHENTICATION (OTLP)
+        self.project_id: Optional[str] = None
+        # AUTHORIZATION (OTLP)
+        self.api_key: Optional[str] = None
         # HEADERS (OTLP)
         self.headers: Dict[str, str] = dict()
         # REFERENCES
@@ -42,8 +46,6 @@ class Tracing(metaclass=Singleton):
 
         # TRACER PROVIDER
         self.tracer_provider: Optional[TracerProvider] = None
-        # TRACE PROCESSORS -- INLINE
-        self.inline: Optional[TraceProcessor] = None
         # TRACER
         self.tracer: Optional[Tracer] = None
         # INLINE SPANS for INLINE TRACES (INLINE PROCESSOR)
@@ -53,74 +55,75 @@ class Tracing(metaclass=Singleton):
 
     def configure(
         self,
+        project_id: Optional[str] = None,
         api_key: Optional[str] = None,
-        # DEPRECATING
+        #
         app_id: Optional[str] = None,
     ):
+        # AUTHENTICATION (OTLP)
+        self.project_id = project_id  # "f7943e42-ec69-498e-bf58-8db034b9286e"
+        self.app_id = app_id
+        # AUTHORIZATION (OTLP)
+        self.api_key = api_key
         # HEADERS (OTLP)
+        self.headers = {}
+        if project_id:
+            self.headers.update(**{"AG-PROJECT-ID": project_id})
+        if app_id:
+            self.headers.update(**{"AG-APP-ID": app_id})
         if api_key:
-            self.headers["Authorization"] = api_key
+            self.headers.update(**{"Authorization": self.api_key})
         # REFERENCES
-        if app_id:
-            self.references["application.id"] = app_id
+        self.references = {"application_id": app_id}
 
         # TRACER PROVIDER
         self.tracer_provider = TracerProvider(
             resource=Resource(attributes={"service.name": "agenta-sdk"})
         )
+        # TRACE PROCESSORS -- CONSOLE
+        # _console = TraceProcessor(
+        #    ConsoleExporter(),
+        #    references=self.references,
+        # )
+        # self.tracer_provider.add_span_processor(_console)
         # TRACE PROCESSORS -- INLINE
         self.inline = TraceProcessor(
-            InlineExporter(
-                registry=self.inline_spans,
-            ),
+            InlineExporter(registry=self.inline_spans),
             references=self.references,
         )
         self.tracer_provider.add_span_processor(self.inline)
         # TRACE PROCESSORS -- OTLP
         try:
-            log.info("--------------------------------------------")
-            log.info(
-                "Agenta SDK - connecting to otlp receiver at: %s",
-                self.otlp_url,
-            )
-            log.info("--------------------------------------------")
+            log.info(f"Connecting to the remote trace receiver at {self.otlp_url}...")
 
-            check(
-                self.otlp_url,
-                headers=self.headers,
-                timeout=1,
-            )
+            check(self.otlp_url, headers=self.headers, timeout=1)
+
+            log.info(f"Connection established.")
 
             _otlp = TraceProcessor(
-                OTLPExporter(
-                    endpoint=self.otlp_url,
-                    headers=self.headers,
-                ),
+                OTLPExporter(endpoint=self.otlp_url, headers=self.headers),
                 references=self.references,
             )
 
             self.tracer_provider.add_span_processor(_otlp)
-
-            log.info("Success: traces will be exported.")
-            log.info("--------------------------------------------")
-
-        except:  # pylint: disable=bare-except
-            log.warning("Failure: traces will not be exported.")
-            log.warning("--------------------------------------------")
-
+        except Exception as e:
+            log.error(e)
+            log.warning(f"Connection failed.")
+            log.warning(
+                f"Warning: Your traces will not be exported since {self.otlp_url} is unreachable."
+            )
         # GLOBAL TRACER PROVIDER -- INSTRUMENTATION LIBRARIES
         set_tracer_provider(self.tracer_provider)
         # TRACER
         self.tracer: Tracer = self.tracer_provider.get_tracer("agenta.tracer")
 
-    def get_current_span(self):
-        _span = None
-
-        with suppress():
-            _span = get_current_span()
+    def get_current_span(
+        self,
+    ):
+        _span = get_current_span()
 
-            if _span.is_recording():
-                return CustomSpan(_span)
+        if _span.is_recording():
+            return CustomSpan(_span)
 
         return _span
 
@@ -129,104 +132,42 @@ class Tracing(metaclass=Singleton):
         attributes: Dict[str, Any],
         span: Optional[Span] = None,
     ):
-        with suppress():
-            if span is None:
-                span = self.get_current_span()
+        if span is None:
+            span = self.get_current_span()
 
-            span.set_attributes(
-                attributes={"internals": attributes},
-                namespace="data",
-            )
-
-    def store_refs(
-        self,
-        refs: Dict[str, str],
-        span: Optional[Span] = None,
-    ):
-        with suppress():
-            if span is None:
-                span = self.get_current_span()
-
-            for key in refs.keys():
-                if key in [_.value for _ in Reference.__members__.values()]:
-                    # ADD REFERENCE TO THIS SPAN
-                    span.set_attribute(
-                        key.value if isinstance(key, Enum) else key,
-                        refs[key],
-                        namespace="refs",
-                    )
-
-                    # AND TO ALL SPANS CREATED AFTER THIS ONE
-                    self.references[key] = refs[key]
-                    # TODO: THIS SHOULD BE REPLACED BY A TRACE CONTEXT !!!
-
-    def store_meta(
-        self,
-        meta: Dict[str, Any],
-        span: Optional[Span] = None,
-    ):
-        with suppress():
-            if span is None:
-                span = self.get_current_span()
-
-            for key in meta.keys():
-                if is_valid_attribute_key(key):
-                    span.set_attribute(
-                        key,
-                        meta[key],
-                        namespace="meta",
-                    )
-
-    def store_metrics(
-        self,
-        metrics: Dict[str, Any],
-        span: Optional[Span] = None,
-    ):
-        with suppress():
-            if span is None:
-                span = self.get_current_span()
-
-            for key in metrics.keys():
-                if is_valid_attribute_key(key):
-                    span.set_attribute(
-                        key,
-                        metrics[key],
-                        namespace="metrics",
-                    )
+        span.set_attributes(attributes={"internals": attributes}, namespace="data")
 
     def is_inline_trace_ready(
         self,
-        trace_id: Optional[int] = None,
+        trace_id: int,
     ) -> bool:
-        is_ready = True
-
-        with suppress():
-            if trace_id is not None:
-                is_ready = self.inline.is_ready(trace_id)
+        is_ready = self.inline.is_ready(trace_id)
 
         return is_ready
 
     def get_inline_trace(
         self,
-        trace_id: Optional[int] = None,
+        trace_id: int,
     ) -> Dict[str, Any]:
-        _inline_trace = {}
+        if trace_id is None:
+            return {}
+
+        is_ready = self.inline.is_ready(trace_id)
+
+        if is_ready is False:
+            return {}
 
-        with suppress():
-            is_ready = self.inline.is_ready(trace_id)
+        otel_spans = self.inline.fetch(trace_id)
 
-            if is_ready is True:
-                otel_spans = self.inline.fetch(trace_id)
+        if not otel_spans:
+            return {}
 
-                if otel_spans:
-                    _inline_trace = parse_inline_trace(otel_spans)
+        inline_trace = parse_inline_trace(self.project_id or self.app_id, otel_spans)
 
-        return _inline_trace
+        return inline_trace
 
 
-def get_tracer(
-    tracing: Tracing,
-) -> Tracer:
+def get_tracer(tracing: Tracing) -> Tracer:
     if tracing is None or tracing.tracer is None or tracing.tracer_provider is None:
         return get_tracer_provider().get_tracer("default.tracer")
 

agenta/sdk/types.py

@@ -1,8 +1,9 @@
 import json
-from dataclasses import dataclass
 from typing import Dict, List, Optional, Any, Union
 
 from pydantic import ConfigDict, BaseModel, HttpUrl
+from dataclasses import dataclass
+from typing import Union
 
 
 @dataclass
@@ -185,63 +186,3 @@ class FileInputURL(HttpUrl):
     @classmethod
     def __schema_type_properties__(cls) -> dict:
         return {"x-parameter": "file_url", "type": "string"}
-
-
-class Context(BaseModel):
-    model_config = ConfigDict(extra="allow")
-
-    def to_json(self):
-        return self.model_dump()
-
-    @classmethod
-    def from_json(cls, json_str: str):
-        data = json.loads(json_str)
-        return cls(**data)
-
-
-class ReferencesResponse(BaseModel):
-    app_id: Optional[str] = None
-    app_slug: Optional[str] = None
-    variant_id: Optional[str] = None
-    variant_slug: Optional[str] = None
-    variant_version: Optional[int] = None
-    environment_id: Optional[str] = None
-    environment_slug: Optional[str] = None
-    environment_version: Optional[int] = None
-
-    def __str__(self):
-        return str(self.model_dump(exclude_none=True))
-
-
-class LifecyclesResponse(ReferencesResponse):
-    committed_at: Optional[str] = None
-    committed_by: Optional[str] = None
-    committed_by_id: Optional[str] = None
-    deployed_at: Optional[str] = None
-    deployed_by: Optional[str] = None
-    deployed_by_id: Optional[str] = None
-
-    def __str__(self):
-        return self.model_dump_json(indent=4)
-
-    def __repr__(self):
-        return self.__str__()
-
-
-class ConfigurationResponse(LifecyclesResponse):
-    params: Dict[str, Any]
-
-
-class DeploymentResponse(LifecyclesResponse):
-    pass
-
-
-class Prompt(BaseModel):
-    temperature: float
-    model: str
-    max_tokens: int
-    prompt_system: str
-    prompt_user: str
-    top_p: float
-    frequency_penalty: float
-    presence_penalty: float

agenta/sdk/utils/exceptions.py

@@ -1,12 +1,9 @@
 from contextlib import AbstractContextManager
 from traceback import format_exc
-from functools import wraps
-from inspect import iscoroutinefunction
-
 from agenta.sdk.utils.logging import log
 
 
-class suppress(AbstractContextManager):  # pylint: disable=invalid-name
+class suppress(AbstractContextManager):
     def __init__(self):
         pass
 
@@ -15,38 +12,8 @@ class suppress(AbstractContextManager):  # pylint: disable=invalid-name
 
     def __exit__(self, exc_type, exc_value, exc_tb):
         if exc_type is None:
-            return True
+            return
         else:
-            log.error("-------------------------------------------------")
-            log.error("Agenta SDK - suppressing tracing exception below:")
-            log.error("-------------------------------------------------")
-            log.error(format_exc().strip("\n"))
-            log.error("-------------------------------------------------")
-            return True
-
-
-def handle_exceptions():
-    def decorator(func):
-        is_coroutine_function = iscoroutinefunction(func)
-
-        @wraps(func)
-        async def async_wrapper(*args, **kwargs):
-            try:
-                return await func(*args, **kwargs)
-            except Exception as e:
-                log.error("--- HANDLING EXCEPTION ---")
-                log.error("--------------------------")
-                raise e
-
-        @wraps(func)
-        def sync_wrapper(*args, **kwargs):
-            try:
-                return func(*args, **kwargs)
-            except Exception as e:
-                log.error("--- HANDLING EXCEPTION ---")
-                log.error("--------------------------")
-                raise e
-
-        return async_wrapper if is_coroutine_function else sync_wrapper
-
-    return decorator
+            print("Agenta SDK - Tracing Exception")
+            log.error(f"{exc_type.__name__}: {exc_value}\n{format_exc()}")
+            return

{agenta-0.27.0.dist-info → agenta-0.27.0a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agenta
-Version: 0.27.0
+Version: 0.27.0a0
 Summary: The SDK for agenta is an open-source LLMOps platform.
 Home-page: https://agenta.ai
 Keywords: LLMOps,LLM,evaluation,prompt engineering