traceable-agent 2.0.0__tar.gz → 2.1.0b1__tar.gz

{traceable-agent-2.0.0 → traceable_agent-2.1.0b1}/PKG-INFO

@@ -1,15 +1,56 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: traceable-agent
-Version: 2.0.0
+Version: 2.1.0b1
 Summary: Traceable.ai Python Agent
 Home-page: https://traceable.ai
 Author: Traceable.ai
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+Requires-Dist: opentelemetry-api==1.41.1
+Requires-Dist: opentelemetry-exporter-otlp==1.41.1
+Requires-Dist: opentelemetry-instrumentation==0.62b1
+Requires-Dist: opentelemetry-instrumentation-aiohttp-client==0.62b1
+Requires-Dist: opentelemetry-instrumentation-botocore==0.62b1
+Requires-Dist: opentelemetry-instrumentation-wsgi==0.62b1
+Requires-Dist: opentelemetry-instrumentation-fastapi==0.62b1
+Requires-Dist: opentelemetry-instrumentation-flask==0.62b1
+Requires-Dist: opentelemetry-instrumentation-mysql==0.62b1
+Requires-Dist: opentelemetry-instrumentation-psycopg2==0.62b1
+Requires-Dist: opentelemetry-instrumentation-requests==0.62b1
+Requires-Dist: opentelemetry-instrumentation-httpx==0.62b1
+Requires-Dist: opentelemetry-instrumentation-grpc==0.62b1
+Requires-Dist: opentelemetry-instrumentation-django==0.62b1
+Requires-Dist: opentelemetry-instrumentation-aws-lambda==0.62b1
+Requires-Dist: opentelemetry-instrumentation-mcp==0.60.0
+Requires-Dist: opentelemetry-semantic-conventions-ai<0.6.0,>=0.5.1
+Requires-Dist: opentelemetry-propagator-b3==1.41.1
+Requires-Dist: opentelemetry-proto==1.41.1
+Requires-Dist: opentelemetry-sdk==1.41.1
+Requires-Dist: opentelemetry-util-http==0.62b1
+Requires-Dist: google>=3.0.0
+Requires-Dist: pyyaml
+Requires-Dist: protobuf
+Requires-Dist: psutil
+Requires-Dist: distro
+Requires-Dist: cffi
+Requires-Dist: setuptools
+Requires-Dist: jaraco.text
+Requires-Dist: platformdirs
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.34.0; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.40.0; extra == "openai"
+Provides-Extra: litellm
+Requires-Dist: litellm>=1.60.0; extra == "litellm"
+Dynamic: author
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # Python Agent
 
