agenta 0.25.4a3__py3-none-any.whl → 0.25.4a4__py3-none-any.whl

agenta/sdk/tracing/processors.py

@@ -1,65 +0,0 @@
-from typing import Optional, Any, Dict
-
-from opentelemetry.context import Context
-from opentelemetry.sdk.trace import Span
-from opentelemetry.sdk.trace.export import (
-    SpanExporter,
-    ReadableSpan,
-    BatchSpanProcessor,
-    _DEFAULT_EXPORT_TIMEOUT_MILLIS,
-    _DEFAULT_MAX_QUEUE_SIZE,
-)
-
-# LOAD CONTEXT, HERE
-
-
-class TraceProcessor(BatchSpanProcessor):
-    def __init__(
-        self,
-        span_exporter: SpanExporter,
-        references: Dict[str, str] = None,
-        max_queue_size: int = None,
-        schedule_delay_millis: float = None,
-        max_export_batch_size: int = None,
-        export_timeout_millis: float = None,
-    ):
-        super().__init__(
-            span_exporter,
-            _DEFAULT_MAX_QUEUE_SIZE,
-            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()
-
-    def on_start(self, span: Span, parent_context: Optional[Context] = None) -> None:
-        # ADD LINKS FROM CONTEXT, HERE
-
-        for key in self.references.keys():
-            span.set_attribute(f"ag.refs.{key}", self.references[key])
-
-        if span.context.trace_id not in self._registry:
-            self._registry[span.context.trace_id] = dict()
-
-        self._registry[span.context.trace_id][span.context.span_id] = True
-
-    def on_end(self, span: ReadableSpan):
-        super().on_end(span)
-
-        del self._registry[span.context.trace_id][span.context.span_id]
-
-        if self.is_ready(span.get_span_context().trace_id):
-            self.force_flush()
-
-    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]:
-        trace = self._exporter.fetch(trace_id)  # type: ignore
-
-        return trace

agenta/sdk/tracing/spans.py

@@ -1,124 +0,0 @@
-from typing import Optional, Union, Any, Dict
-
-from opentelemetry.trace import SpanContext
-from opentelemetry.trace.status import Status, StatusCode
-from opentelemetry.sdk.trace import Span
-
-from agenta.sdk.tracing.attributes import serialize
-
-
-class CustomSpan(Span):  # INHERITANCE FOR TYPING ONLY
-    def __init__(self, span: Span) -> None:
-        super().__init__(  # INHERITANCE FOR TYPING ONLY
-            name=span.name,
-            context=span.context,
-            parent=span.parent,
-            sampler=span._sampler,
-            trace_config=span._trace_config,
-            resource=span.resource,
-            attributes=span.attributes,
-            events=span.events,
-            links=span.links,
-            kind=span.kind,
-            span_processor=span._span_processor,
-            instrumentation_info=span.instrumentation_info,
-            record_exception=span._record_exception,
-            set_status_on_exception=span._set_status_on_exception,
-            limits=span._limits,
-            instrumentation_scope=span.instrumentation_scope,
-        )
-
-        self._span = span
-
-    ## --- PROXY METHODS --- ##
-
-    def get_span_context(self):
-        return self._span.get_span_context()
-
-    def is_recording(self) -> bool:
-        return self._span.is_recording()
-
-    def update_name(self, name: str) -> None:
-        self._span.update_name(name)
-
-    def set_status(
-        self,
-        status: Union[Status, StatusCode],
-        description: Optional[str] = None,
-    ) -> None:
-        self._span.set_status(status=status, description=description)
-
-    def end(self) -> None:
-        self._span.end()
-
-    ## --- CUSTOM METHODS W/ ATTRIBUTES SERALIZATION --- ##
-
-    def set_attributes(
-        self,
-        attributes: Dict[str, Any],
-        namespace: Optional[str] = None,
-        max_depth: Optional[int] = None,
-    ) -> None:
-        self._span.set_attributes(
-            attributes=serialize(
-                namespace=namespace,
-                attributes=attributes,
-                max_depth=max_depth,
-            )
-        )
-
-    def set_attribute(
-        self,
-        key: str,
-        value: Any,
-        namespace: Optional[str] = None,
-    ) -> None:
-        self.set_attributes({key: value}, namespace)
-
-    def add_event(
-        self,
-        name: str,
-        attributes: Optional[Dict[str, Any]] = None,
-        timestamp: Optional[int] = None,
-        namespace: Optional[str] = None,
-    ) -> None:
-        self._span.add_event(
-            name=name,
-            attributes=serialize(
-                namespace=namespace,
-                attributes=attributes,
-            ),
-            timestamp=timestamp,
-        )
-
-    def add_link(
-        self,
-        context: SpanContext,
-        attributes: Optional[Dict[str, Any]] = None,
-        namespace: Optional[str] = None,
-    ) -> None:
-        self._span.add_link(
-            context=context,
-            attributes=serialize(
-                namespace=namespace,
-                attributes=attributes,
-            ),
-        )
-
-    def record_exception(
-        self,
-        exception: BaseException,
-        attributes: Optional[Dict[str, Any]] = None,
-        timestamp: Optional[int] = None,
-        escaped: bool = False,
-        namespace: Optional[str] = None,
-    ) -> None:
-        self._span.record_exception(
-            exception=exception,
-            attributes=serialize(
-                namespace=namespace,
-                attributes=attributes,
-            ),
-            timestamp=timestamp,
-            escaped=escaped,
-        )

