lmnr 0.7.10__py3-none-any.whl → 0.7.12__py3-none-any.whl

lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/__init__.py

@@ -13,6 +13,7 @@ from .event_emitter import (
 )
 from .span_utils import (
     aset_input_attributes,
+    aset_response_attributes,
     set_response_attributes,
 )
 from .streaming import (
@@ -21,6 +22,7 @@ from .streaming import (
 )
 from .utils import (
     acount_prompt_tokens_from_request,
+    ashared_metrics_attributes,
     count_prompt_tokens_from_request,
     dont_throw,
     error_metrics_attributes,
@@ -85,6 +87,46 @@ WRAPPED_METHODS = [
         "method": "stream",
         "span_name": "anthropic.chat",
     },
+    # Beta API methods (regular Anthropic SDK)
+    {
+        "package": "anthropic.resources.beta.messages.messages",
+        "object": "Messages",
+        "method": "create",
+        "span_name": "anthropic.chat",
+    },
+    {
+        "package": "anthropic.resources.beta.messages.messages",
+        "object": "Messages",
+        "method": "stream",
+        "span_name": "anthropic.chat",
+    },
+    # read note on async with above
+    {
+        "package": "anthropic.resources.beta.messages.messages",
+        "object": "AsyncMessages",
+        "method": "stream",
+        "span_name": "anthropic.chat",
+    },
+    # Beta API methods (Bedrock SDK)
+    {
+        "package": "anthropic.lib.bedrock._beta_messages",
+        "object": "Messages",
+        "method": "create",
+        "span_name": "anthropic.chat",
+    },
+    {
+        "package": "anthropic.lib.bedrock._beta_messages",
+        "object": "Messages",
+        "method": "stream",
+        "span_name": "anthropic.chat",
+    },
+    # read note on async with above
+    {
+        "package": "anthropic.lib.bedrock._beta_messages",
+        "object": "AsyncMessages",
+        "method": "stream",
+        "span_name": "anthropic.chat",
+    },
 ]
 
 WRAPPED_AMETHODS = [
@@ -100,6 +142,20 @@ WRAPPED_AMETHODS = [
         "method": "create",
         "span_name": "anthropic.chat",
     },
+    # Beta API async methods (regular Anthropic SDK)
+    {
+        "package": "anthropic.resources.beta.messages.messages",
+        "object": "AsyncMessages",
+        "method": "create",
+        "span_name": "anthropic.chat",
+    },
+    # Beta API async methods (Bedrock SDK)
+    {
+        "package": "anthropic.lib.bedrock._beta_messages",
+        "object": "AsyncMessages",
+        "method": "create",
+        "span_name": "anthropic.chat",
+    },
 ]
 
 
@@ -134,13 +190,20 @@ async def _aset_token_usage(
     token_histogram: Histogram = None,
     choice_counter: Counter = None,
 ):
-    if not isinstance(response, dict):
-        response = response.__dict__
+    # Handle with_raw_response wrapped responses first
+    if response and hasattr(response, "parse") and callable(response.parse):
+        try:
+            response = response.parse()
+        except Exception as e:
+            logger.debug(f"Failed to parse with_raw_response: {e}")
+            return
+
+    usage = getattr(response, "usage", None) if response else None
 
-    if usage := response.get("usage"):
-        prompt_tokens = usage.input_tokens
-        cache_read_tokens = dict(usage).get("cache_read_input_tokens", 0) or 0
-        cache_creation_tokens = dict(usage).get("cache_creation_input_tokens", 0) or 0
+    if usage:
+        prompt_tokens = getattr(usage, "input_tokens", 0)
+        cache_read_tokens = getattr(usage, "cache_read_input_tokens", 0) or 0
+        cache_creation_tokens = getattr(usage, "cache_creation_input_tokens", 0) or 0
     else:
         prompt_tokens = await acount_prompt_tokens_from_request(anthropic, request)
         cache_read_tokens = 0
@@ -157,19 +220,17 @@ async def _aset_token_usage(
             },
         )
 
