langtrace-python-sdk 3.8.8__py3-none-any.whl → 3.8.10__py3-none-any.whl

examples/neo4j_example/__init__.py

@@ -0,0 +1,8 @@
+from .basic import execute_query
+from langtrace_python_sdk import with_langtrace_root_span
+
+
+class Neo4jRunner:
+    @with_langtrace_root_span("Neo4jRunner")
+    def run(self):
+        execute_query()

examples/neo4j_example/basic.py

@@ -0,0 +1,26 @@
+import os
+from langtrace_python_sdk import langtrace
+from neo4j import GraphDatabase
+
+langtrace.init()
+
+def execute_query():
+    driver = GraphDatabase.driver(
+        os.getenv("NEO4J_URI"), 
+        auth=(os.getenv("NEO4J_USERNAME"), os.getenv("NEO4J_PASSWORD"))
+    )
+
+    records, summary, keys = driver.execute_query(
+        "MATCH (p:Person {age: $age}) RETURN p.name AS name",
+        age=42,
+        database_=os.getenv("NEO4J_DATABASE"),
+    )
+
+    # Loop through results and do something with them
+    for person in records:
+        print(person)
+    # Summary information
+    print("The query `{query}` returned {records_count} records in {time} ms.".format(
+        query=summary.query, records_count=len(records),
+        time=summary.result_available_after,
+    ))

examples/neo4j_graphrag_example/__init__.py

@@ -0,0 +1,9 @@
+import asyncio
+from .basic import search
+from langtrace_python_sdk import with_langtrace_root_span
+
+
+class Neo4jGraphRagRunner:
+    @with_langtrace_root_span("Neo4jGraphRagRunner")
+    def run(self):
+        asyncio.run(search())

examples/neo4j_graphrag_example/basic.py

@@ -0,0 +1,52 @@
+import os
+from langtrace_python_sdk import langtrace
+from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
+from neo4j import GraphDatabase
+from neo4j_graphrag.generation import GraphRAG
+from neo4j_graphrag.indexes import create_vector_index
+from neo4j_graphrag.llm import OpenAILLM as LLM
+from neo4j_graphrag.embeddings import OpenAIEmbeddings as Embeddings
+from neo4j_graphrag.retrievers import VectorRetriever
+from neo4j_graphrag.experimental.pipeline.kg_builder import SimpleKGPipeline
+
+langtrace.init()
+
+neo4j_driver = GraphDatabase.driver(os.getenv("NEO4J_URI"), auth=(os.getenv("NEO4J_USERNAME"), os.getenv("NEO4J_PASSWORD")))
+
+ex_llm=LLM(
+   model_name="gpt-4o-mini",
+   model_params={
+       "response_format": {"type": "json_object"},
+       "temperature": 0
+   })
+
+embedder = Embeddings()
+
+@with_langtrace_root_span("run_neo_rag")
+async def search():
+    # 1. Build KG and Store in Neo4j Database
+    kg_builder_pdf = SimpleKGPipeline(
+        llm=ex_llm,
+        driver=neo4j_driver,
+        embedder=embedder,
+        from_pdf=True
+    )
+    await kg_builder_pdf.run_async(file_path='src/examples/neo4j_graphrag_example/data/abramov.pdf')
+    
+    create_vector_index(neo4j_driver, name="text_embeddings", label="Chunk",
+                    embedding_property="embedding", dimensions=1536, similarity_fn="cosine")
+
+    # 2. KG Retriever
+    vector_retriever = VectorRetriever(
+        neo4j_driver,
+        index_name="text_embeddings",
+        embedder=embedder
+    )
+
+    # 3. GraphRAG Class
+    llm = LLM(model_name="gpt-4o")
+    rag = GraphRAG(llm=llm, retriever=vector_retriever)
+
+    # 4. Run
+    response = rag.search("What did the author do in college?")
+    print(response.answer)

langtrace_python_sdk/constants/instrumentation/neo4j.py

@@ -0,0 +1,36 @@
+from langtrace.trace_attributes import Neo4jMethods
+
+APIS = {
+    "RUN": {
+        "METHOD": Neo4jMethods.RUN.value,
+        "OPERATION": "run",
+    },
+    "BEGIN_TRANSACTION": {
+        "METHOD": Neo4jMethods.BEGIN_TRANSACTION.value,
+        "OPERATION": "begin_transaction",
+    },
+    "READ_TRANSACTION": {
+        "METHOD": Neo4jMethods.READ_TRANSACTION.value,
+        "OPERATION": "read_transaction",
+    },
+    "WRITE_TRANSACTION": {
+        "METHOD": Neo4jMethods.WRITE_TRANSACTION.value,
+        "OPERATION": "write_transaction",
+    },
+    "EXECUTE_READ": {
+        "METHOD": Neo4jMethods.EXECUTE_READ.value,
+        "OPERATION": "execute_read",
+    },
+    "EXECUTE_WRITE": {
+        "METHOD": Neo4jMethods.EXECUTE_WRITE.value,
+        "OPERATION": "execute_write",
+    },
+    "EXECUTE_QUERY": {
+        "METHOD": Neo4jMethods.EXECUTE_QUERY.value,
+        "OPERATION": "execute_query",
+    },
+    "TX_RUN": {
+        "METHOD": Neo4jMethods.TX_RUN.value,
+        "OPERATION": "tx_run",
+    },
+}

langtrace_python_sdk/instrumentation/__init__.py

@@ -22,6 +22,7 @@ from .litellm import LiteLLMInstrumentation
 from .llamaindex import LlamaindexInstrumentation
 from .milvus import MilvusInstrumentation
 from .mistral import MistralInstrumentation
+from .neo4j import Neo4jInstrumentation
 from .neo4j_graphrag import Neo4jGraphRAGInstrumentation
 from .ollama import OllamaInstrumentor
 from .openai import OpenAIInstrumentation

langtrace_python_sdk/instrumentation/agno/instrumentation.py

@@ -21,7 +21,7 @@ from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper as _W
 
-from .patch import patch_agent, patch_memory
+from .patch import patch_agent, patch_memory, patch_team
 
 
 class AgnoInstrumentation(BaseInstrumentor):
@@ -76,6 +76,27 @@ class AgnoInstrumentation(BaseInstrumentor):
                 patch_memory("AgentMemory.aupdate_summary", version, tracer),
             )
 
