langtrace-python-sdk 3.7.0__py3-none-any.whl → 3.8.1__py3-none-any.whl

examples/cleanlab_example/simple.py

@@ -0,0 +1,18 @@
+import os
+
+from cleanlab_tlm import TLM
+from dotenv import find_dotenv, load_dotenv
+
+from langtrace_python_sdk import langtrace
+
+_ = load_dotenv(find_dotenv())
+
+langtrace.init()
+
+api_key = os.getenv("CLEANLAB_API_KEY")
+tlm = TLM(api_key=api_key, options={"log": ["explanation"], "model": "gpt-4o-mini"}) # GPT, Claude, etc
+out = tlm.prompt("What's the third month of the year alphabetically?")
+trustworthiness_score = tlm.get_trustworthiness_score("What's the first month of the year?", response="January")
+
+print(out)
+print(trustworthiness_score)

langtrace_python_sdk/constants/instrumentation/common.py

@@ -13,6 +13,8 @@ SERVICE_PROVIDERS = {
     "ARCH": "Arch",
     "AZURE": "Azure",
     "CHROMA": "Chroma",
+    "CLEANLAB": "CleanLab",
+    "COHERE": "Cohere",
     "CREWAI": "CrewAI",
     "DEEPSEEK": "DeepSeek",
     "DSPY": "DSPy",
@@ -25,7 +27,6 @@ SERVICE_PROVIDERS = {
     "LLAMAINDEX": "LlamaIndex",
     "OPENAI": "OpenAI",
     "PINECONE": "Pinecone",
-    "COHERE": "Cohere",
     "PPLX": "Perplexity",
     "QDRANT": "Qdrant",
     "WEAVIATE": "Weaviate",
@@ -42,6 +43,7 @@ SERVICE_PROVIDERS = {
     "MILVUS": "Milvus",
     "GRAPHLIT": "Graphlit",
     "PHIDATA": "Phidata",
+    "AGNO": "Agno",
 }
 
 LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY = "langtrace_additional_attributes"

langtrace_python_sdk/instrumentation/__init__.py

@@ -1,8 +1,10 @@
+from .agno import AgnoInstrumentation
 from .anthropic import AnthropicInstrumentation
 from .autogen import AutogenInstrumentation
 from .aws_bedrock import AWSBedrockInstrumentation
 from .cerebras import CerebrasInstrumentation
 from .chroma import ChromaInstrumentation
+from .cleanlab import CleanLabInstrumentation
 from .cohere import CohereInstrumentation
 from .crewai import CrewAIInstrumentation
 from .crewai_tools import CrewaiToolsInstrumentation
@@ -10,6 +12,7 @@ from .dspy import DspyInstrumentation
 from .embedchain import EmbedchainInstrumentation
 from .gemini import GeminiInstrumentation
 from .google_genai import GoogleGenaiInstrumentation
+from .graphlit import GraphlitInstrumentation
 from .groq import GroqInstrumentation
 from .langchain import LangchainInstrumentation
 from .langchain_community import LangchainCommunityInstrumentation
@@ -21,16 +24,12 @@ from .milvus import MilvusInstrumentation
 from .mistral import MistralInstrumentation
 from .ollama import OllamaInstrumentor
 from .openai import OpenAIInstrumentation
+from .phidata import PhiDataInstrumentation
 from .pinecone import PineconeInstrumentation
 from .pymongo import PyMongoInstrumentation
 from .qdrant import QdrantInstrumentation
 from .vertexai import VertexAIInstrumentation
 from .weaviate import WeaviateInstrumentation
-from .cerebras import CerebrasInstrumentation
-from .milvus import MilvusInstrumentation
-from .google_genai import GoogleGenaiInstrumentation
-from .graphlit import GraphlitInstrumentation
-from .phidata import PhiDataInstrumentation
 
 __all__ = [
     "AnthropicInstrumentation",
@@ -63,4 +62,6 @@ __all__ = [
     "CrewaiToolsInstrumentation",
     "GraphlitInstrumentation",
     "PhiDataInstrumentation",
+    "AgnoInstrumentation",
+    "CleanLabInstrumentation",
 ]

langtrace_python_sdk/instrumentation/agno/__init__.py

@@ -0,0 +1,5 @@
+from .instrumentation import AgnoInstrumentation
+
+__all__ = [
+    "AgnoInstrumentation",
+]

langtrace_python_sdk/instrumentation/agno/instrumentation.py

@@ -0,0 +1,80 @@
+"""
+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 opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.trace import get_tracer
+from wrapt import wrap_function_wrapper as _W
+from typing import Collection
+from importlib_metadata import version as v
+from .patch import patch_agent, patch_memory
+
+class AgnoInstrumentation(BaseInstrumentor):
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["agno >= 1.1.4"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "", tracer_provider)
+        version = v("agno")
+
+        try:
+            _W(
+                "agno.agent.agent",
+                "Agent.run",
+                patch_agent("Agent.run", version, tracer),
+            )
+            _W(
+                "agno.agent.agent",
+                "Agent.arun",
+                patch_agent("Agent.arun", version, tracer),
+            )
+            _W(
+                "agno.agent.agent",
+                "Agent._run",
+                patch_agent("Agent._run", version, tracer),
+            )
+            _W(
+                "agno.agent.agent", 
+                "Agent._arun",
+                patch_agent("Agent._arun", version, tracer),
+            )
+
+            _W(
+                "agno.memory.agent",
+                "AgentMemory.update_memory",
+                patch_memory("AgentMemory.update_memory", version, tracer),
+            )
+            _W(
+                "agno.memory.agent",
+                "AgentMemory.aupdate_memory",
+                patch_memory("AgentMemory.aupdate_memory", version, tracer),
+            )
+            _W(
+                "agno.memory.agent",
+                "AgentMemory.update_summary",
+                patch_memory("AgentMemory.update_summary", version, tracer),
+            )
+            _W(
+                "agno.memory.agent",
+                "AgentMemory.aupdate_summary",
+                patch_memory("AgentMemory.aupdate_summary", version, tracer),
+            )
+
+        except Exception:
+            pass
+
+    def _uninstrument(self, **kwargs):
+        pass

langtrace_python_sdk/instrumentation/agno/patch.py

@@ -0,0 +1,261 @@
+import json
+from importlib_metadata import version as v
+from langtrace.trace_attributes import FrameworkSpanAttributes
+from opentelemetry import baggage
+from opentelemetry.trace import Span, SpanKind, Tracer
+from opentelemetry.trace.status import Status, StatusCode
+from typing import Dict, Any, Optional
+
+from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
+from langtrace_python_sdk.constants.instrumentation.common import (
+    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
+
+def _extract_metrics(metrics: Dict[str, Any]) -> Dict[str, Any]:
+    """Helper function to extract and format metrics"""
+    formatted_metrics = {}
+    
+    # Extract basic metrics
+    for key in ['time', 'time_to_first_token', 'input_tokens', 'output_tokens', 
+                'prompt_tokens', 'completion_tokens', 'total_tokens']:
+        if key in metrics:
+            formatted_metrics[key] = metrics[key]
+    
+    # Extract nested metric details if present
+    if 'prompt_tokens_details' in metrics:
+        formatted_metrics['prompt_tokens_details'] = metrics['prompt_tokens_details']
+    if 'completion_tokens_details' in metrics:
+        formatted_metrics['completion_tokens_details'] = metrics['completion_tokens_details']
+    if 'tool_call_times' in metrics:
+        formatted_metrics['tool_call_times'] = metrics['tool_call_times']
+        
+    return formatted_metrics
+
+def patch_memory(operation_name, version, tracer: Tracer):
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS["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 {}),
+        }
+
+        span_attributes.update({
+            "agno.memory.type": type(instance).__name__,
+            "agno.memory.create_session_summary": str(instance.create_session_summary),
+            "agno.memory.create_user_memories": str(instance.create_user_memories),
+            "agno.memory.retrieval": str(instance.retrieval)
+        })
+
+        inputs = {}
+        if len(args) > 0:
+            inputs["args"] = serialize_args(*args)
+        if len(kwargs) > 0:
+            inputs["kwargs"] = serialize_kwargs(**kwargs)
+        span_attributes["agno.memory.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)
+                result = wrapped(*args, **kwargs)
+
+                if result is not None:
+                    set_span_attribute(span, "agno.memory.output", str(result))
+
+                if instance.summary is not None:
+                    set_span_attribute(span, "agno.memory.summary", str(instance.summary))
+                if instance.memories is not None:
+                    set_span_attribute(span, "agno.memory.memories_count", str(len(instance.memories)))
+                
+                span.set_status(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
+
+def patch_agent(operation_name, version, tracer: Tracer):
+    def traced_method(wrapped, instance, args, kwargs):
+        service_provider = SERVICE_PROVIDERS["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 {}),
+        }
+
+        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_generator = wrapped(*args, **kwargs)
+
+                accumulated_content = ""
+                current_tool_call = None
+                response_metadata = None
+                seen_tool_calls = set()
+
+                try:
+                    for response in result_generator:
+                        if not hasattr(response, 'to_dict'):
+                            yield response
+                            continue
+
+                        if not response_metadata:
+                            response_metadata = {
+                                "run_id": response.run_id,
+                                "agent_id": response.agent_id,
+                                "session_id": response.session_id,
+                                "model": response.model,
+                                "content_type": response.content_type,
+                            }
+                            for key, value in response_metadata.items():
+                                if value is not None:
+                                    set_span_attribute(span, f"agno.agent.{key}", str(value))
+
+                        if response.content:
+                            accumulated_content += response.content
+                            set_span_attribute(span, "agno.agent.response", accumulated_content)
+
+                        if response.messages:
+                            for msg in response.messages:
+                                if msg.tool_calls:
+                                    for tool_call in msg.tool_calls:
+                                        tool_id = tool_call.get('id')
+                                        if tool_id and tool_id not in seen_tool_calls:
+                                            seen_tool_calls.add(tool_id)
+                                            tool_info = {
+                                                'id': tool_id,
+                                                'name': tool_call.get('function', {}).get('name'),
+                                                'arguments': tool_call.get('function', {}).get('arguments'),
+                                                'start_time': msg.created_at,
+                                            }
+                                            current_tool_call = tool_info
+                                            set_span_attribute(span, f"agno.agent.tool_call.{tool_id}", json.dumps(tool_info))
+
+                                if msg.metrics:
+                                    metrics = _extract_metrics(msg.metrics)
+                                    role_prefix = f"agno.agent.metrics.{msg.role}"
+                                    for key, value in metrics.items():
+                                        set_span_attribute(span, f"{role_prefix}.{key}", str(value))
+
+                        if response.tools:
+                            for tool in response.tools:
+                                tool_id = tool.get('tool_call_id')
+                                if tool_id and current_tool_call and current_tool_call['id'] == tool_id:
+                                    tool_result = {
+                                        **current_tool_call,
+                                        'result': tool.get('content'),
+                                        'error': tool.get('tool_call_error'),
+                                        'end_time': tool.get('created_at'),
+                                        'metrics': tool.get('metrics'),
+                                    }
+                                    set_span_attribute(span, f"agno.agent.tool_call.{tool_id}", json.dumps(tool_result))
+                                    current_tool_call = None
+
+                        yield response
+
+                except Exception as err:
+                    span.record_exception(err)
+                    span.set_status(Status(StatusCode.ERROR, str(err)))
+                    raise
+                finally:
+                    span.set_status(Status(StatusCode.OK))
+                    if len(seen_tool_calls) > 0:
+                        span.set_attribute("agno.agent.total_tool_calls", len(seen_tool_calls))
+            except Exception as err:
+                span.record_exception(err)
+                span.set_status(Status(StatusCode.ERROR, str(err)))
+                raise
+
+    return traced_method
+
+class AgnoSpanAttributes:
+    span: Span
+    agent_data: dict
+
+    def __init__(self, span: Span, instance) -> None:
+        self.span = span
+        self.instance = instance
+        self.agent_data = {
+            "memory": {},
+            "model": {},
+            "tools": [],
+        }
+
+        self.run()
+
+    def run(self):
+        instance_attrs = {
+            "agent_id": self.instance.agent_id,
+            "session_id": self.instance.session_id,
+            "name": self.instance.name,
+            "markdown": self.instance.markdown,
+            "reasoning": self.instance.reasoning,
+            "add_references": self.instance.add_references,
+            "show_tool_calls": self.instance.show_tool_calls,
+            "stream": self.instance.stream,
+            "stream_intermediate_steps": self.instance.stream_intermediate_steps,
+        }
+        
+        for key, value in instance_attrs.items():
+            if value is not None:
+                set_span_attribute(self.span, f"agno.agent.{key}", str(value))
+
+        if self.instance.model:
+            model_attrs = {
+                "id": self.instance.model.id,
+                "name": self.instance.model.name,
+                "provider": self.instance.model.provider,
+                "structured_outputs": self.instance.model.structured_outputs,
+                "supports_structured_outputs": self.instance.model.supports_structured_outputs,
+            }
+            for key, value in model_attrs.items():
+                if value is not None:
+                    set_span_attribute(self.span, f"agno.agent.model.{key}", str(value))
+
+            if hasattr(self.instance.model, 'metrics') and self.instance.model.metrics:
+                metrics = _extract_metrics(self.instance.model.metrics)
+                set_span_attribute(self.span, "agno.agent.model.metrics", json.dumps(metrics))
+
+        if self.instance.tools:
+            tool_list = []
+            for tool in self.instance.tools:
+                if hasattr(tool, "name"):
+                    tool_list.append(tool.name)
+                elif hasattr(tool, "__name__"):
+                    tool_list.append(tool.__name__)
+            set_span_attribute(self.span, "agno.agent.tools", str(tool_list))
+
+        if self.instance.memory:
+            memory_attrs = {
+                "create_session_summary": self.instance.memory.create_session_summary,
+                "create_user_memories": self.instance.memory.create_user_memories,
+                "update_session_summary_after_run": self.instance.memory.update_session_summary_after_run,
+                "update_user_memories_after_run": self.instance.memory.update_user_memories_after_run,
+            }
+            for key, value in memory_attrs.items():
+                if value is not None:
+                    set_span_attribute(self.span, f"agno.agent.memory.{key}", str(value))

langtrace_python_sdk/instrumentation/cleanlab/__init__.py

@@ -0,0 +1,5 @@
+from .instrumentation import CleanLabInstrumentation
+
+__all__ = [
+    "CleanLabInstrumentation",
+]

langtrace_python_sdk/instrumentation/cleanlab/instrumentation.py

@@ -0,0 +1,62 @@
+"""
+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 Any, Collection, Optional
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.trace import TracerProvider, get_tracer
+from wrapt import wrap_function_wrapper
+
+from langtrace_python_sdk.instrumentation.cleanlab.patch import generic_patch
+
+logging.basicConfig(level=logging.FATAL)
+
+
+class CleanLabInstrumentation(BaseInstrumentor):  # type: ignore
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["cleanlab-tlm >= 1.0.7", "trace-attributes >= 4.0.5"]
+
+    def _instrument(self, **kwargs: Any) -> None:
+        tracer_provider: Optional[TracerProvider] = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "", tracer_provider)
+        version: str = importlib.metadata.version("cleanlab_tlm")
+
+        wrap_function_wrapper(
+            "cleanlab_tlm.tlm",
+            "TLM.prompt",
+            generic_patch(version, tracer),
+        )
+
+        wrap_function_wrapper(
+            "cleanlab_tlm.tlm",
+            "TLM.get_trustworthiness_score",
+            generic_patch(version, tracer),
+        )
+
+        wrap_function_wrapper(
+            "cleanlab_tlm.tlm",
+            "TLM.try_prompt",
+            generic_patch(version, tracer),
+        )
+
+        wrap_function_wrapper(
+            "cleanlab_tlm.tlm",
+            "TLM.try_get_trustworthiness_score",
+            generic_patch(version, tracer),
+        )
+
+    def _uninstrument(self, **kwargs: Any) -> None:
+        pass

langtrace_python_sdk/instrumentation/cleanlab/patch.py

@@ -0,0 +1,75 @@
+import json
+from typing import Any, Callable, List
+
+from importlib_metadata import version as v
+from langtrace.trace_attributes import FrameworkSpanAttributes
+from opentelemetry import baggage
+from opentelemetry.trace import SpanKind, Tracer
+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)
+from langtrace_python_sdk.instrumentation.openai.types import \
+    ChatCompletionsCreateKwargs
+from langtrace_python_sdk.utils.llm import set_span_attributes
+from langtrace_python_sdk.utils.misc import serialize_args, serialize_kwargs
+
+
+def generic_patch(version: str, tracer: Tracer) -> Callable:
+    """Wrap the `prompt` method of the `TLM` class to trace it."""
+
+    def traced_method(
+        wrapped: Callable,
+        instance: Any,
+        args: List[Any],
+        kwargs: ChatCompletionsCreateKwargs,
+    ) -> Any:
+        service_provider = SERVICE_PROVIDERS["CLEANLAB"]
+        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 {}),
+        }
+
+        span_attributes["tlm.metadata"] = serialize_kwargs(**kwargs)
+        span_attributes["tlm.inputs"] = serialize_args(*args)
+
+        attributes = FrameworkSpanAttributes(**span_attributes)
+
+        with tracer.start_as_current_span(
+            name=f"tlm.{wrapped.__name__}", kind=SpanKind.CLIENT
+        ) as span:
+            try:
+                set_span_attributes(span, attributes)
+                result = wrapped(*args, **kwargs)
+                if result:
+                    # Handle result serialization based on its type
+                    if hasattr(result, 'model_dump_json'):
+                        # For Pydantic models
+                        result_json = json.loads(result.model_dump_json())
+                    elif isinstance(result, dict):
+                        # For dictionary results
+                        result_json = result
+                    else:
+                        # For other types, try to convert to dict or use string representation
+                        try:
+                            result_json = json.loads(json.dumps(result, default=str))
+                        except Exception:  # pylint: disable=W0702, W0718
+                            result_json = str(result)
+
+                    span.set_attribute("tlm.result", str(result_json))
+                    span.set_status(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

langtrace_python_sdk/instrumentation/graphlit/patch.py

@@ -1,4 +1,5 @@
 import json
+
 from importlib_metadata import version as v
 from langtrace.trace_attributes import FrameworkSpanAttributes
 from opentelemetry import baggage
@@ -7,9 +8,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.llm import set_span_attributes
 from langtrace_python_sdk.utils.misc import serialize_args, serialize_kwargs
 
@@ -27,8 +26,8 @@ def patch_graphlit_operation(operation_name, version, tracer: Tracer):
             **(extra_attributes if extra_attributes is not None else {}),
         }
 