-    if usage := response.get("usage"):
-        completion_tokens = usage.output_tokens
+    if usage:
+        completion_tokens = getattr(usage, "output_tokens", 0)
     else:
         completion_tokens = 0
         if hasattr(anthropic, "count_tokens"):
-            if response.get("completion"):
-                completion_tokens = await anthropic.count_tokens(
-                    response.get("completion")
-                )
-            elif response.get("content"):
-                completion_tokens = await anthropic.count_tokens(
-                    response.get("content")[0].text
-                )
+            completion_attr = getattr(response, "completion", None)
+            content_attr = getattr(response, "content", None)
+            if completion_attr:
+                completion_tokens = await anthropic.count_tokens(completion_attr)
+            elif content_attr:
+                completion_tokens = await anthropic.count_tokens(content_attr[0].text)
 
     if (
         token_histogram
@@ -187,9 +248,11 @@ async def _aset_token_usage(
     total_tokens = input_tokens + completion_tokens
 
     choices = 0
-    if isinstance(response.get("content"), list):
-        choices = len(response.get("content"))
-    elif response.get("completion"):
+    content_attr = getattr(response, "content", None)
+    completion_attr = getattr(response, "completion", None)
+    if isinstance(content_attr, list):
+        choices = len(content_attr)
+    elif completion_attr:
         choices = 1
 
     if choices > 0 and choice_counter:
@@ -197,7 +260,9 @@ async def _aset_token_usage(
             choices,
             attributes={
                 **metric_attributes,
-                SpanAttributes.LLM_RESPONSE_STOP_REASON: response.get("stop_reason"),
+                SpanAttributes.LLM_RESPONSE_STOP_REASON: getattr(
+                    response, "stop_reason", None
+                ),
             },
         )
 
@@ -227,13 +292,20 @@ def _set_token_usage(
     token_histogram: Histogram = None,
     choice_counter: Counter = None,
 ):
-    if not isinstance(response, dict):
-        response = response.__dict__
+    # Handle with_raw_response wrapped responses first
+    if response and hasattr(response, "parse") and callable(response.parse):
+        try:
+            response = response.parse()
+        except Exception as e:
+            logger.debug(f"Failed to parse with_raw_response: {e}")
+            return
 
-    if usage := response.get("usage"):
-        prompt_tokens = usage.input_tokens
-        cache_read_tokens = dict(usage).get("cache_read_input_tokens", 0) or 0
-        cache_creation_tokens = dict(usage).get("cache_creation_input_tokens", 0) or 0
+    usage = getattr(response, "usage", None) if response else None
+
+    if usage:
+        prompt_tokens = getattr(usage, "input_tokens", 0)
+        cache_read_tokens = getattr(usage, "cache_read_input_tokens", 0) or 0
+        cache_creation_tokens = getattr(usage, "cache_creation_input_tokens", 0) or 0
     else:
         prompt_tokens = count_prompt_tokens_from_request(anthropic, request)
         cache_read_tokens = 0
@@ -250,17 +322,17 @@ def _set_token_usage(
             },
         )
 
-    if usage := response.get("usage"):
-        completion_tokens = usage.output_tokens
+    if usage:
+        completion_tokens = getattr(usage, "output_tokens", 0)
     else:
         completion_tokens = 0
         if hasattr(anthropic, "count_tokens"):
-            if response.get("completion"):
-                completion_tokens = anthropic.count_tokens(response.get("completion"))
-            elif response.get("content"):
-                completion_tokens = anthropic.count_tokens(
-                    response.get("content")[0].text
-                )
+            completion_attr = getattr(response, "completion", None)
+            content_attr = getattr(response, "content", None)
+            if completion_attr:
+                completion_tokens = anthropic.count_tokens(completion_attr)
+            elif content_attr:
+                completion_tokens = anthropic.count_tokens(content_attr[0].text)
 
     if (
         token_histogram
@@ -274,21 +346,23 @@ def _set_token_usage(
                 SpanAttributes.LLM_TOKEN_TYPE: "output",
             },
         )
-
     total_tokens = input_tokens + completion_tokens
-
     choices = 0
-    if isinstance(response.get("content"), list):
-        choices = len(response.get("content"))
-    elif response.get("completion"):
-        choices = 1
 
+    content_attr = getattr(response, "content", None)
+    completion_attr = getattr(response, "completion", None)
+    if isinstance(content_attr, list):
+        choices = len(content_attr)
+    elif completion_attr:
+        choices = 1
     if choices > 0 and choice_counter:
         choice_counter.add(
             choices,
             attributes={
                 **metric_attributes,
-                SpanAttributes.LLM_RESPONSE_STOP_REASON: response.get("stop_reason"),
+                SpanAttributes.LLM_RESPONSE_STOP_REASON: getattr(
+                    response, "stop_reason", None
+                ),
             },
         )
 
@@ -398,6 +472,17 @@ def _handle_response(span: Span, event_logger: Optional[EventLogger], response):
         set_response_attributes(span, response)
 
 
+@dont_throw
+async def _ahandle_response(span: Span, event_logger: Optional[EventLogger], response):
+    if should_emit_events():
+        emit_response_events(event_logger, response)
+    else:
+        if not span.is_recording():
+            return
+
+        await aset_response_attributes(span, response)
+
+
 @_with_chat_telemetry_wrapper
 def _wrap(
     tracer: Tracer,
@@ -612,7 +697,7 @@ async def _awrap(
                 kwargs,
             )
     elif response:
-        metric_attributes = shared_metrics_attributes(response)
+        metric_attributes = await ashared_metrics_attributes(response)
 
         if duration_histogram:
             duration = time.time() - start_time
@@ -621,7 +706,7 @@ async def _awrap(
                 attributes=metric_attributes,
             )
 
-        _handle_response(span, event_logger, response)
+        await _ahandle_response(span, event_logger, response)
 
         if span.is_recording():
             await _aset_token_usage(
@@ -716,6 +801,13 @@ class AnthropicInstrumentor(BaseInstrumentor):
                         wrapped_method,
                     ),
                 )
+                logger.debug(
+                    f"Successfully wrapped {wrap_package}.{wrap_object}.{wrap_method}"
+                )
+            except Exception as e:
+                logger.debug(
+                    f"Failed to wrap {wrap_package}.{wrap_object}.{wrap_method}: {e}"
+                )
             except ModuleNotFoundError:
                 pass  # that's ok, we don't want to fail if some methods do not exist
 
@@ -737,7 +829,7 @@ class AnthropicInstrumentor(BaseInstrumentor):
                         wrapped_method,
                     ),
                 )
