mseep-agentops 0.4.18__py3-none-any.whl

agentops/sdk/decorators/utility.py

@@ -0,0 +1,216 @@
+import types
+from contextlib import contextmanager
+from typing import Any, Dict, Generator, Optional
+
+from opentelemetry import context as context_api
+from opentelemetry import trace
+from opentelemetry.context import attach, set_value
+from opentelemetry.trace import Span
+
+from agentops.helpers.serialization import safe_serialize
+from agentops.logging import logger
+from agentops.sdk.core import tracer
+from agentops.semconv.span_attributes import SpanAttributes
+
+"""
+!! NOTE !!
+References to SpanKind, span_kind, etc. are NOT destined towards `span.kind`,
+but instead used as an `agentops.semconv.span_attributes.AGENTOPS_SPAN_KIND`
+"""
+
+
+def set_workflow_name(workflow_name: str) -> None:
+    attach(set_value("workflow_name", workflow_name))
+
+
+def set_entity_path(entity_path: str) -> None:
+    attach(set_value("entity_path", entity_path))
+
+
+# Helper functions for content management
+
+
+def _check_content_size(content_json: str) -> bool:
+    """Verify that a JSON string is within acceptable size limits (1MB)"""
+    return len(content_json) < 1_000_000
+
+
+def _process_sync_generator(span: trace.Span, generator: types.GeneratorType):
+    """Process a synchronous generator and manage its span lifecycle"""
+    # Ensure span context is attached to the generator context
+    context_api.attach(trace.set_span_in_context(span))
+
+    # Yield from the generator while maintaining span context
+    yield from generator
+
+    # End the span when generator is exhausted
+    span.end()
+    # No detach because of OpenTelemetry issue #2606
+    # Context will be detached during garbage collection
+
+
+async def _process_async_generator(span: trace.Span, context_token: Any, generator: types.AsyncGeneratorType):
+    """Process an asynchronous generator and manage its span lifecycle"""
+    try:
+        async for item in generator:
+            yield item
+    finally:
+        # Always ensure span is ended and context detached
+        span.end()
+        context_api.detach(context_token)
+
+
+def _get_current_span_info():
+    """Helper to get information about the current span for debugging"""
+    current_span = trace.get_current_span()
+    if hasattr(current_span, "get_span_context"):
+        ctx = current_span.get_span_context()
+        return {
+            "span_id": f"{ctx.span_id:x}" if hasattr(ctx, "span_id") else "None",
+            "trace_id": f"{ctx.trace_id:x}" if hasattr(ctx, "trace_id") else "None",
+            "name": getattr(current_span, "name", "Unknown"),
+            "is_recording": getattr(current_span, "is_recording", False),
+        }
+    return {"name": "No current span"}
+
+
+@contextmanager
+def _create_as_current_span(
+    operation_name: str, span_kind: str, version: Optional[int] = None, attributes: Optional[Dict[str, Any]] = None
+) -> Generator[Span, None, None]:
+    """
+    Create and yield an instrumentation span as the current span using proper context management.
+
+    This function creates a span that will automatically be nested properly
+    within any parent span based on the current execution context, using OpenTelemetry's
+    context management to properly handle span lifecycle.
+
+    Args:
+        operation_name: Name of the operation being traced
+        span_kind: Type of operation (from SpanKind)
+        version: Optional version identifier for the operation
+        attributes: Optional dictionary of attributes to set on the span
+
+    Yields:
+        A span with proper context that will be automatically closed when exiting the context
+    """
+    # Log before we do anything
+    before_span = _get_current_span_info()
+    logger.debug(f"[DEBUG] BEFORE {operation_name}.{span_kind} - Current context: {before_span}")
+
+    # Create span with proper naming convention
+    span_name = f"{operation_name}.{span_kind}"
+
+    # Get tracer
+    otel_tracer = tracer.get_tracer()
+
+    # Prepare attributes
+    if attributes is None:
+        attributes = {}
+
+    # Add span kind to attributes
+    attributes[SpanAttributes.AGENTOPS_SPAN_KIND] = span_kind
+
+    # Add standard attributes
+    attributes[SpanAttributes.OPERATION_NAME] = operation_name
+    if version is not None:
+        attributes[SpanAttributes.OPERATION_VERSION] = version
+
+    # Get current context explicitly to debug it
+    current_context = context_api.get_current()
+
+    # Use OpenTelemetry's context manager to properly handle span lifecycle
+    with otel_tracer.start_as_current_span(span_name, attributes=attributes, context=current_context) as span:
+        # Log after span creation
+        if hasattr(span, "get_span_context"):
+            span_ctx = span.get_span_context()
+            logger.debug(
+                f"[DEBUG] CREATED {span_name} - span_id: {span_ctx.span_id:x}, parent: {before_span.get('span_id', 'None')}"
+            )
+
+        yield span
+
+    # Log after we're done
+    after_span = _get_current_span_info()
+    logger.debug(f"[DEBUG] AFTER {operation_name}.{span_kind} - Returned to context: {after_span}")
+
+
+def _record_entity_input(span: trace.Span, args: tuple, kwargs: Dict[str, Any], entity_kind: str = "entity") -> None:
+    """Record operation input parameters to span if content tracing is enabled"""
+    try:
+        input_data = {"args": args, "kwargs": kwargs}
+        json_data = safe_serialize(input_data)
+
+        if _check_content_size(json_data):
+            span.set_attribute(SpanAttributes.AGENTOPS_DECORATOR_INPUT.format(entity_kind=entity_kind), json_data)
+        else:
+            logger.debug("Operation input exceeds size limit, not recording")
+    except Exception as err:
+        logger.warning(f"Failed to serialize operation input: {err}")
+
+
+def _record_entity_output(span: trace.Span, result: Any, entity_kind: str = "entity") -> None:
+    """Record operation output value to span if content tracing is enabled"""
+    try:
+        json_data = safe_serialize(result)
+
+        if _check_content_size(json_data):
+            span.set_attribute(SpanAttributes.AGENTOPS_DECORATOR_OUTPUT.format(entity_kind=entity_kind), json_data)
+        else:
+            logger.debug("Operation output exceeds size limit, not recording")
+    except Exception as err:
+        logger.warning(f"Failed to serialize operation output: {err}")
+
+
+# Helper functions for HTTP request/response data extraction
+
+
+def _extract_request_data():
+    """Extract HTTP request data from the current web framework context."""
+    request_data = {}
+
+    try:
+        # Try to import Flask and get current request
+        from flask import request
+
+        request_data = {
+            "method": request.method,
+            "url": request.url,
+            "headers": dict(request.headers),
+            "args": dict(request.args),
+            "form": dict(request.form) if request.form else None,
+            "json": request.get_json(silent=True),
+            "data": request.get_data(as_text=True) if request.content_length else None,
+        }
+    except ImportError:
+        logger.debug("Flask not available for request data extraction")
+    except Exception as e:
+        logger.warning(f"Failed to extract request data: {e}")
+
+    return request_data
+
+
+def _extract_response_data(response):
+    """Extract HTTP response data from response object."""
+    response_data = {}
+
+    try:
+        # Handle Flask response objects
+        from flask import Response
+
+        if isinstance(response, Response):
+            response_data = {
+                "status_code": response.status_code,
+                "headers": dict(response.headers),
+                "data": response.get_data(as_text=True) if response.content_length else None,
+            }
+        else:
+            # Handle cases where response is just data (will be converted to Response by Flask)
+            response_data = {
+                "status_code": 200,  # Default status for successful responses
+                "data": str(response) if response is not None else None,
+            }
+    except Exception as e:
+        logger.warning(f"Failed to extract response data: {e}")
+
+    return response_data

