langtrace-python-sdk 3.8.15__tar.gz → 3.8.18__tar.gz

{langtrace_python_sdk-3.8.15 → langtrace_python_sdk-3.8.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langtrace-python-sdk
-Version: 3.8.15
+Version: 3.8.18
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>
@@ -10,7 +10,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
-Requires-Dist: boto3
+Requires-Dist: boto3==1.38.0
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: fsspec>=2024.6.0
 Requires-Dist: opentelemetry-api>=1.25.0

{langtrace_python_sdk-3.8.15 → langtrace_python_sdk-3.8.18}/pyproject.toml

@@ -32,7 +32,7 @@ dependencies = [
   "transformers>=4.11.3",
   "sentry-sdk>=2.14.0",
   "ujson>=5.10.0",
-  "boto3",
+  "boto3==1.38.0",
   "setuptools",
 ]
 
@@ -81,6 +81,9 @@ include = ["/src"]
 [tool.hatch.build.targets.wheel]
 packages = ["src/langtrace_python_sdk", "src/examples", "src/tests"]
 
+[tool.hatch.source]
+url = "https://langtrace.gateway.scarf.sh/simple/"
+
 [project.entry-points."fsspec.specs"]
 langtracefs = "langtrace_python_sdk:LangTraceFileSystem"
 

{langtrace_python_sdk-3.8.15 → langtrace_python_sdk-3.8.18}/src/langtrace_python_sdk/constants/instrumentation/anthropic.py

@@ -3,4 +3,8 @@ APIS = {
         "METHOD": "anthropic.messages.create",
         "ENDPOINT": "/v1/messages",
     },
+    "MESSAGES_STREAM": {
+        "METHOD": "anthropic.messages.stream",
+        "ENDPOINT": "/v1/messages",
+    },
 }

{langtrace_python_sdk-3.8.15 → langtrace_python_sdk-3.8.18}/src/langtrace_python_sdk/instrumentation/anthropic/instrumentation.py

@@ -23,7 +23,7 @@ from opentelemetry.trace import TracerProvider
 from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
 from typing import Any
-from langtrace_python_sdk.instrumentation.anthropic.patch import messages_create
+from langtrace_python_sdk.instrumentation.anthropic.patch import messages_create, messages_stream
 
 logging.basicConfig(level=logging.FATAL)
 
@@ -46,6 +46,12 @@ class AnthropicInstrumentation(BaseInstrumentor):  # type: ignore[misc]
             "Messages.create",
             messages_create(version, tracer),
         )
+        
+        wrap_function_wrapper(
+            "anthropic.resources.messages",
+            "Messages.stream",
+            messages_stream(version, tracer),
+        )
 
     def _instrument_module(self, module_name: str) -> None:
         pass

langtrace_python_sdk-3.8.18/src/langtrace_python_sdk/instrumentation/anthropic/patch.py