-            except ModuleNotFoundError:
+            except Exception:
                 pass  # that's ok, we don't want to fail if some methods do not exist
 
     def _uninstrument(self, **kwargs):

lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/span_utils.py

@@ -8,6 +8,9 @@ from .utils import (
     dont_throw,
     model_as_dict,
     should_send_prompts,
+    _extract_response_data,
+    _aextract_response_data,
+    set_span_attribute,
 )
 from opentelemetry.semconv._incubating.attributes.gen_ai_attributes import (
     GEN_AI_RESPONSE_ID,
@@ -165,6 +168,73 @@ async def aset_input_attributes(span, kwargs):
                     )
 
 
+async def _aset_span_completions(span, response):
+    if not should_send_prompts():
+        return
+
+    response = await _aextract_response_data(response)
+    index = 0
+    prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{index}"
+    set_span_attribute(span, f"{prefix}.finish_reason", response.get("stop_reason"))
+    if response.get("role"):
+        set_span_attribute(span, f"{prefix}.role", response.get("role"))
+
+    if response.get("completion"):
+        set_span_attribute(span, f"{prefix}.content", response.get("completion"))
+    elif response.get("content"):
+        tool_call_index = 0
+        text = ""
+        for content in response.get("content"):
+            content_block_type = content.type
+            # usually, Antrhopic responds with just one text block,
+            # but the API allows for multiple text blocks, so concatenate them
+            if content_block_type == "text" and hasattr(content, "text"):
+                text += content.text
+            elif content_block_type == "thinking":
+                content = dict(content)
+                # override the role to thinking
+                set_span_attribute(
+                    span,
+                    f"{prefix}.role",
+                    "thinking",
+                )
+                set_span_attribute(
+                    span,
+                    f"{prefix}.content",
+                    content.get("thinking"),
+                )
+                # increment the index for subsequent content blocks
+                index += 1
+                prefix = f"{SpanAttributes.LLM_COMPLETIONS}.{index}"
+                # set the role to the original role on the next completions
+                set_span_attribute(
+                    span,
+                    f"{prefix}.role",
+                    response.get("role"),
+                )
+            elif content_block_type == "tool_use":
+                content = dict(content)
+                set_span_attribute(
+                    span,
+                    f"{prefix}.tool_calls.{tool_call_index}.id",
+                    content.get("id"),
+                )
+                set_span_attribute(
+                    span,
+                    f"{prefix}.tool_calls.{tool_call_index}.name",
+                    content.get("name"),
+                )
+                tool_arguments = content.get("input")
+                if tool_arguments is not None:
+                    set_span_attribute(
+                        span,
+                        f"{prefix}.tool_calls.{tool_call_index}.arguments",
+                        json.dumps(tool_arguments),
+                    )
+                tool_call_index += 1
+        set_span_attribute(span, f"{prefix}.content", text)
+
+
 def _set_span_completions(span, response):
     if not should_send_prompts():
         return