agentops/sdk/exporters.py

@@ -0,0 +1,87 @@
+# Define a separate class for the authenticated OTLP exporter
+# This is imported conditionally to avoid dependency issues
+from typing import Dict, Optional, Sequence
+
+import requests
+from opentelemetry.exporter.otlp.proto.http import Compression
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExportResult
+
+from agentops.exceptions import AgentOpsApiJwtExpiredException, ApiServerException
+from agentops.logging import logger
+
+
+class AuthenticatedOTLPExporter(OTLPSpanExporter):
+    """
+    OTLP exporter with JWT authentication support.
+
+    This exporter automatically handles JWT authentication and token refresh
+    for telemetry data sent to the AgentOps API using a dedicated HTTP session
+    with authentication retry logic built in.
+    """
+
+    def __init__(
+        self,
+        endpoint: str,
+        jwt: str,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[int] = None,
+        compression: Optional[Compression] = None,
+        **kwargs,
+    ):
+        # TODO: Implement re-authentication
+        # FIXME: endpoint here is not "endpoint" from config
+        # self._session = HttpClient.get_authenticated_session(endpoint, api_key)
+
+        # Initialize the parent class
+        super().__init__(
+            endpoint=endpoint,
+            headers={
+                "Authorization": f"Bearer {jwt}",
+            },  # Base headers
+            timeout=timeout,
+            compression=compression,
+            # session=self._session,  # Use our authenticated session
+        )
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        """
+        Export spans with automatic authentication handling
+
+        The authentication and retry logic is now handled by the underlying
+        HTTP session adapter, so we just need to call the parent export method.
+
+        Args:
+            spans: The list of spans to export
+
+        Returns:
+            The result of the export
+        """
+        try:
+            return super().export(spans)
+        except AgentOpsApiJwtExpiredException as e:
+            # Authentication token expired or invalid
+            logger.warning(f"Authentication error during span export: {e}")
+            return SpanExportResult.FAILURE
+        except ApiServerException as e:
+            # Server-side error
+            logger.error(f"API server error during span export: {e}")
+            return SpanExportResult.FAILURE
+        except requests.RequestException as e:
+            # Network or HTTP error
+            logger.error(f"Network error during span export: {e}")
+            return SpanExportResult.FAILURE
+        except Exception as e:
+            # Any other error
+            logger.error(f"Unexpected error during span export: {e}")
+            return SpanExportResult.FAILURE
+
+    def clear(self):
+        """
+        Clear any stored spans.
+
+        This method is added for compatibility with test fixtures.
+        The OTLP exporter doesn't store spans, so this is a no-op.
+        """
+        pass