+            _W(
+                "agno.team.team",
+                "Team.run",
+                patch_team("Team.run", version, tracer),
+            )
+            _W(
+                "agno.team.team",
+                "Team.arun",
+                patch_team("Team.arun", version, tracer),
+            )
+            _W(
+                "agno.team.team",
+                "Team._run",
+                patch_team("Team._run", version, tracer),
+            )
+            _W(
+                "agno.team.team",
+                "Team._arun",
+                patch_team("Team._arun", version, tracer),
+            )
+
         except Exception:
             pass
 

langtrace_python_sdk/instrumentation/agno/patch.py

@@ -26,9 +26,7 @@ from opentelemetry.trace.status import Status, StatusCode
 
 from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
 from langtrace_python_sdk.constants.instrumentation.common import (
-    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
-    SERVICE_PROVIDERS,
-)
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY, SERVICE_PROVIDERS)
 from langtrace_python_sdk.utils import set_span_attribute
 from langtrace_python_sdk.utils.llm import get_span_name, set_span_attributes
 from langtrace_python_sdk.utils.misc import serialize_args, serialize_kwargs
@@ -62,9 +60,9 @@ def patch_agent(operation_name, version, tracer: Tracer):
             try:
                 set_span_attributes(span, attributes)
                 AgnoSpanAttributes(span=span, instance=instance)
-                
+
                 result = wrapped(*args, **kwargs)
-                
+
                 span.set_status(Status(StatusCode.OK))
 
                 if operation_name in ["Agent._run", "Agent._arun", "Agent.run", "Agent.arun", "Agent.print_response"]:
@@ -72,14 +70,14 @@ def patch_agent(operation_name, version, tracer: Tracer):
                         if hasattr(instance, "run_response") and instance.run_response:
                             if hasattr(instance.run_response, "run_id") and instance.run_response.run_id:
                                 set_span_attribute(span, "agno.agent.run_id", instance.run_response.run_id)
-                            
+
                             if hasattr(instance.run_response, "created_at") and instance.run_response.created_at:
                                 set_span_attribute(span, "agno.agent.timestamp", instance.run_response.created_at)
 
                             if hasattr(instance.run_response, "content") and instance.run_response.content:
                                 content = str(instance.run_response.content)
                                 set_span_attribute(span, "agno.agent.response_content", content)
-                            
+
                             # Capture any tools that were used
                             if hasattr(instance.run_response, "tools") and instance.run_response.tools:
                                 tools = instance.run_response.tools
@@ -122,7 +120,7 @@ def patch_agent(operation_name, version, tracer: Tracer):
                                     else:
                                         set_span_attribute(span, "agno.agent.token_usage.input", 
                                                            metrics['input_tokens'])
