opentelemetry-instrumentation-replicate 0.16.0__tar.gz → 0.49.1__tar.gz

{opentelemetry_instrumentation_replicate-0.16.0 → opentelemetry_instrumentation_replicate-0.49.1}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: opentelemetry-instrumentation-replicate
-Version: 0.16.0
+Version: 0.49.1
 Summary: OpenTelemetry Replicate instrumentation
-Home-page: https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-replicate
 License: Apache-2.0
 Author: Kartik Prajapati
 Author-email: kartik@ktklab.org
@@ -13,11 +12,13 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: instruments
-Requires-Dist: opentelemetry-api (>=1.24.0,<2.0.0)
-Requires-Dist: opentelemetry-instrumentation (>=0.45b0,<0.46)
-Requires-Dist: opentelemetry-semantic-conventions (>=0.45b0,<0.46)
-Requires-Dist: opentelemetry-semantic-conventions-ai (==0.1.1)
+Requires-Dist: opentelemetry-api (>=1.38.0,<2.0.0)
+Requires-Dist: opentelemetry-instrumentation (>=0.59b0)
+Requires-Dist: opentelemetry-semantic-conventions (>=0.59b0)
+Requires-Dist: opentelemetry-semantic-conventions-ai (>=0.4.13,<0.5.0)
 Project-URL: Repository, https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-replicate
 Description-Content-Type: text/markdown
 

opentelemetry_instrumentation_replicate-0.49.1/opentelemetry/instrumentation/replicate/__init__.py

@@ -0,0 +1,181 @@
+"""OpenTelemetry Replicate instrumentation"""
+
+import logging
+import types
+from typing import Collection
+
+from opentelemetry import context as context_api
+from opentelemetry._logs import get_logger
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.instrumentation.replicate.config import Config
+from opentelemetry.instrumentation.replicate.event_emitter import (
+    emit_choice_events,
+    emit_event,
+)
+from opentelemetry.instrumentation.replicate.event_models import MessageEvent
+from opentelemetry.instrumentation.replicate.span_utils import (
+    set_input_attributes,
+    set_model_input_attributes,
+    set_response_attributes,
+)
+from opentelemetry.instrumentation.replicate.utils import dont_throw, should_emit_events
+from opentelemetry.instrumentation.replicate.version import __version__
+from opentelemetry.instrumentation.utils import (
+    _SUPPRESS_INSTRUMENTATION_KEY,
+    unwrap,
+)
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
+from opentelemetry.semconv_ai import LLMRequestTypeValues, SpanAttributes
+from opentelemetry.trace import SpanKind, get_tracer
+from opentelemetry.trace.status import Status, StatusCode
+from wrapt import wrap_function_wrapper
+
+logger = logging.getLogger(__name__)
+
+_instruments = ("replicate >= 0.22.0",)
+
+WRAPPED_METHODS = [
+    {
+        "module": "replicate",
+        "method": "run",
+        "span_name": "replicate.run",
+    },
+    {
+        "module": "replicate",
+        "method": "stream",
+        "span_name": "replicate.stream",
+    },
+    {
+        "module": "replicate",
+        "method": "predictions.create",
+        "span_name": "replicate.predictions.create",
+    },
+]
+
+
+def is_streaming_response(response):
+    return isinstance(response, types.GeneratorType)
+
+
+def _build_from_streaming_response(span, event_logger, response):
+    complete_response = ""
+    for item in response:
+        item_to_yield = item
+        complete_response += str(item)
+
+        yield item_to_yield
+
+    _handle_response(span, event_logger, complete_response)
+
+    span.end()
+
+
+@dont_throw
+def _handle_request(span, event_logger, args, kwargs):
+    set_model_input_attributes(span, args, kwargs)
+
+    model_input = kwargs.get("input") or (args[1] if len(args) > 1 else None)
+
+    if should_emit_events() and event_logger:
+        emit_event(MessageEvent(content=model_input.get("prompt")), event_logger)
+    else:
+        set_input_attributes(span, args, kwargs)
+
+
+@dont_throw
+def _handle_response(span, event_logger, response):
+    if should_emit_events() and event_logger:
+        emit_choice_events(response, event_logger)
+    else:
+        set_response_attributes(span, response)
+
+    if span.is_recording():
+        span.set_status(Status(StatusCode.OK))
+
+
+def _with_tracer_wrapper(func):
+    """Helper for providing tracer for wrapper functions."""
+
+    def _with_tracer(tracer, event_logger, to_wrap):
+        def wrapper(wrapped, instance, args, kwargs):
+            return func(tracer, event_logger, to_wrap, wrapped, instance, args, kwargs)
+
+        return wrapper
+
+    return _with_tracer
+
+
+@_with_tracer_wrapper
+def _wrap(
+    tracer,
+    event_logger,
+    to_wrap,
+    wrapped,
+    instance,
+    args,
+    kwargs,
+):
+    """Instruments and calls every function defined in TO_WRAP."""
+    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
+        return wrapped(*args, **kwargs)
+
+    name = to_wrap.get("span_name")
+    span = tracer.start_span(
+        name,
+        kind=SpanKind.CLIENT,
+        attributes={
+            GenAIAttributes.GEN_AI_SYSTEM: "Replicate",
+            SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
+        },
+    )
+
+    _handle_request(span, event_logger, args, kwargs)
+
+    response = wrapped(*args, **kwargs)
+
+    if response:
+        if is_streaming_response(response):
+            return _build_from_streaming_response(span, event_logger, response)
+        else:
+            _handle_response(span, event_logger, response)
+
+    span.end()
+    return response
+
+
+class ReplicateInstrumentor(BaseInstrumentor):
+    """An instrumentor for Replicate's client library."""
+
+    def __init__(self, exception_logger=None, use_legacy_attributes=True):
+        super().__init__()
+        Config.exception_logger = exception_logger
+        Config.use_legacy_attributes = use_legacy_attributes
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, __version__, tracer_provider)
+
+        event_logger = None
+        if not Config.use_legacy_attributes:
+            logger_provider = kwargs.get("logger_provider")
+            event_logger = get_logger(
+                __name__, __version__, logger_provider=logger_provider
+            )
+
+        for wrapper_method in WRAPPED_METHODS:
+            wrap_function_wrapper(
+                wrapper_method.get("module"),
+                wrapper_method.get("method"),
+                _wrap(tracer, event_logger, wrapper_method),
+            )
+
+    def _uninstrument(self, **kwargs):
+        import replicate
+
+        for wrapper_method in WRAPPED_METHODS:
+            unwrap(replicate, wrapper_method.get("method", ""))