@@ -233,11 +303,30 @@ def _set_span_completions(span, response):
 
 
 @dont_throw
-def set_response_attributes(span, response):
-    from .utils import set_span_attribute
+async def aset_response_attributes(span, response):
+    response = await _aextract_response_data(response)
+    set_span_attribute(span, SpanAttributes.LLM_RESPONSE_MODEL, response.get("model"))
+    set_span_attribute(span, GEN_AI_RESPONSE_ID, response.get("id"))
 
-    if not isinstance(response, dict):
-        response = response.__dict__
+    if response.get("usage"):
+        prompt_tokens = response.get("usage").input_tokens
+        completion_tokens = response.get("usage").output_tokens
+        set_span_attribute(span, SpanAttributes.LLM_USAGE_PROMPT_TOKENS, prompt_tokens)
+        set_span_attribute(
+            span, SpanAttributes.LLM_USAGE_COMPLETION_TOKENS, completion_tokens
+        )
+        set_span_attribute(
+            span,
+            SpanAttributes.LLM_USAGE_TOTAL_TOKENS,
+            prompt_tokens + completion_tokens,
+        )
+
+    await _aset_span_completions(span, response)
+
+
+@dont_throw
+def set_response_attributes(span, response):
+    response = _extract_response_data(response)
     set_span_attribute(span, SpanAttributes.LLM_RESPONSE_MODEL, response.get("model"))
     set_span_attribute(span, GEN_AI_RESPONSE_ID, response.get("id"))
 
@@ -262,8 +351,6 @@ def set_streaming_response_attributes(span, complete_response_events):
     if not should_send_prompts():
         return
 
-    from .utils import set_span_attribute
-
     if not span.is_recording() or not complete_response_events:
         return
 

lmnr/opentelemetry_lib/opentelemetry/instrumentation/anthropic/utils.py

@@ -61,17 +61,169 @@ def dont_throw(func):
     return async_wrapper if asyncio.iscoroutinefunction(func) else sync_wrapper
 
 