-                                
+
                                 if 'output_tokens' in metrics:
                                     if isinstance(metrics['output_tokens'], list) and metrics['output_tokens']:
                                         set_span_attribute(span, "agno.agent.token_usage.output", 
@@ -130,7 +128,7 @@ def patch_agent(operation_name, version, tracer: Tracer):
                                     else:
                                         set_span_attribute(span, "agno.agent.token_usage.output", 
                                                            metrics['output_tokens'])
-                                
+
                                 if 'total_tokens' in metrics:
                                     if isinstance(metrics['total_tokens'], list) and metrics['total_tokens']:
                                         set_span_attribute(span, "agno.agent.token_usage.total", 
@@ -140,21 +138,21 @@ def patch_agent(operation_name, version, tracer: Tracer):
                                                            metrics['total_tokens'])
                     except Exception as err:
                         set_span_attribute(span, "agno.agent.run_response_error", str(err))
-                
+
                 return result
-            
+
             except Exception as err:
                 span.record_exception(err)
                 span.set_status(Status(StatusCode.ERROR, str(err)))
                 raise
-    
+
     return traced_method
 
 
 def patch_memory(operation_name, version, tracer: Tracer):
     """
     Apply instrumentation patches to AgentMemory class methods.
-    
+
     Args:
         operation_name: The name of the operation
         version: The version of Agno
@@ -163,7 +161,7 @@ def patch_memory(operation_name, version, tracer: Tracer):
     def traced_method(wrapped, instance, args, kwargs):
         service_provider = SERVICE_PROVIDERS.get("AGNO", "agno")
         extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
-        
+
         # Collect basic span attributes
         span_attributes = {
             "langtrace.sdk.name": "langtrace-python-sdk",
@@ -180,7 +178,7 @@ def patch_memory(operation_name, version, tracer: Tracer):
             inputs["args"] = serialize_args(*args)
         if len(kwargs) > 0:
             inputs["kwargs"] = serialize_kwargs(**kwargs)
-        
+
         span_attributes["agno.memory.inputs"] = json.dumps(inputs)
 
         if hasattr(instance, "messages"):
@@ -199,10 +197,10 @@ def patch_memory(operation_name, version, tracer: Tracer):
             try:
                 # Set attributes
                 set_span_attributes(span, attributes)
-                
+
                 # Execute the wrapped method
                 result = wrapped(*args, **kwargs)
-                
+
                 # Add memory stats after operation
                 if hasattr(instance, "messages"):
                     set_span_attribute(span, "agno.memory.messages_count_after", len(instance.messages))
@@ -210,37 +208,153 @@ def patch_memory(operation_name, version, tracer: Tracer):
                     set_span_attribute(span, "agno.memory.runs_count_after", len(instance.runs))
                 if hasattr(instance, "memories") and instance.memories:
                     set_span_attribute(span, "agno.memory.memories_count_after", len(instance.memories))
-                
+
                 # Record execution time
                 set_span_attribute(span, "agno.memory.execution_time_ms", int((time.time() - start_time) * 1000))
-                
+
                 # Record success status
                 span.set_status(Status(StatusCode.OK))
-                
+
                 # Add result if relevant
                 if result is not None:
                     set_span_attribute(span, "agno.memory.result", str(result))
-                
+
                 return result
-            
+
             except Exception as err:
                 # Record the exception
                 span.record_exception(err)
                 span.set_status(Status(StatusCode.ERROR, str(err)))
                 raise
-    
+
     return traced_method
 
 
+def patch_team(operation_name, version, tracer: Tracer):
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS.get("AGNO", "agno")
+        extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
+
+        span_attributes = {
+            "langtrace.sdk.name": "langtrace-python-sdk",
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": v(LANGTRACE_SDK_NAME),
+            **(extra_attributes if extra_attributes is not None else {}),
+        }
+
+        inputs = {}
+        if len(args) > 0:
+            inputs["args"] = serialize_args(*args)
+        if len(kwargs) > 0:
+            inputs["kwargs"] = serialize_kwargs(**kwargs)
+        span_attributes["agno.team.inputs"] = json.dumps(inputs)
+        attributes = FrameworkSpanAttributes(**span_attributes)
+
+        with tracer.start_as_current_span(
+            get_span_name(operation_name), kind=SpanKind.CLIENT
+        ) as span:
+            try:
+                set_span_attributes(span, attributes)
+                AgnoSpanAttributes(span=span, instance=instance)
+
+                result = wrapped(*args, **kwargs)
+
+                span.set_status(Status(StatusCode.OK))
+
+                if operation_name in ["Team.run", "Team.arun", "Team._run", "Team._arun"]:
+                    try:
+                        if hasattr(instance, "run_response") and instance.run_response:
+                            if hasattr(instance.run_response, "run_id") and instance.run_response.run_id:
+                                set_span_attribute(span, "agno.team.run_id", instance.run_response.run_id)
+
+                            if hasattr(instance.run_response, "created_at") and instance.run_response.created_at:
+                                set_span_attribute(span, "agno.team.timestamp", instance.run_response.created_at)
+
+                            if hasattr(instance.run_response, "content") and instance.run_response.content:
+                                content = str(instance.run_response.content)
+                                set_span_attribute(span, "agno.team.response_content", content)
+
+                            # Capture any tools that were used
+                            if hasattr(instance.run_response, "tools") and instance.run_response.tools:
+                                tools = instance.run_response.tools
+                                tool_summary = []
+                                for tool in tools:
+                                    if 'tool_name' in tool:
+                                        tool_summary.append(tool['tool_name'])
+                                    elif 'function' in tool and 'name' in tool['function']:
+                                        tool_summary.append(tool['function']['name'])
+                                set_span_attribute(span, "agno.team.tools_used", json.dumps(tool_summary))
+
+                            if hasattr(instance.run_response, "metrics") and instance.run_response.metrics:
+                                metrics = instance.run_response.metrics
+                                for metric_name, metric_values in metrics.items():
+                                    if isinstance(metric_values, list):
+
+                                        if all(isinstance(v, (int, float)) for v in metric_values):
+                                            set_span_attribute(
+                                                span,
+                                                f"agno.team.metrics.{metric_name}",
+                                                sum(metric_values) / len(metric_values) if metric_values else 0
+                                            )
+                                        elif len(metric_values) > 0:
+                                            set_span_attribute(
+                                                span,
+                                                f"agno.team.metrics.{metric_name}",
+                                                str(metric_values[-1])
+                                            )
+                                    else:
+                                        set_span_attribute(
+                                            span,
+                                            f"agno.team.metrics.{metric_name}",
+                                            str(metric_values)
+                                        )
+
+                                if 'input_tokens' in metrics:
+                                    if isinstance(metrics['input_tokens'], list) and metrics['input_tokens']:
+                                        set_span_attribute(span, "agno.team.token_usage.input", 
+                                                           sum(metrics['input_tokens']))
+                                    else:
+                                        set_span_attribute(span, "agno.team.token_usage.input", 
+                                                           metrics['input_tokens'])
+
+                                if 'output_tokens' in metrics:
+                                    if isinstance(metrics['output_tokens'], list) and metrics['output_tokens']:
+                                        set_span_attribute(span, "agno.team.token_usage.output", 
+                                                           sum(metrics['output_tokens']))
+                                    else:
+                                        set_span_attribute(span, "agno.team.token_usage.output", 
+                                                           metrics['output_tokens'])
+
+                                if 'total_tokens' in metrics:
+                                    if isinstance(metrics['total_tokens'], list) and metrics['total_tokens']:
+                                        set_span_attribute(span, "agno.team.token_usage.total", 
+                                                           sum(metrics['total_tokens']))
+                                    else:
+                                        set_span_attribute(span, "agno.team.token_usage.total", 
+                                                           metrics['total_tokens'])
+                    except Exception as err:
+                        set_span_attribute(span, "agno.team.run_response_error", str(err))
+
+                return result
+
+            except Exception as err:
+                span.record_exception(err)
+                span.set_status(Status(StatusCode.ERROR, str(err)))
+                raise
+
+    return traced_method
+
 class AgnoSpanAttributes:
     """
     Helper class to extract and set Agno Agent attributes on spans.
     """
-    
+
     def __init__(self, span: Span, instance: Any) -> None:
         """
         Initialize with a span and Agno instance.
-        
+
         Args:
             span: OpenTelemetry span to update
             instance: Agno Agent instance
@@ -248,14 +362,14 @@ class AgnoSpanAttributes:
         self.span = span
         self.instance = instance
         self.agent_data = {}
-        
+
         self.run()
-    
+
     def run(self) -> None:
         """Process the instance attributes and add them to the span."""
         # Collect basic agent attributes
         self.collect_agent_attributes()
-        
+
         # Add attributes to span
         for key, value in self.agent_data.items():
             if value is not None:
@@ -264,68 +378,68 @@ class AgnoSpanAttributes:
                     f"agno.agent.{key}", 
                     str(value) if not isinstance(value, (int, float, bool)) else value
                 )
-    
+
     def collect_agent_attributes(self) -> None:
         """Collect important attributes from the Agent instance."""
         # Extract basic agent information
         if hasattr(self.instance, "agent_id"):
             self.agent_data["id"] = self.instance.agent_id
-        
+
         if hasattr(self.instance, "name"):
             self.agent_data["name"] = self.instance.name
-        
+
         if hasattr(self.instance, "session_id"):
             self.agent_data["session_id"] = self.instance.session_id
-        
+
         if hasattr(self.instance, "user_id"):
             self.agent_data["user_id"] = self.instance.user_id
-        
+
         if hasattr(self.instance, "run_id"):
             self.agent_data["run_id"] = self.instance.run_id
-        
-                        # Extract model information
+
+        # Extract model information
         if hasattr(self.instance, "model") and self.instance.model:
             model = self.instance.model
             model_info = {}
-            
+
             if hasattr(model, "id"):
                 model_info["id"] = model.id
-            
+
             if hasattr(model, "name"):
                 model_info["name"] = model.name
-                
+
             if hasattr(model, "provider"):
                 model_info["provider"] = model.provider
-                
+
             # Add temperature if available
             if hasattr(model, "temperature") and model.temperature is not None:
                 model_info["temperature"] = model.temperature
-                
+ 
             # Add max_tokens if available
             if hasattr(model, "max_tokens") and model.max_tokens is not None:
                 model_info["max_tokens"] = model.max_tokens