agenta/sdk/tracing/tracing.py

@@ -1,174 +0,0 @@
-from typing import Optional, Any, Dict
-
-from httpx import get as check
-
-from opentelemetry.trace import (
-    get_current_span,
-    set_tracer_provider,
-    get_tracer_provider,
-    Status,
-    StatusCode,
-)
-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  # USE IT !
-from agenta.sdk.utils.logging import log
-
-from agenta.sdk.tracing.processors import TraceProcessor
-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
-
-
-class Tracing(metaclass=Singleton):
-    VERSION = "0.1.0"
-
-    Status = Status
-    StatusCode = StatusCode
-
-    def __init__(
-        self,
-        url: str,
-    ) -> 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
-        self.references: Dict[str, str] = dict()
-
-        # TRACER PROVIDER
-        self.tracer_provider: Optional[TracerProvider] = None
-        # TRACER
-        self.tracer: Optional[Tracer] = None
-        # INLINE SPANS for INLINE TRACES (INLINE PROCESSOR)
-        self.inline_spans: Dict[str, Any] = dict()
-
-    # PUBLIC
-
-    def configure(
-        self,
-        project_id: Optional[str] = None,
-        api_key: Optional[str] = None,
-        #
-        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.update(**{"Authorization": self.api_key})
-        # REFERENCES
-        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),
-            references=self.references,
-        )
-        self.tracer_provider.add_span_processor(self.inline)
-        # TRACE PROCESSORS -- OTLP
-        try:
-            log.info(f"Connecting to the remote trace receiver at {self.otlp_url}...")
-
-            check(self.otlp_url, headers=self.headers, timeout=1)
-
-            log.info(f"Connection established.")
-
-            _otlp = TraceProcessor(
-                OTLPExporter(endpoint=self.otlp_url, headers=self.headers),
-                references=self.references,
-            )
-
-            self.tracer_provider.add_span_processor(_otlp)
-        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 = get_current_span()
-
-        if _span.is_recording():
-            return CustomSpan(_span)
-
-        return _span
-
-    def store_internals(
-        self,
-        attributes: Dict[str, Any],
-        span: Optional[Span] = None,
-    ):
-        if span is None:
-            span = self.get_current_span()
-
-        span.set_attributes(attributes={"internals": attributes}, namespace="data")
-
-    def is_inline_trace_ready(
-        self,
-        trace_id: int,
-    ) -> bool:
-        is_ready = self.inline.is_ready(trace_id)
-
-        return is_ready
-
-    def get_inline_trace(
-        self,
-        trace_id: int,
-    ) -> Dict[str, Any]:
-        if trace_id is None:
-            return {}
-
-        is_ready = self.inline.is_ready(trace_id)
-
-        if is_ready is False:
-            return {}
-
-        otel_spans = self.inline.fetch(trace_id)
-
-        if not otel_spans:
-            return {}
-
-        inline_trace = parse_inline_trace(self.project_id or self.app_id, otel_spans)
-
-        return inline_trace
-
-
-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")
-
-    return tracing.tracer

agenta/sdk/utils/exceptions.py

@@ -1,19 +0,0 @@
-from contextlib import AbstractContextManager
-from traceback import format_exc
-from agenta.sdk.utils.logging import log
-
-
-class suppress(AbstractContextManager):
-    def __init__(self):
-        pass
-
-    def __enter__(self):
-        pass
-
-    def __exit__(self, exc_type, exc_value, exc_tb):
-        if exc_type is None:
-            return
-        else:
-            print("Agenta SDK - Tracing Exception")
-            log.error(f"{exc_type.__name__}: {exc_value}\n{format_exc()}")
-            return

agenta/sdk/utils/singleton.py

@@ -1,13 +0,0 @@
-from threading import Lock
-
-
-class Singleton(type):
-    _instances = {}
-
-    _lock: Lock = Lock()
-
-    def __call__(cls, *args, **kwargs):
-        with cls._lock:
-            if cls not in cls._instances:
-                cls._instances[cls] = super().__call__(*args, **kwargs)
-        return cls._instances[cls]