opentelemetry_instrumentation_replicate-0.49.1/opentelemetry/instrumentation/replicate/config.py

@@ -0,0 +1,3 @@
+class Config:
+    exception_logger = None
+    use_legacy_attributes = True

opentelemetry_instrumentation_replicate-0.49.1/opentelemetry/instrumentation/replicate/event_emitter.py

@@ -0,0 +1,143 @@
+from dataclasses import asdict
+from enum import Enum
+from typing import Union
+
+from opentelemetry._logs import Logger, LogRecord
+from opentelemetry.instrumentation.replicate.event_models import (
+    ChoiceEvent,
+    MessageEvent,
+)
+from opentelemetry.instrumentation.replicate.utils import (
+    dont_throw,
+    should_emit_events,
+    should_send_prompts,
+)
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
+
+from replicate.prediction import Prediction
+
+
+class Roles(Enum):
+    USER = "user"
+    ASSISTANT = "assistant"
+    SYSTEM = "system"
+    TOOL = "tool"
+
+
+VALID_MESSAGE_ROLES = {role.value for role in Roles}
+"""The valid roles for naming the message event."""
+
+EVENT_ATTRIBUTES = {GenAIAttributes.GEN_AI_SYSTEM: "replicate"}
+"""The attributes to be used for the event."""
+
+
+@dont_throw
+def emit_choice_events(
+    response: Union[str, list, Prediction], event_logger: Union[Logger, None]
+):
+    # Handle replicate.run responses
+    if isinstance(response, list):
+        for i, generation in enumerate(response):
+            emit_event(
+                ChoiceEvent(
+                    index=i, message={"content": generation, "role": "assistant"}
+                ),
+                event_logger,
+            )
+    # Handle replicate.predictions.create responses
+    elif isinstance(response, Prediction):
+        emit_event(
+            ChoiceEvent(
+                index=0, message={"content": response.output, "role": "assistant"}
+            ),
+            event_logger,
+        )
+    # Handle replicate.stream responses built from _build_from_streaming_response
+    elif isinstance(response, str):
+        emit_event(
+            ChoiceEvent(index=0, message={"content": response, "role": "assistant"}),
+            event_logger,
+        )
+    else:
+        raise ValueError(
+            "It wasn't possible to emit the choice events due to an unsupported response type"
+        )
+
+
+def emit_event(
+    event: Union[MessageEvent, ChoiceEvent], event_logger: Union[Logger, None]
+) -> None:
+    """
+    Emit an event to the OpenTelemetry SDK.
+
+    Args:
+        event: The event to emit.
+    """
+    if not should_emit_events() or event_logger is None:
+        return
+
+    if isinstance(event, MessageEvent):
+        _emit_message_event(event, event_logger)
+    elif isinstance(event, ChoiceEvent):
+        _emit_choice_event(event, event_logger)
+    else:
+        raise TypeError("Unsupported event type")
+
+
+def _emit_message_event(event: MessageEvent, event_logger: Logger) -> None:
+    body = asdict(event)
+
+    if event.role in VALID_MESSAGE_ROLES:
+        name = "gen_ai.{}.message".format(event.role)
+        # According to the semantic conventions, the role is conditionally required if available
+        # and not equal to the "role" in the message name. So, remove the role from the body if
+        # it is the same as the in the event name.
+        body.pop("role", None)
+    else:
+        name = "gen_ai.user.message"
+
+    # According to the semantic conventions, only the assistant role has tool call
+    if event.role != Roles.ASSISTANT.value and event.tool_calls is not None:
+        del body["tool_calls"]
+    elif event.tool_calls is None:
+        del body["tool_calls"]
+
+    if not should_send_prompts():
+        del body["content"]
+        if body.get("tool_calls") is not None:
+            for tool_call in body["tool_calls"]:
+                tool_call["function"].pop("arguments", None)
+
+    log_record = LogRecord(
+        body=body,
+        attributes=EVENT_ATTRIBUTES,
+        event_name=name
+    )
+    event_logger.emit(log_record)
+
+
+def _emit_choice_event(event: ChoiceEvent, event_logger: Logger) -> None:
+    body = asdict(event)
+    if event.message["role"] == Roles.ASSISTANT.value:
+        # According to the semantic conventions, the role is conditionally required if available
+        # and not equal to "assistant", so remove the role from the body if it is "assistant".
+        body["message"].pop("role", None)
+
+    if event.tool_calls is None:
+        del body["tool_calls"]
+
+    if not should_send_prompts():
+        body["message"].pop("content", None)
+        if body.get("tool_calls") is not None:
+            for tool_call in body["tool_calls"]:
+                tool_call["function"].pop("arguments", None)
+
+    log_record = LogRecord(
+        body=body,
+        attributes=EVENT_ATTRIBUTES,
+        event_name="gen_ai.choice"
+
+    )
+    event_logger.emit(log_record)