-            
+
             self.agent_data["model"] = json.dumps(model_info)
-        
+
         # Extract tool information
         if hasattr(self.instance, "tools") and self.instance.tools:
             tool_info = []
             for tool in self.instance.tools:
                 tool_data = {}
-                
+
                 # Handle different types of tools
                 if hasattr(tool, "name"):
                     tool_data["name"] = tool.name
-                    
+
                     # Handle DuckDuckGoTools and similar toolkits
                     if hasattr(tool, "functions") and isinstance(tool.functions, dict):
                         tool_data["functions"] = list(tool.functions.keys())
-                        
+
                 elif hasattr(tool, "__name__"):
                     tool_data["name"] = tool.__name__
                 else:
                     tool_data["name"] = str(tool)
-                
+
                 # Add functions if available
                 if not "functions" in tool_data and hasattr(tool, "functions"):
                     if callable(getattr(tool, "functions")):
@@ -336,28 +450,28 @@ class AgnoSpanAttributes:
                                                          for f in tool_functions]
                         except:
                             pass
-                
+
                 tool_info.append(tool_data)
-            
+
             self.agent_data["tools"] = json.dumps(tool_info)
-        
+
         # Extract reasoning settings
         if hasattr(self.instance, "reasoning") and self.instance.reasoning:
             self.agent_data["reasoning_enabled"] = True
-            
+
             if hasattr(self.instance, "reasoning_model") and self.instance.reasoning_model:
                 self.agent_data["reasoning_model"] = str(self.instance.reasoning_model.id)
-            
+
             if hasattr(self.instance, "reasoning_min_steps"):
                 self.agent_data["reasoning_min_steps"] = self.instance.reasoning_min_steps
-                
+
             if hasattr(self.instance, "reasoning_max_steps"):
                 self.agent_data["reasoning_max_steps"] = self.instance.reasoning_max_steps
-        
+
         # Extract knowledge settings
         if hasattr(self.instance, "knowledge") and self.instance.knowledge:
             self.agent_data["knowledge_enabled"] = True
-        
+
         # Extract streaming settings
         if hasattr(self.instance, "stream"):
-            self.agent_data["stream"] = self.instance.stream
+            self.agent_data["stream"] = self.instance.stream

langtrace_python_sdk/instrumentation/google_genai/instrumentation.py

@@ -8,7 +8,7 @@ from .patch import patch_google_genai, patch_google_genai_streaming
 
 class GoogleGenaiInstrumentation(BaseInstrumentor):
     def instrumentation_dependencies(self) -> Collection[str]:
-        return ["google-genai >= 0.1.0", "google-generativeai < 1.0.0"]
+        return ["google-genai >= 0.1.0"]
 
     def _instrument(self, **kwargs):
         trace_provider = kwargs.get("tracer_provider")

langtrace_python_sdk/instrumentation/neo4j/__init__.py

@@ -0,0 +1,3 @@
+from .instrumentation import Neo4jInstrumentation
+
+__all__ = ["Neo4jInstrumentation"]

langtrace_python_sdk/instrumentation/neo4j/instrumentation.py

@@ -0,0 +1,51 @@
+"""
+Copyright (c) 2025 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.
+"""
+
+import importlib.metadata
+import logging
+from typing import Collection
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.trace import get_tracer
+from wrapt import wrap_function_wrapper
+
+from langtrace_python_sdk.constants.instrumentation.neo4j import APIS
+from langtrace_python_sdk.instrumentation.neo4j.patch import driver_patch
+
+logging.basicConfig(level=logging.FATAL)
+
+
+class Neo4jInstrumentation(BaseInstrumentor):
+    """
+    The Neo4jInstrumentation class represents the Neo4j graph database instrumentation
+    """
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["neo4j >= 5.25.0"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "", tracer_provider)
+        version = importlib.metadata.version("neo4j")
+        
+        wrap_function_wrapper(
+            "neo4j._sync.driver",
+            "Driver.execute_query",
+            driver_patch("EXECUTE_QUERY", version, tracer),
+        )
+
+    def _uninstrument(self, **kwargs):
+        pass

langtrace_python_sdk/instrumentation/neo4j/patch.py