agentops/sdk/processors.py

@@ -0,0 +1,71 @@
+"""
+Span processors for AgentOps SDK.
+
+This module contains processors for OpenTelemetry spans.
+"""
+
+from typing import Optional
+
+from opentelemetry.context import Context
+from opentelemetry.sdk.trace import ReadableSpan, Span, SpanProcessor
+
+from agentops.logging import logger, upload_logfile
+
+
+class InternalSpanProcessor(SpanProcessor):
+    """
+    A span processor that prints information about spans.
+
+    This processor is particularly useful for debugging and monitoring
+    as it prints information about spans as they are created and ended.
+    For session spans, it prints a URL to the AgentOps dashboard.
+
+    Note about span kinds:
+    - OpenTelemetry spans have a native 'kind' property (INTERNAL, CLIENT, CONSUMER, etc.)
+    - AgentOps also uses a semantic convention attribute AGENTOPS_SPAN_KIND for domain-specific kinds
+    - This processor tries to use the native kind first, then falls back to the attribute
+    """
+
+    _root_span_id: Optional[int] = None
+
+    def on_start(self, span: Span, parent_context: Optional[Context] = None) -> None:
+        """
+        Called when a span is started.
+
+        Args:
+            span: The span that was started.
+            parent_context: The parent context, if any.
+        """
+        # Skip if span is not sampled
+        if not span.context or not span.context.trace_flags.sampled:
+            return
+
+        if not self._root_span_id:
+            self._root_span_id = span.context.span_id
+            logger.debug(f"[agentops.InternalSpanProcessor] Found root span: {span.name}")
+
+    def on_end(self, span: ReadableSpan) -> None:
+        """
+        Called when a span is ended.
+
+        Args:
+            span: The span that was ended.
+        """
+        # Skip if span is not sampled
+        if not span.context or not span.context.trace_flags.sampled:
+            return
+
+        if self._root_span_id and (span.context.span_id is self._root_span_id):
+            logger.debug(f"[agentops.InternalSpanProcessor] Ending root span: {span.name}")
+            try:
+                upload_logfile(span.context.trace_id)
+            except Exception as e:
+                logger.error(f"[agentops.InternalSpanProcessor] Error uploading logfile: {e}")
+
+    def shutdown(self) -> None:
+        """Shutdown the processor."""
+        self._root_span_id = None
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """Force flush the processor."""
+        return True