opentelemetry_instrumentation_replicate-0.49.1/opentelemetry/instrumentation/replicate/event_models.py

@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+from typing import Any, List, Literal, Optional, TypedDict
+
+
+class _FunctionToolCall(TypedDict):
+    function_name: str
+    arguments: Optional[dict[str, Any]]
+
+
+class ToolCall(TypedDict):
+    """Represents a tool call in the AI model."""
+
+    id: str
+    function: _FunctionToolCall
+    type: Literal["function"]
+
+
+class CompletionMessage(TypedDict):
+    """Represents a message in the AI model."""
+
+    content: Any
+    role: str = "assistant"
+
+
+@dataclass
+class MessageEvent:
+    """Represents an input event for the AI model."""
+
+    content: Any
+    role: str = "user"
+    tool_calls: Optional[List[ToolCall]] = None
+
+
+@dataclass
+class ChoiceEvent:
+    """Represents a completion event for the AI model."""
+
+    index: int
+    message: CompletionMessage
+    finish_reason: str = "unknown"
+    tool_calls: Optional[List[ToolCall]] = None

opentelemetry_instrumentation_replicate-0.49.1/opentelemetry/instrumentation/replicate/span_utils.py

@@ -0,0 +1,63 @@
+from opentelemetry.instrumentation.replicate.utils import (
+    dont_throw,
+    should_send_prompts,
+)
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAIAttributes,
+)
+
+
+def _set_span_attribute(span, name, value):
+    if value is not None:
+        if value != "":
+            span.set_attribute(name, value)
+    return
+
+
+@dont_throw
+def set_input_attributes(span, args, kwargs):
+    if not span.is_recording():
+        return
+
+    input_attribute = kwargs.get("input")
+    if should_send_prompts():
+        _set_span_attribute(
+            span, f"{GenAIAttributes.GEN_AI_PROMPT}.0.user", input_attribute.get("prompt")
+        )
+
+
+@dont_throw
+def set_model_input_attributes(span, args, kwargs):
+    if not span.is_recording():
+        return
+
+    if args is not None and len(args) > 0:
+        _set_span_attribute(span, GenAIAttributes.GEN_AI_REQUEST_MODEL, args[0])
+    elif kwargs.get("version"):
+        _set_span_attribute(
+            span, GenAIAttributes.GEN_AI_REQUEST_MODEL, kwargs.get("version").id
+        )
+    else:
+        _set_span_attribute(span, GenAIAttributes.GEN_AI_REQUEST_MODEL, "unknown")
+
+    input_attribute = kwargs.get("input")
+
+    _set_span_attribute(
+        span, GenAIAttributes.GEN_AI_REQUEST_TEMPERATURE, input_attribute.get("temperature")
+    )
+    _set_span_attribute(
+        span, GenAIAttributes.GEN_AI_REQUEST_TOP_P, input_attribute.get("top_p")
+    )
+
+
+@dont_throw
+def set_response_attributes(span, response):
+    if should_send_prompts():
+        if isinstance(response, list):
+            for index, item in enumerate(response):
+                prefix = f"{GenAIAttributes.GEN_AI_COMPLETION}.{index}"
+                _set_span_attribute(span, f"{prefix}.content", item)
+        elif isinstance(response, str):
+            _set_span_attribute(
+                span, f"{GenAIAttributes.GEN_AI_COMPLETION}.0.content", response
+            )