@@ -0,0 +1,180 @@
+"""
+Copyright (c) 2025 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.
+"""
+
+import json
+
+from langtrace_python_sdk.utils.llm import get_span_name
+from langtrace_python_sdk.utils.silently_fail import silently_fail
+from langtrace.trace_attributes import DatabaseSpanAttributes
+from langtrace_python_sdk.utils import set_span_attribute
+from opentelemetry import baggage, trace
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace.status import Status, StatusCode
+from opentelemetry.trace.propagation import set_span_in_context
+
+from langtrace_python_sdk.constants.instrumentation.common import (
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
+    SERVICE_PROVIDERS,
+)
+from langtrace_python_sdk.constants.instrumentation.neo4j import APIS
+from importlib.metadata import version as v
+
+from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
+
+
+def driver_patch(operation_name, version, tracer):
+    def traced_method(wrapped, instance, args, kwargs):
+        
+        api = APIS[operation_name]
+        service_provider = SERVICE_PROVIDERS.get("NEO4J", "neo4j")
+        extra_attributes = baggage.get_baggage(LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY)
+        span_attributes = {
+            "langtrace.sdk.name": "langtrace-python-sdk",
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "vectordb",
+            "langtrace.service.version": version,
+            "langtrace.version": v(LANGTRACE_SDK_NAME),
+            "db.system": "neo4j",
+            "db.operation": api["OPERATION"],
+            "db.query": json.dumps(args[0]) if args and len(args) > 0 else "",
+            **(extra_attributes if extra_attributes is not None else {}),
+        }
+        
+        attributes = DatabaseSpanAttributes(**span_attributes)
+        
+        with tracer.start_as_current_span(
+            name=get_span_name(api["METHOD"]),
+            kind=SpanKind.CLIENT,
+            context=set_span_in_context(trace.get_current_span()),
+        ) as span:
+            for field, value in attributes.model_dump(by_alias=True).items():
+                if value is not None:
+                    span.set_attribute(field, value)
+
+            if operation_name == "EXECUTE_QUERY":
+                _set_execute_query_attributes(span, args, kwargs)
+            
+            try:
+                result = wrapped(*args, **kwargs)
+
+                if isinstance(result, tuple) and len(result) == 3:
+                    records, result_summary, keys = result
+                    _set_result_attributes(span, records, result_summary, keys)
+                else:
+                    res = json.dumps(result)
+                    set_span_attribute(span, "neo4j.result.query_response", res)
+
+                span.set_status(StatusCode.OK)
+                return result
+            except Exception as err:
+                span.record_exception(err)
+                span.set_status(Status(StatusCode.ERROR, str(err)))
+                raise
+    
+    return traced_method
+
+
+@silently_fail
+def _set_execute_query_attributes(span, args, kwargs):
+    query = args[0] if args else kwargs.get("query_", None)
+    if query:
+        if hasattr(query, "text"):
+            set_span_attribute(span, "db.query", query.text)
+            if hasattr(query, "metadata") and query.metadata:
+                set_span_attribute(span, "db.query.metadata", json.dumps(query.metadata))
+            if hasattr(query, "timeout") and query.timeout:
+                set_span_attribute(span, "db.query.timeout", query.timeout)
+        else:
+            set_span_attribute(span, "db.query", query)
+
+    parameters = kwargs.get("parameters_", None)
+    if parameters:
+        try:
+            set_span_attribute(span, "db.statement.parameters", json.dumps(parameters))
+        except (TypeError, ValueError):
+            pass
+
+    database = kwargs.get("database_", None)
+    if database:
+        set_span_attribute(span, "neo4j.db.name", database)
+
+    routing = kwargs.get("routing_", None)
+    if routing:
+        set_span_attribute(span, "neo4j.db.routing", str(routing))
+        
+        
+@silently_fail
+def _set_result_attributes(span, records, result_summary, keys):
+    """
+    Set attributes related to the query result and summary
+    """
+    if records is not None:
+        record_count = len(records)
+        set_span_attribute(span, "neo4j.result.record_count", record_count)
+        if record_count > 0:
+            set_span_attribute(span, "neo4j.result.records", json.dumps(records))
+
+    if keys is not None:
+        set_span_attribute(span, "neo4j.result.keys", json.dumps(keys))
+
+    if result_summary:
+        if hasattr(result_summary, "database") and result_summary.database:
+            set_span_attribute(span, "neo4j.db.name", result_summary.database)
+
+        if hasattr(result_summary, "query_type") and result_summary.query_type:
+            set_span_attribute(span, "neo4j.result.query_type", result_summary.query_type)
+
+        if hasattr(result_summary, "parameters") and result_summary.parameters:
+            try:
+                set_span_attribute(span, "neo4j.result.parameters", json.dumps(result_summary.parameters))
+            except (TypeError, ValueError):
+                pass
+        
+        if hasattr(result_summary, "result_available_after") and result_summary.result_available_after is not None:
+            set_span_attribute(span, "neo4j.result.available_after_ms", result_summary.result_available_after)
+        
+        if hasattr(result_summary, "result_consumed_after") and result_summary.result_consumed_after is not None:
+            set_span_attribute(span, "neo4j.result.consumed_after_ms", result_summary.result_consumed_after)
+
+        if hasattr(result_summary, "counters") and result_summary.counters:
+            counters = result_summary.counters
+            if hasattr(counters, "nodes_created") and counters.nodes_created:
+                set_span_attribute(span, "neo4j.result.nodes_created", counters.nodes_created)
+            
+            if hasattr(counters, "nodes_deleted") and counters.nodes_deleted:
+                set_span_attribute(span, "neo4j.result.nodes_deleted", counters.nodes_deleted)
+            
+            if hasattr(counters, "relationships_created") and counters.relationships_created:
+                set_span_attribute(span, "neo4j.result.relationships_created", counters.relationships_created)
+            
+            if hasattr(counters, "relationships_deleted") and counters.relationships_deleted:
+                set_span_attribute(span, "neo4j.result.relationships_deleted", counters.relationships_deleted)
+            
+            if hasattr(counters, "properties_set") and counters.properties_set:
+                set_span_attribute(span, "neo4j.result.properties_set", counters.properties_set)
+
+        if hasattr(result_summary, "plan") and result_summary.plan:
+            try:
+                set_span_attribute(span, "neo4j.result.plan", json.dumps(result_summary.plan))
+            except (TypeError, ValueError):
+                pass
+
+        if hasattr(result_summary, "notifications") and result_summary.notifications:
+            try:
+                set_span_attribute(span, "neo4j.result.notification_count", len(result_summary.notifications))
+                set_span_attribute(span, "neo4j.result.notifications", json.dumps(result_summary.notifications))
+            except (AttributeError, TypeError):
+                pass

langtrace_python_sdk/instrumentation/weaviate/patch.py

@@ -26,9 +26,7 @@ from opentelemetry.trace.status import Status, StatusCode
 
 from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
 from langtrace_python_sdk.constants.instrumentation.common import (
-    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
-    SERVICE_PROVIDERS,
-)
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY, SERVICE_PROVIDERS)
 from langtrace_python_sdk.constants.instrumentation.weaviate import APIS
 from langtrace_python_sdk.utils.llm import get_span_name
 from langtrace_python_sdk.utils.misc import extract_input_params, to_iso_format
@@ -53,6 +51,8 @@ def extract_inputs(args, kwargs):
         for k, v in kwargs.items()
         if k not in ["properties", "fusion_type", "filters"]
     }
+    # don't include vector in kwargs_without_properties
+    kwargs_without_properties.pop("vector", None)
     extracted_params.update(extract_input_params(args, kwargs_without_properties))
     if kwargs.get("filters", None):
         extracted_params["filters"] = str(kwargs["filters"])
@@ -109,7 +109,7 @@ def get_response_object_attributes(response_object):
         **{k: convert_value(v) for k, v in response_object.properties.items()},
         "uuid": str(response_object.uuid) if hasattr(response_object, "uuid") else None,
         "collection": getattr(response_object, "collection", None),