agentops/sdk/types.py

@@ -0,0 +1,21 @@
+from typing import Annotated, Optional, TypedDict
+
+from opentelemetry.sdk.trace import SpanProcessor
+from opentelemetry.sdk.trace.export import SpanExporter
+
+ISOTimeStamp = Annotated[str, "ISO 8601 formatted timestamp string (e.g. '2023-04-15T12:30:45.123456+00:00')"]
+
+
+class TracingConfig(TypedDict, total=False):
+    """Configuration for the tracing core."""
+
+    service_name: Optional[str]
+    exporter: Optional[SpanExporter]
+    processor: Optional[SpanProcessor]
+    exporter_endpoint: Optional[str]
+    metrics_endpoint: Optional[str]
+    api_key: Optional[str]  # API key for authentication with AgentOps services
+    project_id: Optional[str]  # Project ID to include in resource attributes
+    max_queue_size: int  # Required with a default value
+    max_wait_time: int  # Required with a default value
+    export_flush_interval: int  # Time interval between automatic exports

agentops/semconv/__init__.py

@@ -0,0 +1,36 @@
+"""AgentOps semantic conventions for spans."""
+
+from agentops.semconv.span_kinds import SpanKind
+from agentops.semconv.core import CoreAttributes
+from agentops.semconv.agent import AgentAttributes
+from agentops.semconv.tool import ToolAttributes
+from agentops.semconv.status import ToolStatus
+from agentops.semconv.workflow import WorkflowAttributes
+from agentops.semconv.instrumentation import InstrumentationAttributes
+from agentops.semconv.enum import LLMRequestTypeValues
+from agentops.semconv.span_attributes import SpanAttributes
+from agentops.semconv.meters import Meters
+from agentops.semconv.span_kinds import AgentOpsSpanKindValues
+from agentops.semconv.resource import ResourceAttributes
+from agentops.semconv.message import MessageAttributes
+from agentops.semconv.langchain import LangChainAttributes, LangChainAttributeValues
+
+SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY = "suppress_language_model_instrumentation"
+__all__ = [
+    "SUPPRESS_LANGUAGE_MODEL_INSTRUMENTATION_KEY",
+    "SpanKind",
+    "CoreAttributes",
+    "AgentAttributes",
+    "ToolAttributes",
+    "ToolStatus",
+    "WorkflowAttributes",
+    "InstrumentationAttributes",
+    "LLMRequestTypeValues",
+    "SpanAttributes",
+    "Meters",
+    "AgentOpsSpanKindValues",
+    "ResourceAttributes",
+    "MessageAttributes",
+    "LangChainAttributes",
+    "LangChainAttributeValues",
+]

agentops/semconv/agent.py