opentelemetry_instrumentation_replicate-0.49.1/opentelemetry/instrumentation/replicate/utils.py

@@ -0,0 +1,48 @@
+import logging
+import os
+import traceback
+
+from opentelemetry import context as context_api
+from opentelemetry.instrumentation.replicate.config import Config
+
+TRACELOOP_TRACE_CONTENT = "TRACELOOP_TRACE_CONTENT"
+
+
+def should_send_prompts():
+    return (
+        os.getenv(TRACELOOP_TRACE_CONTENT) or "true"
+    ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
+
+
+def dont_throw(func):
+    """
+    A decorator that wraps the passed in function and logs exceptions instead of throwing them.
+
+    @param func: The function to wrap
+    @return: The wrapper function
+    """
+    # Obtain a logger specific to the function's module
+    logger = logging.getLogger(func.__module__)
+
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            logger.debug(
+                "OpenLLMetry failed to trace in %s, error: %s",
+                func.__name__,
+                traceback.format_exc(),
+            )
+            if Config.exception_logger:
+                Config.exception_logger(e)
+
+    return wrapper
+
+
+def should_emit_events() -> bool:
+    """
+    Checks if the instrumentation isn't using the legacy attributes
+    and if the event logger is not None.
+    """
+
+    return not Config.use_legacy_attributes

opentelemetry_instrumentation_replicate-0.49.1/opentelemetry/instrumentation/replicate/version.py

@@ -0,0 +1 @@
+__version__ = "0.49.1"

{opentelemetry_instrumentation_replicate-0.16.0 → opentelemetry_instrumentation_replicate-0.49.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.coverage.run]
 branch = true
-source = [ "opentelemetry/instrumentation/replicate" ]
+source = ["opentelemetry/instrumentation/replicate"]
 
 [tool.coverage.report]
 exclude_lines = ['if TYPE_CHECKING:']
@@ -8,9 +8,9 @@ show_missing = true
 
 [tool.poetry]
 name = "opentelemetry-instrumentation-replicate"
-version = "0.16.0"
+version = "0.49.1"
 description = "OpenTelemetry Replicate instrumentation"
-authors = [ "Kartik Prajapati <kartik@ktklab.org>" ]
+authors = ["Kartik Prajapati <kartik@ktklab.org>"]
 repository = "https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-replicate"
 license = 'Apache-2.0'
 readme = 'README.md'
@@ -20,24 +20,24 @@ include = "opentelemetry/instrumentation/replicate"
 
 [tool.poetry.dependencies]
 python = ">=3.9,<4"
-opentelemetry-api = "^1.24.0"
-opentelemetry-instrumentation = "^0.45b0"
-opentelemetry-semantic-conventions = "^0.45b0"
-opentelemetry-semantic-conventions-ai = "0.1.1"
+opentelemetry-api = "^1.38.0"
+opentelemetry-instrumentation = ">=0.59b0"
+opentelemetry-semantic-conventions = ">=0.59b0"
+opentelemetry-semantic-conventions-ai = "^0.4.13"
 
 [tool.poetry.group.dev.dependencies]
-autopep8 = "2.1.0"
+autopep8 = "^2.2.0"
 flake8 = "7.0.0"
-pytest = "8.1.1"
+pytest = "^8.2.2"
 pytest-sugar = "1.0.0"
 
 [tool.poetry.group.test.dependencies]
-pytest = "8.1.1"
+pytest = "^8.2.2"
 pytest-sugar = "1.0.0"
 vcrpy = "^6.0.1"
 pytest-recording = "^0.13.1"
-opentelemetry-sdk = "^1.23.0"
-replicate = ">=0.23.1,<0.26.0"
+opentelemetry-sdk = "^1.38.0"
+replicate = ">=0.23.1,<0.27.0"
 
 [build-system]
 requires = ["poetry-core"]

opentelemetry_instrumentation_replicate-0.16.0/opentelemetry/instrumentation/replicate/__init__.py

@@ -1,216 +0,0 @@
-"""OpenTelemetry Replicate instrumentation"""
-import logging
-import os
-import types
-from typing import Collection
-from wrapt import wrap_function_wrapper
-
-from opentelemetry import context as context_api
-from opentelemetry.trace import get_tracer, SpanKind
-from opentelemetry.trace.status import Status, StatusCode
-
-from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
-from opentelemetry.instrumentation.utils import (
-    _SUPPRESS_INSTRUMENTATION_KEY,
-    unwrap,
-)
-
-from opentelemetry.semconv.ai import SpanAttributes, LLMRequestTypeValues
-from opentelemetry.instrumentation.replicate.version import __version__
-
-logger = logging.getLogger(__name__)
-
-_instruments = ("replicate >= 0.22.0",)
-
-WRAPPED_METHODS = [
-    {
-        "module": "replicate",
-        "method": "run",
-        "span_name": "replicate.run",
-    },
-    {
-        "module": "replicate",
-        "method": "stream",
-        "span_name": "replicate.stream",
-    },
-    {
-        "module": "replicate",
-        "method": "predictions.create",
-        "span_name": "replicate.predictions.create",
-    },
-]
-
-
-def should_send_prompts():
-    return (
-        os.getenv("TRACELOOP_TRACE_CONTENT") or "true"
-    ).lower() == "true" or context_api.get_value("override_enable_content_tracing")
-
-
-def is_streaming_response(response):
-    return isinstance(response, types.GeneratorType)
-
-
-def _set_span_attribute(span, name, value):
-    if value is not None:
-        if value != "":
-            span.set_attribute(name, value)
-    return
-
-
-input_attribute_map = {
-    "prompt": f"{SpanAttributes.LLM_PROMPTS}.0.user",
-    "temperature": SpanAttributes.LLM_TEMPERATURE,
-    "top_p": SpanAttributes.LLM_TOP_P,
-}
-
-
-def _set_input_attributes(span, args, kwargs):
-    if args is not None and len(args) > 0:
-        _set_span_attribute(span, SpanAttributes.LLM_REQUEST_MODEL, args[0])
-    elif kwargs.get("version"):
-        _set_span_attribute(
-            span, SpanAttributes.LLM_REQUEST_MODEL, kwargs.get("version").id
-        )
-    else:
-        _set_span_attribute(span, SpanAttributes.LLM_REQUEST_MODEL, "unknown")
-
-    input_attribute = kwargs.get("input")
-    for key in input_attribute:
-        if key in input_attribute_map:
-            if key == "prompt" and not should_send_prompts():
-                continue
-            _set_span_attribute(
-                span,
-                input_attribute_map.get(key, f"llm.request.{key}"),
-                input_attribute.get(key),
-            )
-    return
-
-
-def _set_span_completions(span, response):
-    if response is None:
-        return
-    if isinstance(response, list):
-        for index, item in enumerate(response):
-            prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{index}"
-            _set_span_attribute(span, f"{prefix}.content", item)
-    elif isinstance(response, str):
-        _set_span_attribute(
-            span, f"{SpanAttributes.LLM_COMPLETIONS}.0.content", response
-        )
-
-
-def _set_response_attributes(span, response):
-    if should_send_prompts():
-        if isinstance(response, list):
-            for index, item in enumerate(response):
-                prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{index}"
-                _set_span_attribute(span, f"{prefix}.content", item)
-        elif isinstance(response, str):
-            _set_span_attribute(
-                span, f"{SpanAttributes.LLM_COMPLETIONS}.0.content", response
-            )
-    return
-
-
-def _build_from_streaming_response(span, response):
-    complete_response = ""
-    for item in response:
-        item_to_yield = item
-        complete_response += str(item)
-
-        yield item_to_yield
-
-    _set_response_attributes(span, complete_response)
-
-    span.set_status(Status(StatusCode.OK))
-    span.end()
-
-
-def _handle_request(span, args, kwargs):
-    try:
-        if span.is_recording():
-            _set_input_attributes(span, args, kwargs)
-
-    except Exception as ex:  # pylint: disable=broad-except
-        logger.warning(
-            "Failed to set input attributes for replicate span, error: %s", str(ex)
-        )
-
-
-def _handle_response(span, response):
-    try:
-        if span.is_recording():
-            _set_response_attributes(span, response)
-
-    except Exception as ex:  # pylint: disable=broad-except
-        logger.warning(
-            "Failed to set response attributes for replicate span, error: %s",
-            str(ex),
-        )
-    if span.is_recording():
-        span.set_status(Status(StatusCode.OK))
-
-
-def _with_tracer_wrapper(func):
-    """Helper for providing tracer for wrapper functions."""
-
-    def _with_tracer(tracer, to_wrap):
-        def wrapper(wrapped, instance, args, kwargs):
-            return func(tracer, to_wrap, wrapped, instance, args, kwargs)
-
-        return wrapper
-
-    return _with_tracer
-
-
-@_with_tracer_wrapper
-def _wrap(tracer, to_wrap, wrapped, instance, args, kwargs):
-    """Instruments and calls every function defined in TO_WRAP."""
-    if context_api.get_value(_SUPPRESS_INSTRUMENTATION_KEY):
-        return wrapped(*args, **kwargs)
-
-    name = to_wrap.get("span_name")
-    span = tracer.start_span(
-        name,
-        kind=SpanKind.CLIENT,
-        attributes={
-            SpanAttributes.LLM_VENDOR: "Replicate",
-            SpanAttributes.LLM_REQUEST_TYPE: LLMRequestTypeValues.COMPLETION.value,
-        },
-    )
-
-    _handle_request(span, args, kwargs)
-
-    response = wrapped(*args, **kwargs)
-
-    if response:
-        if is_streaming_response(response):
-            return _build_from_streaming_response(span, response)
-        else:
-            _handle_response(span, response)
-
-    span.end()
-    return response
-
-
-class ReplicateInstrumentor(BaseInstrumentor):
-    """An instrumentor for Replicate's client library."""
-
-    def instrumentation_dependencies(self) -> Collection[str]:
-        return _instruments
-
-    def _instrument(self, **kwargs):
-        tracer_provider = kwargs.get("tracer_provider")
-        tracer = get_tracer(__name__, __version__, tracer_provider)
-        for wrapper_method in WRAPPED_METHODS:
-            wrap_function_wrapper(
-                wrapper_method.get("module"),
-                wrapper_method.get("method"),
-                _wrap(tracer, wrapper_method),
-            )
-
-    def _uninstrument(self, **kwargs):
-        for wrapper_method in WRAPPED_METHODS:
-            unwrap(wrapper_method.get("module"), wrapper_method.get("method", ""))

opentelemetry_instrumentation_replicate-0.16.0/opentelemetry/instrumentation/replicate/version.py

@@ -1 +0,0 @@
-__version__ = "0.16.0"