-        span_attributes["langchain.metadata"] = serialize_kwargs(**kwargs)
-        span_attributes["langchain.inputs"] = serialize_args(*args)
+        span_attributes["graphlit.metadata"] = serialize_kwargs(**kwargs)
+        span_attributes["graphlit.inputs"] = serialize_args(*args)
 
         attributes = FrameworkSpanAttributes(**span_attributes)
 

langtrace_python_sdk/langtrace.py

@@ -29,53 +29,9 @@ from opentelemetry.exporter.otlp.proto.http.trace_exporter import \
 from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
 from opentelemetry.sdk.resources import SERVICE_NAME, Resource
 from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import (
-    BatchSpanProcessor,
-    ConsoleSpanExporter,
-    SimpleSpanProcessor,
-)
-
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
-    OTLPSpanExporter as GRPCExporter,
-)
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
-    OTLPSpanExporter as HTTPExporter,
-)
-from langtrace_python_sdk.constants.exporter.langtrace_exporter import (
-    LANGTRACE_REMOTE_URL,
-    LANGTRACE_SESSION_ID_HEADER,
-)
-from langtrace_python_sdk.instrumentation import (
-    AnthropicInstrumentation,
-    ChromaInstrumentation,
-    CohereInstrumentation,
-    CrewAIInstrumentation,
-    DspyInstrumentation,
-    EmbedchainInstrumentation,
-    GeminiInstrumentation,
-    GroqInstrumentation,
-    LangchainCommunityInstrumentation,
-    LangchainCoreInstrumentation,
-    LangchainInstrumentation,
-    LanggraphInstrumentation,
-    LiteLLMInstrumentation,
-    LlamaindexInstrumentation,
-    MistralInstrumentation,
-    AWSBedrockInstrumentation,
-    OllamaInstrumentor,
-    OpenAIInstrumentation,
-    PineconeInstrumentation,
-    QdrantInstrumentation,
-    AutogenInstrumentation,
-    VertexAIInstrumentation,
-    WeaviateInstrumentation,
-    PyMongoInstrumentation,
-    CerebrasInstrumentation,
-    MilvusInstrumentation,
-    GoogleGenaiInstrumentation,
-    GraphlitInstrumentation,
-    PhiDataInstrumentation,
-)
+from opentelemetry.sdk.trace.export import (BatchSpanProcessor,
+                                            ConsoleSpanExporter,
+                                            SimpleSpanProcessor)
 from opentelemetry.util.re import parse_env_headers
 from sentry_sdk.types import Event, Hint
 
