Same agent Smaller bill. The tools and infrastructure to get more work from your AI. Fewer tokens. Less compute. Lower cost.
TypeScript agent-harnessagent-harness-engineeringai-engineeringai-observabilityamd-gpuclaude-codeclickhousecodexcoding-agentcoding-agentscursorgenaigpu-monitoringllm-observabilityllmopsnvidia-smiobservabilityopen-sourceopenaiopentelemetry
feat: add instrumentation for DigitalOcean Inference (#1184)
Aman Agarwalfdfafbecb472
diff --git a/README.md b/README.mdindex 6a823890..4d1f381d 100644--- a/README.md+++ b/README.md@@ -220,6 +220,8 @@ OpenLIT auto-instruments **50+ LLM providers, AI frameworks, and vector database<tr><td align="center" width="160"><a href="https://docs.openlit.io/latest/sdk/integrations/multion"><b>MultiOn</b></a><br/><img src="https://img.shields.io/badge/Python-3776AB?logo=python&logoColor=white&style=flat-square" height="18"></td><td align="center" width="160"><a href="https://docs.openlit.io/latest/sdk/integrations/replicate"><b>Replicate</b></a><br/><img src="https://img.shields.io/badge/TypeScript-3178C6?logo=typescript&logoColor=white&style=flat-square" height="18"></td>+<td align="center" width="160"><a href="https://docs.openlit.io/latest/sdk/integrations/digitalocean"><b>DigitalOcean (pydo)</b></a><br/><img src="https://img.shields.io/badge/Python-3776AB?logo=python&logoColor=white&style=flat-square" height="18"></td>+<td align="center" width="160"><a href="https://docs.openlit.io/latest/sdk/integrations/digitalocean-gradient"><b>DigitalOcean Gradient</b></a><br/><img src="https://img.shields.io/badge/Python-3776AB?logo=python&logoColor=white&style=flat-square" height="18"></td></tr></table>diff --git a/docs/docs.json b/docs/docs.jsonindex 1dae9516..4d98b78e 100644--- a/docs/docs.json+++ b/docs/docs.json@@ -257,6 +257,8 @@"latest/sdk/integrations/elevenlabs","latest/sdk/integrations/ai21","latest/sdk/integrations/together",+ "latest/sdk/integrations/digitalocean",+ "latest/sdk/integrations/digitalocean-gradient","latest/sdk/integrations/assemblyai","latest/sdk/integrations/featherless","latest/sdk/integrations/reka",diff --git a/docs/latest/sdk/integrations/digitalocean-gradient.mdx b/docs/latest/sdk/integrations/digitalocean-gradient.mdxnew file mode 100644index 00000000..4596c395--- /dev/null+++ b/docs/latest/sdk/integrations/digitalocean-gradient.mdx@@ -0,0 +1,51 @@+---+title: 'Monitor DigitalOcean Gradient using OpenTelemetry'+sidebarTitle: 'DigitalOcean Gradient'+---++import IntegrationMethods from '/snippets/integration-methods.mdx';++OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built on DigitalOcean's Gradient AI Platform via the [`gradient`](https://github.com/digitalocean/gradient-python) SDK. This includes tracking performance, token usage, costs, and how users interact with chat completions, the OpenAI-style Responses API, image generation, DigitalOcean Agents, and knowledge-base retrieval (RAG).++Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding OpenLIT in your application, all the necessary monitoring configurations are automatically set up.++The integration is compatible with:+- DigitalOcean `gradient` Python SDK `>= 3.0.0` (sync `Gradient` and async `AsyncGradient` clients)++## Get started++<Steps>+ <Step title="Install OpenLIT">+ Open your command line or terminal and run:++ <Tabs>+ <Tab title="Python">+ ```shell+ pip install openlit+ ```+ </Tab>+ </Tabs>+ </Step>+ <IntegrationMethods />+</Steps>++---++<CardGroup cols={3}>+ <Card title="Quickstart: LLM Observability" href="/latest/sdk/quickstart-ai-observability" icon='bolt'>+ Production-ready AI monitoring setup in 2 simple steps with zero code changes+ </Card>+ <Card title="Configuration" href="/latest/sdk/configuration" icon='bolt'>+ Configure the OpenLIT SDK according to you requirements.+ </Card>+ <Card title="Destinations" href="/latest/sdk/destinations/overview" icon='link'>+ Send telemetry to Datadog, Grafana, New Relic, and other observability stacks+ </Card>+</CardGroup>+<Card+ title="Zero-code observability with the OpenLIT Controller"+ icon="tower-broadcast"+ href="/latest/controller/overview"+ >+ Discover and instrument LLM traffic across Kubernetes, Docker, and Linux using eBPF — no code changes required.+ </Card>diff --git a/docs/latest/sdk/integrations/digitalocean.mdx b/docs/latest/sdk/integrations/digitalocean.mdxnew file mode 100644index 00000000..3622a04a--- /dev/null+++ b/docs/latest/sdk/integrations/digitalocean.mdx@@ -0,0 +1,51 @@+---+title: 'Monitor DigitalOcean GenAI (pydo) using OpenTelemetry'+sidebarTitle: 'DigitalOcean (pydo)'+---++import IntegrationMethods from '/snippets/integration-methods.mdx';++OpenLIT uses OpenTelemetry Auto-Instrumentation to help you monitor LLM applications built on DigitalOcean's GenAI Platform via the [`pydo`](https://github.com/digitalocean/pydo) SDK. This includes tracking performance, token usage, costs, cache hits, and how users interact with chat completions, embeddings, the Anthropic-style messages API, the OpenAI-style Responses API, and DigitalOcean Agents.++Auto-instrumentation means you don't have to set up monitoring manually for different LLMs, frameworks, or databases. By simply adding OpenLIT in your application, all the necessary monitoring configurations are automatically set up.++The integration is compatible with:+- DigitalOcean `pydo` Python SDK `>= 0.10.0` (sync `pydo.Client` and async `pydo.aio.Client`)++## Get started++<Steps>+ <Step title="Install OpenLIT">+ Open your command line or terminal and run:++ <Tabs>+ <Tab title="Python">+ ```shell+ pip install openlit+ ```+ </Tab>+ </Tabs>+ </Step>+ <IntegrationMethods />+</Steps>++---++<CardGroup cols={3}>+ <Card title="Quickstart: LLM Observability" href="/latest/sdk/quickstart-ai-observability" icon='bolt'>+ Production-ready AI monitoring setup in 2 simple steps with zero code changes+ </Card>+ <Card title="Configuration" href="/latest/sdk/configuration" icon='bolt'>+ Configure the OpenLIT SDK according to you requirements.+ </Card>+ <Card title="Destinations" href="/latest/sdk/destinations/overview" icon='link'>+ Send telemetry to Datadog, Grafana, New Relic, and other observability stacks+ </Card>+</CardGroup>+<Card+ title="Zero-code observability with the OpenLIT Controller"+ icon="tower-broadcast"+ href="/latest/controller/overview"+ >+ Discover and instrument LLM traffic across Kubernetes, Docker, and Linux using eBPF — no code changes required.+ </Card>diff --git a/examples/azure-inference-chat-app/app.py b/examples/azure-inference-chat-app/app.pyindex f316a2dd..a10e9464 100644--- a/examples/azure-inference-chat-app/app.py+++ b/examples/azure-inference-chat-app/app.py@@ -3,11 +3,15 @@ import timefrom azure.ai.inference import ChatCompletionsClientfrom azure.core.credentials import AzureKeyCredential-endpoint = os.environ.get("AZURE_INFERENCE_ENDPOINT", "https://models.inference.ai.azure.com")+endpoint = os.environ.get(+ "AZURE_INFERENCE_ENDPOINT", "https://models.inference.ai.azure.com"+)api_key = os.environ["AZURE_INFERENCE_API_KEY"]model = os.environ.get("AZURE_INFERENCE_MODEL", "gpt-4o-mini")-client = ChatCompletionsClient(endpoint=endpoint, credential=AzureKeyCredential(api_key))+client = ChatCompletionsClient(+ endpoint=endpoint, credential=AzureKeyCredential(api_key)+)print(f"Azure AI Inference test app starting -- calling {model} every 45s")i = 0diff --git a/sdk/python/README.md b/sdk/python/README.mdindex 1aa58a24..98f703af 100644--- a/sdk/python/README.md+++ b/sdk/python/README.md@@ -60,6 +60,8 @@ This project proudly follows and maintains the [Semantic Conventions](https://gi| [✅ Assembly AI](https://docs.openlit.io/latest/integrations/assemblyai) | | | || [✅ Together](https://docs.openlit.io/latest/integrations/together) | | | || [✅ DeepSeek](https://docs.openlit.io/latest/integrations/deepseek) | | | |+| [✅ DigitalOcean (pydo)](https://docs.openlit.io/latest/sdk/integrations/digitalocean) | | | |+| [✅ DigitalOcean Gradient](https://docs.openlit.io/latest/sdk/integrations/digitalocean-gradient) | | | |## Supported Destinations- [✅ OpenTelemetry Collector](https://docs.openlit.io/latest/connections/otelcol)diff --git a/sdk/python/src/openlit/_instrumentors.py b/sdk/python/src/openlit/_instrumentors.pyindex cd8a399d..e7aa9c40 100644--- a/sdk/python/src/openlit/_instrumentors.py+++ b/sdk/python/src/openlit/_instrumentors.py@@ -49,6 +49,8 @@ MODULE_NAME_MAP = {"firecrawl": "firecrawl","letta": "letta_client","together": "together",+ "pydo": "pydo",+ "gradient": "gradient","openai-agents": "agents","pydantic_ai": "pydantic_ai","sarvam": "sarvamai",@@ -93,6 +95,9 @@ INSTRUMENTOR_ALIASES = {"agent_framework": "agent-framework","psycopg_pool": "psycopg-pool","http": "httpx",+ "digitalocean": "pydo",+ "digital_ocean": "pydo",+ "do_gradient": "gradient",}@@ -165,6 +170,8 @@ INSTRUMENTOR_MAP = {"firecrawl": "openlit.instrumentation.firecrawl.FireCrawlInstrumentor","letta": "openlit.instrumentation.letta.LettaInstrumentor","together": "openlit.instrumentation.together.TogetherInstrumentor",+ "pydo": "openlit.instrumentation.pydo.PydoInstrumentor",+ "gradient": "openlit.instrumentation.gradient.GradientInstrumentor","openai-agents": "openlit.instrumentation.openai_agents.OpenAIAgentsInstrumentor","pydantic_ai": "openlit.instrumentation.pydantic_ai.PydanticAIInstrumentor","sarvam": "openlit.instrumentation.sarvam.SarvamInstrumentor",diff --git a/sdk/python/src/openlit/instrumentation/gradient/__init__.py b/sdk/python/src/openlit/instrumentation/gradient/__init__.pynew file mode 100644index 00000000..926ab3d6--- /dev/null+++ b/sdk/python/src/openlit/instrumentation/gradient/__init__.py@@ -0,0 +1,156 @@+"""Initializer of Auto Instrumentation of DigitalOcean Gradient SDK Functions"""++import logging+from typing import Collection+import importlib.metadata+from opentelemetry import _logs, trace+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor+from wrapt import wrap_function_wrapper++from openlit._config import OpenlitConfig+from openlit.instrumentation.gradient.gradient import (+ chat_completions,+ responses_create,+ image_generate,+ agent_chat_completions,+ retrieve_documents,+)+from openlit.instrumentation.gradient.async_gradient import (+ async_chat_completions,+ async_responses_create,+ async_image_generate,+ async_agent_chat_completions,+ async_retrieve_documents,+)++_instruments = ("gradient >= 3.0.0",)++logger = logging.getLogger(__name__)+++def _standard_args(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+):+ return (+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+ )+++def _safe_wrap(module, class_method, wrapper):+ try:+ wrap_function_wrapper(module, class_method, wrapper)+ except (ModuleNotFoundError, AttributeError):+ logger.debug(+ "Skipping %s.%s — not available in this gradient version",+ module,+ class_method,+ )+++class GradientInstrumentor(BaseInstrumentor):+ """An instrumentor for the DigitalOcean Gradient SDK."""++ def instrumentation_dependencies(self) -> Collection[str]:+ return _instruments++ def _instrument(self, **kwargs):+ version = importlib.metadata.version("gradient")+ environment = kwargs.get("environment", "default")+ application_name = kwargs.get("application_name", "default")+ tracer = trace.get_tracer(__name__)+ pricing_info = kwargs.get("pricing_info", {})+ capture_message_content = kwargs.get("capture_message_content", False)+ metrics = OpenlitConfig.metrics_dict+ disable_metrics = kwargs.get("disable_metrics")+ event_provider = _logs.get_logger_provider().get_logger(__name__)++ sa = _standard_args(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+ )++ # Chat completions+ _safe_wrap(+ "gradient.resources.chat.completions",+ "CompletionsResource.create",+ chat_completions(*sa),+ )+ _safe_wrap(+ "gradient.resources.chat.completions",+ "AsyncCompletionsResource.create",+ async_chat_completions(*sa),+ )++ # Responses API+ _safe_wrap(+ "gradient.resources.responses",+ "ResponsesResource.create",+ responses_create(*sa),+ )+ _safe_wrap(+ "gradient.resources.responses",+ "AsyncResponsesResource.create",+ async_responses_create(*sa),+ )++ # Image generation+ _safe_wrap(+ "gradient.resources.images",+ "ImagesResource.generate",+ image_generate(*sa),+ )+ _safe_wrap(+ "gradient.resources.images",+ "AsyncImagesResource.generate",+ async_image_generate(*sa),+ )++ # Agent chat completions+ _safe_wrap(+ "gradient.resources.agents.chat.completions",+ "CompletionsResource.create",+ agent_chat_completions(*sa),+ )+ _safe_wrap(+ "gradient.resources.agents.chat.completions",+ "AsyncCompletionsResource.create",+ async_agent_chat_completions(*sa),+ )++ # Knowledge-base retrieval (RAG)+ _safe_wrap(+ "gradient.resources.retrieve",+ "RetrieveResource.documents",+ retrieve_documents(*sa),+ )+ _safe_wrap(+ "gradient.resources.retrieve",+ "AsyncRetrieveResource.documents",+ async_retrieve_documents(*sa),+ )++ def _uninstrument(self, **kwargs):+ passdiff --git a/sdk/python/src/openlit/instrumentation/gradient/async_gradient.py b/sdk/python/src/openlit/instrumentation/gradient/async_gradient.pynew file mode 100644index 00000000..e628b17d--- /dev/null+++ b/sdk/python/src/openlit/instrumentation/gradient/async_gradient.py@@ -0,0 +1,468 @@+"""+Asynchronous wrappers for DigitalOcean Gradient SDK resources.+"""++import time++from opentelemetry import context as context_api, trace as trace_api+from opentelemetry.trace import SpanKind++from openlit.__helpers import (+ handle_exception,+ is_framework_llm_active,+ record_completion_metrics,+ response_as_dict,+)+from openlit.instrumentation.gradient.gradient import _resolve_endpoint+from openlit.instrumentation.gradient.utils import (+ _new_scope,+ common_chat_logic,+ process_chat_response,+ process_chunk,+ process_image_response,+ process_response_chunk,+ process_responses_response,+ process_retrieve_response,+ process_streaming_chat_response,+)+from openlit.semcov import SemanticConvention+++_DEFAULT_INFERENCE_HOST = "inference.do-ai.run"+_DEFAULT_AGENT_HOST = "agents.do-ai.run"+_DEFAULT_KB_HOST = "kbaas.do-ai.run"+++def _agent_id_from_host(host):+ if not host or "agents.do-ai.run" not in host:+ return None+ head = host.split(".agents.do-ai.run", 1)[0]+ return head or None+++def _make_traced_async_stream(chunk_processor, final_processor):+ class TracedAsyncStream:+ """Wraps a Gradient AsyncStream so chunks are observed and the span closes on completion."""++ def __init__(+ self, wrapped, span, body, server_address, server_port, finalize_kwargs+ ):+ self.__wrapped__ = wrapped+ self._span = span+ self._body = body+ self._server_address = server_address+ self._server_port = server_port+ self._finalize_kwargs = finalize_kwargs+ self._llmresponse = ""+ self._reasoning_text = ""+ self._response_id = ""+ self._response_model = ""+ self._finish_reason = ""+ self._tools = None+ self._timestamps = []+ self._ttft = 0+ self._tbt = 0+ self._input_tokens = 0+ self._output_tokens = 0+ self._reasoning_tokens = 0+ self._start_time = time.time()+ self._end_time = None+ self._finalized = False+ self._aiter = None++ async def __aenter__(self):+ if hasattr(self.__wrapped__, "__aenter__"):+ await self.__wrapped__.__aenter__()+ return self++ async def __aexit__(self, exc_type, exc_value, traceback):+ if hasattr(self.__wrapped__, "__aexit__"):+ await self.__wrapped__.__aexit__(exc_type, exc_value, traceback)+ self._finalize()++ def __aiter__(self):+ return self++ def __getattr__(self, name):+ return getattr(self.__wrapped__, name)++ def _ensure_aiter(self):+ if self._aiter is None:+ if hasattr(self.__wrapped__, "__anext__"):+ self._aiter = self.__wrapped__+ else:+ self._aiter = aiter(self.__wrapped__)+ return self._aiter++ async def __anext__(self):+ try:+ chunk = await self._ensure_aiter().__anext__()+ chunk_processor(self, chunk)+ return chunk+ except StopAsyncIteration:+ self._finalize()+ raise++ def _finalize(self):+ if self._finalized:+ return+ self._finalized = True+ try:+ with trace_api.use_span( # pylint: disable=not-context-manager+ self._span, end_on_exit=True+ ):+ final_processor(self, **self._finalize_kwargs)+ except Exception as exc:+ handle_exception(self._span, exc)++ return TracedAsyncStream+++def _build_async_wrapper(+ operation_name,+ api_type,+ process_response,+ chunk_processor,+ streaming_finalizer,+ default_host,+ span_name_prefix,+ is_agent=False,+ endpoint_kind="inference",+):+ def factory(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+ ):+ TracedAsyncStream = _make_traced_async_stream(+ chunk_processor, streaming_finalizer+ )++ async def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return await wrapped(*args, **kwargs)+ body = dict(kwargs) if kwargs else {}+ streaming = bool(body.get("stream"))+ server_address, server_port = _resolve_endpoint(+ instance, endpoint_kind, default_host+ )+ request_model = body.get("model", "unknown")+ span_name = f"{span_name_prefix} {request_model}"+ start_time = time.time()+ agent_id = _agent_id_from_host(server_address) if is_agent else None++ if streaming:+ span = tracer.start_span(span_name, kind=SpanKind.CLIENT)+ if agent_id:+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID, agent_id)+ ctx = trace_api.set_span_in_context(span)+ token = context_api.attach(ctx)+ try:+ result = await wrapped(*args, **kwargs)+ except Exception as exc:+ err_type = type(exc).__name__ or "_OTHER"+ handle_exception(span, exc)+ if not disable_metrics and metrics:+ record_completion_metrics(+ metrics,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ "unknown",+ environment,+ application_name,+ start_time,+ time.time(),+ 0,+ 0,+ 0,+ None,+ None,+ error_type=err_type,+ )+ context_api.detach(token)+ span.end()+ raise+ context_api.detach(token)++ if not hasattr(result, "__anext__") and not hasattr(+ result, "__aiter__"+ ):+ try:+ with trace_api.use_span( # pylint: disable=not-context-manager+ span, end_on_exit=True+ ):+ return process_response(+ response=result,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ raise++ finalize_kwargs = {+ "pricing_info": pricing_info,+ "environment": environment,+ "application_name": application_name,+ "metrics": metrics,+ "capture_message_content": capture_message_content,+ "disable_metrics": disable_metrics,+ "version": version,+ "event_provider": event_provider,+ "operation_name": operation_name,+ "api_type": api_type,+ }+ return TracedAsyncStream(+ result, span, body, server_address, server_port, finalize_kwargs+ )++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ if agent_id:+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID, agent_id)+ try:+ response = await wrapped(*args, **kwargs)+ except Exception as exc:+ err_type = type(exc).__name__ or "_OTHER"+ handle_exception(span, exc)+ if not disable_metrics and metrics:+ record_completion_metrics(+ metrics,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ "unknown",+ environment,+ application_name,+ start_time,+ time.time(),+ 0,+ 0,+ 0,+ None,+ None,+ error_type=err_type,+ )+ raise+ try:+ if is_agent:+ response_dict = response_as_dict(response)+ scope = _new_scope(+ body,+ span,+ start_time,+ server_address,+ server_port,+ response_dict,+ )+ choices = response_dict.get("choices") or []+ if choices:+ choice0 = choices[0]+ message = choice0.get("message") or {}+ scope._llmresponse = message.get("content") or ""+ scope._finish_reason = choice0.get("finish_reason") or ""+ if message.get("tool_calls"):+ scope._tools = message["tool_calls"]+ usage = response_dict.get("usage") or {}+ scope._input_tokens = usage.get("prompt_tokens", 0) or 0+ scope._output_tokens = usage.get("completion_tokens", 0) or 0+ common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream=False,+ operation_name=operation_name,+ api_type=api_type,+ event_provider=event_provider,+ )+ return response+ return process_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper++ return factory+++async_chat_completions = _build_async_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="chat",+ process_response=process_chat_response,+ chunk_processor=process_chunk,+ streaming_finalizer=process_streaming_chat_response,+ default_host=_DEFAULT_INFERENCE_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+)++async_responses_create = _build_async_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="responses",+ process_response=process_responses_response,+ chunk_processor=process_response_chunk,+ streaming_finalizer=process_streaming_chat_response,+ default_host=_DEFAULT_INFERENCE_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+)++async_agent_chat_completions = _build_async_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,+ api_type="chat",+ process_response=process_chat_response,+ chunk_processor=process_chunk,+ streaming_finalizer=process_streaming_chat_response,+ default_host=_DEFAULT_AGENT_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,+ is_agent=True,+ endpoint_kind="agent",+)+++def async_image_generate(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Async wrapper factory for AsyncImagesResource.generate."""++ async def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return await wrapped(*args, **kwargs)+ body = dict(kwargs) if kwargs else {}+ server_address, server_port = _resolve_endpoint(+ instance, "inference", _DEFAULT_INFERENCE_HOST+ )+ request_model = body.get("model", "unknown")+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"+ start_time = time.time()+ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ try:+ response = await wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ raise+ try:+ return process_image_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper+++def async_retrieve_documents(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Async wrapper factory for AsyncRetrieveResource.documents."""++ async def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return await wrapped(*args, **kwargs)+ body = dict(kwargs) if kwargs else {}+ server_address, server_port = _resolve_endpoint(+ instance, "kb", _DEFAULT_KB_HOST+ )+ kb_id = body.get("knowledge_base_uuid") or body.get("knowledge_base_id") or ""+ span_name = (+ f"{SemanticConvention.GEN_AI_OPERATION_TYPE_RETRIEVE} {kb_id or 'unknown'}"+ )+ start_time = time.time()+ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ try:+ response = await wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ raise+ try:+ return process_retrieve_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapperdiff --git a/sdk/python/src/openlit/instrumentation/gradient/gradient.py b/sdk/python/src/openlit/instrumentation/gradient/gradient.pynew file mode 100644index 00000000..60906d75--- /dev/null+++ b/sdk/python/src/openlit/instrumentation/gradient/gradient.py@@ -0,0 +1,504 @@+"""+Synchronous wrappers for DigitalOcean Gradient SDK resources.+"""++import time++from opentelemetry import context as context_api, trace as trace_api+from opentelemetry.trace import SpanKind++from openlit.__helpers import (+ handle_exception,+ is_framework_llm_active,+ record_completion_metrics,+ response_as_dict,+)+from openlit.instrumentation.gradient.utils import (+ _new_scope,+ common_chat_logic,+ process_chat_response,+ process_chunk,+ process_image_response,+ process_response_chunk,+ process_responses_response,+ process_retrieve_response,+ process_streaming_chat_response,+)+from openlit.semcov import SemanticConvention+++_DEFAULT_INFERENCE_HOST = "inference.do-ai.run"+_DEFAULT_AGENT_HOST = "agents.do-ai.run"+_DEFAULT_KB_HOST = "kbaas.do-ai.run"+++def _agent_id_from_host(host):+ if not host or "agents.do-ai.run" not in host:+ return None+ head = host.split(".agents.do-ai.run", 1)[0]+ return head or None+++def _resolve_endpoint(instance, kind, default_host):+ """Walk up to the Gradient client and read the per-resource endpoint.++ The shared Azure-style `_client.base_url` points to the control plane+ (api.digitalocean.com), not the actual inference / agent / KB host. The+ Gradient client stores the real per-route bases as `_inference_endpoint`,+ `_agent_endpoint`, and `_kbass_endpoint` (sic) — read those instead.+ `kind` is one of "inference", "agent", or "kb".+ """+ from urllib.parse import urlparse++ attr = {+ "inference": "_inference_endpoint",+ "agent": "_agent_endpoint",+ "kb": "_kbass_endpoint",+ }.get(kind)++ # Walk: resource → parent (.._client → top-level Gradient client)+ candidates = [instance]+ parent = getattr(instance, "_client", None)+ while parent is not None and parent not in candidates:+ candidates.append(parent)+ parent = getattr(parent, "_client", None)++ url = None+ for cand in candidates:+ if attr:+ url = getattr(cand, attr, None) or url+ if url:+ break++ if not url:+ return default_host, 443+ parsed = urlparse(str(url))+ host = parsed.hostname or default_host+ port = parsed.port or (443 if parsed.scheme == "https" else 80)+ return host, port+++def _make_traced_stream(chunk_processor, final_processor):+ class TracedSyncStream:+ """Wraps a Gradient sync Stream so chunks are observed and the span closes on completion."""++ def __init__(+ self, wrapped, span, body, server_address, server_port, finalize_kwargs+ ):+ self.__wrapped__ = wrapped+ self._span = span+ self._body = body+ self._server_address = server_address+ self._server_port = server_port+ self._finalize_kwargs = finalize_kwargs+ self._llmresponse = ""+ self._reasoning_text = ""+ self._response_id = ""+ self._response_model = ""+ self._finish_reason = ""+ self._tools = None+ self._timestamps = []+ self._ttft = 0+ self._tbt = 0+ self._input_tokens = 0+ self._output_tokens = 0+ self._reasoning_tokens = 0+ self._start_time = time.time()+ self._end_time = None+ self._finalized = False+ self._iter = None++ def __enter__(self):+ if hasattr(self.__wrapped__, "__enter__"):+ self.__wrapped__.__enter__()+ return self++ def __exit__(self, exc_type, exc_value, traceback):+ if hasattr(self.__wrapped__, "__exit__"):+ self.__wrapped__.__exit__(exc_type, exc_value, traceback)+ self._finalize()++ def __iter__(self):+ return self++ def __getattr__(self, name):+ return getattr(self.__wrapped__, name)++ def _ensure_iter(self):+ if self._iter is None:+ if hasattr(self.__wrapped__, "__next__"):+ self._iter = self.__wrapped__+ else:+ self._iter = iter(self.__wrapped__)+ return self._iter++ def __next__(self):+ try:+ chunk = next(self._ensure_iter())+ chunk_processor(self, chunk)+ return chunk+ except StopIteration:+ self._finalize()+ raise++ def _finalize(self):+ if self._finalized:+ return+ self._finalized = True+ try:+ with trace_api.use_span( # pylint: disable=not-context-manager+ self._span, end_on_exit=True+ ):+ final_processor(self, **self._finalize_kwargs)+ except Exception as exc:+ handle_exception(self._span, exc)++ return TracedSyncStream+++def _build_wrapper(+ operation_name,+ api_type,+ process_response,+ chunk_processor,+ streaming_finalizer,+ default_host,+ span_name_prefix,+ is_agent=False,+ endpoint_kind="inference",+):+ def factory(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+ ):+ TracedSyncStream = _make_traced_stream(chunk_processor, streaming_finalizer)++ def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return wrapped(*args, **kwargs)++ body = dict(kwargs) if kwargs else {}+ streaming = bool(body.get("stream"))+ server_address, server_port = _resolve_endpoint(+ instance, endpoint_kind, default_host+ )+ request_model = body.get("model", "unknown")+ span_name = f"{span_name_prefix} {request_model}"+ start_time = time.time()+ agent_id = _agent_id_from_host(server_address) if is_agent else None++ if streaming:+ span = tracer.start_span(span_name, kind=SpanKind.CLIENT)+ if agent_id:+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID, agent_id)+ ctx = trace_api.set_span_in_context(span)+ token = context_api.attach(ctx)+ try:+ result = wrapped(*args, **kwargs)+ except Exception as exc:+ err_type = type(exc).__name__ or "_OTHER"+ handle_exception(span, exc)+ if not disable_metrics and metrics:+ record_completion_metrics(+ metrics,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ "unknown",+ environment,+ application_name,+ start_time,+ time.time(),+ 0,+ 0,+ 0,+ None,+ None,+ error_type=err_type,+ )+ context_api.detach(token)+ span.end()+ raise+ context_api.detach(token)++ if not hasattr(result, "__next__") and not hasattr(result, "__iter__"):+ try:+ with trace_api.use_span( # pylint: disable=not-context-manager+ span, end_on_exit=True+ ):+ return process_response(+ response=result,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ raise++ finalize_kwargs = {+ "pricing_info": pricing_info,+ "environment": environment,+ "application_name": application_name,+ "metrics": metrics,+ "capture_message_content": capture_message_content,+ "disable_metrics": disable_metrics,+ "version": version,+ "event_provider": event_provider,+ "operation_name": operation_name,+ "api_type": api_type,+ }+ return TracedSyncStream(+ result, span, body, server_address, server_port, finalize_kwargs+ )++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ if agent_id:+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID, agent_id)+ try:+ response = wrapped(*args, **kwargs)+ except Exception as exc:+ err_type = type(exc).__name__ or "_OTHER"+ handle_exception(span, exc)+ if not disable_metrics and metrics:+ record_completion_metrics(+ metrics,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ "unknown",+ environment,+ application_name,+ start_time,+ time.time(),+ 0,+ 0,+ 0,+ None,+ None,+ error_type=err_type,+ )+ raise+ try:+ if is_agent:+ # Reuse plain chat handling, but span operation is invoke_agent+ response_dict = response_as_dict(response)+ scope = _new_scope(+ body,+ span,+ start_time,+ server_address,+ server_port,+ response_dict,+ )+ choices = response_dict.get("choices") or []+ if choices:+ choice0 = choices[0]+ message = choice0.get("message") or {}+ scope._llmresponse = message.get("content") or ""+ scope._finish_reason = choice0.get("finish_reason") or ""+ if message.get("tool_calls"):+ scope._tools = message["tool_calls"]+ usage = response_dict.get("usage") or {}+ scope._input_tokens = usage.get("prompt_tokens", 0) or 0+ scope._output_tokens = usage.get("completion_tokens", 0) or 0+ common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream=False,+ operation_name=operation_name,+ api_type=api_type,+ event_provider=event_provider,+ )+ return response+ return process_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper++ return factory+++chat_completions = _build_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="chat",+ process_response=process_chat_response,+ chunk_processor=process_chunk,+ streaming_finalizer=process_streaming_chat_response,+ default_host=_DEFAULT_INFERENCE_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+)++responses_create = _build_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="responses",+ process_response=process_responses_response,+ chunk_processor=process_response_chunk,+ streaming_finalizer=process_streaming_chat_response,+ default_host=_DEFAULT_INFERENCE_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+)++agent_chat_completions = _build_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,+ api_type="chat",+ process_response=process_chat_response,+ chunk_processor=process_chunk,+ streaming_finalizer=process_streaming_chat_response,+ default_host=_DEFAULT_AGENT_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,+ is_agent=True,+ endpoint_kind="agent",+)+++def image_generate(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Sync wrapper for ImagesResource.generate."""++ def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return wrapped(*args, **kwargs)+ body = dict(kwargs) if kwargs else {}+ server_address, server_port = _resolve_endpoint(+ instance, "inference", _DEFAULT_INFERENCE_HOST+ )+ request_model = body.get("model", "unknown")+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"+ start_time = time.time()+ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ try:+ response = wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ raise+ try:+ return process_image_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper+++def retrieve_documents(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Sync wrapper for RetrieveResource.documents."""++ def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return wrapped(*args, **kwargs)+ body = dict(kwargs) if kwargs else {}+ server_address, server_port = _resolve_endpoint(+ instance, "kb", _DEFAULT_KB_HOST+ )+ kb_id = body.get("knowledge_base_uuid") or body.get("knowledge_base_id") or ""+ span_name = (+ f"{SemanticConvention.GEN_AI_OPERATION_TYPE_RETRIEVE} {kb_id or 'unknown'}"+ )+ start_time = time.time()+ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ try:+ response = wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ raise+ try:+ return process_retrieve_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapperdiff --git a/sdk/python/src/openlit/instrumentation/gradient/utils.py b/sdk/python/src/openlit/instrumentation/gradient/utils.pynew file mode 100644index 00000000..5e93edee--- /dev/null+++ b/sdk/python/src/openlit/instrumentation/gradient/utils.py@@ -0,0 +1,1037 @@+"""+DigitalOcean Gradient SDK OpenTelemetry instrumentation utility functions.++The Gradient SDK is OpenAI-style: flat kwargs at the resource layer, Pydantic+response models, and SSE streaming via gradient._streaming.{Stream, AsyncStream}.+"""++import json+import logging+import time++from opentelemetry.trace import Status, StatusCode++from openlit.__helpers import (+ calculate_ttft,+ calculate_tbt,+ common_span_attributes,+ general_tokens,+ get_chat_model_cost,+ get_image_model_cost,+ otel_event,+ record_completion_metrics,+ response_as_dict,+ truncate_message_content,+)+from openlit._config import OpenlitConfig+from openlit.semcov import SemanticConvention++logger = logging.getLogger(__name__)+++_FINISH_REASON_MAP = {+ "stop": "stop",+ "length": "length",+ "content_filter": "content_filter",+ "tool_calls": "tool_call",+ "function_call": "tool_call",+ "end_turn": "stop",+ "max_tokens": "length",+ "stop_sequence": "stop",+ "tool_use": "tool_call",+}+++def _parse_args(value):+ """Parse JSON-string arguments into structured form when possible.++ OpenAI-style SDKs encode `function.arguments` as a JSON string.+ The OTel `tool_call` part schema specifies `arguments` as `any` —+ consumers expect the parsed object, not a JSON-encoded string.+ """+ if value is None:+ return None+ if isinstance(value, (dict, list)):+ return value+ if isinstance(value, str):+ s = value.strip()+ if not s:+ return s+ try:+ return json.loads(s)+ except (ValueError, TypeError):+ return value+ return value+++def _tool_call_part(tool_id, name, arguments):+ """Build a spec-compliant `tool_call` part. Drops empty optional fields."""+ part = {"type": "tool_call", "name": name or ""}+ if tool_id:+ part["id"] = str(tool_id)+ parsed = _parse_args(arguments)+ if parsed is not None and parsed != "":+ part["arguments"] = parsed+ return part+++def _tool_response_part(tool_id, response):+ """Build a spec-compliant `tool_call_response` part."""+ part = {"type": "tool_call_response", "response": response}+ if tool_id:+ part["id"] = str(tool_id)+ return part+++def _build_tool_definitions(tools):+ """Convert OpenAI-style `tools` array into spec §10.4 flattened shape."""+ if not isinstance(tools, list):+ return None+ out = []+ for tool in tools:+ if not isinstance(tool, dict):+ continue+ ttype = tool.get("type", "function")+ if ttype == "function" and isinstance(tool.get("function"), dict):+ fn = tool["function"]+ entry = {"type": "function", "name": fn.get("name", "")}+ if fn.get("description"):+ entry["description"] = fn["description"]+ if fn.get("parameters") is not None:+ entry["parameters"] = fn["parameters"]+ out.append(entry)+ else:+ entry = {"type": ttype, "name": tool.get("name", "")}+ for key in ("description", "parameters"):+ if tool.get(key) is not None:+ entry[key] = tool[key]+ out.append(entry)+ return out or None+++def format_content(messages):+ """Flatten messages to a single string for token estimation fallback."""+ if not messages:+ return ""+ formatted = []+ for message in messages:+ role = (+ message.get("role", "user")+ if isinstance(message, dict)+ else getattr(message, "role", "user")+ )+ content = (+ message.get("content", "")+ if isinstance(message, dict)+ else getattr(message, "content", "")+ )+ if isinstance(content, list):+ parts = []+ for item in content:+ if isinstance(item, dict):+ if "text" in item:+ parts.append(item["text"])+ elif item.get("type") == "image_url":+ parts.append("[image]")+ formatted.append(f"{role}: {', '.join(parts)}")+ else:+ formatted.append(f"{role}: {content}")+ return "\n".join(formatted)+++def build_input_messages(messages):+ """Convert request messages into the OTel `gen_ai.input.messages` schema."""+ if not messages:+ return []+ out = []+ for message in messages:+ try:+ role = (+ message.get("role", "user")+ if isinstance(message, dict)+ else getattr(message, "role", "user")+ )+ content = (+ message.get("content", "")+ if isinstance(message, dict)+ else getattr(message, "content", "")+ )+ parts = []+ if isinstance(content, list):+ for item in content:+ if not isinstance(item, dict):+ continue+ item_type = item.get("type")+ if item_type == "text" and item.get("text"):+ parts.append({"type": "text", "content": item["text"]})+ elif item_type == "image_url":+ url = (item.get("image_url") or {}).get("url", "")+ if url and not str(url).startswith("data:"):+ parts.append(+ {"type": "uri", "modality": "image", "uri": url}+ )+ elif isinstance(content, str) and content:+ parts.append({"type": "text", "content": content})++ # OpenAI-style assistant message with tool_calls array+ if role == "assistant" and isinstance(message, dict):+ for tc in message.get("tool_calls") or []:+ if not isinstance(tc, dict):+ continue+ fn = tc.get("function") or {}+ parts.append(+ _tool_call_part(+ tc.get("id"),+ fn.get("name", ""),+ fn.get("arguments"),+ )+ )++ if role == "tool":+ tool_call_id = (+ message.get("tool_call_id")+ if isinstance(message, dict)+ else getattr(message, "tool_call_id", None)+ )+ tool_content = content if isinstance(content, str) else str(content)+ parts = [_tool_response_part(tool_call_id, tool_content)]++ if parts:+ out.append({"role": role, "parts": parts})+ except Exception as exc:+ logger.warning("Failed to process input message: %s", exc, exc_info=True)+ return out+++def build_output_messages(+ response_text, finish_reason, tool_calls=None, reasoning=None+):+ """Build the OTel `gen_ai.output.messages` array from accumulated response state."""+ parts = []+ try:+ if reasoning:+ parts.append({"type": "reasoning", "content": reasoning})+ if response_text:+ parts.append({"type": "text", "content": response_text})+ if tool_calls:+ tools = tool_calls if isinstance(tool_calls, list) else [tool_calls]+ for tool in tools:+ if not isinstance(tool, dict):+ continue+ fn = tool.get("function") or {}+ parts.append(+ _tool_call_part(+ tool.get("id"),+ fn.get("name", ""),+ fn.get("arguments"),+ )+ )+ otel_finish = _FINISH_REASON_MAP.get(finish_reason, finish_reason or "stop")+ return [{"role": "assistant", "parts": parts, "finish_reason": otel_finish}]+ except Exception as exc:+ logger.warning("Failed to build output messages: %s", exc, exc_info=True)+ return [{"role": "assistant", "parts": [], "finish_reason": "stop"}]+++def _set_span_messages_as_array(span, input_messages, output_messages):+ try:+ truncate_message_content(input_messages)+ truncate_message_content(output_messages)+ if input_messages is not None:+ span.set_attribute(+ SemanticConvention.GEN_AI_INPUT_MESSAGES,+ json.dumps(input_messages)+ if isinstance(input_messages, list)+ else input_messages,+ )+ if output_messages is not None:+ span.set_attribute(+ SemanticConvention.GEN_AI_OUTPUT_MESSAGES,+ json.dumps(output_messages)+ if isinstance(output_messages, list)+ else output_messages,+ )+ except Exception as exc:+ logger.warning("Failed to set span message attributes: %s", exc, exc_info=True)+++def emit_inference_event(+ event_provider,+ operation_name,+ request_model,+ response_model,+ input_messages=None,+ output_messages=None,+ tool_definitions=None,+ server_address=None,+ server_port=None,+ **extra,+):+ """Emit the `gen_ai.client.inference.operation.details` event."""+ if not event_provider:+ return+ try:+ attributes = {SemanticConvention.GEN_AI_OPERATION: operation_name}+ if request_model:+ attributes[SemanticConvention.GEN_AI_REQUEST_MODEL] = request_model+ if response_model:+ attributes[SemanticConvention.GEN_AI_RESPONSE_MODEL] = response_model+ if server_address:+ attributes[SemanticConvention.SERVER_ADDRESS] = server_address+ if server_port is not None:+ attributes[SemanticConvention.SERVER_PORT] = server_port+ if input_messages is not None:+ attributes[SemanticConvention.GEN_AI_INPUT_MESSAGES] = input_messages+ if output_messages is not None:+ attributes[SemanticConvention.GEN_AI_OUTPUT_MESSAGES] = output_messages+ if tool_definitions is not None:+ attributes[SemanticConvention.GEN_AI_TOOL_DEFINITIONS] = tool_definitions+ for key, value in extra.items():+ if value is None:+ continue+ if key == "response_id":+ attributes[SemanticConvention.GEN_AI_RESPONSE_ID] = value+ elif key == "finish_reasons":+ attributes[SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON] = value+ elif key == "output_type":+ attributes[SemanticConvention.GEN_AI_OUTPUT_TYPE] = value+ elif key == "temperature":+ attributes[SemanticConvention.GEN_AI_REQUEST_TEMPERATURE] = value+ elif key == "max_tokens":+ attributes[SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS] = value+ elif key == "top_p":+ attributes[SemanticConvention.GEN_AI_REQUEST_TOP_P] = value+ elif key == "input_tokens":+ attributes[SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS] = value+ elif key == "output_tokens":+ attributes[SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS] = value+ elif key == "error_type":+ attributes[SemanticConvention.ERROR_TYPE] = value+ else:+ attributes[key] = value+ event = otel_event(+ name=SemanticConvention.GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS,+ attributes=attributes,+ body="",+ )+ if not OpenlitConfig.disable_events:+ event_provider.emit(event)+ except Exception as exc:+ logger.warning("Failed to emit inference event: %s", exc, exc_info=True)+++def _normalize_stop(stop):+ if stop is None:+ return []+ if isinstance(stop, str):+ return [stop]+ if isinstance(stop, list):+ return stop+ return [str(stop)]+++# ---------------------------------------------------------------------------+# Streaming chunk processors+# ---------------------------------------------------------------------------+++def process_chunk(scope, chunk):+ """Chat-completions chunk handler (Gradient OpenAI-compatible)."""+ end_time = time.time()+ scope._timestamps.append(end_time)+ if len(scope._timestamps) == 1:+ scope._ttft = calculate_ttft(scope._timestamps, scope._start_time)++ chunked = response_as_dict(chunk)++ choices = chunked.get("choices") or []+ if choices:+ choice0 = choices[0]+ delta = choice0.get("delta") or {}+ content = delta.get("content")+ if content:+ scope._llmresponse += content+ finish = choice0.get("finish_reason")+ if finish:+ scope._finish_reason = finish++ delta_tools = delta.get("tool_calls")+ if delta_tools:+ scope._tools = scope._tools or []+ for tool in delta_tools:+ idx = tool.get("index", 0) or 0+ while len(scope._tools) <= idx:+ scope._tools.append({})+ if tool.get("id"):+ scope._tools[idx] = {+ "id": tool["id"],+ "type": tool.get("type", "function"),+ "function": {+ "name": (tool.get("function") or {}).get("name") or "",+ "arguments": (tool.get("function") or {}).get("arguments")+ or "",+ },+ }+ elif scope._tools[idx]:+ fn = tool.get("function") or {}+ if "function" not in scope._tools[idx]:+ scope._tools[idx]["function"] = {"name": "", "arguments": ""}+ scope._tools[idx]["function"]["arguments"] += (+ fn.get("arguments") or ""+ )+ if fn.get("name"):+ scope._tools[idx]["function"]["name"] = fn["name"]++ if chunked.get("id"):+ scope._response_id = chunked["id"]+ if chunked.get("model"):+ scope._response_model = chunked["model"]++ usage = chunked.get("usage")+ if usage:+ scope._input_tokens = usage.get("prompt_tokens") or scope._input_tokens+ scope._output_tokens = usage.get("completion_tokens") or scope._output_tokens+++def process_response_chunk(scope, chunk):+ """Responses-API chunk handler."""+ end_time = time.time()+ scope._timestamps.append(end_time)+ if len(scope._timestamps) == 1:+ scope._ttft = calculate_ttft(scope._timestamps, scope._start_time)++ chunked = response_as_dict(chunk)+ chunk_type = chunked.get("type") or chunked.get("object")++ if chunk_type and "output_text.delta" in chunk_type:+ delta = chunked.get("delta", "")+ if isinstance(delta, str):+ scope._llmresponse += delta+ elif chunk_type and "reasoning_text.delta" in chunk_type:+ delta = chunked.get("delta", "")+ if isinstance(delta, str):+ scope._reasoning_text = getattr(scope, "_reasoning_text", "") + delta++ response = chunked.get("response")+ if isinstance(response, dict):+ scope._response_id = response.get("id") or scope._response_id+ scope._response_model = response.get("model") or scope._response_model+ usage = response.get("usage") or {}+ scope._input_tokens = usage.get("input_tokens", scope._input_tokens)+ scope._output_tokens = usage.get("output_tokens", scope._output_tokens)+ details = usage.get("output_tokens_details") or {}+ scope._reasoning_tokens = details.get(+ "reasoning_tokens", getattr(scope, "_reasoning_tokens", 0)+ )+++# ---------------------------------------------------------------------------+# Common attribute setter (chat / responses / agent-chat)+# ---------------------------------------------------------------------------+++def common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type=None,+ event_provider=None,+):+ """Set span attributes, emit event, record metrics for chat-style operations."""+ scope._end_time = time.time()+ if len(scope._timestamps) > 1:+ scope._tbt = calculate_tbt(scope._timestamps)++ body = scope._body or {}+ request_model = body.get("model", "unknown")++ if not scope._input_tokens:+ scope._input_tokens = general_tokens(format_content(body.get("messages", [])))+ if not scope._output_tokens:+ scope._output_tokens = general_tokens(scope._llmresponse or "")++ cost = get_chat_model_cost(+ request_model, pricing_info, scope._input_tokens, scope._output_tokens+ )++ common_span_attributes(+ scope,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ scope._server_address,+ scope._server_port,+ request_model,+ getattr(scope, "_response_model", request_model) or request_model,+ environment,+ application_name,+ is_stream,+ scope._tbt,+ scope._ttft,+ version,+ )++ if body.get("temperature") is not None:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, body["temperature"]+ )+ if body.get("top_p") is not None:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_TOP_P, body["top_p"]+ )+ max_tokens = body.get("max_completion_tokens") or body.get("max_tokens")+ if max_tokens is not None:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, max_tokens+ )+ if body.get("frequency_penalty") is not None:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY,+ body["frequency_penalty"],+ )+ if body.get("presence_penalty") is not None:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY,+ body["presence_penalty"],+ )+ stop_sequences = _normalize_stop(body.get("stop") or body.get("stop_sequences"))+ if stop_sequences:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES, stop_sequences+ )+ if body.get("seed") is not None:+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SEED, body["seed"])+ n_choices = body.get("n")+ if n_choices is not None and n_choices != 1:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_CHOICE_COUNT, n_choices+ )+ if body.get("user"):+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, body["user"])+ if body.get("reasoning_effort"):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_REASONING_EFFORT,+ body["reasoning_effort"],+ )++ if getattr(scope, "_response_id", None):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_RESPONSE_ID, scope._response_id+ )+ if getattr(scope, "_finish_reason", None):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON,+ [_FINISH_REASON_MAP.get(scope._finish_reason, scope._finish_reason)],+ )+ output_type = (+ "json"+ if (body.get("response_format") or {}).get("type") == "json_object"+ else "text"+ )+ scope._span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, output_type)+ if api_type:+ scope._span.set_attribute(SemanticConvention.OPENAI_API_TYPE, api_type)++ if scope._tools:+ first = scope._tools[0] if isinstance(scope._tools, list) else scope._tools+ if isinstance(first, dict):+ fn = first.get("function") or {}+ if fn.get("name"):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_TOOL_NAME, fn.get("name", "")+ )+ if first.get("id"):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_TOOL_CALL_ID, str(first.get("id", ""))+ )+ if capture_message_content and fn.get("arguments"):+ args_val = fn.get("arguments")+ if not isinstance(args_val, str):+ try:+ args_val = json.dumps(args_val)+ except (TypeError, ValueError):+ args_val = str(args_val)+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_TOOL_CALL_ARGUMENTS, args_val+ )++ scope._span.set_attribute(+ SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, scope._input_tokens+ )+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, scope._output_tokens+ )+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE,+ scope._input_tokens + scope._output_tokens,+ )+ scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)+ if getattr(scope, "_reasoning_tokens", 0):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_USAGE_REASONING_TOKENS, scope._reasoning_tokens+ )++ if is_stream and scope._ttft:+ scope._span.set_attribute("gen_ai.response.time_to_first_chunk", scope._ttft)++ if capture_message_content:+ input_msgs = build_input_messages(body.get("messages", []))+ output_msgs = build_output_messages(+ scope._llmresponse,+ scope._finish_reason,+ tool_calls=scope._tools,+ reasoning=getattr(scope, "_reasoning_text", "") or None,+ )+ _set_span_messages_as_array(scope._span, input_msgs, output_msgs)+ tool_defs = _build_tool_definitions(body.get("tools"))+ if tool_defs:+ try:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_TOOL_DEFINITIONS,+ json.dumps(tool_defs),+ )+ except (TypeError, ValueError):+ pass+ emit_inference_event(+ event_provider=event_provider,+ operation_name=operation_name,+ request_model=request_model,+ response_model=getattr(scope, "_response_model", request_model)+ or request_model,+ input_messages=input_msgs,+ output_messages=output_msgs,+ tool_definitions=tool_defs,+ server_address=scope._server_address,+ server_port=scope._server_port,+ response_id=getattr(scope, "_response_id", None),+ finish_reasons=[+ _FINISH_REASON_MAP.get(+ scope._finish_reason, scope._finish_reason or "stop"+ )+ ],+ output_type=output_type,+ temperature=body.get("temperature"),+ max_tokens=max_tokens,+ top_p=body.get("top_p"),+ input_tokens=scope._input_tokens,+ output_tokens=scope._output_tokens,+ )++ scope._span.set_status(Status(StatusCode.OK))++ if not disable_metrics and metrics:+ inter_chunk_durations = None+ if len(scope._timestamps) > 1:+ inter_chunk_durations = [+ scope._timestamps[i] - scope._timestamps[i - 1]+ for i in range(1, len(scope._timestamps))+ ]+ record_completion_metrics(+ metrics,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ scope._server_address,+ scope._server_port,+ request_model,+ getattr(scope, "_response_model", request_model) or request_model,+ environment,+ application_name,+ scope._start_time,+ scope._end_time,+ scope._input_tokens,+ scope._output_tokens,+ cost,+ scope._tbt,+ scope._ttft,+ is_stream=is_stream,+ time_per_chunk_observations=inter_chunk_durations,+ )+++def _new_scope(body, span, start_time, server_address, server_port, response_dict=None):+ scope = type("GradientScope", (), {})()+ scope._body = body+ scope._span = span+ scope._start_time = start_time+ scope._end_time = time.time()+ scope._server_address = server_address+ scope._server_port = server_port+ scope._llmresponse = ""+ scope._reasoning_text = ""+ scope._response_id = ""+ scope._response_model = ""+ scope._finish_reason = ""+ scope._tools = None+ scope._timestamps = []+ scope._ttft = 0+ scope._tbt = 0+ scope._input_tokens = 0+ scope._output_tokens = 0+ scope._reasoning_tokens = 0+ if response_dict is not None:+ scope._response_id = response_dict.get("id", "") or ""+ scope._response_model = response_dict.get("model", "") or ""+ return scope+++# ---------------------------------------------------------------------------+# Non-streaming response processors+# ---------------------------------------------------------------------------+++def process_chat_response(+ response,+ body,+ pricing_info,+ server_address,+ server_port,+ environment,+ application_name,+ metrics,+ start_time,+ span,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+):+ """Non-streaming chat completion processor."""+ response_dict = response_as_dict(response)+ scope = _new_scope(+ body, span, start_time, server_address, server_port, response_dict+ )++ choices = response_dict.get("choices") or []+ if choices:+ choice0 = choices[0]+ message = choice0.get("message") or {}+ content = message.get("content") or ""+ scope._llmresponse = content if isinstance(content, str) else str(content)+ scope._finish_reason = choice0.get("finish_reason") or ""+ if message.get("tool_calls"):+ scope._tools = message["tool_calls"]++ usage = response_dict.get("usage") or {}+ scope._input_tokens = usage.get("prompt_tokens", 0) or 0+ scope._output_tokens = usage.get("completion_tokens", 0) or 0++ common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream=False,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="chat",+ event_provider=event_provider,+ )+ return response+++def process_streaming_chat_response(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="chat",+):+ """Finalize a streaming chat (or responses) span by delegating to common_chat_logic."""+ common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream=True,+ operation_name=operation_name,+ api_type=api_type,+ event_provider=event_provider,+ )+++def process_responses_response(+ response,+ body,+ pricing_info,+ server_address,+ server_port,+ environment,+ application_name,+ metrics,+ start_time,+ span,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+):+ """Non-streaming Responses-API processor (OpenAI Responses surface)."""+ response_dict = response_as_dict(response)+ scope = _new_scope(+ body, span, start_time, server_address, server_port, response_dict+ )++ output_text = []+ reasoning_text = []+ tool_calls = []+ finish = ""+ for item in response_dict.get("output") or []:+ if not isinstance(item, dict):+ continue+ finish = item.get("status") or finish+ if item.get("type") == "message":+ for content in item.get("content") or []:+ if not isinstance(content, dict):+ continue+ if content.get("type") == "output_text" and content.get("text"):+ output_text.append(content["text"])+ elif content.get("type") == "reasoning_text" and content.get("text"):+ reasoning_text.append(content["text"])+ elif item.get("type") == "function_call":+ tool_calls.append(+ {+ "id": item.get("call_id", ""),+ "type": "function",+ "function": {+ "name": item.get("name", ""),+ "arguments": item.get("arguments", ""),+ },+ }+ )++ scope._llmresponse = "".join(output_text)+ scope._reasoning_text = "".join(reasoning_text)+ scope._finish_reason = finish+ if tool_calls:+ scope._tools = tool_calls++ usage = response_dict.get("usage") or {}+ scope._input_tokens = usage.get("input_tokens", 0) or 0+ scope._output_tokens = usage.get("output_tokens", 0) or 0+ details = usage.get("output_tokens_details") or {}+ scope._reasoning_tokens = details.get("reasoning_tokens", 0) or 0++ common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream=False,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="responses",+ event_provider=event_provider,+ )+ return response+++# ---------------------------------------------------------------------------+# Image generation+# ---------------------------------------------------------------------------+++def process_image_response(+ response,+ body,+ pricing_info,+ server_address,+ server_port,+ environment,+ application_name,+ metrics,+ start_time,+ span,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+):+ """Non-streaming image-generation response processor."""+ end_time = time.time()+ response_dict = response_as_dict(response)+ request_model = body.get("model", "unknown")+ response_model = response_dict.get("model") or request_model+ size = body.get("size", "1024x1024")+ quality = body.get("quality", "standard")++ cost = get_image_model_cost(request_model, pricing_info, size, quality)++ scope = _new_scope(+ body, span, start_time, server_address, server_port, response_dict+ )+ scope._end_time = end_time++ common_span_attributes(+ scope,+ SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ response_model,+ environment,+ application_name,+ False,+ 0,+ 0,+ version,+ )+ span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, "image")+ if response_dict.get("created"):+ span.set_attribute(+ SemanticConvention.GEN_AI_RESPONSE_ID, str(response_dict["created"])+ )+ span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)++ if capture_message_content:+ prompt = body.get("prompt", "")+ input_msgs = (+ [+ {+ "role": "user",+ "parts": [{"type": "text", "content": str(prompt)}],+ }+ ]+ if prompt+ else None+ )+ _set_span_messages_as_array(span, input_msgs, None)++ span.set_status(Status(StatusCode.OK))++ if not disable_metrics and metrics:+ record_completion_metrics(+ metrics,+ SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ response_model,+ environment,+ application_name,+ start_time,+ end_time,+ 0,+ 0,+ cost,+ None,+ None,+ )+ return response+++# ---------------------------------------------------------------------------+# Knowledge-base retrieval (RAG)+# ---------------------------------------------------------------------------+++def process_retrieve_response(+ response,+ body,+ pricing_info,+ server_address,+ server_port,+ environment,+ application_name,+ metrics,+ start_time,+ span,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+):+ """Non-streaming retrieval response processor."""+ end_time = time.time()+ response_dict = response_as_dict(response)++ kb_id = body.get("knowledge_base_uuid") or body.get("knowledge_base_id") or ""++ scope = _new_scope(+ body, span, start_time, server_address, server_port, response_dict+ )+ scope._end_time = end_time++ common_span_attributes(+ scope,+ SemanticConvention.GEN_AI_OPERATION_TYPE_RETRIEVE,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ None,+ None,+ environment,+ application_name,+ False,+ 0,+ 0,+ version,+ )+ if kb_id:+ span.set_attribute(SemanticConvention.GEN_AI_DATA_SOURCE_ID, kb_id)+ if body.get("top_k") is not None:+ span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_K, body["top_k"])++ if capture_message_content:+ query = body.get("query")+ if query is not None:+ span.set_attribute(+ SemanticConvention.GEN_AI_RETRIEVAL_QUERY_TEXT, str(query)+ )+ retrieved = response_dict.get("retrieved_data") or response_dict.get(+ "documents"+ )+ if retrieved is not None:+ try:+ span.set_attribute(+ SemanticConvention.GEN_AI_RETRIEVAL_DOCUMENTS,+ json.dumps(retrieved)[:65536],+ )+ except Exception:+ pass++ span.set_status(Status(StatusCode.OK))++ if not disable_metrics and metrics:+ record_completion_metrics(+ metrics,+ SemanticConvention.GEN_AI_OPERATION_TYPE_RETRIEVE,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ kb_id or "unknown",+ kb_id or "unknown",+ environment,+ application_name,+ start_time,+ end_time,+ 0,+ 0,+ 0,+ None,+ None,+ )+ return responsediff --git a/sdk/python/src/openlit/instrumentation/pydo/__init__.py b/sdk/python/src/openlit/instrumentation/pydo/__init__.pynew file mode 100644index 00000000..615661a8--- /dev/null+++ b/sdk/python/src/openlit/instrumentation/pydo/__init__.py@@ -0,0 +1,186 @@+"""Initializer of Auto Instrumentation of DigitalOcean pydo Functions"""++import logging+from typing import Collection+import importlib.metadata+from opentelemetry import _logs, trace+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor+from wrapt import wrap_function_wrapper++from openlit._config import OpenlitConfig+from openlit.instrumentation.pydo.pydo import (+ chat_completions,+ embeddings,+ responses_create,+ messages_create,+ agent_chat_completions,+ async_invoke_create,+ list_models,+)+from openlit.instrumentation.pydo.async_pydo import (+ async_chat_completions,+ async_embeddings,+ async_responses_create,+ async_messages_create,+ async_agent_chat_completions,+ async_async_invoke_create,+ async_list_models,+)++_instruments = ("pydo >= 0.10.0",)++logger = logging.getLogger(__name__)+++def _standard_args(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+):+ return (+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+ )+++def _safe_wrap(module, class_method, wrapper):+ """Wrap a function, silently skipping if the module/class is missing."""+ try:+ wrap_function_wrapper(module, class_method, wrapper)+ except (ModuleNotFoundError, AttributeError):+ logger.debug(+ "Skipping %s.%s — not available in this pydo version",+ module,+ class_method,+ )+++class PydoInstrumentor(BaseInstrumentor):+ """An instrumentor for the DigitalOcean pydo client library."""++ def instrumentation_dependencies(self) -> Collection[str]:+ return _instruments++ def _instrument(self, **kwargs):+ version = importlib.metadata.version("pydo")+ environment = kwargs.get("environment", "default")+ application_name = kwargs.get("application_name", "default")+ tracer = trace.get_tracer(__name__)+ pricing_info = kwargs.get("pricing_info", {})+ capture_message_content = kwargs.get("capture_message_content", False)+ metrics = OpenlitConfig.metrics_dict+ disable_metrics = kwargs.get("disable_metrics")+ event_provider = _logs.get_logger_provider().get_logger(__name__)++ sa = _standard_args(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider,+ )++ # Wrap the facade methods. Pydo's facades take flat kwargs and route to+ # `self._client.inference.create_*(body, ...)` — the streaming dispatch+ # is monkey-patched onto the operations *instance*, so wrapping the+ # raw class method is effectively dead (the instance attribute wins+ # at lookup). The facade is the only reliable hook point for both+ # streaming and non-streaming traffic.+ _safe_wrap(+ "pydo.resources.inference.chat.completions",+ "Completions.create",+ chat_completions(*sa),+ )+ _safe_wrap(+ "pydo.resources.aio.inference.chat.completions",+ "Completions.create",+ async_chat_completions(*sa),+ )++ _safe_wrap(+ "pydo.resources.inference.embeddings",+ "Embeddings.create",+ embeddings(*sa),+ )+ _safe_wrap(+ "pydo.resources.aio.inference.embeddings",+ "Embeddings.create",+ async_embeddings(*sa),+ )++ _safe_wrap(+ "pydo.resources.inference.responses",+ "Responses.create",+ responses_create(*sa),+ )+ _safe_wrap(+ "pydo.resources.aio.inference.responses",+ "Responses.create",+ async_responses_create(*sa),+ )++ _safe_wrap(+ "pydo.resources.inference.messages",+ "Messages.create",+ messages_create(*sa),+ )+ _safe_wrap(+ "pydo.resources.aio.inference.messages",+ "Messages.create",+ async_messages_create(*sa),+ )++ _safe_wrap(+ "pydo.resources.agent_inference.chat.completions",+ "Completions.create",+ agent_chat_completions(*sa),+ )+ _safe_wrap(+ "pydo.resources.aio.agent_inference.chat.completions",+ "Completions.create",+ async_agent_chat_completions(*sa),+ )++ # Async-invoke (queued image/audio/video generation)+ _safe_wrap(+ "pydo.resources.inference.async_invoke",+ "AsyncInvoke.create",+ async_invoke_create(*sa),+ )+ _safe_wrap(+ "pydo.resources.aio.inference.async_invoke",+ "AsyncInvoke.create",+ async_async_invoke_create(*sa),+ )++ # Models list (metadata)+ _safe_wrap(+ "pydo.resources.inference.models",+ "Models.list",+ list_models(*sa),+ )+ _safe_wrap(+ "pydo.resources.aio.inference.models",+ "Models.list",+ async_list_models(*sa),+ )++ def _uninstrument(self, **kwargs):+ passdiff --git a/sdk/python/src/openlit/instrumentation/pydo/async_pydo.py b/sdk/python/src/openlit/instrumentation/pydo/async_pydo.pynew file mode 100644index 00000000..63db8aee--- /dev/null+++ b/sdk/python/src/openlit/instrumentation/pydo/async_pydo.py@@ -0,0 +1,609 @@+"""+Asynchronous wrappers for DigitalOcean pydo inference operations.+"""++import time++from opentelemetry import context as context_api, trace as trace_api+from opentelemetry.trace import SpanKind++from openlit.__helpers import (+ handle_exception,+ is_framework_llm_active,+ record_completion_metrics,+ record_embedding_metrics,+ response_as_dict,+ set_server_address_and_port,+)+from openlit.instrumentation.pydo.pydo import _extract_body+from openlit.instrumentation.pydo.utils import (+ _new_scope,+ common_chat_logic,+ process_async_invoke_response,+ process_chat_response,+ process_chunk,+ process_embedding_response,+ process_messages_chunk,+ process_messages_response,+ process_response_chunk,+ process_responses_response,+ process_streaming_chat_response,+ process_streaming_messages_response,+)+from openlit.semcov import SemanticConvention+++_DEFAULT_INFERENCE_HOST = "inference.do-ai.run"+_DEFAULT_AGENT_HOST = "agents.do-ai.run"+++def _agent_id_from_host(host):+ if not host or "agents.do-ai.run" not in host:+ return None+ head = host.split(".agents.do-ai.run", 1)[0]+ return head or None+++def _make_traced_async_stream(chunk_processor, final_processor):+ class TracedAsyncStream:+ """Wraps a pydo AsyncSSEStream so chunks are observed and the span closes on completion."""++ def __init__(+ self, wrapped, span, body, server_address, server_port, finalize_kwargs+ ):+ self.__wrapped__ = wrapped+ self._span = span+ self._body = body+ self._server_address = server_address+ self._server_port = server_port+ self._finalize_kwargs = finalize_kwargs+ self._llmresponse = ""+ self._reasoning_text = ""+ self._response_id = ""+ self._response_model = ""+ self._finish_reason = ""+ self._system_fingerprint = ""+ self._tools = None+ self._timestamps = []+ self._ttft = 0+ self._tbt = 0+ self._input_tokens = 0+ self._output_tokens = 0+ self._reasoning_tokens = 0+ self._cache_read_input_tokens = 0+ self._cache_creation_input_tokens = 0+ self._start_time = time.time()+ self._end_time = None+ self._finalized = False+ self._aiter = None++ async def __aenter__(self):+ if hasattr(self.__wrapped__, "__aenter__"):+ await self.__wrapped__.__aenter__()+ return self++ async def __aexit__(self, exc_type, exc_value, traceback):+ if hasattr(self.__wrapped__, "__aexit__"):+ await self.__wrapped__.__aexit__(exc_type, exc_value, traceback)+ self._finalize()++ def __aiter__(self):+ return self++ def __getattr__(self, name):+ return getattr(self.__wrapped__, name)++ def _ensure_aiter(self):+ if self._aiter is None:+ if hasattr(self.__wrapped__, "__anext__"):+ self._aiter = self.__wrapped__+ else:+ self._aiter = aiter(self.__wrapped__)+ return self._aiter++ async def __anext__(self):+ try:+ chunk = await self._ensure_aiter().__anext__()+ chunk_processor(self, chunk)+ return chunk+ except StopAsyncIteration:+ self._finalize()+ raise++ def _finalize(self):+ if self._finalized:+ return+ self._finalized = True+ try:+ with trace_api.use_span( # pylint: disable=not-context-manager+ self._span, end_on_exit=True+ ):+ final_processor(self, **self._finalize_kwargs)+ except Exception as exc:+ handle_exception(self._span, exc)++ return TracedAsyncStream+++def _build_async_wrapper(+ operation_name,+ api_type,+ process_response,+ chunk_processor,+ streaming_finalizer,+ default_host,+ span_name_prefix,+ use_messages_finalizer=False,+):+ def factory(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+ ):+ TracedAsyncStream = _make_traced_async_stream(+ chunk_processor, streaming_finalizer+ )++ async def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return await wrapped(*args, **kwargs)++ body, _ = _extract_body(args, kwargs)+ if not isinstance(body, dict) or not body:+ return await wrapped(*args, **kwargs)++ streaming = bool(body.get("stream"))+ server_address, server_port = set_server_address_and_port(+ instance, default_host, 443+ )+ request_model = body.get("model", "unknown")+ span_name = f"{span_name_prefix} {request_model}"+ start_time = time.time()++ if streaming:+ span = tracer.start_span(span_name, kind=SpanKind.CLIENT)+ ctx = trace_api.set_span_in_context(span)+ token = context_api.attach(ctx)+ try:+ result = await wrapped(*args, **kwargs)+ except Exception as exc:+ err_type = type(exc).__name__ or "_OTHER"+ handle_exception(span, exc)+ if not disable_metrics and metrics:+ record_completion_metrics(+ metrics,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ "unknown",+ environment,+ application_name,+ start_time,+ time.time(),+ 0,+ 0,+ 0,+ None,+ None,+ error_type=err_type,+ )+ context_api.detach(token)+ span.end()+ raise+ context_api.detach(token)++ if not hasattr(result, "__anext__") and not hasattr(+ result, "__aiter__"+ ):+ try:+ with trace_api.use_span( # pylint: disable=not-context-manager+ span, end_on_exit=True+ ):+ return process_response(+ response=result,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ raise++ finalize_kwargs = {+ "pricing_info": pricing_info,+ "environment": environment,+ "application_name": application_name,+ "metrics": metrics,+ "capture_message_content": capture_message_content,+ "disable_metrics": disable_metrics,+ "version": version,+ "event_provider": event_provider,+ }+ if not use_messages_finalizer:+ finalize_kwargs["operation_name"] = operation_name+ finalize_kwargs["api_type"] = api_type+ return TracedAsyncStream(+ result, span, body, server_address, server_port, finalize_kwargs+ )++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ try:+ response = await wrapped(*args, **kwargs)+ except Exception as exc:+ err_type = type(exc).__name__ or "_OTHER"+ handle_exception(span, exc)+ if not disable_metrics and metrics:+ record_completion_metrics(+ metrics,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ "unknown",+ environment,+ application_name,+ start_time,+ time.time(),+ 0,+ 0,+ 0,+ None,+ None,+ error_type=err_type,+ )+ raise++ try:+ return process_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper++ return factory+++async_chat_completions = _build_async_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="chat",+ process_response=process_chat_response,+ chunk_processor=process_chunk,+ streaming_finalizer=process_streaming_chat_response,+ default_host=_DEFAULT_INFERENCE_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+)++async_responses_create = _build_async_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="responses",+ process_response=process_responses_response,+ chunk_processor=process_response_chunk,+ streaming_finalizer=process_streaming_chat_response,+ default_host=_DEFAULT_INFERENCE_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+)++async_messages_create = _build_async_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="messages",+ process_response=process_messages_response,+ chunk_processor=process_messages_chunk,+ streaming_finalizer=process_streaming_messages_response,+ default_host=_DEFAULT_INFERENCE_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ use_messages_finalizer=True,+)+++def async_agent_chat_completions(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Async wrapper factory for AgentInferenceOperations.create_chat_completion."""+ TracedAsyncStream = _make_traced_async_stream(+ process_chunk, process_streaming_chat_response+ )++ async def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return await wrapped(*args, **kwargs)++ body, _ = _extract_body(args, kwargs)+ if not isinstance(body, dict) or not body:+ return await wrapped(*args, **kwargs)++ streaming = bool(body.get("stream"))+ server_address, server_port = set_server_address_and_port(+ instance, _DEFAULT_AGENT_HOST, 443+ )+ agent_id = _agent_id_from_host(server_address)+ request_model = body.get("model", "unknown")+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT} {request_model}"+ start_time = time.time()++ if streaming:+ span = tracer.start_span(span_name, kind=SpanKind.CLIENT)+ if agent_id:+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID, agent_id)+ ctx = trace_api.set_span_in_context(span)+ token = context_api.attach(ctx)+ try:+ result = await wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ context_api.detach(token)+ span.end()+ raise+ context_api.detach(token)+ finalize_kwargs = {+ "pricing_info": pricing_info,+ "environment": environment,+ "application_name": application_name,+ "metrics": metrics,+ "capture_message_content": capture_message_content,+ "disable_metrics": disable_metrics,+ "version": version,+ "event_provider": event_provider,+ "operation_name": SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,+ "api_type": "chat",+ }+ return TracedAsyncStream(+ result, span, body, server_address, server_port, finalize_kwargs+ )++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ if agent_id:+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID, agent_id)+ try:+ response = await wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ raise+ try:+ response_dict = response_as_dict(response)+ scope = _new_scope(+ body, span, start_time, server_address, server_port, response_dict+ )+ choices = response_dict.get("choices") or []+ if choices:+ choice0 = choices[0]+ message = choice0.get("message") or {}+ scope._llmresponse = message.get("content") or ""+ scope._finish_reason = choice0.get("finish_reason") or ""+ if message.get("tool_calls"):+ scope._tools = message["tool_calls"]+ usage = response_dict.get("usage") or {}+ scope._input_tokens = usage.get("prompt_tokens", 0) or 0+ scope._output_tokens = usage.get("completion_tokens", 0) or 0+ common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream=False,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,+ api_type="chat",+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper+++def async_embeddings(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Async wrapper factory for InferenceOperations.create_embedding."""++ async def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return await wrapped(*args, **kwargs)++ body, _ = _extract_body(args, kwargs)+ if not isinstance(body, dict) or not body:+ return await wrapped(*args, **kwargs)++ server_address, server_port = set_server_address_and_port(+ instance, _DEFAULT_INFERENCE_HOST, 443+ )+ request_model = body.get("model", "unknown")+ span_name = (+ f"{SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING} {request_model}"+ )+ start_time = time.time()++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ try:+ response = await wrapped(*args, **kwargs)+ except Exception as exc:+ err_type = type(exc).__name__ or "_OTHER"+ handle_exception(span, exc)+ if not disable_metrics and metrics:+ record_embedding_metrics(+ metrics,+ SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ "unknown",+ environment,+ application_name,+ start_time,+ time.time(),+ 0,+ 0,+ error_type=err_type,+ )+ raise+ try:+ return process_embedding_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper+++def async_async_invoke_create(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Async wrapper factory for InferenceOperations.create_async_invoke."""++ async def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return await wrapped(*args, **kwargs)++ body, _ = _extract_body(args, kwargs)+ if not isinstance(body, dict) or not body:+ return await wrapped(*args, **kwargs)++ server_address, server_port = set_server_address_and_port(+ instance, _DEFAULT_INFERENCE_HOST, 443+ )+ request_model = body.get("model_id") or body.get("model", "unknown")+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"+ start_time = time.time()++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ try:+ response = await wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ raise+ try:+ return process_async_invoke_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper+++def async_list_models(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Async wrapper factory for InferenceOperations.list_models — minimal metadata span."""++ async def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return await wrapped(*args, **kwargs)+ server_address, server_port = set_server_address_and_port(+ instance, _DEFAULT_INFERENCE_HOST, 443+ )+ with tracer.start_as_current_span("models.list", kind=SpanKind.CLIENT) as span:+ span.set_attribute(+ SemanticConvention.GEN_AI_PROVIDER_NAME,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ )+ span.set_attribute(SemanticConvention.SERVER_ADDRESS, server_address)+ span.set_attribute(SemanticConvention.SERVER_PORT, server_port)+ try:+ return await wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ raise++ return wrapperdiff --git a/sdk/python/src/openlit/instrumentation/pydo/pydo.py b/sdk/python/src/openlit/instrumentation/pydo/pydo.pynew file mode 100644index 00000000..30011204--- /dev/null+++ b/sdk/python/src/openlit/instrumentation/pydo/pydo.py@@ -0,0 +1,651 @@+"""+Synchronous wrappers for DigitalOcean pydo inference operations.+"""++import time++from opentelemetry import context as context_api, trace as trace_api+from opentelemetry.trace import SpanKind++from openlit.__helpers import (+ handle_exception,+ is_framework_llm_active,+ record_completion_metrics,+ set_server_address_and_port,+)+from openlit.instrumentation.pydo.utils import (+ process_async_invoke_response,+ process_chat_response,+ process_chunk,+ process_embedding_response,+ process_messages_chunk,+ process_messages_response,+ process_response_chunk,+ process_responses_response,+ process_streaming_chat_response,+ process_streaming_messages_response,+)+from openlit.semcov import SemanticConvention+++_DEFAULT_INFERENCE_HOST = "inference.do-ai.run"+_DEFAULT_AGENT_HOST = "agents.do-ai.run"++# Pydo facade kwargs that are transport-only and should NOT be treated as request body fields+_PYDO_SDK_KWARGS = {+ "headers",+ "params",+ "content_type",+ "cls",+ "raw_request_hook",+ "raw_response_hook",+ "polling",+ "continuation_token",+ "form_content_type",+ "error_map",+}+++def _agent_id_from_host(host):+ """Extract agent UUID from `<id>.agents.do-ai.run`-style hostnames."""+ if not host or "agents.do-ai.run" not in host:+ return None+ head = host.split(".agents.do-ai.run", 1)[0]+ return head or None+++def _extract_body(args, kwargs):+ """Return (body_dict, is_facade_call).++ - Raw operation: `args[0]` (or `kwargs["body"]`) is the body dict.+ - Facade: kwargs are flat — anything outside `_PYDO_SDK_KWARGS` is body.+ """+ if args and isinstance(args[0], dict):+ return args[0], False+ if isinstance(kwargs.get("body"), dict):+ return kwargs["body"], False+ if kwargs:+ body = {k: v for k, v in kwargs.items() if k not in _PYDO_SDK_KWARGS}+ return body, True+ return {}, False+++def _make_traced_stream(chunk_processor, final_processor):+ """Build a TracedSyncStream class bound to the given chunk/final processors."""++ class TracedSyncStream:+ """Wraps a pydo SSEStream so chunks are observed and the span closes on completion."""++ def __init__(+ self, wrapped, span, body, server_address, server_port, finalize_kwargs+ ):+ self.__wrapped__ = wrapped+ self._span = span+ self._body = body+ self._server_address = server_address+ self._server_port = server_port+ self._finalize_kwargs = finalize_kwargs+ self._llmresponse = ""+ self._reasoning_text = ""+ self._response_id = ""+ self._response_model = ""+ self._finish_reason = ""+ self._system_fingerprint = ""+ self._tools = None+ self._timestamps = []+ self._ttft = 0+ self._tbt = 0+ self._input_tokens = 0+ self._output_tokens = 0+ self._reasoning_tokens = 0+ self._cache_read_input_tokens = 0+ self._cache_creation_input_tokens = 0+ self._start_time = time.time()+ self._end_time = None+ self._finalized = False+ self._iter = None++ def __enter__(self):+ if hasattr(self.__wrapped__, "__enter__"):+ self.__wrapped__.__enter__()+ return self++ def __exit__(self, exc_type, exc_value, traceback):+ if hasattr(self.__wrapped__, "__exit__"):+ self.__wrapped__.__exit__(exc_type, exc_value, traceback)+ self._finalize()++ def __iter__(self):+ return self++ def __getattr__(self, name):+ return getattr(self.__wrapped__, name)++ def _ensure_iter(self):+ if self._iter is None:+ # Build a real iterator from the wrapped object. Works for+ # objects that define __next__ directly, and for pure+ # iterables (like pydo's SSEStream) that only define __iter__.+ if hasattr(self.__wrapped__, "__next__"):+ self._iter = self.__wrapped__+ else:+ self._iter = iter(self.__wrapped__)+ return self._iter++ def __next__(self):+ try:+ chunk = next(self._ensure_iter())+ chunk_processor(self, chunk)+ return chunk+ except StopIteration:+ self._finalize()+ raise++ def _finalize(self):+ if self._finalized:+ return+ self._finalized = True+ try:+ with trace_api.use_span( # pylint: disable=not-context-manager+ self._span, end_on_exit=True+ ):+ final_processor(self, **self._finalize_kwargs)+ except Exception as exc:+ handle_exception(self._span, exc)++ return TracedSyncStream+++def _build_wrapper(+ operation_name,+ api_type,+ process_response,+ chunk_processor,+ streaming_finalizer,+ default_host,+ span_name_prefix,+ use_messages_finalizer=False,+):+ """Common factory for chat/responses/messages-style sync wrappers."""++ def factory(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+ ):+ TracedSyncStream = _make_traced_stream(chunk_processor, streaming_finalizer)++ def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return wrapped(*args, **kwargs)++ body, _ = _extract_body(args, kwargs)+ if not isinstance(body, dict) or not body:+ return wrapped(*args, **kwargs)++ streaming = bool(body.get("stream"))+ server_address, server_port = set_server_address_and_port(+ instance, default_host, 443+ )+ request_model = body.get("model", "unknown")+ span_name = f"{span_name_prefix} {request_model}"+ start_time = time.time()++ if streaming:+ span = tracer.start_span(span_name, kind=SpanKind.CLIENT)+ ctx = trace_api.set_span_in_context(span)+ token = context_api.attach(ctx)+ try:+ result = wrapped(*args, **kwargs)+ except Exception as exc:+ err_type = type(exc).__name__ or "_OTHER"+ handle_exception(span, exc)+ if not disable_metrics and metrics:+ record_completion_metrics(+ metrics,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ "unknown",+ environment,+ application_name,+ start_time,+ time.time(),+ 0,+ 0,+ 0,+ None,+ None,+ error_type=err_type,+ )+ context_api.detach(token)+ span.end()+ raise+ context_api.detach(token)++ # Defensive: if the SDK returned a non-stream object despite stream=True+ if not hasattr(result, "__next__") and not hasattr(result, "__iter__"):+ try:+ with trace_api.use_span( # pylint: disable=not-context-manager+ span, end_on_exit=True+ ):+ return process_response(+ response=result,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ raise++ finalize_kwargs = {+ "pricing_info": pricing_info,+ "environment": environment,+ "application_name": application_name,+ "metrics": metrics,+ "capture_message_content": capture_message_content,+ "disable_metrics": disable_metrics,+ "version": version,+ "event_provider": event_provider,+ }+ if not use_messages_finalizer:+ finalize_kwargs["operation_name"] = operation_name+ finalize_kwargs["api_type"] = api_type+ return TracedSyncStream(+ result, span, body, server_address, server_port, finalize_kwargs+ )++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ try:+ response = wrapped(*args, **kwargs)+ except Exception as exc:+ err_type = type(exc).__name__ or "_OTHER"+ handle_exception(span, exc)+ if not disable_metrics and metrics:+ record_completion_metrics(+ metrics,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ "unknown",+ environment,+ application_name,+ start_time,+ time.time(),+ 0,+ 0,+ 0,+ None,+ None,+ error_type=err_type,+ )+ raise++ try:+ return process_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper++ return factory+++# ---- factories per operation ------------------------------------------------++chat_completions = _build_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="chat",+ process_response=process_chat_response,+ chunk_processor=process_chunk,+ streaming_finalizer=process_streaming_chat_response,+ default_host=_DEFAULT_INFERENCE_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+)++responses_create = _build_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="responses",+ process_response=process_responses_response,+ chunk_processor=process_response_chunk,+ streaming_finalizer=process_streaming_chat_response,+ default_host=_DEFAULT_INFERENCE_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+)++messages_create = _build_wrapper(+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="messages",+ process_response=process_messages_response,+ chunk_processor=process_messages_chunk,+ streaming_finalizer=process_streaming_messages_response,+ default_host=_DEFAULT_INFERENCE_HOST,+ span_name_prefix=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ use_messages_finalizer=True,+)+++def agent_chat_completions(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Sync wrapper for AgentInferenceOperations.create_chat_completion."""+ TracedSyncStream = _make_traced_stream(+ process_chunk, process_streaming_chat_response+ )++ def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return wrapped(*args, **kwargs)++ body, _ = _extract_body(args, kwargs)+ if not isinstance(body, dict) or not body:+ return wrapped(*args, **kwargs)++ streaming = bool(body.get("stream"))+ server_address, server_port = set_server_address_and_port(+ instance, _DEFAULT_AGENT_HOST, 443+ )+ agent_id = _agent_id_from_host(server_address)+ request_model = body.get("model", "unknown")+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT} {request_model}"+ start_time = time.time()++ if streaming:+ span = tracer.start_span(span_name, kind=SpanKind.CLIENT)+ if agent_id:+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID, agent_id)+ ctx = trace_api.set_span_in_context(span)+ token = context_api.attach(ctx)+ try:+ result = wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ context_api.detach(token)+ span.end()+ raise+ context_api.detach(token)+ finalize_kwargs = {+ "pricing_info": pricing_info,+ "environment": environment,+ "application_name": application_name,+ "metrics": metrics,+ "capture_message_content": capture_message_content,+ "disable_metrics": disable_metrics,+ "version": version,+ "event_provider": event_provider,+ "operation_name": SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,+ "api_type": "chat",+ }+ return TracedSyncStream(+ result, span, body, server_address, server_port, finalize_kwargs+ )++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ if agent_id:+ span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID, agent_id)+ try:+ response = wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ raise+ try:+ # Reuse chat-response processor but with invoke_agent operation+ from openlit.instrumentation.pydo.utils import (+ _new_scope,+ common_chat_logic,+ )++ response_dict = __import__(+ "openlit.__helpers", fromlist=["response_as_dict"]+ ).response_as_dict(response)+ scope = _new_scope(+ body, span, start_time, server_address, server_port, response_dict+ )+ choices = response_dict.get("choices") or []+ if choices:+ choice0 = choices[0]+ message = choice0.get("message") or {}+ scope._llmresponse = message.get("content") or ""+ scope._finish_reason = choice0.get("finish_reason") or ""+ if message.get("tool_calls"):+ scope._tools = message["tool_calls"]+ usage = response_dict.get("usage") or {}+ scope._input_tokens = usage.get("prompt_tokens", 0) or 0+ scope._output_tokens = usage.get("completion_tokens", 0) or 0+ common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream=False,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,+ api_type="chat",+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper+++def embeddings(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Sync wrapper for InferenceOperations.create_embedding."""++ def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return wrapped(*args, **kwargs)++ body, _ = _extract_body(args, kwargs)+ if not isinstance(body, dict) or not body:+ return wrapped(*args, **kwargs)++ server_address, server_port = set_server_address_and_port(+ instance, _DEFAULT_INFERENCE_HOST, 443+ )+ request_model = body.get("model", "unknown")+ span_name = (+ f"{SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING} {request_model}"+ )+ start_time = time.time()++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ try:+ response = wrapped(*args, **kwargs)+ except Exception as exc:+ err_type = type(exc).__name__ or "_OTHER"+ handle_exception(span, exc)+ if not disable_metrics and metrics:+ from openlit.__helpers import record_embedding_metrics++ record_embedding_metrics(+ metrics,+ SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ "unknown",+ environment,+ application_name,+ start_time,+ time.time(),+ 0,+ 0,+ error_type=err_type,+ )+ raise+ try:+ return process_embedding_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper+++def async_invoke_create(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Sync wrapper for InferenceOperations.create_async_invoke (queued generation)."""++ def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return wrapped(*args, **kwargs)++ body, _ = _extract_body(args, kwargs)+ if not isinstance(body, dict) or not body:+ return wrapped(*args, **kwargs)++ server_address, server_port = set_server_address_and_port(+ instance, _DEFAULT_INFERENCE_HOST, 443+ )+ request_model = body.get("model_id") or body.get("model", "unknown")+ span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"+ start_time = time.time()++ with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:+ try:+ response = wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ raise+ try:+ return process_async_invoke_response(+ response=response,+ body=body,+ pricing_info=pricing_info,+ server_address=server_address,+ server_port=server_port,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ event_provider=event_provider,+ )+ except Exception as exc:+ handle_exception(span, exc)+ return response++ return wrapper+++def list_models(+ version,+ environment,+ application_name,+ tracer,+ pricing_info,+ capture_message_content,+ metrics,+ disable_metrics,+ event_provider=None,+):+ """Sync wrapper for InferenceOperations.list_models — minimal metadata span."""++ def wrapper(wrapped, instance, args, kwargs):+ if is_framework_llm_active():+ return wrapped(*args, **kwargs)+ server_address, server_port = set_server_address_and_port(+ instance, _DEFAULT_INFERENCE_HOST, 443+ )+ with tracer.start_as_current_span("models.list", kind=SpanKind.CLIENT) as span:+ span.set_attribute(+ SemanticConvention.GEN_AI_PROVIDER_NAME,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ )+ span.set_attribute(SemanticConvention.SERVER_ADDRESS, server_address)+ span.set_attribute(SemanticConvention.SERVER_PORT, server_port)+ try:+ return wrapped(*args, **kwargs)+ except Exception as exc:+ handle_exception(span, exc)+ raise++ return wrapperdiff --git a/sdk/python/src/openlit/instrumentation/pydo/utils.py b/sdk/python/src/openlit/instrumentation/pydo/utils.pynew file mode 100644index 00000000..f0faf827--- /dev/null+++ b/sdk/python/src/openlit/instrumentation/pydo/utils.py@@ -0,0 +1,1316 @@+"""+DigitalOcean pydo OpenTelemetry instrumentation utility functions.+"""++import json+import logging+import time++from opentelemetry.trace import Status, StatusCode++from openlit.__helpers import (+ calculate_ttft,+ calculate_tbt,+ common_span_attributes,+ general_tokens,+ get_chat_model_cost,+ get_embed_model_cost,+ otel_event,+ record_completion_metrics,+ record_embedding_metrics,+ response_as_dict,+ truncate_message_content,+)+from openlit._config import OpenlitConfig+from openlit.semcov import SemanticConvention++logger = logging.getLogger(__name__)+++_FINISH_REASON_MAP = {+ "stop": "stop",+ "length": "length",+ "content_filter": "content_filter",+ "tool_calls": "tool_call",+ "function_call": "tool_call",+ "end_turn": "stop",+ "max_tokens": "length",+ "stop_sequence": "stop",+ "tool_use": "tool_call",+}+++def _parse_args(value):+ """Parse JSON-string arguments into structured form when possible.++ OpenAI/DigitalOcean encode `function.arguments` as a JSON string.+ The OTel `tool_call` part schema specifies `arguments` as `any` —+ consumers expect the parsed object, not a JSON-encoded string.+ Falls back to the raw string if parsing fails.+ """+ if value is None:+ return None+ if isinstance(value, (dict, list)):+ return value+ if isinstance(value, str):+ s = value.strip()+ if not s:+ return s+ try:+ return json.loads(s)+ except (ValueError, TypeError):+ return value+ return value+++def _tool_call_part(tool_id, name, arguments):+ """Build a spec-compliant `tool_call` part. Drops empty optional fields."""+ part = {"type": "tool_call", "name": name or ""}+ if tool_id:+ part["id"] = str(tool_id)+ parsed = _parse_args(arguments)+ if parsed is not None and parsed != "":+ part["arguments"] = parsed+ return part+++def _tool_response_part(tool_id, response):+ """Build a spec-compliant `tool_call_response` part."""+ part = {"type": "tool_call_response", "response": response}+ if tool_id:+ part["id"] = str(tool_id)+ return part+++def _build_tool_definitions(tools):+ """Convert OpenAI/DO `tools` array into spec §10.4 flattened shape.++ Input shape: `[{"type":"function","function":{"name":...,"description":...,"parameters":...}}]`+ Output shape: `[{"type":"function","name":...,"description":...,"parameters":...}]`+ """+ if not isinstance(tools, list):+ return None+ out = []+ for tool in tools:+ if not isinstance(tool, dict):+ continue+ ttype = tool.get("type", "function")+ if ttype == "function" and isinstance(tool.get("function"), dict):+ fn = tool["function"]+ entry = {"type": "function", "name": fn.get("name", "")}+ if fn.get("description"):+ entry["description"] = fn["description"]+ if fn.get("parameters") is not None:+ entry["parameters"] = fn["parameters"]+ out.append(entry)+ else:+ entry = {"type": ttype, "name": tool.get("name", "")}+ for key in ("description", "parameters"):+ if tool.get(key) is not None:+ entry[key] = tool[key]+ out.append(entry)+ return out or None+++def format_content(messages):+ """Flatten messages to a single string for token estimation fallback."""+ if not messages:+ return ""+ formatted = []+ for message in messages:+ role = (+ message.get("role", "user")+ if isinstance(message, dict)+ else getattr(message, "role", "user")+ )+ content = (+ message.get("content", "")+ if isinstance(message, dict)+ else getattr(message, "content", "")+ )+ if isinstance(content, list):+ parts = []+ for item in content:+ if isinstance(item, dict):+ if "text" in item:+ parts.append(item["text"])+ elif item.get("type") == "image_url":+ parts.append("[image]")+ formatted.append(f"{role}: {', '.join(parts)}")+ else:+ formatted.append(f"{role}: {content}")+ return "\n".join(formatted)+++def build_input_messages(messages):+ """Convert request messages into OTel `gen_ai.input.messages` shape."""+ if not messages:+ return []+ out = []+ for message in messages:+ try:+ role = (+ message.get("role", "user")+ if isinstance(message, dict)+ else getattr(message, "role", "user")+ )+ content = (+ message.get("content", "")+ if isinstance(message, dict)+ else getattr(message, "content", "")+ )+ parts = []+ if isinstance(content, list):+ for item in content:+ if not isinstance(item, dict):+ continue+ item_type = item.get("type")+ if item_type == "text" and item.get("text"):+ parts.append({"type": "text", "content": item["text"]})+ elif item_type == "image_url":+ url = (item.get("image_url") or {}).get("url", "")+ if url and not str(url).startswith("data:"):+ parts.append(+ {"type": "uri", "modality": "image", "uri": url}+ )+ elif item_type == "image":+ # Anthropic-style image block+ source = item.get("source") or {}+ if source.get("type") == "base64" and source.get("data"):+ parts.append(+ {+ "type": "blob",+ "modality": "image",+ "content": source["data"],+ "mime_type": source.get("media_type", ""),+ }+ )+ elif source.get("type") == "url" and source.get("url"):+ parts.append(+ {+ "type": "uri",+ "modality": "image",+ "uri": source["url"],+ }+ )+ elif item_type == "tool_use":+ parts.append(+ _tool_call_part(+ item.get("id"),+ item.get("name", ""),+ item.get("input", {}),+ )+ )+ elif item_type == "tool_result":+ parts.append(+ _tool_response_part(+ item.get("tool_use_id"),+ item.get("content", ""),+ )+ )+ elif isinstance(content, str) and content:+ parts.append({"type": "text", "content": content})++ # OpenAI-style assistant message with tool_calls array+ if role == "assistant" and isinstance(message, dict):+ for tc in message.get("tool_calls") or []:+ if not isinstance(tc, dict):+ continue+ fn = tc.get("function") or {}+ parts.append(+ _tool_call_part(+ tc.get("id"),+ fn.get("name", ""),+ fn.get("arguments"),+ )+ )++ if role == "tool":+ tool_call_id = (+ message.get("tool_call_id")+ if isinstance(message, dict)+ else getattr(message, "tool_call_id", None)+ )+ tool_content = content if isinstance(content, str) else str(content)+ parts = [_tool_response_part(tool_call_id, tool_content)]++ if parts:+ out.append({"role": role, "parts": parts})+ except Exception as exc:+ logger.warning("Failed to process input message: %s", exc, exc_info=True)+ return out+++def build_output_messages(+ response_text, finish_reason, tool_calls=None, reasoning=None+):+ """Build OTel `gen_ai.output.messages` from accumulated response state."""+ parts = []+ try:+ if reasoning:+ parts.append({"type": "reasoning", "content": reasoning})+ if response_text:+ parts.append({"type": "text", "content": response_text})+ if tool_calls:+ tools = tool_calls if isinstance(tool_calls, list) else [tool_calls]+ for tool in tools:+ if not isinstance(tool, dict):+ continue+ fn = tool.get("function") or {}+ parts.append(+ _tool_call_part(+ tool.get("id"),+ fn.get("name", ""),+ fn.get("arguments"),+ )+ )+ otel_finish = _FINISH_REASON_MAP.get(finish_reason, finish_reason or "stop")+ return [{"role": "assistant", "parts": parts, "finish_reason": otel_finish}]+ except Exception as exc:+ logger.warning("Failed to build output messages: %s", exc, exc_info=True)+ return [{"role": "assistant", "parts": [], "finish_reason": "stop"}]+++def _set_span_messages_as_array(span, input_messages, output_messages):+ """Set gen_ai.input.messages / gen_ai.output.messages as JSON arrays on the span."""+ try:+ truncate_message_content(input_messages)+ truncate_message_content(output_messages)+ if input_messages is not None:+ span.set_attribute(+ SemanticConvention.GEN_AI_INPUT_MESSAGES,+ json.dumps(input_messages)+ if isinstance(input_messages, list)+ else input_messages,+ )+ if output_messages is not None:+ span.set_attribute(+ SemanticConvention.GEN_AI_OUTPUT_MESSAGES,+ json.dumps(output_messages)+ if isinstance(output_messages, list)+ else output_messages,+ )+ except Exception as exc:+ logger.warning("Failed to set span message attributes: %s", exc, exc_info=True)+++def emit_inference_event(+ event_provider,+ operation_name,+ request_model,+ response_model,+ input_messages=None,+ output_messages=None,+ tool_definitions=None,+ server_address=None,+ server_port=None,+ **extra,+):+ """Emit gen_ai.client.inference.operation.details event."""+ if not event_provider:+ return+ try:+ attributes = {SemanticConvention.GEN_AI_OPERATION: operation_name}+ if request_model:+ attributes[SemanticConvention.GEN_AI_REQUEST_MODEL] = request_model+ if response_model:+ attributes[SemanticConvention.GEN_AI_RESPONSE_MODEL] = response_model+ if server_address:+ attributes[SemanticConvention.SERVER_ADDRESS] = server_address+ if server_port is not None:+ attributes[SemanticConvention.SERVER_PORT] = server_port+ if input_messages is not None:+ attributes[SemanticConvention.GEN_AI_INPUT_MESSAGES] = input_messages+ if output_messages is not None:+ attributes[SemanticConvention.GEN_AI_OUTPUT_MESSAGES] = output_messages+ if tool_definitions is not None:+ attributes[SemanticConvention.GEN_AI_TOOL_DEFINITIONS] = tool_definitions++ for key, value in extra.items():+ if value is None:+ continue+ if key == "response_id":+ attributes[SemanticConvention.GEN_AI_RESPONSE_ID] = value+ elif key == "finish_reasons":+ attributes[SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON] = value+ elif key == "output_type":+ attributes[SemanticConvention.GEN_AI_OUTPUT_TYPE] = value+ elif key == "temperature":+ attributes[SemanticConvention.GEN_AI_REQUEST_TEMPERATURE] = value+ elif key == "max_tokens":+ attributes[SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS] = value+ elif key == "top_p":+ attributes[SemanticConvention.GEN_AI_REQUEST_TOP_P] = value+ elif key == "frequency_penalty":+ attributes[SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY] = value+ elif key == "presence_penalty":+ attributes[SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY] = value+ elif key == "stop_sequences":+ attributes[SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES] = value+ elif key == "seed":+ attributes[SemanticConvention.GEN_AI_REQUEST_SEED] = value+ elif key == "input_tokens":+ attributes[SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS] = value+ elif key == "output_tokens":+ attributes[SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS] = value+ elif key == "cache_read_input_tokens":+ attributes[SemanticConvention.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS] = (+ value+ )+ elif key == "cache_creation_input_tokens":+ attributes[+ SemanticConvention.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS+ ] = value+ elif key == "error_type":+ attributes[SemanticConvention.ERROR_TYPE] = value+ else:+ attributes[key] = value++ event = otel_event(+ name=SemanticConvention.GEN_AI_CLIENT_INFERENCE_OPERATION_DETAILS,+ attributes=attributes,+ body="",+ )+ if not OpenlitConfig.disable_events:+ event_provider.emit(event)+ except Exception as exc:+ logger.warning("Failed to emit inference event: %s", exc, exc_info=True)+++def _normalize_stop(stop):+ """Normalize a stop value (string or list) to a list."""+ if stop is None:+ return []+ if isinstance(stop, str):+ return [stop]+ if isinstance(stop, list):+ return stop+ return [str(stop)]+++# ---------------------------------------------------------------------------+# Chunk handlers (streaming)+# ---------------------------------------------------------------------------+++def process_chunk(scope, chunk):+ """Process a chat-completion chunk and update accumulator state."""+ end_time = time.time()+ scope._timestamps.append(end_time)+ if len(scope._timestamps) == 1:+ scope._ttft = calculate_ttft(scope._timestamps, scope._start_time)++ chunked = response_as_dict(chunk)++ choices = chunked.get("choices") or []+ if choices:+ choice0 = choices[0]+ delta = choice0.get("delta") or {}+ content = delta.get("content")+ if content:+ scope._llmresponse += content+ reasoning = delta.get("reasoning_content")+ if reasoning:+ scope._reasoning_text = getattr(scope, "_reasoning_text", "") + reasoning+ finish_reason = choice0.get("finish_reason")+ if finish_reason:+ scope._finish_reason = finish_reason++ # Streamed tool-call assembly (assemble args by index)+ delta_tools = delta.get("tool_calls")+ if delta_tools:+ scope._tools = scope._tools or []+ for tool in delta_tools:+ idx = tool.get("index", 0) or 0+ while len(scope._tools) <= idx:+ scope._tools.append({})+ if tool.get("id"):+ scope._tools[idx] = {+ "id": tool["id"],+ "type": tool.get("type", "function"),+ "function": {+ "name": (tool.get("function") or {}).get("name") or "",+ "arguments": (tool.get("function") or {}).get("arguments")+ or "",+ },+ }+ elif scope._tools[idx]:+ fn = tool.get("function") or {}+ if "function" not in scope._tools[idx]:+ scope._tools[idx]["function"] = {"name": "", "arguments": ""}+ scope._tools[idx]["function"]["arguments"] += (+ fn.get("arguments") or ""+ )+ if fn.get("name"):+ scope._tools[idx]["function"]["name"] = fn["name"]++ # Metadata fields can show up on any chunk+ if chunked.get("id"):+ scope._response_id = chunked["id"]+ if chunked.get("model"):+ scope._response_model = chunked["model"]+ if chunked.get("system_fingerprint"):+ scope._system_fingerprint = chunked["system_fingerprint"]++ # Final pre-[DONE] chunk may carry usage when stream_options.include_usage=True+ usage = chunked.get("usage")+ if usage:+ scope._input_tokens = usage.get("prompt_tokens") or scope._input_tokens+ scope._output_tokens = usage.get("completion_tokens") or scope._output_tokens+ scope._cache_read_input_tokens = (+ usage.get("cache_read_input_tokens")+ or (usage.get("prompt_tokens_details") or {}).get("cached_tokens", 0)+ or scope._cache_read_input_tokens+ )+ scope._cache_creation_input_tokens = (+ usage.get("cache_created_input_tokens")+ or scope._cache_creation_input_tokens+ )+++def process_response_chunk(scope, chunk):+ """Process a Responses-API stream chunk."""+ end_time = time.time()+ scope._timestamps.append(end_time)+ if len(scope._timestamps) == 1:+ scope._ttft = calculate_ttft(scope._timestamps, scope._start_time)++ chunked = response_as_dict(chunk)+ chunk_type = chunked.get("type") or chunked.get("object")++ # Text delta events+ if chunk_type and "output_text.delta" in chunk_type:+ delta = chunked.get("delta", "")+ if isinstance(delta, str):+ scope._llmresponse += delta+ elif chunk_type and "reasoning_text.delta" in chunk_type:+ delta = chunked.get("delta", "")+ if isinstance(delta, str):+ scope._reasoning_text = getattr(scope, "_reasoning_text", "") + delta++ # Final response.completed event carries the full response+ response = chunked.get("response")+ if isinstance(response, dict):+ scope._response_id = response.get("id") or scope._response_id+ scope._response_model = response.get("model") or scope._response_model+ usage = response.get("usage") or {}+ scope._input_tokens = usage.get("input_tokens", scope._input_tokens)+ scope._output_tokens = usage.get("output_tokens", scope._output_tokens)+ details = usage.get("output_tokens_details") or {}+ scope._reasoning_tokens = details.get(+ "reasoning_tokens", getattr(scope, "_reasoning_tokens", 0)+ )+ outputs = response.get("output") or []+ if outputs:+ last = outputs[-1]+ if isinstance(last, dict):+ scope._finish_reason = last.get("status") or scope._finish_reason+++def process_messages_chunk(scope, chunk):+ """Process an Anthropic-style messages stream event."""+ end_time = time.time()+ scope._timestamps.append(end_time)+ if len(scope._timestamps) == 1:+ scope._ttft = calculate_ttft(scope._timestamps, scope._start_time)++ chunked = response_as_dict(chunk)+ event_type = chunked.get("type")++ if event_type == "message_start":+ message = chunked.get("message") or {}+ scope._response_id = message.get("id") or scope._response_id+ scope._response_model = message.get("model") or scope._response_model+ usage = message.get("usage") or {}+ scope._input_tokens = usage.get("input_tokens", 0) or 0+ scope._cache_read_input_tokens = usage.get("cache_read_input_tokens", 0) or 0+ scope._cache_creation_input_tokens = (+ usage.get("cache_creation_input_tokens", 0) or 0+ )+ elif event_type == "content_block_delta":+ delta = chunked.get("delta") or {}+ if delta.get("type") == "text_delta":+ scope._llmresponse += delta.get("text", "")+ elif delta.get("type") == "input_json_delta":+ # Tool input fragment — append to last tool's arguments+ if scope._tools:+ last = scope._tools[-1]+ last.setdefault("function", {"name": "", "arguments": ""})+ last["function"]["arguments"] += delta.get("partial_json", "")+ elif event_type == "content_block_start":+ block = chunked.get("content_block") or {}+ if block.get("type") == "tool_use":+ scope._tools = scope._tools or []+ scope._tools.append(+ {+ "id": block.get("id", ""),+ "type": "function",+ "function": {"name": block.get("name", ""), "arguments": ""},+ }+ )+ elif event_type == "message_delta":+ delta = chunked.get("delta") or {}+ if delta.get("stop_reason"):+ scope._finish_reason = delta["stop_reason"]+ usage = chunked.get("usage") or {}+ if usage.get("output_tokens") is not None:+ scope._output_tokens = usage["output_tokens"]+++# ---------------------------------------------------------------------------+# Common attribute setter+# ---------------------------------------------------------------------------+++def common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type=None,+ event_provider=None,+):+ """Set span attributes, emit event, record metrics for chat-style operations."""+ scope._end_time = time.time()+ if len(scope._timestamps) > 1:+ scope._tbt = calculate_tbt(scope._timestamps)++ body = scope._body or {}+ request_model = body.get("model", "unknown")++ # Token fallback if usage absent+ if not scope._input_tokens:+ scope._input_tokens = general_tokens(format_content(body.get("messages", [])))+ if not scope._output_tokens:+ scope._output_tokens = general_tokens(scope._llmresponse or "")++ cost = get_chat_model_cost(+ request_model, pricing_info, scope._input_tokens, scope._output_tokens+ )++ common_span_attributes(+ scope,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ scope._server_address,+ scope._server_port,+ request_model,+ getattr(scope, "_response_model", request_model) or request_model,+ environment,+ application_name,+ is_stream,+ scope._tbt,+ scope._ttft,+ version,+ )++ # Request parameters+ if body.get("temperature") is not None:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, body["temperature"]+ )+ if body.get("top_p") is not None:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_TOP_P, body["top_p"]+ )+ max_tokens = body.get("max_completion_tokens") or body.get("max_tokens")+ if max_tokens is not None:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, max_tokens+ )+ if body.get("frequency_penalty") is not None:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY,+ body["frequency_penalty"],+ )+ if body.get("presence_penalty") is not None:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY,+ body["presence_penalty"],+ )+ stop_sequences = _normalize_stop(body.get("stop") or body.get("stop_sequences"))+ if stop_sequences:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_STOP_SEQUENCES, stop_sequences+ )+ if body.get("seed") is not None:+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_SEED, body["seed"])+ n_choices = body.get("n")+ if n_choices is not None and n_choices != 1:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_CHOICE_COUNT, n_choices+ )+ if body.get("user"):+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_USER, body["user"])+ if body.get("reasoning_effort"):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_REASONING_EFFORT,+ body["reasoning_effort"],+ )++ # Response metadata+ if getattr(scope, "_response_id", None):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_RESPONSE_ID, scope._response_id+ )+ if getattr(scope, "_finish_reason", None):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON,+ [_FINISH_REASON_MAP.get(scope._finish_reason, scope._finish_reason)],+ )+ if getattr(scope, "_system_fingerprint", None):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_RESPONSE_SYSTEM_FINGERPRINT,+ scope._system_fingerprint,+ )+ output_type = (+ "json"+ if (body.get("response_format") or {}).get("type") == "json_object"+ else "text"+ )+ scope._span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, output_type)++ if api_type:+ scope._span.set_attribute(SemanticConvention.OPENAI_API_TYPE, api_type)++ # Tool calls+ if scope._tools:+ first = scope._tools[0] if isinstance(scope._tools, list) else scope._tools+ if isinstance(first, dict):+ fn = first.get("function") or {}+ if fn.get("name"):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_TOOL_NAME, fn.get("name", "")+ )+ if first.get("id"):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_TOOL_CALL_ID, str(first.get("id", ""))+ )+ if capture_message_content and fn.get("arguments"):+ args_val = fn.get("arguments")+ if not isinstance(args_val, str):+ try:+ args_val = json.dumps(args_val)+ except (TypeError, ValueError):+ args_val = str(args_val)+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_TOOL_CALL_ARGUMENTS, args_val+ )++ # Token / cost attributes+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, scope._input_tokens+ )+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, scope._output_tokens+ )+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE,+ scope._input_tokens + scope._output_tokens,+ )+ scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS,+ getattr(scope, "_cache_read_input_tokens", 0) or 0,+ )+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS,+ getattr(scope, "_cache_creation_input_tokens", 0) or 0,+ )+ if getattr(scope, "_reasoning_tokens", 0):+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_USAGE_REASONING_TOKENS, scope._reasoning_tokens+ )++ if is_stream and scope._ttft:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_RESPONSE_TIME_TO_FIRST_CHUNK+ if hasattr(SemanticConvention, "GEN_AI_RESPONSE_TIME_TO_FIRST_CHUNK")+ else "gen_ai.response.time_to_first_chunk",+ scope._ttft,+ )++ # Content / event capture+ if capture_message_content:+ input_msgs = build_input_messages(body.get("messages", []))+ output_msgs = build_output_messages(+ scope._llmresponse,+ scope._finish_reason,+ tool_calls=scope._tools,+ reasoning=getattr(scope, "_reasoning_text", "") or None,+ )+ _set_span_messages_as_array(scope._span, input_msgs, output_msgs)+ tool_defs = _build_tool_definitions(body.get("tools"))+ if tool_defs:+ try:+ scope._span.set_attribute(+ SemanticConvention.GEN_AI_TOOL_DEFINITIONS,+ json.dumps(tool_defs),+ )+ except (TypeError, ValueError):+ pass+ emit_inference_event(+ event_provider=event_provider,+ operation_name=operation_name,+ request_model=request_model,+ response_model=getattr(scope, "_response_model", request_model)+ or request_model,+ input_messages=input_msgs,+ output_messages=output_msgs,+ tool_definitions=_build_tool_definitions(body.get("tools")),+ server_address=scope._server_address,+ server_port=scope._server_port,+ response_id=getattr(scope, "_response_id", None),+ finish_reasons=[+ _FINISH_REASON_MAP.get(+ scope._finish_reason, scope._finish_reason or "stop"+ )+ ],+ output_type=output_type,+ temperature=body.get("temperature"),+ max_tokens=max_tokens,+ top_p=body.get("top_p"),+ frequency_penalty=body.get("frequency_penalty"),+ presence_penalty=body.get("presence_penalty"),+ stop_sequences=stop_sequences or None,+ seed=body.get("seed"),+ input_tokens=scope._input_tokens,+ output_tokens=scope._output_tokens,+ cache_read_input_tokens=getattr(scope, "_cache_read_input_tokens", 0)+ or None,+ cache_creation_input_tokens=getattr(+ scope, "_cache_creation_input_tokens", 0+ )+ or None,+ )++ scope._span.set_status(Status(StatusCode.OK))++ if not disable_metrics and metrics:+ inter_chunk_durations = None+ if len(scope._timestamps) > 1:+ inter_chunk_durations = [+ scope._timestamps[i] - scope._timestamps[i - 1]+ for i in range(1, len(scope._timestamps))+ ]+ record_completion_metrics(+ metrics,+ operation_name,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ scope._server_address,+ scope._server_port,+ request_model,+ getattr(scope, "_response_model", request_model) or request_model,+ environment,+ application_name,+ scope._start_time,+ scope._end_time,+ scope._input_tokens,+ scope._output_tokens,+ cost,+ scope._tbt,+ scope._ttft,+ is_stream=is_stream,+ time_per_chunk_observations=inter_chunk_durations,+ )+++def _new_scope(body, span, start_time, server_address, server_port, response_dict=None):+ """Build a generic accumulator object for both streaming and non-streaming flows."""+ scope = type("PydoScope", (), {})()+ scope._body = body+ scope._span = span+ scope._start_time = start_time+ scope._end_time = time.time()+ scope._server_address = server_address+ scope._server_port = server_port+ scope._llmresponse = ""+ scope._reasoning_text = ""+ scope._response_id = ""+ scope._response_model = ""+ scope._finish_reason = ""+ scope._system_fingerprint = ""+ scope._tools = None+ scope._timestamps = []+ scope._ttft = 0+ scope._tbt = 0+ scope._input_tokens = 0+ scope._output_tokens = 0+ scope._reasoning_tokens = 0+ scope._cache_read_input_tokens = 0+ scope._cache_creation_input_tokens = 0+ if response_dict is not None:+ # Populate from a non-streaming response+ scope._response_id = response_dict.get("id", "") or ""+ scope._response_model = response_dict.get("model", "") or ""+ scope._system_fingerprint = response_dict.get("system_fingerprint", "") or ""+ return scope+++# ---------------------------------------------------------------------------+# Non-streaming response processors+# ---------------------------------------------------------------------------+++def process_chat_response(+ response,+ body,+ pricing_info,+ server_address,+ server_port,+ environment,+ application_name,+ metrics,+ start_time,+ span,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+):+ """Non-streaming chat completion processor."""+ response_dict = response_as_dict(response)+ scope = _new_scope(+ body, span, start_time, server_address, server_port, response_dict+ )++ choices = response_dict.get("choices") or []+ if choices:+ choice0 = choices[0]+ message = choice0.get("message") or {}+ content = message.get("content") or ""+ scope._llmresponse = content if isinstance(content, str) else str(content)+ scope._reasoning_text = message.get("reasoning_content") or ""+ scope._finish_reason = choice0.get("finish_reason") or ""+ if message.get("tool_calls"):+ scope._tools = message["tool_calls"]++ usage = response_dict.get("usage") or {}+ scope._input_tokens = usage.get("prompt_tokens", 0) or 0+ scope._output_tokens = usage.get("completion_tokens", 0) or 0+ scope._cache_read_input_tokens = (+ usage.get("cache_read_input_tokens")+ or (usage.get("prompt_tokens_details") or {}).get("cached_tokens", 0)+ or 0+ )+ scope._cache_creation_input_tokens = usage.get("cache_created_input_tokens", 0) or 0++ common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream=False,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="chat",+ event_provider=event_provider,+ )+ return response+++def process_streaming_chat_response(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="chat",+):+ """Finalize a streaming chat (or responses) span by delegating to common_chat_logic."""+ common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream=True,+ operation_name=operation_name,+ api_type=api_type,+ event_provider=event_provider,+ )+++def process_responses_response(+ response,+ body,+ pricing_info,+ server_address,+ server_port,+ environment,+ application_name,+ metrics,+ start_time,+ span,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+):+ """Non-streaming Responses-API processor (OpenAI Responses surface)."""+ response_dict = response_as_dict(response)+ scope = _new_scope(+ body, span, start_time, server_address, server_port, response_dict+ )++ output_text = []+ reasoning_text = []+ tool_calls = []+ finish = ""+ for item in response_dict.get("output") or []:+ if not isinstance(item, dict):+ continue+ item_type = item.get("type")+ finish = item.get("status") or finish+ if item_type == "message":+ for content in item.get("content") or []:+ if not isinstance(content, dict):+ continue+ if content.get("type") == "output_text" and content.get("text"):+ output_text.append(content["text"])+ elif content.get("type") == "reasoning_text" and content.get("text"):+ reasoning_text.append(content["text"])+ elif item_type == "reasoning":+ for content in item.get("content") or []:+ if isinstance(content, dict) and content.get("text"):+ reasoning_text.append(content["text"])+ elif item_type == "function_call":+ tool_calls.append(+ {+ "id": item.get("call_id", ""),+ "type": "function",+ "function": {+ "name": item.get("name", ""),+ "arguments": item.get("arguments", ""),+ },+ }+ )++ scope._llmresponse = "".join(output_text)+ scope._reasoning_text = "".join(reasoning_text)+ scope._finish_reason = finish+ if tool_calls:+ scope._tools = tool_calls++ usage = response_dict.get("usage") or {}+ scope._input_tokens = usage.get("input_tokens", 0) or 0+ scope._output_tokens = usage.get("output_tokens", 0) or 0+ details = usage.get("output_tokens_details") or {}+ scope._reasoning_tokens = details.get("reasoning_tokens", 0) or 0+ scope._cache_read_input_tokens = (usage.get("input_tokens_details") or {}).get(+ "cached_tokens", 0+ ) or 0++ common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream=False,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="responses",+ event_provider=event_provider,+ )+ return response+++def process_messages_response(+ response,+ body,+ pricing_info,+ server_address,+ server_port,+ environment,+ application_name,+ metrics,+ start_time,+ span,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+):+ """Non-streaming Anthropic-style messages processor."""+ response_dict = response_as_dict(response)+ scope = _new_scope(+ body, span, start_time, server_address, server_port, response_dict+ )++ text_parts = []+ tool_calls = []+ for block in response_dict.get("content") or []:+ if not isinstance(block, dict):+ continue+ if block.get("type") == "text" and block.get("text"):+ text_parts.append(block["text"])+ elif block.get("type") == "tool_use":+ tool_calls.append(+ {+ "id": block.get("id", ""),+ "type": "function",+ "function": {+ "name": block.get("name", ""),+ "arguments": json.dumps(block.get("input", {})),+ },+ }+ )+ scope._llmresponse = "".join(text_parts)+ scope._finish_reason = response_dict.get("stop_reason") or ""+ if tool_calls:+ scope._tools = tool_calls++ usage = response_dict.get("usage") or {}+ api_input = usage.get("input_tokens", 0) or 0+ cache_read = usage.get("cache_read_input_tokens", 0) or 0+ cache_create = usage.get("cache_creation_input_tokens", 0) or 0+ # Anthropic input-token rule: include cache buckets in the total+ scope._input_tokens = api_input + cache_read + cache_create+ scope._output_tokens = usage.get("output_tokens", 0) or 0+ scope._cache_read_input_tokens = cache_read+ scope._cache_creation_input_tokens = cache_create++ common_chat_logic(+ scope,+ pricing_info,+ environment,+ application_name,+ metrics,+ capture_message_content,+ disable_metrics,+ version,+ is_stream=False,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ api_type="messages",+ event_provider=event_provider,+ )+ return response+++def process_streaming_messages_response(scope, **kwargs):+ """Final-pass for streaming Anthropic-style messages."""+ api_input = scope._input_tokens or 0+ scope._input_tokens = (+ api_input+ + (scope._cache_read_input_tokens or 0)+ + (scope._cache_creation_input_tokens or 0)+ )+ common_chat_logic(scope, is_stream=True, api_type="messages", **kwargs)+++# ---------------------------------------------------------------------------+# Embeddings / async-invoke / list_models+# ---------------------------------------------------------------------------+++def process_embedding_response(+ response,+ body,+ pricing_info,+ server_address,+ server_port,+ environment,+ application_name,+ metrics,+ start_time,+ span,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+):+ """Non-streaming embeddings processor."""+ end_time = time.time()+ response_dict = response_as_dict(response)+ request_model = body.get("model", "unknown")+ response_model = response_dict.get("model") or request_model++ usage = response_dict.get("usage") or {}+ input_tokens = usage.get("prompt_tokens", 0) or 0+ cost = get_embed_model_cost(request_model, pricing_info, input_tokens)++ scope = _new_scope(+ body, span, start_time, server_address, server_port, response_dict+ )+ scope._end_time = end_time+ scope._input_tokens = input_tokens++ common_span_attributes(+ scope,+ SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ response_model,+ environment,+ application_name,+ False,+ 0,+ 0,+ version,+ )++ encoding = body.get("encoding_format")+ if encoding:+ span.set_attribute(+ SemanticConvention.GEN_AI_REQUEST_ENCODING_FORMATS, [encoding]+ )++ data = response_dict.get("data") or []+ if data and isinstance(data[0], dict):+ embedding = data[0].get("embedding")+ if isinstance(embedding, list):+ span.set_attribute(+ SemanticConvention.GEN_AI_EMBEDDINGS_DIMENSION_COUNT, len(embedding)+ )++ span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, input_tokens)+ span.set_attribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, input_tokens)+ span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)++ if capture_message_content:+ # Record the input(s) as a single user message in OTel shape+ prompt_input = body.get("input")+ if isinstance(prompt_input, list):+ text = "\n".join(str(p) for p in prompt_input)+ else:+ text = str(prompt_input or "")+ input_msgs = [{"role": "user", "parts": [{"type": "text", "content": text}]}]+ _set_span_messages_as_array(span, input_msgs, None)+ emit_inference_event(+ event_provider=event_provider,+ operation_name=SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,+ request_model=request_model,+ response_model=response_model,+ input_messages=input_msgs,+ output_messages=None,+ server_address=server_address,+ server_port=server_port,+ input_tokens=input_tokens,+ )++ span.set_status(Status(StatusCode.OK))++ if not disable_metrics and metrics:+ record_embedding_metrics(+ metrics,+ SemanticConvention.GEN_AI_OPERATION_TYPE_EMBEDDING,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ response_model,+ environment,+ application_name,+ start_time,+ end_time,+ input_tokens,+ cost,+ )++ return response+++def process_async_invoke_response(+ response,+ body,+ pricing_info,+ server_address,+ server_port,+ environment,+ application_name,+ metrics,+ start_time,+ span,+ capture_message_content,+ disable_metrics,+ version,+ event_provider=None,+):+ """Non-streaming async-invoke (queued generation) processor."""+ end_time = time.time()+ response_dict = response_as_dict(response)+ request_model = body.get("model", "") or body.get("model_id", "unknown")+ response_model = response_dict.get("model_id") or request_model++ scope = _new_scope(+ body, span, start_time, server_address, server_port, response_dict+ )+ scope._end_time = end_time++ common_span_attributes(+ scope,+ SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ response_model,+ environment,+ application_name,+ False,+ 0,+ 0,+ version,+ )++ request_id = response_dict.get("request_id")+ if request_id:+ span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, request_id)++ status = response_dict.get("status")+ if status:+ span.set_attribute("gen_ai.async.status", status)++ # Best-effort output type from model id+ model_lc = (request_model or "").lower()+ output_type = "text"+ if any(k in model_lc for k in ("image", "sdxl", "flux", "stable-diffusion")):+ output_type = "image"+ elif any(k in model_lc for k in ("tts", "speech", "audio")):+ output_type = "speech"+ span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, output_type)++ span.set_status(Status(StatusCode.OK))++ if not disable_metrics and metrics:+ record_completion_metrics(+ metrics,+ SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,+ SemanticConvention.GEN_AI_SYSTEM_DIGITALOCEAN,+ server_address,+ server_port,+ request_model,+ response_model,+ environment,+ application_name,+ start_time,+ end_time,+ 0,+ 0,+ 0,+ None,+ None,+ )+ return responsediff --git a/sdk/python/src/openlit/semcov/__init__.py b/sdk/python/src/openlit/semcov/__init__.pyindex 1bab9fd0..47b47517 100644--- a/sdk/python/src/openlit/semcov/__init__.py+++ b/sdk/python/src/openlit/semcov/__init__.py@@ -352,6 +352,7 @@ class SemanticConvention:GEN_AI_SYSTEM_FIRECRAWL = "firecrawl"GEN_AI_SYSTEM_LETTA = "letta"GEN_AI_SYSTEM_TOGETHER = "together"+ GEN_AI_SYSTEM_DIGITALOCEAN = "digitalocean"GEN_AI_SYSTEM_OPENAI_AGENTS = "openai_agents"GEN_AI_SYSTEM_PYDANTIC_AI = "pydantic_ai"GEN_AI_SYSTEM_SARVAM = "sarvam"@@ -405,7 +406,7 @@ class SemanticConvention:)# GenAI Request Attributes (Extra)- GEN_AI_REQUEST_IS_STREAM = "gen_ai.request.is_stream"+ GEN_AI_REQUEST_IS_STREAM = "gen_ai.request.stream"GEN_AI_REQUEST_USER = "gen_ai.request.user"GEN_AI_REQUEST_EMBEDDING_DIMENSION = "gen_ai.request.embedding_dimension"GEN_AI_REQUEST_TOOL_CHOICE = "gen_ai.request.tool_choice"diff --git a/sdk/python/tests/test_gradient.py b/sdk/python/tests/test_gradient.pynew file mode 100644index 00000000..e7f996ae--- /dev/null+++ b/sdk/python/tests/test_gradient.py@@ -0,0 +1,106 @@+# pylint: disable=duplicate-code, no-name-in-module+"""+Tests for the DigitalOcean Gradient SDK instrumentation.++Exercises chat completions (sync + async, streaming + non-streaming) and+the OpenAI-style Responses API.++Environment Variables:+ - DIGITALOCEAN_ACCESS_TOKEN: DO control-plane token+ - GRADIENT_MODEL_ACCESS_KEY: Serverless inference key+ - GRADIENT_AGENT_ACCESS_KEY: Agent inference key (optional)+"""++import os+import pytest++import openlit++gradient_pkg = pytest.importorskip("gradient")+Gradient = gradient_pkg.Gradient+AsyncGradient = getattr(gradient_pkg, "AsyncGradient", None)++sync_client = Gradient(+ access_token=os.getenv("DIGITALOCEAN_ACCESS_TOKEN", ""),+ model_access_key=os.getenv("GRADIENT_MODEL_ACCESS_KEY", ""),+)+async_client = None+if AsyncGradient is not None:+ try:+ async_client = AsyncGradient(+ access_token=os.getenv("DIGITALOCEAN_ACCESS_TOKEN", ""),+ model_access_key=os.getenv("GRADIENT_MODEL_ACCESS_KEY", ""),+ )+ except Exception:+ async_client = None++openlit.init(environment="openlit-testing", application_name="openlit-python-test")+++def _benign_or_raise(exc):+ msg = str(exc).lower()+ if any(+ keyword in msg+ for keyword in (+ "rate limit",+ "unauthorized",+ "401",+ "403",+ "credentials",+ "token",+ "api key",+ "forbidden",+ "not found",+ "404",+ "connection",+ )+ ):+ print("Skipping due to environment:", exc)+ return+ raise exc+++def test_sync_gradient_chat():+ """Sync non-streaming chat completion."""+ try:+ resp = sync_client.chat.completions.create(+ model="llama3.3-70b-instruct",+ messages=[{"role": "user", "content": "Say hi"}],+ max_tokens=5,+ stream=False,+ )+ assert resp is not None+ except Exception as exc:+ _benign_or_raise(exc)+++def test_sync_gradient_chat_stream():+ """Sync streaming chat completion."""+ try:+ stream = sync_client.chat.completions.create(+ model="llama3.3-70b-instruct",+ messages=[{"role": "user", "content": "Count to 3"}],+ max_tokens=10,+ stream=True,+ )+ for _chunk in stream:+ pass+ except Exception as exc:+ _benign_or_raise(exc)+++async def test_async_gradient_chat():+ """Async non-streaming chat completion."""+ if async_client is None:+ pytest.skip("AsyncGradient unavailable")+ try:+ resp = await async_client.chat.completions.create(+ model="llama3.3-70b-instruct",+ messages=[{"role": "user", "content": "Say hi"}],+ max_tokens=5,+ stream=False,+ )+ assert resp is not None+ except Exception as exc:+ _benign_or_raise(exc)diff --git a/sdk/python/tests/test_pydo.py b/sdk/python/tests/test_pydo.pynew file mode 100644index 00000000..288eae02--- /dev/null+++ b/sdk/python/tests/test_pydo.py@@ -0,0 +1,108 @@+# pylint: disable=duplicate-code, no-name-in-module+"""+Tests for the DigitalOcean pydo SDK instrumentation.++Exercises chat completions (sync + async, streaming + non-streaming),+embeddings, and the Anthropic-style messages API.++Environment Variables:+ - DIGITALOCEAN_TOKEN: DO token for serverless inference at inference.do-ai.run+"""++import os+import pytest++import openlit++pydo = pytest.importorskip("pydo")++sync_client = pydo.Client(token=os.getenv("DIGITALOCEAN_TOKEN", ""))+async_client = None+try:+ async_client = pydo.aio.Client(token=os.getenv("DIGITALOCEAN_TOKEN", ""))+except Exception:+ async_client = None++openlit.init(environment="openlit-testing", application_name="openlit-python-test")+++def _benign_or_raise(exc):+ msg = str(exc).lower()+ if any(+ keyword in msg+ for keyword in (+ "rate limit",+ "unauthorized",+ "401",+ "403",+ "credentials",+ "token",+ "forbidden",+ "not found",+ "404",+ "connection",+ )+ ):+ print("Skipping due to environment:", exc)+ return+ raise exc+++def test_sync_pydo_chat():+ """Sync non-streaming chat completion."""+ try:+ resp = sync_client.chat.completions.create(+ model="llama3.3-70b-instruct",+ messages=[{"role": "user", "content": "Say hi"}],+ max_tokens=5,+ stream=False,+ )+ assert resp is not None+ except Exception as exc:+ _benign_or_raise(exc)+++def test_sync_pydo_chat_stream():+ """Sync streaming chat completion."""+ try:+ stream = sync_client.chat.completions.create(+ model="llama3.3-70b-instruct",+ messages=[{"role": "user", "content": "Count to 3"}],+ max_tokens=10,+ stream=True,+ )+ # SSEStream is a context manager; iterating drains it+ with stream:+ for _chunk in stream:+ pass+ except Exception as exc:+ _benign_or_raise(exc)+++async def test_async_pydo_chat():+ """Async non-streaming chat completion."""+ if async_client is None:+ pytest.skip("pydo.aio.Client unavailable")+ try:+ resp = await async_client.chat.completions.create(+ model="llama3.3-70b-instruct",+ messages=[{"role": "user", "content": "Say hi"}],+ max_tokens=5,+ stream=False,+ )+ assert resp is not None+ except Exception as exc:+ _benign_or_raise(exc)+++def test_sync_pydo_embeddings():+ """Sync embeddings."""+ try:+ resp = sync_client.embeddings.create(+ model="gte-large-en-v1.5",+ input="hello world",+ )+ assert resp is not None+ except Exception as exc:+ _benign_or_raise(exc)