@@ -0,0 +1,29 @@
+"""Attributes specific to agent spans."""
+
+
+class AgentAttributes:
+    """Attributes specific to agent spans."""
+
+    # Identity
+    AGENT_ID = "agent.id"  # Unique identifier for the agent
+    AGENT_NAME = "agent.name"  # Name of the agent
+    AGENT_ROLE = "agent.role"  # Role of the agent
+
+    # Capabilities
+    AGENT_TOOLS = "agent.tools"  # Tools available to the agent
+    AGENT_MODELS = "agent.models"  # Models available to the agent
+
+    TOOLS = "tools"
+    HANDOFFS = "handoffs"
+
+    # NOTE: This attribute deviates from the OpenTelemetry GenAI semantic conventions.
+    # According to OpenTelemetry GenAI conventions, this should be named "gen_ai.agent.source"
+    # or follow a similar pattern under the "gen_ai" namespace.
+    FROM_AGENT = "from_agent"
+
+    # NOTE: This attribute deviates from the OpenTelemetry GenAI semantic conventions.
+    # According to OpenTelemetry GenAI conventions, this should be named "gen_ai.agent.destination"
+    # or follow a similar pattern under the "gen_ai" namespace.
+    TO_AGENT = "to_agent"
+
+    AGENT_REASONING = "agent.reasoning"

agentops/semconv/core.py

@@ -0,0 +1,19 @@
+"""Core attributes applicable to all spans."""
+
+
+class CoreAttributes:
+    """Core attributes applicable to all spans."""
+
+    # Error attributes
+    ERROR_TYPE = "error.type"  # Type of error if status is error
+    ERROR_MESSAGE = "error.message"  # Error message if status is error
+
+    TAGS = "agentops.tags"  # Tags passed to agentops.init
+
+    # Trace context attributes
+    TRACE_ID = "trace.id"  # Trace ID
+    SPAN_ID = "span.id"  # Span ID
+    PARENT_ID = "parent.id"  # Parent ID
+    GROUP_ID = "group.id"  # Group ID
+
+    # Note: WORKFLOW_NAME is defined in WorkflowAttributes to avoid duplication

agentops/semconv/enum.py

@@ -0,0 +1,11 @@
+"""Enum for LLM request types."""
+
+from enum import Enum
+
+
+class LLMRequestTypeValues(Enum):
+    COMPLETION = "completion"
+    CHAT = "chat"
+    RERANK = "rerank"
+    EMBEDDING = "embedding"
+    UNKNOWN = "unknown"

agentops/semconv/instrumentation.py

@@ -0,0 +1,13 @@
+"""Attributes specific to instrumentation."""
+
+
+class InstrumentationAttributes:
+    """Instrumentation specific attributes."""
+
+    NAME = "instrumentation.name"  # Name of the instrumentation
+    VERSION = "instrumentation.version"  # Version of the instrumentation
+
+    LIBRARY_NAME = "library.name"  # Name of the library
+    LIBRARY_VERSION = "library.version"  # Version of the library
+
+    INSTRUMENTATION_TYPE = "instrumentation.type"  # Type of instrumentation

agentops/semconv/langchain.py