+async def _aextract_response_data(response):
+    """Async version of _extract_response_data that can await coroutines."""
+    import inspect
+
+    # If we get a coroutine, await it
+    if inspect.iscoroutine(response):
+        try:
+            response = await response
+        except Exception as e:
+            import logging
+
+            logger = logging.getLogger(__name__)
+            logger.debug(f"Failed to await coroutine response: {e}")
+            return {}
+
+    if isinstance(response, dict):
+        return response
+
+    # Handle with_raw_response wrapped responses
+    if hasattr(response, "parse") and callable(response.parse):
+        try:
+            # For with_raw_response, parse() gives us the actual response object
+            parsed_response = response.parse()
+            if not isinstance(parsed_response, dict):
+                parsed_response = parsed_response.__dict__
+            return parsed_response
+        except Exception as e:
+            import logging
+
+            logger = logging.getLogger(__name__)
+            logger.debug(
+                f"Failed to parse response: {e}, response type: {type(response)}"
+            )
+
+    # Fallback to __dict__ for regular response objects
+    if hasattr(response, "__dict__"):
+        response_dict = response.__dict__
+        return response_dict
+
+    return {}
+
+
+def _extract_response_data(response):
+    """Extract the actual response data from both regular and with_raw_response wrapped responses."""
+    import inspect
+
+    # If we get a coroutine, we cannot process it in sync context
+    if inspect.iscoroutine(response):
+        import logging
+
+        logger = logging.getLogger(__name__)
+        logger.warning(
+            f"_extract_response_data received coroutine {response} - response processing skipped"
+        )
+        return {}
+
+    if isinstance(response, dict):
+        return response
+
+    # Handle with_raw_response wrapped responses
+    if hasattr(response, "parse") and callable(response.parse):
+        try:
+            # For with_raw_response, parse() gives us the actual response object
+            parsed_response = response.parse()
+            if not isinstance(parsed_response, dict):
+                parsed_response = parsed_response.__dict__
+            return parsed_response
+        except Exception as e:
+            import logging
+
+            logger = logging.getLogger(__name__)
+            logger.debug(
+                f"Failed to parse response: {e}, response type: {type(response)}"
+            )
+
+    # Fallback to __dict__ for regular response objects
+    if hasattr(response, "__dict__"):
+        response_dict = response.__dict__
+        return response_dict
+
+    return {}
+
+
+@dont_throw
+async def ashared_metrics_attributes(response):
+    import inspect
+
+    # If we get a coroutine, await it
+    if inspect.iscoroutine(response):
+        try:
+            response = await response
+        except Exception as e:
+            import logging
+
+            logger = logging.getLogger(__name__)
+            logger.debug(f"Failed to await coroutine response: {e}")
+            response = None
+
+    # If it's already a dict (e.g., from streaming), use it directly
+    if isinstance(response, dict):
+        model = response.get("model")
+    else:
+        # Handle with_raw_response wrapped responses first
+        if response and hasattr(response, "parse") and callable(response.parse):
+            try:
+                response = response.parse()
+            except Exception as e:
+                import logging
+
+                logger = logging.getLogger(__name__)
+                logger.debug(f"Failed to parse with_raw_response: {e}")
+                response = None
+
+        # Safely get model attribute without extracting the whole object
+        model = getattr(response, "model", None) if response else None
+
+    common_attributes = Config.get_common_metrics_attributes()
+
+    return {
+        **common_attributes,
+        GEN_AI_SYSTEM: GEN_AI_SYSTEM_ANTHROPIC,
+        SpanAttributes.LLM_RESPONSE_MODEL: model,
+    }
+
+
 @dont_throw
 def shared_metrics_attributes(response):
-    if not isinstance(response, dict):
-        response = response.__dict__
+    import inspect
+
+    # If we get a coroutine, we cannot process it in sync context
+    if inspect.iscoroutine(response):
+        import logging
+
+        logger = logging.getLogger(__name__)
+        logger.warning(
+            f"shared_metrics_attributes received coroutine {response} - using None for model"
+        )
+        response = None
+
+    # If it's already a dict (e.g., from streaming), use it directly
+    if isinstance(response, dict):
+        model = response.get("model")
+    else:
+        # Handle with_raw_response wrapped responses first
+        if response and hasattr(response, "parse") and callable(response.parse):
+            try:
+                response = response.parse()
+            except Exception as e:
+                import logging
+
+                logger = logging.getLogger(__name__)
+                logger.debug(f"Failed to parse with_raw_response: {e}")
+                response = None
+
+        # Safely get model attribute without extracting the whole object
+        model = getattr(response, "model", None) if response else None
 
     common_attributes = Config.get_common_metrics_attributes()
 
     return {
         **common_attributes,
         GEN_AI_SYSTEM: GEN_AI_SYSTEM_ANTHROPIC,
-        SpanAttributes.LLM_RESPONSE_MODEL: response.get("model"),
+        SpanAttributes.LLM_RESPONSE_MODEL: model,
     }