@@ -0,0 +1,280 @@
+"""
+Copyright (c) 2024 Scale3 Labs
+
+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.
+"""
+
+from typing import Any, Callable, List, Iterator, Union
+from langtrace.trace_attributes import SpanAttributes, LLMSpanAttributes
+import json
+
+from langtrace_python_sdk.utils.llm import (
+    StreamWrapper,
+    get_extra_attributes,
+    get_langtrace_attributes,
+    get_llm_request_attributes,
+    get_llm_url,
+    get_span_name,
+    set_event_completion,
+    set_span_attributes,
+    set_usage_attributes,
+    set_span_attribute,
+)
+from opentelemetry.trace import Span, Tracer, SpanKind
+from opentelemetry.trace.status import StatusCode
+from langtrace_python_sdk.constants.instrumentation.anthropic import APIS
+from langtrace_python_sdk.constants.instrumentation.common import SERVICE_PROVIDERS
+from langtrace_python_sdk.instrumentation.anthropic.types import (
+    StreamingResult,
+    ResultType,
+    MessagesCreateKwargs,
+)
+
+
+def messages_create(version: str, tracer: Tracer) -> Callable[..., Any]:
+    """Wrap the `messages_create` method."""
+
+    def traced_method(
+        wrapped: Callable[..., Any],
+        instance: Any,
+        args: List[Any],
+        kwargs: MessagesCreateKwargs,
+    ) -> Any:
+        service_provider = SERVICE_PROVIDERS["ANTHROPIC"]
+
+        # Extract system from kwargs and attach as a role to the prompts
+        prompts = kwargs.get("messages", [])
+        system = kwargs.get("system")
+        if system:
+            prompts.append({"role": "system", "content": system})
+        span_attributes = {
+            **get_langtrace_attributes(version, service_provider),
+            **get_llm_request_attributes(kwargs, prompts=prompts),
+            **get_llm_url(instance),
+            SpanAttributes.LLM_PATH: APIS["MESSAGES_CREATE"]["ENDPOINT"],
+            **get_extra_attributes(),
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+        span = tracer.start_span(
+            name=get_span_name(APIS["MESSAGES_CREATE"]["METHOD"]), kind=SpanKind.CLIENT
+        )
+        
+        set_span_attributes(span, attributes)
+        
+        tools = []
+        if kwargs.get("tools") is not None and kwargs.get("tools"):
+            tools.append(json.dumps(kwargs.get("tools")))
+            set_span_attribute(span, SpanAttributes.LLM_TOOLS, json.dumps(tools))
+
+        try:
+            # Attempt to call the original method
+            result = wrapped(*args, **kwargs)
+            return set_response_attributes(result, span)
+
+        except Exception as err:
+            # Record the exception in the span
+            span.record_exception(err)
+            # Set the span status to indicate an error
+            span.set_status(StatusCode.ERROR, str(err))
+            # Reraise the exception to ensure it's not swallowed
+            span.end()
+            raise
+
+    def set_response_attributes(
+        result: Union[ResultType, StreamingResult], span: Span
+    ) -> Any:
+        if not isinstance(result, Iterator):
+            if hasattr(result, "content") and result.content is not None:
+                set_span_attribute(
+                    span, SpanAttributes.LLM_RESPONSE_MODEL, result.model
+                )
+                if hasattr(result, "content") and result.content[0] is not None:
+                    content = result.content[0]
+                    typ = content.type
+                    role = result.role if result.role else "assistant"
+                    if typ == "tool_result" or typ == "tool_use":
+                        content = content.json()  # type: ignore
+                        set_span_attribute(
+                            span, SpanAttributes.LLM_TOOL_RESULTS, json.dumps(content)
+                        )
+                    if typ == "text":
+                        content = result.content[0].text
+                        set_event_completion(
+                            span, [{"type": typ, "role": role, "content": content}]
+                        )
+
+            if (
+                hasattr(result, "system_fingerprint")
+                and result.system_fingerprint is not None
+            ):
+                span.set_attribute(
+                    SpanAttributes.LLM_SYSTEM_FINGERPRINT,
+                    result.system_fingerprint,
+                )
+            # Get the usage
+            if hasattr(result, "usage") and result.usage is not None:
+                usage = result.usage
+                set_usage_attributes(span, vars(usage))
+
+            span.set_status(StatusCode.OK)
+            span.end()
+            return result
+        else:
+            return StreamWrapper(result, span, tool_calls=True)
+
+    # return the wrapped method
+    return traced_method
+
+
+def messages_stream(version: str, tracer: Tracer) -> Callable[..., Any]:
+
+    def traced_method(
+        wrapped: Callable[..., Any],
+        instance: Any,
+        args: List[Any],
+        kwargs: MessagesCreateKwargs,
+    ) -> Any:
+        service_provider = SERVICE_PROVIDERS["ANTHROPIC"]
+
+        prompts = kwargs.get("messages", [])
+        system = kwargs.get("system")
+        if system:
+            prompts.append({"role": "assistant", "content": system})
+        span_attributes = {
+            **get_langtrace_attributes(version, service_provider),
+            **get_llm_request_attributes(kwargs, prompts=prompts),
+            **get_llm_url(instance),
+            SpanAttributes.LLM_PATH: APIS["MESSAGES_STREAM"]["ENDPOINT"],
+            **get_extra_attributes(),
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+        span = tracer.start_span(
+            name=get_span_name(APIS["MESSAGES_STREAM"]["METHOD"]), kind=SpanKind.CLIENT
+        )
+        
+        set_span_attributes(span, attributes)
+        
+        tools = []
+        if kwargs.get("tools") is not None:
+            tools.append(json.dumps(kwargs.get("tools")))
+            set_span_attribute(span, SpanAttributes.LLM_TOOLS, json.dumps(tools))
+            
+        try:
+            # Create the original message stream manager
+            original_stream_manager = wrapped(*args, **kwargs)
+            
+            # Create a new stream manager that will instrument the stream
+            # while preserving the stream
+            class InstrumentedMessageStreamManager:
+                def __init__(self, original_manager, span):
+                    self.original_manager = original_manager
+                    self.span = span
+                
+                def __enter__(self):
+                    # Enter the original context manager to get the stream
+                    original_stream = self.original_manager.__enter__()
+                    
+                    # Create a wrapper iterator
+                    class InstrumentedStream:
+                        def __init__(self, original_stream, span):
+                            self.original_stream = original_stream
+                            self.span = span
+                            self.message_stop_processed = False
+                        
+                        def __iter__(self):
+                            return self
+                        
+                        def __next__(self):
+                            try:
+                                chunk = next(self.original_stream)
+                                
+                                # Apply instrumentation only once on message_stop
+                                if chunk.type == "message_stop" and not self.message_stop_processed:
+                                    self.message_stop_processed = True
+                                    response_message = chunk.message
+                                        
+                                    responses = [
+                                        {
+                                            "role": (
+                                                response_message.role
+                                                if response_message.role
+                                                else "assistant"
+                                            ),
+                                            "content": message.text,
+                                        }
+                                        for message in response_message.content if message.type == "text"
+                                    ]
+                                    
+                                    set_event_completion(self.span, responses)
+                                    
+                                    if hasattr(response_message, "usage") and response_message.usage is not None:
+                                        set_span_attribute(
+                                            self.span,
+                                            SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
+                                            response_message.usage.input_tokens,
+                                        )
+                                        set_span_attribute(
+                                            self.span,
+                                            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
+                                            response_message.usage.output_tokens,
+                                        )
+                                        set_span_attribute(
+                                            self.span,
+                                            SpanAttributes.LLM_USAGE_TOTAL_TOKENS,
+                                            response_message.usage.input_tokens + response_message.usage.output_tokens,
+                                        )
+                                
+                                # Forward the chunk
+                                return chunk
+                            except StopIteration:
+                                # End the span when we're done with the stream
+                                self.span.end()
+                                raise
+                            except Exception as err:
+                                self.span.record_exception(err)
+                                self.span.set_status(StatusCode.ERROR, str(err))
+                                self.span.end()
+                                raise
+                        
+                        def close(self):
+                            self.original_stream.close()
+                            if not self.message_stop_processed:
+                                self.span.end()
+                    
+                    # Return our instrumented stream wrapper
+                    return InstrumentedStream(original_stream, self.span)
+                
+                def __exit__(self, exc_type, exc_val, exc_tb):
+                    result = self.original_manager.__exit__(exc_type, exc_val, exc_tb)
+
+                    if exc_type is not None:
+                        self.span.record_exception(exc_val)
+                        self.span.set_status(StatusCode.ERROR, str(exc_val))
+                        self.span.end()
+                    
+                    return result
+            
+            # Return the instrumented stream manager
+            return InstrumentedMessageStreamManager(original_stream_manager, span)
+
+        except Exception as err:
+            span.record_exception(err)
+            span.set_status(StatusCode.ERROR, str(err))
+            span.end()
+            raise
+
+    return traced_method

{langtrace_python_sdk-3.8.15 → langtrace_python_sdk-3.8.18}/src/langtrace_python_sdk/instrumentation/google_genai/patch.py

@@ -1,3 +1,4 @@
+import base64
 from langtrace_python_sdk.utils.llm import (
     get_langtrace_attributes,
     get_llm_request_attributes,
@@ -14,20 +15,65 @@ from langtrace.trace_attributes import SpanAttributes
 
 from typing import Iterator
 
+def capture_input_data(contents):
+    input_data = []
+    
+    if isinstance(contents, list):
+        content_parts = []
+        for content in contents:
+            if hasattr(content, 'parts'):
+                for part in content.parts:
+                    if hasattr(part, 'text') and part.text:
+                        content_parts.append({
+                            "type": "text",
+                            "text": part.text
+                        })
+                    if hasattr(part, 'inline_data') and part.inline_data:
+                        content_parts.append({
+                            "type": "image_url",
+                            "image_url": f"data:{part.inline_data.mime_type};base64,{base64.b64encode(part.inline_data.data).decode('utf-8')}"
+                        })
+            else:
+                if isinstance(content, str):
+                    content_parts.append({
+                        "type": "text",
+                        "text": content
+                    })
+                elif hasattr(content, 'text') and content.text:
+                    content_parts.append({
+                        "type": "text",
+                        "text": content.text
+                    })
+                elif hasattr(content, 'inline_data') and content.inline_data:
+                    content_parts.append({
+                        "type": "image_url",
+                        "image_url": f"data:{content.inline_data.mime_type};base64,{base64.b64encode(content.inline_data.data).decode('utf-8')}"
+                    })
+                else:
+                    content_parts.append({
+                        "type": "text",
+                        "text": content
+                    })
+        input_data.append({
+            "role": "user",
+            "content": content_parts
+        })
+    else:
+        input_data.append({
+            "role": "user",
+            "content": contents
+        })
+    
+    return input_data
+
 
 def patch_google_genai(tracer: Tracer, version: str):
     def traced_method(wrapped, instance, args, kwargs):
-        prompt = [
-            {
-                "role": "user",
-                "content": kwargs["contents"],
-            }
-        ]
         span_attributes = {
             **get_langtrace_attributes(
                 service_provider="google_genai", version=version
             ),
-            **get_llm_request_attributes(kwargs=kwargs, prompts=prompt),
+            **get_llm_request_attributes(kwargs=kwargs, prompts=capture_input_data(kwargs["contents"])),
         }
         with tracer.start_as_current_span(
             name="google.genai.generate_content",

langtrace_python_sdk-3.8.18/src/langtrace_python_sdk/version.py

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

langtrace_python_sdk-3.8.15/src/langtrace_python_sdk/instrumentation/anthropic/patch.py

@@ -1,133 +0,0 @@
-"""
-Copyright (c) 2024 Scale3 Labs
-
-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.
-"""
-
-from typing import Any, Callable, List, Iterator, Union
-from langtrace.trace_attributes import SpanAttributes, LLMSpanAttributes
-import json
-
-from langtrace_python_sdk.utils.llm import (
-    StreamWrapper,
-    get_extra_attributes,
-    get_langtrace_attributes,
-    get_llm_request_attributes,
-    get_llm_url,
-    get_span_name,
-    set_event_completion,
-    set_span_attributes,
-    set_usage_attributes,
-    set_span_attribute,
-)
-from opentelemetry.trace import Span, Tracer, SpanKind
-from opentelemetry.trace.status import StatusCode
-from langtrace_python_sdk.constants.instrumentation.anthropic import APIS
-from langtrace_python_sdk.constants.instrumentation.common import SERVICE_PROVIDERS
-from langtrace_python_sdk.instrumentation.anthropic.types import (
-    StreamingResult,
-    ResultType,
-    MessagesCreateKwargs,
-)
-
-
-def messages_create(version: str, tracer: Tracer) -> Callable[..., Any]:
-    """Wrap the `messages_create` method."""
-
-    def traced_method(
-        wrapped: Callable[..., Any],
-        instance: Any,
-        args: List[Any],
-        kwargs: MessagesCreateKwargs,
-    ) -> Any:
-        service_provider = SERVICE_PROVIDERS["ANTHROPIC"]
-
-        # Extract system from kwargs and attach as a role to the prompts
-        prompts = kwargs.get("messages", [])
-        system = kwargs.get("system")
-        if system:
-            prompts = [{"role": "system", "content": system}] + kwargs.get(
-                "messages", []
-            )
-        span_attributes = {
-            **get_langtrace_attributes(version, service_provider),
-            **get_llm_request_attributes(kwargs, prompts=prompts),
-            **get_llm_url(instance),
-            SpanAttributes.LLM_PATH: APIS["MESSAGES_CREATE"]["ENDPOINT"],
-            **get_extra_attributes(),
-        }
-
-        attributes = LLMSpanAttributes(**span_attributes)
-
-        span = tracer.start_span(
-            name=get_span_name(APIS["MESSAGES_CREATE"]["METHOD"]), kind=SpanKind.CLIENT
-        )
-        set_span_attributes(span, attributes)
-        try:
-            # Attempt to call the original method
-            result = wrapped(*args, **kwargs)
-            return set_response_attributes(result, span)
-
-        except Exception as err:
-            # Record the exception in the span
-            span.record_exception(err)
-            # Set the span status to indicate an error
-            span.set_status(StatusCode.ERROR, str(err))
-            # Reraise the exception to ensure it's not swallowed
-            span.end()
-            raise
-
-    def set_response_attributes(
-        result: Union[ResultType, StreamingResult], span: Span
-    ) -> Any:
-        if not isinstance(result, Iterator):
-            if hasattr(result, "content") and result.content is not None:
-                set_span_attribute(
-                    span, SpanAttributes.LLM_RESPONSE_MODEL, result.model
-                )
-                if hasattr(result, "content") and result.content[0] is not None:
-                    content = result.content[0]
-                    typ = content.type
-                    role = result.role if result.role else "assistant"
-                    if typ == "tool_result" or typ == "tool_use":
-                        content = content.json()  # type: ignore
-                        set_span_attribute(
-                            span, SpanAttributes.LLM_TOOL_RESULTS, json.dumps(content)
-                        )
-                    if typ == "text":
-                        content = result.content[0].text
-                        set_event_completion(
-                            span, [{"type": typ, "role": role, "content": content}]
-                        )
-
-            if (
-                hasattr(result, "system_fingerprint")
-                and result.system_fingerprint is not None
-            ):
-                span.set_attribute(
-                    SpanAttributes.LLM_SYSTEM_FINGERPRINT,
-                    result.system_fingerprint,
-                )
-            # Get the usage
-            if hasattr(result, "usage") and result.usage is not None:
-                usage = result.usage
-                set_usage_attributes(span, vars(usage))
-
-            span.set_status(StatusCode.OK)
-            span.end()
-            return result
-        else:
-            return StreamWrapper(result, span)
-
-    # return the wrapped method
-    return traced_method

langtrace_python_sdk-3.8.15/src/langtrace_python_sdk/version.py

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