@@ -0,0 +1,63 @@
+"""Semantic conventions for LangChain instrumentation."""
+
+
+class LangChainAttributeValues:
+    """Standard values for LangChain attributes."""
+
+    CHAIN_KIND_SEQUENTIAL = "sequential"
+    CHAIN_KIND_LLM = "llm"
+    CHAIN_KIND_ROUTER = "router"
+
+    # Chat message roles
+    ROLE_SYSTEM = "system"
+    ROLE_USER = "user"
+    ROLE_ASSISTANT = "assistant"
+    ROLE_FUNCTION = "function"
+    ROLE_TOOL = "tool"
+
+
+class LangChainAttributes:
+    """
+    Attributes for LangChain instrumentation.
+
+    Note: LLM-specific attributes are derived from SpanAttributes to maintain
+    consistency across instrumentations.
+    """
+
+    # Session attributes
+    SESSION_TAGS = "langchain.session.tags"
+
+    LLM_NAME = "langchain.llm.name"
+    LLM_MODEL = "langchain.llm.model"
+
+    # Chain attributes - specific to LangChain
+    CHAIN_NAME = "langchain.chain.name"
+    CHAIN_TYPE = "langchain.chain.type"
+    CHAIN_ERROR = "langchain.chain.error"
+    CHAIN_KIND = "langchain.chain.kind"
+    CHAIN_VERBOSE = "langchain.chain.verbose"
+
+    # Agent attributes - specific to LangChain agents
+    AGENT_ACTION_LOG = "langchain.agent.action.log"
+    AGENT_ACTION_INPUT = "langchain.agent.action.input"
+    AGENT_ACTION_TOOL = "langchain.agent.action.tool"
+    AGENT_FINISH_RETURN_VALUES = "langchain.agent.finish.return_values"
+    AGENT_FINISH_LOG = "langchain.agent.finish.log"
+
+    # Tool attributes - specific to LangChain tools
+    TOOL_NAME = "langchain.tool.name"
+    TOOL_INPUT = "langchain.tool.input"
+    TOOL_OUTPUT = "langchain.tool.output"
+    TOOL_DESCRIPTION = "langchain.tool.description"
+    TOOL_ERROR = "langchain.tool.error"
+    TOOL_ARGS_SCHEMA = "langchain.tool.args_schema"
+    TOOL_RETURN_DIRECT = "langchain.tool.return_direct"
+
+    # Chat attributes - specific to LangChain chat models
+    CHAT_MESSAGE_ROLES = "langchain.chat_message.roles"
+    CHAT_MODEL_TYPE = "langchain.chat_model.type"
+
+    # Text callback attributes
+    TEXT_CONTENT = "langchain.text.content"
+
+    LLM_ERROR = "langchain.llm.error"

agentops/semconv/message.py

@@ -0,0 +1,61 @@
+"""Semantic conventions for message-related attributes in AI systems."""
+
+
+class MessageAttributes:
+    """Semantic conventions for message-related attributes in AI systems."""
+
+    PROMPT_ROLE = "gen_ai.prompt.{i}.role"  # Role of the prompt message
+    PROMPT_CONTENT = "gen_ai.prompt.{i}.content"  # Content of the prompt message
+    PROMPT_TYPE = "gen_ai.prompt.{i}.type"  # Type of the prompt message
+    PROMPT_SPEAKER = "gen_ai.prompt.{i}.speaker"  # Speaker/agent name for the prompt message
+
+    # Indexed function calls (with {i} for interpolation)
+    TOOL_CALL_ID = "gen_ai.request.tools.{i}.id"  # Unique identifier for the function call at index {i}
+    TOOL_CALL_TYPE = "gen_ai.request.tools.{i}.type"  # Type of the function call at index {i}
+    TOOL_CALL_NAME = "gen_ai.request.tools.{i}.name"  # Name of the function call at index {i}
+    TOOL_CALL_DESCRIPTION = "gen_ai.request.tools.{i}.description"  # Description of the function call at index {i}
+    TOOL_CALL_ARGUMENTS = "gen_ai.request.tools.{i}.arguments"  # Arguments for function call at index {i}
+
+    # Indexed completions (with {i} for interpolation)
+    COMPLETION_ID = "gen_ai.completion.{i}.id"  # Unique identifier for the completion
+    COMPLETION_TYPE = "gen_ai.completion.{i}.type"  # Type of the completion at index {i}
+    COMPLETION_ROLE = "gen_ai.completion.{i}.role"  # Role of the completion message at index {i}
+    COMPLETION_CONTENT = "gen_ai.completion.{i}.content"  # Content of the completion message at index {i}
+    COMPLETION_FINISH_REASON = "gen_ai.completion.{i}.finish_reason"  # Finish reason for completion at index {i}
+    COMPLETION_SPEAKER = "gen_ai.completion.{i}.speaker"  # Speaker/agent name for the completion message
+
+    # Indexed tool calls (with {i}/{j} for nested interpolation)
+    COMPLETION_TOOL_CALL_ID = "gen_ai.completion.{i}.tool_calls.{j}.id"  # ID of tool call {j} in completion {i}
+    COMPLETION_TOOL_CALL_TYPE = "gen_ai.completion.{i}.tool_calls.{j}.type"  # Type of tool call {j} in completion {i}
+    COMPLETION_TOOL_CALL_STATUS = (
+        "gen_ai.completion.{i}.tool_calls.{j}.status"  # Status of tool call {j} in completion {i}
+    )
+    COMPLETION_TOOL_CALL_NAME = (
+        "gen_ai.completion.{i}.tool_calls.{j}.name"  # Name of the tool called in tool call {j} in completion {i}
+    )
+    COMPLETION_TOOL_CALL_DESCRIPTION = (
+        "gen_ai.completion.{i}.tool_calls.{j}.description"  # Description of the tool call {j} in completion {i}
+    )
+    COMPLETION_TOOL_CALL_STATUS = (
+        "gen_ai.completion.{i}.tool_calls.{j}.status"  # Status of the tool call {j} in completion {i}
+    )
+    COMPLETION_TOOL_CALL_ARGUMENTS = (
+        "gen_ai.completion.{i}.tool_calls.{j}.arguments"  # Arguments for tool call {j} in completion {i}
+    )
+
+    # Indexed annotations of the internal tools (with {i}/{j} for nested interpolation)
+    COMPLETION_ANNOTATION_START_INDEX = (
+        "gen_ai.completion.{i}.annotations.{j}.start_index"  # Start index of the URL annotation {j} in completion {i}
+    )
+    COMPLETION_ANNOTATION_END_INDEX = (
+        "gen_ai.completion.{i}.annotations.{j}.end_index"  # End index of the URL annotation {j} in completion {i}
+    )
+    COMPLETION_ANNOTATION_TITLE = (
+        "gen_ai.completion.{i}.annotations.{j}.title"  # Title of the URL annotation {j} in completion {i}
+    )
+    COMPLETION_ANNOTATION_TYPE = (
+        "gen_ai.completion.{i}.annotations.{j}.type"  # Type of the URL annotation {j} in completion {i}
+    )
+    COMPLETION_ANNOTATION_URL = (
+        "gen_ai.completion.{i}.annotations.{j}.url"  # URL link of the URL annotation {j} in completion {i}
+    )