-        "vector": getattr(response_object, "vector", None),
+        # "vector": getattr(response_object, "vector", None),
         "references": getattr(response_object, "references", None),
         "metadata": (
             extract_metadata(response_object.metadata)

langtrace_python_sdk/langtrace.py

@@ -47,9 +47,9 @@ from langtrace_python_sdk.instrumentation import (
     CrewaiToolsInstrumentation, DspyInstrumentation, EmbedchainInstrumentation,
     GeminiInstrumentation, GoogleGenaiInstrumentation, GraphlitInstrumentation,
     GroqInstrumentation, LangchainCommunityInstrumentation,
-    LangchainCoreInstrumentation, LangchainInstrumentation,
-    LanggraphInstrumentation, LiteLLMInstrumentation, LlamaindexInstrumentation,
-    MilvusInstrumentation, MistralInstrumentation, Neo4jGraphRAGInstrumentation,
+    LangchainCoreInstrumentation, LangchainInstrumentation, LanggraphInstrumentation, 
+    LiteLLMInstrumentation, LlamaindexInstrumentation, MilvusInstrumentation, 
+    MistralInstrumentation, Neo4jInstrumentation, Neo4jGraphRAGInstrumentation,
     OllamaInstrumentor, OpenAIAgentsInstrumentation, OpenAIInstrumentation,
     PhiDataInstrumentation, PineconeInstrumentation, PyMongoInstrumentation,
     QdrantInstrumentation, VertexAIInstrumentation, WeaviateInstrumentation)
@@ -284,6 +284,7 @@ def init(
         "phidata": PhiDataInstrumentation(),
         "agno": AgnoInstrumentation(),
         "mistralai": MistralInstrumentation(),
+        "neo4j": Neo4jInstrumentation(),
         "neo4j-graphrag": Neo4jGraphRAGInstrumentation(),
         "boto3": AWSBedrockInstrumentation(),
         "autogen": AutogenInstrumentation(),

langtrace_python_sdk/utils/llm.py

@@ -14,25 +14,24 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+import json
+import os
 from typing import Any, Dict, Union
-from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
-from langtrace_python_sdk.utils import set_span_attribute
-from langtrace_python_sdk.types import NOT_GIVEN
-from tiktoken import get_encoding, list_encoding_names
 
-from langtrace_python_sdk.constants.instrumentation.common import (
-    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
-    TIKTOKEN_MODEL_MAPPING,
-)
-from langtrace_python_sdk.constants.instrumentation.openai import OPENAI_COST_TABLE
-from langtrace.trace_attributes import SpanAttributes
 from importlib_metadata import version as v
-import json
+from langtrace.trace_attributes import SpanAttributes
 from opentelemetry import baggage
 from opentelemetry.trace import Span
 from opentelemetry.trace.status import StatusCode
+from tiktoken import get_encoding, list_encoding_names
 
-import os
+from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
+from langtrace_python_sdk.constants.instrumentation.common import (
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY, TIKTOKEN_MODEL_MAPPING)
+from langtrace_python_sdk.constants.instrumentation.openai import \
+    OPENAI_COST_TABLE
+from langtrace_python_sdk.types import NOT_GIVEN
+from langtrace_python_sdk.utils import set_span_attribute
 
 
 def get_span_name(operation_name):
@@ -437,7 +436,6 @@ class StreamWrapper:
                 "".join(self.result_content), response_model
             )
         if self._span_started:
-            print("SPAAN", self.span)
             set_span_attribute(
                 self.span,
                 SpanAttributes.LLM_RESPONSE_MODEL,

langtrace_python_sdk/version.py

@@ -1 +1 @@
-__version__ = "3.8.8"
+__version__ = "3.8.10"

{langtrace_python_sdk-3.8.8.dist-info → langtrace_python_sdk-3.8.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langtrace-python-sdk
-Version: 3.8.8
+Version: 3.8.10
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>
@@ -23,7 +23,7 @@ Requires-Dist: sentry-sdk>=2.14.0
 Requires-Dist: setuptools
 Requires-Dist: sqlalchemy
 Requires-Dist: tiktoken>=0.1.1
-Requires-Dist: trace-attributes==7.2.0
+Requires-Dist: trace-attributes==7.2.1
 Requires-Dist: transformers>=4.11.3
 Requires-Dist: ujson>=5.10.0
 Provides-Extra: dev

{langtrace_python_sdk-3.8.8.dist-info → langtrace_python_sdk-3.8.10.dist-info}/RECORD

@@ -83,6 +83,11 @@ examples/mistral_example/complete.py,sha256=Ydf5iOCGM2tySSd5vzGvNh3Qz39aTpxcCItB
 examples/mistral_example/complete_async.py,sha256=-SVOLNLNi5JL3o4obBsCXKOt8A6b61j3otbrrYPOOtM,586
 examples/mistral_example/embeddings.py,sha256=LKq_k3Y-TS2SCkyFKw2tLiYreVRHqlY6z0Gfh1y_7u0,468
 examples/mongo_vector_search_example/main.py,sha256=6bHOxR3LfAZwmGmv74jgNCciATS5h5e-Tb5z0cD0z3Q,1542
+examples/neo4j_example/__init__.py,sha256=YG7-_cQnXt-fJQtH2bJu_uSNyVCmYyUevU4H-GML_Sk,200
+examples/neo4j_example/basic.py,sha256=xw5fNi5y-U5wzrVIsnvbKBZDURUzoYriawu6nyEXi3o,780
+examples/neo4j_graphrag_example/__init__.py,sha256=YCXutcM3otTKEff1S3qTciFBxOMrQw7mQ4WGfJ7-mU8,230
+examples/neo4j_graphrag_example/basic.py,sha256=uYf4O8bT3GkU5Qa-tluEr9sYTm5gjdzHAKf-C8bi5GY,1727
+examples/neo4j_graphrag_example/data/abramov.pdf,sha256=Fm93bGdz74PJel-Dw_wZeuqqedloTTZiOakIWLzYDPA,46933
 examples/ollama_example/__init__.py,sha256=qOx0jGCPuSpRCPiqtDVm7F0z8hIZ8C75hDZ_C8Apz-s,399
 examples/ollama_example/basic.py,sha256=EPbsigOF4xBDBgLgAD0EzPo737ycVm7aXZr7F5Xt-A4,1062
 examples/openai_example/__init__.py,sha256=6faH7wTegSozKmS89sd1Tgv8AcEH0GfKkC7YaBWA8tg,849
@@ -115,8 +120,8 @@ examples/vertexai_example/main.py,sha256=gndId5X5ksD-ycxnAWMdEqIDbLc3kz5Vt8vm4YP
 examples/weaviate_example/__init__.py,sha256=8JMDBsRSEV10HfTd-YC7xb4txBjD3la56snk-Bbg2Kw,618
 examples/weaviate_example/query_text.py,sha256=wPHQTc_58kPoKTZMygVjTj-2ZcdrIuaausJfMxNQnQc,127162
 langtrace_python_sdk/__init__.py,sha256=VZM6i71NR7pBQK6XvJWRelknuTYUhqwqE7PlicKa5Wg,1166
-langtrace_python_sdk/langtrace.py,sha256=4nhcy9_T3h4m5T5Blyrvs0BJcKzPWMtkIyEDSbba8P8,13879
-langtrace_python_sdk/version.py,sha256=3SjfTmtUQqjDdaQC3uiCoISksstrQ1Sqj4ASUtoUrzs,22
+langtrace_python_sdk/langtrace.py,sha256=P7aHGunNP8YQqd2glsVLXhSe4QDeAarfG2eCV9hhAm4,13944
+langtrace_python_sdk/version.py,sha256=Sz-5SfPXsiZbJO0dp0pVWeIm92HyINLVnoY9zyB3FQI,23
 langtrace_python_sdk/constants/__init__.py,sha256=3CNYkWMdd1DrkGqzLUgNZXjdAlM6UFMlf_F-odAToyc,146
 langtrace_python_sdk/constants/exporter/langtrace_exporter.py,sha256=EVCrouYCpY98f0KSaKr4PzNxPULTZZO6dSA_crEOyJU,106
 langtrace_python_sdk/constants/instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -131,6 +136,7 @@ langtrace_python_sdk/constants/instrumentation/groq.py,sha256=VFXmIl4aqGY_fS0PAm
 langtrace_python_sdk/constants/instrumentation/litellm.py,sha256=bMAlpY2scFe6Lql0Nl7euGNSO9QEV5Uzne12hnw3mSE,449
 langtrace_python_sdk/constants/instrumentation/milvus.py,sha256=lnl7RtV2Wc66mEmtVMjV5eWalt-caH4-sQEHpN1LmEE,1029
 langtrace_python_sdk/constants/instrumentation/mistral.py,sha256=9PlmcC5P5_BHJ-zsX1xekht6rSm7arTin58HAfdYvLk,730
+langtrace_python_sdk/constants/instrumentation/neo4j.py,sha256=-coUUCiroN2shr_C-HcWPYPmEcjIz1CQpaXtZo2uVFU,1002
 langtrace_python_sdk/constants/instrumentation/ollama.py,sha256=H_-S0xjqRsi5qSp7mAlK7Y9NlQ3BqOkG6ASogqqgdJY,212
 langtrace_python_sdk/constants/instrumentation/openai.py,sha256=uEOH5UXapU2DSf2AdgXTRhhJEHGWXUNFkUGD5QafflM,1164
 langtrace_python_sdk/constants/instrumentation/pinecone.py,sha256=0TityERbGWaHGSN8-vyYZtYCjVj8fQOKae8lng0O0Bk,478
@@ -141,10 +147,10 @@ langtrace_python_sdk/constants/instrumentation/weaviate.py,sha256=gtv-JBxvNGClEM
 langtrace_python_sdk/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/extensions/langtrace_exporter.py,sha256=ckd8dMmY6h2oxE04p1JFLwUB5PSJX_Cy4eDFEM6aj4Y,6605
 langtrace_python_sdk/extensions/langtrace_filesystem.py,sha256=34fZutG28EJ66l67OvTGsydAH3ZpXgikdE7hVLqBpG4,7863
-langtrace_python_sdk/instrumentation/__init__.py,sha256=lw53EsTTtOK-dMhImudipmbVhZqORylt4hO5A7Mv8Uo,2652
+langtrace_python_sdk/instrumentation/__init__.py,sha256=sUVSZtidQev87AspZmWK4M8J51mBnJXXNDwfBsl_Dcs,2692
 langtrace_python_sdk/instrumentation/agno/__init__.py,sha256=95fn4oA-CHB0mxc6KnVB20KSbXGl_ZZr9n99EEaXzrY,91
-langtrace_python_sdk/instrumentation/agno/instrumentation.py,sha256=XUnfvqpp13IgdF03xGKasq7kGjeaN1sXLIwCf-Nt_Nc,2667
-langtrace_python_sdk/instrumentation/agno/patch.py,sha256=qCUxCkzU9cYu_d8BzLgj_Ss97qib07tRVYpYDiNnNMs,16876
+langtrace_python_sdk/instrumentation/agno/instrumentation.py,sha256=DWOIEl9Q4IhCFgFQPW3pILdVq_C0RJiaGm_diZ73XJU,3284
+langtrace_python_sdk/instrumentation/agno/patch.py,sha256=wHMDNiH-XOUTnqC6HKGGbYOp04R8DG2xJqm9Ex_h9AE,22868
 langtrace_python_sdk/instrumentation/anthropic/__init__.py,sha256=donrurJAGYlxrSRA3BIf76jGeUcAx9Tq8CVpah68S0Y,101
 langtrace_python_sdk/instrumentation/anthropic/instrumentation.py,sha256=ndXdruI0BG7n75rsuEpKjfzePxrZxg40gZ39ONmD_v4,1845
 langtrace_python_sdk/instrumentation/anthropic/patch.py,sha256=ztPN4VZujoxYOKhTbFnup7Ibms9NAzYCPAJY43NUgKw,4935
@@ -185,7 +191,7 @@ langtrace_python_sdk/instrumentation/gemini/__init__.py,sha256=ilWmKA4Li-g3DX6R1
 langtrace_python_sdk/instrumentation/gemini/instrumentation.py,sha256=eGWr2dy1f_9TVZiXSH_MlNQINyS4I28EsOTKREdMVio,1304
 langtrace_python_sdk/instrumentation/gemini/patch.py,sha256=PG5E5v253x2ufQ81-aUUFzDRYq-DDhiqwmNoplHPjsM,6261
 langtrace_python_sdk/instrumentation/google_genai/__init__.py,sha256=nQ2kSsUDpLGZ_kz2QGddDwnawL9juVA7pW4G-BOe5VI,98
-langtrace_python_sdk/instrumentation/google_genai/instrumentation.py,sha256=oqKDhVcRRHhD5tK3adAIQo9Bpe7CA-k33gla1IymwXU,1080
+langtrace_python_sdk/instrumentation/google_genai/instrumentation.py,sha256=rSB3nOXXe4gMVPWMGPnIHvWjqyPeRvifxOI62ulJ7uY,1049
 langtrace_python_sdk/instrumentation/google_genai/patch.py,sha256=X0TWY1D4XHweaNu70PlXBDzKEaHIibLpkJiIsp4jF6A,4115
 langtrace_python_sdk/instrumentation/graphlit/__init__.py,sha256=mkUPwozR-I-D5ZrumJs1gS7sSouY0UN68Ne9LiNEBTs,92
 langtrace_python_sdk/instrumentation/graphlit/instrumentation.py,sha256=V9GRZ6cj2lt20xCVfL55lGU4p0HlZxAYUqwpWogXDtY,2074
@@ -218,6 +224,9 @@ langtrace_python_sdk/instrumentation/milvus/patch.py,sha256=0yY5aQz0x7hpQZ8U-0qf
 langtrace_python_sdk/instrumentation/mistral/__init__.py,sha256=mkGALBQvq0jSfwDl6TU09SFwnVs6O4zkUi-yVmd3SNg,90
 langtrace_python_sdk/instrumentation/mistral/instrumentation.py,sha256=qtCkHCSOaiicUChbmTID4lcK1rbeW8oRSbpda2ogbgM,2328
 langtrace_python_sdk/instrumentation/mistral/patch.py,sha256=5EzqMeIEcMUH8P-l9-ijpRNWSc6mYwe9Gz0VY4PLrS0,6559
+langtrace_python_sdk/instrumentation/neo4j/__init__.py,sha256=6pG7SKOSKENaFEsstMJ4ZUH9wUP53JdQKdjHzJ4Lbko,86
+langtrace_python_sdk/instrumentation/neo4j/instrumentation.py,sha256=KECuFv7OuVBgh_NTZl4_W18GAGbKnaeQqRZM8NPZgjU,1668
+langtrace_python_sdk/instrumentation/neo4j/patch.py,sha256=wPAxslFdsHdYU5k1nHzWAqaHxQA-HhxgfVnb_U5qaZ0,7922
 langtrace_python_sdk/instrumentation/neo4j_graphrag/__init__.py,sha256=K-Qpfh-kn2EPxnYZ_oubLZNqAUO9Cx7mnMrJu_ms3UU,102
 langtrace_python_sdk/instrumentation/neo4j_graphrag/instrumentation.py,sha256=FLnddPSozuu5puqYD_FnXLMFet8YToVdWP-cY5QZrvM,2216
 langtrace_python_sdk/instrumentation/neo4j_graphrag/patch.py,sha256=4c7NKcTJeYsbi5V4aSsuPzTiFoBqtlcXmYx2bMlE7qg,9713
@@ -248,11 +257,11 @@ langtrace_python_sdk/instrumentation/vertexai/instrumentation.py,sha256=yz4trw0B
 langtrace_python_sdk/instrumentation/vertexai/patch.py,sha256=PzBio8x6zdVpX286TKtaTR-sf1HCHQ7RrdvpyNaGk4Q,5571
 langtrace_python_sdk/instrumentation/weaviate/__init__.py,sha256=Mc-Je6evPo-kKQzerTG7bd1XO5JOh4YGTE3wBxaUBwg,99
 langtrace_python_sdk/instrumentation/weaviate/instrumentation.py,sha256=Kwq5QQTUQNRHrWrMnNe9X0TcqtXGiNpBidsuToRTqG0,2417
-langtrace_python_sdk/instrumentation/weaviate/patch.py,sha256=Lqixz32uAvDA2VLU3zXLiJ9ohpKeD_LveahX7uro3ZY,6934
+langtrace_python_sdk/instrumentation/weaviate/patch.py,sha256=igqYUR_bEjs1XtyyZ8z3N2Eb3pbtjb6gqeEhVtnLKxw,7036
 langtrace_python_sdk/types/__init__.py,sha256=SJSJzkgPjGGTVJXUZ_FyR3p9DJ5kWGx7iAnJfY4ZYHU,4669
 langtrace_python_sdk/utils/__init__.py,sha256=VVDOG-QLd59ZvSHp0avjof0sbxlZ1QQOf0KoOF7ofhQ,3310
 langtrace_python_sdk/utils/langtrace_sampler.py,sha256=BupNndHbU9IL_wGleKetz8FdcveqHMBVz1bfKTTW80w,1753
-langtrace_python_sdk/utils/llm.py,sha256=UGfCfOcQ6NiGKsA1_aJt9Pt7yi4iGKq26TJQroOwktg,23463
+langtrace_python_sdk/utils/llm.py,sha256=UOPgt8OcOyjBiBEtxWGYBVLg9EfVCBLyusgcVwLr8Us,23425
 langtrace_python_sdk/utils/misc.py,sha256=LaQr5LOmZMiuwVdjYh7aIu6o2C_Xb1wgpQGNOVmRzfE,1918
 langtrace_python_sdk/utils/prompt_registry.py,sha256=n5dQMVLBw8aJZY8Utvf67bncc25ELf6AH9BYw8_hSzo,2619
 langtrace_python_sdk/utils/sdk_version_checker.py,sha256=F-VVVH7Fmhr5LcY0IIe-34zIi5RQcx26uuxFpPzZesM,1782
@@ -303,8 +312,8 @@ tests/pinecone/cassettes/test_query.yaml,sha256=b5v9G3ssUy00oG63PlFUR3JErF2Js-5A
 tests/pinecone/cassettes/test_upsert.yaml,sha256=neWmQ1v3d03V8WoLl8FoFeeCYImb8pxlJBWnFd_lITU,38607
 tests/qdrant/conftest.py,sha256=9n0uHxxIjWk9fbYc4bx-uP8lSAgLBVx-cV9UjnsyCHM,381
 tests/qdrant/test_qdrant.py,sha256=pzjAjVY2kmsmGfrI2Gs2xrolfuaNHz7l1fqGQCjp5_o,3353
-langtrace_python_sdk-3.8.8.dist-info/METADATA,sha256=deElB8UvrgQqY6ZaOFhY7bKQnvXEinTTrnNkgz4b04o,15844
-langtrace_python_sdk-3.8.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langtrace_python_sdk-3.8.8.dist-info/entry_points.txt,sha256=1_b9-qvf2fE7uQNZcbUei9vLpFZBbbh9LrtGw95ssAo,70
-langtrace_python_sdk-3.8.8.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-langtrace_python_sdk-3.8.8.dist-info/RECORD,,
+langtrace_python_sdk-3.8.10.dist-info/METADATA,sha256=-4u_t1c_jWQZ_yk1oIedRtGD9L5gCxcUbJBwfwTbfh0,15845
+langtrace_python_sdk-3.8.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langtrace_python_sdk-3.8.10.dist-info/entry_points.txt,sha256=1_b9-qvf2fE7uQNZcbUei9vLpFZBbbh9LrtGw95ssAo,70
+langtrace_python_sdk-3.8.10.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+langtrace_python_sdk-3.8.10.dist-info/RECORD,,