@@ -85,17 +41,18 @@ from langtrace_python_sdk.constants.exporter.langtrace_exporter import (
 from langtrace_python_sdk.extensions.langtrace_exporter import \
     LangTraceExporter
 from langtrace_python_sdk.instrumentation import (
-    AnthropicInstrumentation, AutogenInstrumentation,
+    AgnoInstrumentation, AnthropicInstrumentation, AutogenInstrumentation,
     AWSBedrockInstrumentation, CerebrasInstrumentation, ChromaInstrumentation,
-    CohereInstrumentation, CrewAIInstrumentation, CrewaiToolsInstrumentation,
-    DspyInstrumentation, EmbedchainInstrumentation, GeminiInstrumentation,
-    GoogleGenaiInstrumentation, GroqInstrumentation,
-    LangchainCommunityInstrumentation, LangchainCoreInstrumentation,
-    LangchainInstrumentation, LanggraphInstrumentation, LiteLLMInstrumentation,
+    CleanLabInstrumentation, CohereInstrumentation, CrewAIInstrumentation,
+    CrewaiToolsInstrumentation, DspyInstrumentation, EmbedchainInstrumentation,
+    GeminiInstrumentation, GoogleGenaiInstrumentation, GraphlitInstrumentation,
+    GroqInstrumentation, LangchainCommunityInstrumentation,
+    LangchainCoreInstrumentation, LangchainInstrumentation,
+    LanggraphInstrumentation, LiteLLMInstrumentation,
     LlamaindexInstrumentation, MilvusInstrumentation, MistralInstrumentation,
-    OllamaInstrumentor, OpenAIInstrumentation, PineconeInstrumentation,
-    PyMongoInstrumentation, QdrantInstrumentation, VertexAIInstrumentation,
-    WeaviateInstrumentation)
+    OllamaInstrumentor, OpenAIInstrumentation, PhiDataInstrumentation,
+    PineconeInstrumentation, PyMongoInstrumentation, QdrantInstrumentation,
+    VertexAIInstrumentation, WeaviateInstrumentation)
 from langtrace_python_sdk.types import (DisableInstrumentations,
                                         InstrumentationMethods)
 from langtrace_python_sdk.utils import (check_if_sdk_is_outdated,
@@ -325,6 +282,7 @@ def init(
         "google-genai": GoogleGenaiInstrumentation(),
         "graphlit-client": GraphlitInstrumentation(),
         "phidata": PhiDataInstrumentation(),
+        "agno": AgnoInstrumentation(),
         "mistralai": MistralInstrumentation(),
         "boto3": AWSBedrockInstrumentation(),
         "autogen": AutogenInstrumentation(),
@@ -332,6 +290,7 @@ def init(
         "cerebras-cloud-sdk": CerebrasInstrumentation(),
         "pymilvus": MilvusInstrumentation(),
         "crewai-tools": CrewaiToolsInstrumentation(),
+        "cleanlab-tlm": CleanLabInstrumentation(),
     }
 
     init_instrumentations(config.disable_instrumentations, all_instrumentations)

langtrace_python_sdk/version.py

@@ -1 +1 @@
-__version__ = "3.7.0"
+__version__ = "3.8.1"

{langtrace_python_sdk-3.7.0.dist-info → langtrace_python_sdk-3.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langtrace-python-sdk
-Version: 3.7.0
+Version: 3.8.1
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>

{langtrace_python_sdk-3.7.0.dist-info → langtrace_python_sdk-3.8.1.dist-info}/RECORD

@@ -11,6 +11,7 @@ examples/cerebras_example/__init__.py,sha256=ydfNi0DjFMGVcfo79XVG3VEbzIrHo5wYBgS
 examples/cerebras_example/main.py,sha256=QrzQLTEr0dkrrPrlOPqwXkeeGU4dwc8tPR4LhHPOQ3k,6573
 examples/chroma_example/__init__.py,sha256=Mrf8KptW1hhzu6WDdRRTxbaB-0kM7x5u-Goc_zR7G5c,203
 examples/chroma_example/basic.py,sha256=oO7-__8HptnFXLVKbnPgoz02yM-CAPi721xsbUb_gYg,868
+examples/cleanlab_example/simple.py,sha256=YxKzHikcsTlwWVBtRzhgC35j_XsCGDPgTjzMQQ3PMjQ,548
 examples/cohere_example/__init__.py,sha256=7Sa0MEQrRU5gBZg31Ao6kXGDC9raHoLU0BxqVWAX8b8,736
 examples/cohere_example/chat.py,sha256=A1ZSkkPPOj3h27VSSa_o_Thabz08ZUzUgTVgAG0pgcA,901
 examples/cohere_example/chat_stream.py,sha256=BvhUgBEuyMhyzRZ_2i_SBvO9Ndf0b7-aRDyO399RyFE,664
@@ -114,8 +115,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=_ZvCPqk2i9qXFxyJ7-jIJvEC97O9EM0rM_4_ngHskLI,14684
-langtrace_python_sdk/version.py,sha256=ibJtaVWNEhFI-zyI5L2qNlBxgnDWfNBmPNsp-pdAAm8,22
+langtrace_python_sdk/langtrace.py,sha256=L0ktJXsGjvKS0dc6kWGCOUoNsGTERLEmd-1QfzDppq8,13706
+langtrace_python_sdk/version.py,sha256=kZzGpxWKY4rWDQrrrlM7bN7YKRAjy17Wv4w__djvVYU,22
 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
@@ -123,7 +124,7 @@ langtrace_python_sdk/constants/instrumentation/anthropic.py,sha256=YX3llt3zwDY6X
 langtrace_python_sdk/constants/instrumentation/aws_bedrock.py,sha256=QwKtO4NBarOZoGkt5cFCcpxAw3zvZxcMMWBbzPPGv-g,422
 langtrace_python_sdk/constants/instrumentation/chroma.py,sha256=hiPGYdHS0Yj4Kh3eaYBbuCAl_swqIygu80yFqkOgdak,955
 langtrace_python_sdk/constants/instrumentation/cohere.py,sha256=9yD133VdrYZ5BoJR4nJHlj67gHEImB9-KsD-NkzHW1I,1159
-langtrace_python_sdk/constants/instrumentation/common.py,sha256=OCml2ysh-Y5M_Jj4fQhFePR3qikRCmgJUkvdIwFUqAk,1278
+langtrace_python_sdk/constants/instrumentation/common.py,sha256=DxcrwO9iI4Q1-ECTAbfFzY6vjU3K9kyoU54W-I2Ebs0,1326
 langtrace_python_sdk/constants/instrumentation/embedchain.py,sha256=HodCJvaFjILoOG50OwFObxfVxt_8VUaIAIqvgoN3tzo,278
 langtrace_python_sdk/constants/instrumentation/gemini.py,sha256=UAmfgg9FM7uNeOCdPfWlir6OIH-8BoxFGPRpdBd9ZZs,358
 langtrace_python_sdk/constants/instrumentation/groq.py,sha256=VFXmIl4aqGY_fS0PAmjPj_Qm7Tibxbx7Ur_e7rQpqXc,134
@@ -140,7 +141,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=GcMx5OXJlbFA33JlY6i7Ulw0rDhxgoGHN5nqJimK51o,2468
+langtrace_python_sdk/instrumentation/__init__.py,sha256=UOtU6nT-ZT-ZvHzOgPNhG_IooMe5jU8lzgdoDCHpeBc,2469
+langtrace_python_sdk/instrumentation/agno/__init__.py,sha256=95fn4oA-CHB0mxc6KnVB20KSbXGl_ZZr9n99EEaXzrY,91
+langtrace_python_sdk/instrumentation/agno/instrumentation.py,sha256=CrwHzkzLpdo2m2nBHE69d8MIFMxZuvTsT1LTxqlTWV0,2664
+langtrace_python_sdk/instrumentation/agno/patch.py,sha256=EOaz3n_FYx7qXtd_liSjvBqjvD5E1ze6FL1K51v8NBc,12060
 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
@@ -159,6 +163,9 @@ langtrace_python_sdk/instrumentation/cerebras/patch.py,sha256=HR4slOrE3pMp0ABafn
 langtrace_python_sdk/instrumentation/chroma/__init__.py,sha256=pNZ5UO8Q-d5VkXSobBf79reB6AmEl_usnnTp5Itv818,95
 langtrace_python_sdk/instrumentation/chroma/instrumentation.py,sha256=nT6PS6bsrIOO9kLV5GuUeRjMe6THHHAZGvqWBP1dYog,1807
 langtrace_python_sdk/instrumentation/chroma/patch.py,sha256=jYcqBeu-0cYA29PO880oXYRwYh-R1oseXmzfK6UDBps,9074
+langtrace_python_sdk/instrumentation/cleanlab/__init__.py,sha256=UuwRiRAPH2i6cucqK8CgNYOGrsG4t_SGAQJSExRuZ1U,99
+langtrace_python_sdk/instrumentation/cleanlab/instrumentation.py,sha256=CtWdtDUCqh60HU2Vs38O9Y32rlB4jzHIEbVRbwIf_Wg,2088
+langtrace_python_sdk/instrumentation/cleanlab/patch.py,sha256=aI0QfG9UH5P7OvmzeIdeMhRd28oV4JMuXIkPv8s869s,3138
 langtrace_python_sdk/instrumentation/cohere/__init__.py,sha256=sGUSLdTUyYf36Tm6L5jQflhzCqvmWrhnBOMYHjvp6Hs,95
 langtrace_python_sdk/instrumentation/cohere/instrumentation.py,sha256=1wxMhWMfsvKprdV52BIfCZhZS1beRYBW9rUzUDDkyCk,2854
 langtrace_python_sdk/instrumentation/cohere/patch.py,sha256=q29gJnik8bnJ7fnwaJ8PArHTQbJkWhhwBfDdQOTRBng,25422
@@ -182,7 +189,7 @@ langtrace_python_sdk/instrumentation/google_genai/instrumentation.py,sha256=oqKD
 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
-langtrace_python_sdk/instrumentation/graphlit/patch.py,sha256=4LNqY8hOnkRKJ8QWc7mczs1vs-4Tvfug57B55omB4Cg,2928
+langtrace_python_sdk/instrumentation/graphlit/patch.py,sha256=jVME4xlFTwJRPWOBGUtQiZrGkr1ScR2DSYwcWPd5smk,2921
 langtrace_python_sdk/instrumentation/groq/__init__.py,sha256=ZXeq_nrej6Lm_uoMFEg8wbSejhjB2UJ5IoHQBPc2-C0,91
 langtrace_python_sdk/instrumentation/groq/instrumentation.py,sha256=Ttf07XVKhdYY1_fqJc7QWiSdmgEhEVyQB_3Az2_wqYo,1832
 langtrace_python_sdk/instrumentation/groq/patch.py,sha256=J0h8SXEw2LyMIJhKZTVydEysyKfSLWkCuhEharzDS4w,23161
@@ -290,8 +297,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.7.0.dist-info/METADATA,sha256=j2FPiSVBVA-scxnzPs-H8a7QTvPjGQHbTp3NIEX_s4o,15792
-langtrace_python_sdk-3.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langtrace_python_sdk-3.7.0.dist-info/entry_points.txt,sha256=1_b9-qvf2fE7uQNZcbUei9vLpFZBbbh9LrtGw95ssAo,70
-langtrace_python_sdk-3.7.0.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-langtrace_python_sdk-3.7.0.dist-info/RECORD,,
+langtrace_python_sdk-3.8.1.dist-info/METADATA,sha256=ktcD9oBxDhCg6GZuUXQYLAwcvGdo9NvD-QYwlQSaQ2c,15792
+langtrace_python_sdk-3.8.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langtrace_python_sdk-3.8.1.dist-info/entry_points.txt,sha256=1_b9-qvf2fE7uQNZcbUei9vLpFZBbbh9LrtGw95ssAo,70
+langtrace_python_sdk-3.8.1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+langtrace_python_sdk-3.8.1.dist-info/RECORD,,