agentops/semconv/meters.py

@@ -0,0 +1,24 @@
+"""Metrics for OpenTelemetry semantic conventions."""
+
+
+class Meters:
+    # Gen AI metrics (OpenTelemetry standard)
+    LLM_GENERATION_CHOICES = "gen_ai.client.generation.choices"
+    LLM_TOKEN_USAGE = "gen_ai.client.token.usage"
+    LLM_OPERATION_DURATION = "gen_ai.client.operation.duration"
+
+    # OpenAI specific metrics
+    LLM_COMPLETIONS_EXCEPTIONS = "gen_ai.openai.chat_completions.exceptions"
+    LLM_STREAMING_TIME_TO_FIRST_TOKEN = "gen_ai.openai.chat_completions.streaming_time_to_first_token"
+    LLM_STREAMING_TIME_TO_GENERATE = "gen_ai.openai.chat_completions.streaming_time_to_generate"
+    LLM_EMBEDDINGS_EXCEPTIONS = "gen_ai.openai.embeddings.exceptions"
+    LLM_EMBEDDINGS_VECTOR_SIZE = "gen_ai.openai.embeddings.vector_size"
+    LLM_IMAGE_GENERATIONS_EXCEPTIONS = "gen_ai.openai.image_generations.exceptions"
+
+    # Anthropic specific metrics
+    LLM_ANTHROPIC_COMPLETION_EXCEPTIONS = "gen_ai.anthropic.completion.exceptions"
+
+    # Agent metrics
+    AGENT_RUNS = "gen_ai.agent.runs"
+    AGENT_TURNS = "gen_ai.agent.turns"
+    AGENT_EXECUTION_TIME = "gen_ai.agent.execution_time"