@@ -93,5 +134,3 @@ git submodule update --init --recursive
         ```
 - Test applications
     1. Refer to `docker/test_apps/`.
-
-

traceable_agent-2.1.0b1/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = [
+    "setuptools>=42",
+    "wheel",
+
+]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["test"]
+
+[tool.pylint.messages_control]
+disable = ["trailing-whitespace"]
+

traceable_agent-2.1.0b1/setup.py

@@ -0,0 +1,113 @@
+# pylint: skip-file
+import os
+from setuptools import setup, find_packages, Extension
+
+exec(open('src/traceableai/version.py').read())
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+# Bundle pre-release vendor packages that aren't yet on PyPI.
+# These are fetched by scripts/fetch-vendor.sh before building.
+# We copy them under src/ and list them explicitly (they're namespace packages
+# so find_packages() won't discover them automatically).
+# Once they're published to PyPI, remove this block and add them
+# as versioned dependencies in extras_require['anthropic'] instead.
+import shutil
+
+_ROOT = os.path.dirname(os.path.abspath(__file__))
+
+_VENDOR_SRC = [
+    os.path.join(_ROOT, 'temporary-vendor', 'opentelemetry-instrumentation-anthropic', 'src', 'opentelemetry'),
+    os.path.join(_ROOT, 'temporary-vendor', 'opentelemetry-instrumentation-openai-v2', 'src', 'opentelemetry'),
+    os.path.join(_ROOT, 'temporary-vendor', 'opentelemetry-util-genai', 'src', 'opentelemetry'),
+]
+_VENDOR_DST = os.path.join(_ROOT, 'src', 'opentelemetry')
+
+for _src in _VENDOR_SRC:
+    if os.path.isdir(_src):
+        shutil.copytree(_src, _VENDOR_DST, dirs_exist_ok=True)
+
+# Collect all sub-packages with __init__.py from the merged destination
+# (namespace package roots like opentelemetry/ have no __init__.py and are excluded)
+_VENDOR_PACKAGES = []
+if os.path.isdir(_VENDOR_DST):
+    for _dirpath, _dirnames, _filenames in os.walk(_VENDOR_DST):
+        if '__init__.py' in _filenames:
+            _rel = os.path.relpath(_dirpath, os.path.join(_ROOT, 'src'))
+            _VENDOR_PACKAGES.append(_rel.replace(os.sep, '.'))
+
+setup(
+    name="traceable-agent",
+    version=__version__,
+    author="Traceable.ai",
+    description="Traceable.ai Python Agent",
+    url="https://traceable.ai",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent"
+    ],
+    package_dir={"": "src"},
+    packages=find_packages(where="src") + _VENDOR_PACKAGES,
+    include_package_data=True,
+    python_requires=">=3.10",
+    ext_modules=[
+        # this option will let wheel builder know to package c extensions when ran from CI. No effect for source tar installs
+        Extension(
+            name='traceableai.filter._libtraceable',
+            sources=[],
+            optional=os.environ.get('CIBUILDWHEEL', '0') != '1'
+        )
+    ],
+    install_requires=[
+        "opentelemetry-api==1.41.1",
+        "opentelemetry-exporter-otlp==1.41.1",
+        "opentelemetry-instrumentation==0.62b1",
+        "opentelemetry-instrumentation-aiohttp-client==0.62b1",
+        "opentelemetry-instrumentation-botocore==0.62b1",
+        "opentelemetry-instrumentation-wsgi==0.62b1",
+        "opentelemetry-instrumentation-fastapi==0.62b1",
+        "opentelemetry-instrumentation-flask==0.62b1",
+        "opentelemetry-instrumentation-mysql==0.62b1",
+        "opentelemetry-instrumentation-psycopg2==0.62b1",
+        "opentelemetry-instrumentation-requests==0.62b1",
+        "opentelemetry-instrumentation-httpx==0.62b1",
+        "opentelemetry-instrumentation-grpc==0.62b1",
+        "opentelemetry-instrumentation-django==0.62b1",
+        "opentelemetry-instrumentation-aws-lambda==0.62b1",
+        "opentelemetry-instrumentation-mcp==0.60.0",
+        "opentelemetry-semantic-conventions-ai>=0.5.1,<0.6.0",
+        "opentelemetry-propagator-b3==1.41.1",
+        "opentelemetry-proto==1.41.1",
+        "opentelemetry-sdk==1.41.1",
+        "opentelemetry-util-http==0.62b1",
+        "google>=3.0.0",
+        "pyyaml",
+        "protobuf",
+        "psutil",
+        "distro",
+        "cffi",
+        "setuptools",
+        "jaraco.text",
+        "platformdirs"
+    ],
+    entry_points={
+        'console_scripts': [
+            'traceableai-instrument = traceableai.autoinstrumentation.wrapper:run',
+        ],
+    },
+    extras_require={
+        'anthropic': [
+            'anthropic>=0.34.0',
+            # opentelemetry-util-genai and opentelemetry-instrumentation-anthropic
+            # are bundled directly (not yet on PyPI). When they are published,
+            # add them here as versioned deps and remove the bundle logic above.
+        ],
+        'openai': [
+            'openai>=1.40.0',
+        ],
+        'litellm': [
+            'litellm>=1.60.0',
+        ],
+    },
+)

traceable_agent-2.1.0b1/src/opentelemetry/instrumentation/anthropic/__init__.py

@@ -0,0 +1,119 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+OpenTelemetry Anthropic Instrumentation
+========================================
+
+Instrumentation for the Anthropic Python SDK.
+
+Usage
+-----
+
+.. code-block:: python
+
+    from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
+    import anthropic
+
+    # Enable instrumentation
+    AnthropicInstrumentor().instrument()
+
+    # Use Anthropic client normally
+    client = anthropic.Anthropic()
+    response = client.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        max_tokens=1024,
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+
+Configuration
+-------------
+
+Message content capture can be enabled by setting the environment variable:
+``OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true``
+
+API
+---
+"""
+
+from typing import Any, Collection
+
+from wrapt import (
+    wrap_function_wrapper,  # pyright: ignore[reportUnknownVariableType]
+)
+
+from opentelemetry.instrumentation.anthropic.package import _instruments
+from opentelemetry.instrumentation.anthropic.patch import (
+    messages_create,
+)
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.utils import unwrap
+from opentelemetry.util.genai.handler import TelemetryHandler
+
+
+class AnthropicInstrumentor(BaseInstrumentor):
+    """An instrumentor for the Anthropic Python SDK.
+
+    This instrumentor will automatically trace Anthropic API calls and
+    optionally capture message content as events.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._tracer = None
+        self._logger = None
+        self._meter = None
+
+    # pylint: disable=no-self-use
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs: Any) -> None:
+        """Enable Anthropic instrumentation.
+
+        Args:
+            **kwargs: Optional arguments
+                - tracer_provider: TracerProvider instance
+                - meter_provider: MeterProvider instance
+                - logger_provider: LoggerProvider instance
+        """
+        # Get providers from kwargs
+        tracer_provider = kwargs.get("tracer_provider")
+        meter_provider = kwargs.get("meter_provider")
+        logger_provider = kwargs.get("logger_provider")
+
+        handler = TelemetryHandler(
+            tracer_provider=tracer_provider,
+            meter_provider=meter_provider,
+            logger_provider=logger_provider,
+        )
+
+        # Patch Messages.create
+        wrap_function_wrapper(
+            "anthropic.resources.messages",
+            "Messages.create",
+            messages_create(handler),
+        )
+
+    def _uninstrument(self, **kwargs: Any) -> None:
+        """Disable Anthropic instrumentation.
+
+        This removes all patches applied during instrumentation.
+        """
+        import anthropic  # pylint: disable=import-outside-toplevel  # noqa: PLC0415
+
+        unwrap(
+            anthropic.resources.messages.Messages,  # pyright: ignore[reportAttributeAccessIssue,reportUnknownMemberType,reportUnknownArgumentType]
+            "create",
+        )

traceable_agent-2.1.0b1/src/opentelemetry/instrumentation/anthropic/messages_extractors.py

@@ -0,0 +1,251 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Get/extract helpers for Anthropic Messages instrumentation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Sequence
+
+from anthropic.types import MessageDeltaUsage
+
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
+from opentelemetry.semconv._incubating.attributes import (
+    server_attributes as ServerAttributes,
+)
+from opentelemetry.util.genai.types import (
+    InputMessage,
+    LLMInvocation,
+    MessagePart,
+    OutputMessage,
+)
+from opentelemetry.util.types import AttributeValue
+
+from .utils import (
+    convert_content_to_parts,
+    normalize_finish_reason,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping
+
+    import httpx
+    from anthropic.resources.messages import Messages
+    from anthropic.types import (
+        Message,
+        MessageParam,
+        MetadataParam,
+        TextBlockParam,
+        ThinkingConfigParam,
+        ToolChoiceParam,
+        ToolUnionParam,
+        Usage,
+    )
+
+
+@dataclass
+class MessageRequestParams:
+    model: str | None = None
+    max_tokens: int | None = None
+    temperature: float | None = None
+    top_k: int | None = None
+    top_p: float | None = None
+    stop_sequences: Sequence[str] | None = None
+    stream: bool | None = None
+    messages: Iterable[MessageParam] | None = None
+    system: str | Iterable[TextBlockParam] | None = None
+
+
+GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS = (
+    "gen_ai.usage.cache_creation.input_tokens"
+)
+GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS = "gen_ai.usage.cache_read.input_tokens"
+
+
+@dataclass
+class UsageTokens:
+    input_tokens: int | None = None
+    output_tokens: int | None = None
+    cache_creation_input_tokens: int | None = None
+    cache_read_input_tokens: int | None = None
+
+
+def extract_usage_tokens(
+    usage: Usage | MessageDeltaUsage | None,
+) -> UsageTokens:
+    if usage is None:
+        return UsageTokens()
+
+    input_tokens = usage.input_tokens
+    output_tokens = usage.output_tokens
+    cache_creation_input_tokens = usage.cache_creation_input_tokens
+    cache_read_input_tokens = usage.cache_read_input_tokens
+
+    if (
+        input_tokens is None
+        and cache_creation_input_tokens is None
+        and cache_read_input_tokens is None
+    ):
+        total_input_tokens = None
+    else:
+        total_input_tokens = (
+            (input_tokens or 0)
+            + (cache_creation_input_tokens or 0)
+            + (cache_read_input_tokens or 0)
+        )
+
+    return UsageTokens(
+        input_tokens=total_input_tokens,
+        output_tokens=output_tokens,
+        cache_creation_input_tokens=cache_creation_input_tokens,
+        cache_read_input_tokens=cache_read_input_tokens,
+    )
+
+
+def get_input_messages(
+    messages: Iterable[MessageParam] | None,
+) -> list[InputMessage]:
+    if messages is None:
+        return []
+    result: list[InputMessage] = []
+    for message in messages:
+        role = message["role"]
+        parts = convert_content_to_parts(message["content"])
+        result.append(InputMessage(role=role, parts=parts))
+    return result
+
+
+def get_system_instruction(
+    system: str | Iterable[TextBlockParam] | None,
+) -> list[MessagePart]:
+    if system is None:
+        return []
+    return convert_content_to_parts(system)
+
+
+def get_output_messages_from_message(
+    message: Message | None,
+) -> list[OutputMessage]:
+    if message is None:
+        return []
+
+    parts = convert_content_to_parts(message.content)
+    finish_reason = normalize_finish_reason(message.stop_reason)
+    return [
+        OutputMessage(
+            role=message.role,
+            parts=parts,
+            finish_reason=finish_reason or "",
+        )
+    ]
+
+
+def set_invocation_response_attributes(
+    invocation: LLMInvocation,
+    message: Message | None,
+    capture_content: bool,
+) -> None:
+    if message is None:
+        return
+
+    invocation.response_model_name = message.model
+    invocation.response_id = message.id
+
+    finish_reason = normalize_finish_reason(message.stop_reason)
+    if finish_reason:
+        invocation.finish_reasons = [finish_reason]
+
+    tokens = extract_usage_tokens(message.usage)
+    invocation.input_tokens = tokens.input_tokens
+    invocation.output_tokens = tokens.output_tokens
+    if tokens.cache_creation_input_tokens is not None:
+        invocation.attributes[GEN_AI_USAGE_CACHE_CREATION_INPUT_TOKENS] = (
+            tokens.cache_creation_input_tokens
+        )
+    if tokens.cache_read_input_tokens is not None:
+        invocation.attributes[GEN_AI_USAGE_CACHE_READ_INPUT_TOKENS] = (
+            tokens.cache_read_input_tokens
+        )
+
+    if capture_content:
+        invocation.output_messages = get_output_messages_from_message(message)
+
+
+def extract_params(  # pylint: disable=too-many-locals
+    *,
+    max_tokens: int | None = None,
+    messages: Iterable[MessageParam] | None = None,
+    model: str | None = None,
+    metadata: MetadataParam | None = None,
+    service_tier: str | None = None,
+    stop_sequences: Sequence[str] | None = None,
+    stream: bool | None = None,
+    system: str | Iterable[TextBlockParam] | None = None,
+    temperature: float | None = None,
+    thinking: ThinkingConfigParam | None = None,
+    tool_choice: ToolChoiceParam | None = None,
+    tools: Iterable[ToolUnionParam] | None = None,
+    top_k: int | None = None,
+    top_p: float | None = None,
+    extra_headers: Mapping[str, str] | None = None,
+    extra_query: Mapping[str, object] | None = None,
+    extra_body: object | None = None,
+    timeout: float | httpx.Timeout | None = None,
+    **_kwargs: object,
+) -> MessageRequestParams:
+    return MessageRequestParams(
+        model=model,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        top_p=top_p,
+        top_k=top_k,
+        stop_sequences=stop_sequences,
+        stream=stream,
+        messages=messages,
+        system=system,
+    )
+
+
+def _set_server_address_and_port(
+    client_instance: "Messages",
+    attributes: dict[str, AttributeValue | None],
+) -> None:
+    base_url = client_instance._client.base_url
+    host = base_url.host
+    if host:
+        attributes[ServerAttributes.SERVER_ADDRESS] = host
+
+    port = base_url.port
+    if port and port != 443 and port > 0:
+        attributes[ServerAttributes.SERVER_PORT] = port
+
+
+def get_llm_request_attributes(
+    params: MessageRequestParams, client_instance: "Messages"
+) -> dict[str, AttributeValue]:
+    attributes: dict[str, AttributeValue | None] = {
+        GenAIAttributes.GEN_AI_OPERATION_NAME: GenAIAttributes.GenAiOperationNameValues.CHAT.value,
+        GenAIAttributes.GEN_AI_SYSTEM: GenAIAttributes.GenAiSystemValues.ANTHROPIC.value,  # pyright: ignore[reportDeprecated]
+        GenAIAttributes.GEN_AI_REQUEST_MODEL: params.model,
+        GenAIAttributes.GEN_AI_REQUEST_MAX_TOKENS: params.max_tokens,
+        GenAIAttributes.GEN_AI_REQUEST_TEMPERATURE: params.temperature,
+        GenAIAttributes.GEN_AI_REQUEST_TOP_P: params.top_p,
+        GenAIAttributes.GEN_AI_REQUEST_TOP_K: params.top_k,
+        GenAIAttributes.GEN_AI_REQUEST_STOP_SEQUENCES: params.stop_sequences,
+    }
+    _set_server_address_and_port(client_instance, attributes)
+    return {k: v for k, v in attributes.items() if v is not None}

traceable_agent-2.1.0b1/src/opentelemetry/instrumentation/anthropic/package.py

@@ -0,0 +1,15 @@
+# Copyright The OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+_instruments = ("anthropic >= 0.16.0",)