langtrace-python-sdk 2.1.20__py3-none-any.whl → 2.1.22__py3-none-any.whl

examples/crewai_example/basic.py

@@ -0,0 +1,70 @@
+import os
+
+os.environ["OPENAI_MODEL_NAME"] = "gpt-3.5-turbo"
+os.environ["SERPER_API_KEY"] = ""  # serper.dev API key
+from langtrace_python_sdk import langtrace
+from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
+from crewai import Crew, Process
+from crewai import Task
+from crewai import Agent
+from crewai_tools import SerperDevTool
+from crewai_tools import YoutubeVideoSearchTool
+
+langtrace.init()
+
+search_tool = SerperDevTool()
+
+# Targeted search within a specific Youtube video's content
+youtube_tool = YoutubeVideoSearchTool(
+    youtube_video_url="https://www.youtube.com/watch?v=blqIZGXWUpU"
+)
+
+# Creating a senior researcher agent with memory and verbose mode
+researcher = Agent(
+    role="Senior Researcher",
+    goal="Uncover groundbreaking technologies in {topic}",
+    verbose=True,
+    memory=True,
+    backstory=(
+        "Driven by curiosity, you're at the forefront of"
+        "innovation, eager to explore and share knowledge that could change"
+        "the world."
+    ),
+    tools=[youtube_tool],
+)
+
+# Research task
+research_task = Task(
+    description=(
+        "Do a {topic} of the given youtube video."
+        "Focus on identifying the overall narrative."
+        "Your final report should clearly articulate the key points."
+    ),
+    expected_output="10 key points from the shared video.",
+    tools=[youtube_tool],
+    agent=researcher,
+    callback="research_callback",  # Example of task callback
+    human_input=True,
+)
+
+
+# Forming the tech-focused crew with some enhanced configurations
+crew = Crew(
+    agents=[researcher],
+    tasks=[research_task],
+    process=Process.sequential,  # Optional: Sequential task execution is default
+    memory=False,
+    cache=False,
+    max_rpm=20,
+)
+
+# Starting the task execution process with enhanced feedback
+
+
+@with_langtrace_root_span("Crew")
+def test_crew():
+    result = crew.kickoff(inputs={"topic": "summary"})
+    return result
+
+
+test_crew()

examples/dspy_example/math_problems_cot.py

@@ -0,0 +1,42 @@
+import dspy
+from dspy.datasets.gsm8k import GSM8K, gsm8k_metric
+from dspy.teleprompt import BootstrapFewShot
+
+# flake8: noqa
+from langtrace_python_sdk import langtrace, with_langtrace_root_span
+
+langtrace.init()
+
+turbo = dspy.OpenAI(model="gpt-3.5-turbo", max_tokens=250)
+dspy.settings.configure(lm=turbo)
+
+# Load math questions from the GSM8K dataset
+gsm8k = GSM8K()
+gsm8k_trainset, gsm8k_devset = gsm8k.train[:10], gsm8k.dev[:10]
+
+
+class CoT(dspy.Module):
+    def __init__(self):
+        super().__init__()
+        self.prog = dspy.ChainOfThought("question -> answer")
+
+    def forward(self, question):
+        return self.prog(question=question)
+
+
+@with_langtrace_root_span(name="math_problems_cot_example")
+def example():
+
+    # Set up the optimizer: we want to "bootstrap" (i.e., self-generate) 4-shot examples of our CoT program.
+    config = dict(max_bootstrapped_demos=4, max_labeled_demos=4)
+
+    # Optimize! Use the `gsm8k_metric` here. In general, the metric is going to tell the optimizer how well it's doing.
+    teleprompter = BootstrapFewShot(metric=gsm8k_metric, **config)
+    optimized_cot = teleprompter.compile(CoT(), trainset=gsm8k_trainset)
+
+    ans = optimized_cot(question="What is the sqrt of 345?")
+    print(ans)
+
+
+if __name__ == "__main__":
+    example()

examples/dspy_example/program_of_thought_basic.py

@@ -0,0 +1,35 @@
+import dspy
+
+# flake8: noqa
+from langtrace_python_sdk import langtrace, with_langtrace_root_span
+
+langtrace.init()
+
+turbo = dspy.OpenAI(model="gpt-3.5-turbo", max_tokens=250)
+dspy.settings.configure(lm=turbo)
+
+
+# Define a simple signature for basic question answering
+class BasicQA(dspy.Signature):
+    """Answer questions with short factoid answers."""
+
+    question = dspy.InputField()
+    answer = dspy.OutputField(desc="often between 1 and 5 words")
+
+
+@with_langtrace_root_span(name="pot_example")
+def example():
+
+    # Pass signature to ProgramOfThought Module
+    pot = dspy.ProgramOfThought(BasicQA)
+
+    # Call the ProgramOfThought module on a particular input
+    question = "Sarah has 5 apples. She buys 7 more apples from the store. How many apples does Sarah have now?"
+    result = pot(question=question)
+
+    print(f"Question: {question}")
+    print(f"Final Predicted Answer (after ProgramOfThought process): {result.answer}")
+
+
+if __name__ == "__main__":
+    example()

examples/dspy_example/quiz_gen.py

@@ -0,0 +1,113 @@
+import dspy
+import json
+from dspy.datasets import HotPotQA
+from dspy.teleprompt import BootstrapFewShot
+from dspy.evaluate.evaluate import Evaluate
+
+# flake8: noqa
+from langtrace_python_sdk import langtrace, with_langtrace_root_span
+
+langtrace.init()
+
+
+colbertv2_wiki17_abstracts = dspy.ColBERTv2(
+    url="http://20.102.90.50:2017/wiki17_abstracts"
+)
+dspy.settings.configure(rm=colbertv2_wiki17_abstracts)
+turbo = dspy.OpenAI(model="gpt-3.5-turbo-0613", max_tokens=500)
+dspy.settings.configure(lm=turbo, trace=[], temperature=0.7)
+
+dataset = HotPotQA(
+    train_seed=1,
+    train_size=300,
+    eval_seed=2023,
+    dev_size=300,
+    test_size=0,
+    keep_details=True,
+)
+trainset = [x.with_inputs("question", "answer") for x in dataset.train]
+devset = [x.with_inputs("question", "answer") for x in dataset.dev]
+
+
+class GenerateAnswerChoices(dspy.Signature):
+    """Generate answer choices in JSON format that include the correct answer and plausible distractors for the specified question."""
+
+    question = dspy.InputField()
+    correct_answer = dspy.InputField()
+    number_of_choices = dspy.InputField()
+    answer_choices = dspy.OutputField(desc="JSON key-value pairs")
+
+
+class QuizAnswerGenerator(dspy.Module):
+    def __init__(self):
+        super().__init__()
+        self.prog = dspy.ChainOfThought(GenerateAnswerChoices)
+
+    def forward(self, question, answer):
+        choices = self.prog(
+            question=question, correct_answer=answer, number_of_choices="4"
+        ).answer_choices
+        # dspy.Suggest(
+        #     format_checker(choices),
+        #     "The format of the answer choices should be in JSON format. Please revise accordingly.",
+        #     target_module=GenerateAnswerChoices,
+        # )
+        return dspy.Prediction(choices=choices)
+
+
+def format_checker(choice_string):
+    try:
+        choices = json.loads(choice_string)
+        if isinstance(choices, dict) and all(
+            isinstance(key, str) and isinstance(value, str)
+            for key, value in choices.items()
+        ):
+            return True
+    except json.JSONDecodeError:
+        return False
+
+    return False
+
+
+def format_valid_metric(gold, pred, trace=None):
+    generated_choices = pred.choices
+    format_valid = format_checker(generated_choices)
+    score = format_valid
+    return score
+
+
+@with_langtrace_root_span(name="quiz_generator_1")
+def quiz_generator_1():
+    quiz_generator = QuizAnswerGenerator()
+
+    example = devset[67]
+    print("Example Question: ", example.question)
+    print("Example Answer: ", example.answer)
+    # quiz_choices = quiz_generator(question=example.question, answer=example.answer)
+    # print("Generated Quiz Choices: ", quiz_choices.choices)
+
+    optimizer = BootstrapFewShot(
+        metric=format_valid_metric, max_bootstrapped_demos=4, max_labeled_demos=4
+    )
+    compiled_quiz_generator = optimizer.compile(
+        quiz_generator,
+        trainset=trainset,
+    )
+    quiz_choices = compiled_quiz_generator(
+        question=example.question, answer=example.answer
+    )
+    print("Generated Quiz Choices: ", quiz_choices.choices)
+
+    # Evaluate
+    evaluate = Evaluate(
+        metric=format_valid_metric,
+        devset=devset[67:70],
+        num_threads=1,
+        display_progress=True,
+        display_table=5,
+    )
+    evaluate(quiz_generator)
+
+
+if __name__ == "__main__":
+    quiz_generator_1()

examples/dspy_example/react.py

@@ -0,0 +1,39 @@
+import sys
+import os
+import dspy
+
+# Add the local src folder to the Python path
+sys.path.insert(0, os.path.abspath('/Users/karthikkalyanaraman/work/langtrace/langtrace-python-sdk/src'))
+
+# flake8: noqa
+from langtrace_python_sdk import langtrace, with_langtrace_root_span
+langtrace.init()
+
+turbo = dspy.OpenAI(model='gpt-3.5-turbo', max_tokens=250)
+dspy.settings.configure(lm=turbo)
+
+colbertv2_wiki17_abstracts = dspy.ColBERTv2(url='http://20.102.90.50:2017/wiki17_abstracts')
+dspy.settings.configure(rm=colbertv2_wiki17_abstracts)
+retriever = dspy.Retrieve(k=3)
+
+# Define a simple signature for basic question answering
+class BasicQA(dspy.Signature):
+    """Answer questions with short factoid answers."""
+    question = dspy.InputField()
+    answer = dspy.OutputField(desc="often between 1 and 5 words")
+
+@with_langtrace_root_span(name="react_example")
+def example():
+
+    # Pass signature to ReAct module
+    react_module = dspy.ReAct(BasicQA)
+
+    # Call the ReAct module on a particular input
+    question = 'Aside from the Apple Remote, what other devices can control the program Apple Remote was originally designed to interact with?'
+    result = react_module(question=question)
+
+    print(f"Question: {question}")
+    print(f"Final Predicted Answer (after ReAct process): {result.answer}")
+
+if __name__ == '__main__':
+    example()

langtrace_python_sdk/constants/instrumentation/common.py

@@ -11,6 +11,8 @@ SERVICE_PROVIDERS = {
     "ANTHROPIC": "Anthropic",
     "AZURE": "Azure",
     "CHROMA": "Chroma",
+    "CREWAI": "CrewAI",
+    "DSPY": "DSPy",
     "GROQ": "Groq",
     "LANGCHAIN": "Langchain",
     "LANGCHAIN_COMMUNITY": "Langchain Community",

langtrace_python_sdk/instrumentation/__init__.py

@@ -1,6 +1,7 @@
 from .anthropic import AnthropicInstrumentation
 from .chroma import ChromaInstrumentation
 from .cohere import CohereInstrumentation
+from .crewai import CrewAIInstrumentation
 from .groq import GroqInstrumentation
 from .langchain import LangchainInstrumentation
 from .langchain_community import LangchainCommunityInstrumentation
@@ -12,11 +13,13 @@ from .pinecone import PineconeInstrumentation
 from .qdrant import QdrantInstrumentation
 from .weaviate import WeaviateInstrumentation
 from .ollama import OllamaInstrumentor
+from .dspy import DspyInstrumentation
 
 __all__ = [
     "AnthropicInstrumentation",
     "ChromaInstrumentation",
     "CohereInstrumentation",
+    "CrewAIInstrumentation",
     "GroqInstrumentation",
     "LangchainInstrumentation",
     "LangchainCommunityInstrumentation",
@@ -28,4 +31,5 @@ __all__ = [
     "QdrantInstrumentation",
     "WeaviateInstrumentation",
     "OllamaInstrumentor",
+    "DspyInstrumentation",
 ]

langtrace_python_sdk/instrumentation/crewai/__init__.py

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

langtrace_python_sdk/instrumentation/crewai/instrumentation.py

@@ -0,0 +1,53 @@
+"""
+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_crew
+
+
+class CrewAIInstrumentation(BaseInstrumentor):
+    """
+    The CrewAIInstrumentation class represents the CrewAI instrumentation"""
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["crewai >= 0.32.0"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "", tracer_provider)
+        version = v("crewai")
+        _W(
+            "crewai.crew",
+            "Crew.kickoff",
+            patch_crew("Crew.kickoff", version, tracer),
+        )
+        _W(
+            "crewai.agent",
+            "Agent.execute_task",
+            patch_crew("Agent.execute_task", version, tracer),
+        )
+        _W(
+            "crewai.task",
+            "Task.execute",
+            patch_crew("Task.execute", version, tracer),
+        )
+
+    def _uninstrument(self, **kwargs):
+        pass

langtrace_python_sdk/instrumentation/crewai/patch.py

@@ -0,0 +1,173 @@
+import json
+from importlib_metadata import version as v
+from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
+from langtrace_python_sdk.utils import set_span_attribute
+from langtrace_python_sdk.utils.silently_fail import silently_fail
+from langtrace_python_sdk.constants.instrumentation.common import (
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
+    SERVICE_PROVIDERS,
+)
+from opentelemetry import baggage
+from langtrace.trace_attributes import FrameworkSpanAttributes
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace.status import Status, StatusCode
+
+
+crew_properties = {
+    "tasks": "object",
+    "agents": "object",
+    "cache": "bool",
+    "process": "object",
+    "verbose": "bool",
+    "memory": "bool",
+    "embedder": "json",
+    "full_output": "bool",
+    "manager_llm": "object",
+    "manager_agent": "object",
+    "manager_callbacks": "object",
+    "function_calling_llm": "object",
+    "config": "json",
+    "id": "object",
+    "max_rpm": "int",
+    "share_crew": "bool",
+    "step_callback": "object",
+    "task_callback": "object",
+    "prompt_file": "object",
+    "output_log_file": "object",
+}
+
+task_properties = {
+    "id": "object",
+    "used_tools": "int",
+    "tools_errors": "int",
+    "delegations": "int",
+    "i18n": "object",
+    "thread": "object",
+    "prompt_context": "object",
+    "description": "str",
+    "expected_output": "str",
+    "config": "object",
+    "callback": "str",
+    "agent": "object",
+    "context": "object",
+    "async_execution": "bool",
+    "output_json": "object",
+    "output_pydantic": "object",
+    "output_file": "object",
+    "output": "object",
+    "tools": "object",
+    "human_input": "bool",
+}
+
+agent_properties = {
+    "formatting_errors": "int",
+    "id": "object",
+    "role": "str",
+    "goal": "str",
+    "backstory": "str",
+    "cache": "bool",
+    "config": "object",
+    "max_rpm": "int",
+    "verbose": "bool",
+    "allow_delegation": "bool",
+    "tools": "object",
+    "max_iter": "int",
+    "max_execution_time": "object",
+    "agent_executor": "object",
+    "tools_handler": "object",
+    "force_answer_max_iterations": "int",
+    "crew": "object",
+    "cache_handler": "object",
+    "step_callback": "object",
+    "i18n": "object",
+    "llm": "object",
+    "function_calling_llm": "object",
+    "callbacks": "object",
+    "system_template": "object",
+    "prompt_template": "object",
+    "response_template": "object",
+}
+
+
+def patch_crew(operation_name, version, tracer):
+    def traced_method(wrapped, instance, args, kwargs):
+
+        service_provider = SERVICE_PROVIDERS["CREWAI"]
+        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 {}),
+        }
+
+        crew_config = {}
+        for key, value in instance.__dict__.items():
+            if instance.__class__.__name__ == "Crew":
+                if key in crew_properties and value is not None:
+                    if crew_properties[key] == "json":
+                        crew_config[key] = json.dumps(value)
+                    elif crew_properties[key] == "object":
+                        crew_config[key] = str(value)
+                    else:
+                        crew_config[key] = value
+            elif instance.__class__.__name__ == "Agent":
+                if key in agent_properties and value is not None:
+                    if agent_properties[key] == "json":
+                        crew_config[key] = json.dumps(value)
+                    elif agent_properties[key] == "object":
+                        crew_config[key] = str(value)
+                    else:
+                        crew_config[key] = value
+            elif instance.__class__.__name__ == "Task":
+                if key in task_properties and value is not None:
+                    if task_properties[key] == "json":
+                        crew_config[key] = json.dumps(value)
+                    elif task_properties[key] == "object":
+                        crew_config[key] = str(value)
+                    else:
+                        crew_config[key] = value
+        if crew_config:
+            if instance.__class__.__name__ == "Crew":
+                if "inputs" in kwargs and kwargs["inputs"]:
+                    crew_config["inputs"] = json.dumps(kwargs["inputs"])
+                span_attributes["crewai.crew.config"] = json.dumps(crew_config)
+            elif instance.__class__.__name__ == "Agent":
+                if "context" in kwargs and kwargs["context"]:
+                    crew_config["context"] = json.dumps(kwargs["context"])
+                span_attributes["crewai.agent.config"] = json.dumps(crew_config)
+            elif instance.__class__.__name__ == "Task":
+                span_attributes["crewai.task.config"] = json.dumps(crew_config)
+
+        attributes = FrameworkSpanAttributes(**span_attributes)
+
+        with tracer.start_as_current_span(operation_name, kind=SpanKind.CLIENT) as span:
+            _set_input_attributes(span, kwargs, attributes)
+
+            try:
+                result = wrapped(*args, **kwargs)
+                if result:
+                    span.set_status(Status(StatusCode.OK))
+
+                span.end()
+                return result
+
+            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(Status(StatusCode.ERROR, str(err)))
+
+                # Reraise the exception to ensure it's not swallowed
+                raise
+
+    return traced_method
+
+
+@silently_fail
+def _set_input_attributes(span, kwargs, attributes):
+    for field, value in attributes.model_dump(by_alias=True).items():
+        set_span_attribute(span, field, value)

langtrace_python_sdk/instrumentation/dspy/__init__.py

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

langtrace_python_sdk/instrumentation/dspy/instrumentation.py

@@ -0,0 +1,85 @@
+"""
+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_bootstrapfewshot_optimizer, patch_signature, patch_evaluate
+
+
+class DspyInstrumentation(BaseInstrumentor):
+    """
+    The DspyInstrumentor class represents the DSPy instrumentation"""
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["dspy >= 0.1.5"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "", tracer_provider)
+        version = v("dspy")
+        _W(
+            "dspy.teleprompt.bootstrap",
+            "BootstrapFewShot.compile",
+            patch_bootstrapfewshot_optimizer(
+                "BootstrapFewShot.compile", version, tracer
+            ),
+        )
+        _W(
+            "dspy.predict.predict",
+            "Predict.forward",
+            patch_signature("Predict.forward", version, tracer),
+        )
+        _W(
+            "dspy.predict.chain_of_thought",
+            "ChainOfThought.forward",
+            patch_signature("ChainOfThought.forward", version, tracer),
+        )
+        _W(
+            "dspy.predict.chain_of_thought_with_hint",
+            "ChainOfThoughtWithHint.forward",
+            patch_signature("ChainOfThoughtWithHint.forward", version, tracer),
+        )
+        _W(
+            "dspy.predict.react",
+            "ReAct.forward",
+            patch_signature("ReAct.forward", version, tracer),
+        )
+        _W(
+            "dspy.predict.program_of_thought",
+            "ProgramOfThought.forward",
+            patch_signature("ProgramOfThought.forward", version, tracer),
+        )
+        _W(
+            "dspy.predict.multi_chain_comparison",
+            "MultiChainComparison.forward",
+            patch_signature("MultiChainComparison.forward", version, tracer),
+        )
+        _W(
+            "dspy.predict.retry",
+            "Retry.forward",
+            patch_signature("Retry.forward", version, tracer),
+        )
+        _W(
+            "dspy.evaluate.evaluate",
+            "Evaluate.__call__",
+            patch_evaluate("Evaluate", version, tracer),
+        )
+
+    def _uninstrument(self, **kwargs):
+        pass

langtrace_python_sdk/instrumentation/dspy/patch.py

@@ -0,0 +1,206 @@
+import json
+from importlib_metadata import version as v
+from langtrace_python_sdk.constants import LANGTRACE_SDK_NAME
+from langtrace_python_sdk.utils import set_span_attribute
+from langtrace_python_sdk.utils.silently_fail import silently_fail
+from langtrace_python_sdk.constants.instrumentation.common import (
+    LANGTRACE_ADDITIONAL_SPAN_ATTRIBUTES_KEY,
+    SERVICE_PROVIDERS,
+)
+from opentelemetry import baggage
+from langtrace.trace_attributes import FrameworkSpanAttributes
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace.status import Status, StatusCode
+
+
+def patch_bootstrapfewshot_optimizer(operation_name, version, tracer):
+    def traced_method(wrapped, instance, args, kwargs):
+
+        service_provider = SERVICE_PROVIDERS["DSPY"]
+        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 {}),
+        }
+
+        if instance.__class__.__name__:
+            span_attributes["dspy.optimizer"] = instance.__class__.__name__
+        if len(args) > 0:
+            span_attributes["dspy.optimizer.module"] = args[0].__class__.__name__
+            if args[0].prog:
+                prog = {
+                    "name": args[0].prog.__class__.__name__,
+                    "signature": str(args[0].prog.signature) if args[0].prog.signature else None,
+                }
+                span_attributes["dspy.optimizer.module.prog"] = json.dumps(prog)
+        if "metric" in instance and instance.metric:
+            span_attributes["dspy.optimizer.metric"] = instance.metric.__name__
+        if kwargs.get("trainset") and len(kwargs.get("trainset")) > 0:
+            span_attributes["dspy.optimizer.trainset"] = str(kwargs.get("trainset"))
+        config = {}
+        if "metric_threshold" in instance and instance.metric_threshold:
+            config["metric_threshold"] = instance.metric_threshold
+        if "teacher_settings" in instance and instance.teacher_settings:
+            config["teacher_settings"] = instance.teacher_settings
+        if "max_bootstrapped_demos" in instance and instance.max_bootstrapped_demos:
+            config["max_bootstrapped_demos"] = instance.max_bootstrapped_demos
+        if "max_labeled_demos" in instance and instance.max_labeled_demos:
+            config["max_labeled_demos"] = instance.max_labeled_demos
+        if "max_rounds" in instance and instance.max_rounds:
+            config["max_rounds"] = instance.max_rounds
+        if "max_errors" in instance and instance.max_errors:
+            config["max_errors"] = instance.max_errors
+        if "error_count" in instance and instance.error_count:
+            config["error_count"] = instance.error_count
+        if config and len(config) > 0:
+            span_attributes["dspy.optimizer.config"] = json.dumps(config)
+
+        attributes = FrameworkSpanAttributes(**span_attributes)
+        with tracer.start_as_current_span(
+            operation_name, kind=SpanKind.CLIENT
+        ) as span:
+            _set_input_attributes(span, kwargs, attributes)
+
+            try:
+                result = wrapped(*args, **kwargs)
+                if result:
+                    span.set_status(Status(StatusCode.OK))
+
+                span.end()
+                return result
+
+            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(Status(StatusCode.ERROR, str(err)))
+
+                # Reraise the exception to ensure it's not swallowed
+                raise
+
+    return traced_method
+
+
+def patch_signature(operation_name, version, tracer):
+    def traced_method(wrapped, instance, args, kwargs):
+
+        service_provider = SERVICE_PROVIDERS["DSPY"]
+        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 {}),
+        }
+
+        if instance.__class__.__name__:
+            span_attributes["dspy.signature.name"] = instance.__class__.__name__
+            span_attributes["dspy.signature"] = str(instance)
+
+        if kwargs and len(kwargs) > 0:
+            span_attributes["dspy.signature.args"] = str(kwargs)
+
+        attributes = FrameworkSpanAttributes(**span_attributes)
+        with tracer.start_as_current_span(
+            operation_name, kind=SpanKind.CLIENT
+        ) as span:
+            _set_input_attributes(span, kwargs, attributes)
+
+            try:
+                result = wrapped(*args, **kwargs)
+                if result:
+                    set_span_attribute(span, "dspy.signature.result", str(result))
+                    span.set_status(Status(StatusCode.OK))
+
+                span.end()
+                return result
+
+            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(Status(StatusCode.ERROR, str(err)))
+
+                # Reraise the exception to ensure it's not swallowed
+                raise
+
+    return traced_method
+
+
+def patch_evaluate(operation_name, version, tracer):
+    def traced_method(wrapped, instance, args, kwargs):
+
+        service_provider = SERVICE_PROVIDERS["DSPY"]
+        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 {}),
+        }
+
+        if "devset" in instance and instance.devset is not None:
+            span_attributes["dspy.evaluate.devset"] = str(instance.devset)
+        if "display" in instance and instance.display is not None:
+            span_attributes["dspy.evaluate.display"] = str(instance.display)
+        if "num_threads" in instance and instance.num_threads is not None:
+            span_attributes["dspy.evaluate.num_threads"] = str(instance.num_threads)
+        if "return_outputs" in instance and instance.return_outputs is not None:
+            span_attributes["dspy.evaluate.return_outputs"] = str(instance.return_outputs)
+        if "display_table" in instance and instance.display_table is not None:
+            span_attributes["dspy.evaluate.display_table"] = str(instance.display_table)
+        if "display_progress" in instance and instance.display_progress is not None:
+            span_attributes["dspy.evaluate.display_progress"] = str(instance.display_progress)
+        if "metric" in instance and instance.metric is not None:
+            span_attributes["dspy.evaluate.metric"] = instance.metric.__name__
+        if "error_count" in instance and instance.error_count is not None:
+            span_attributes["dspy.evaluate.error_count"] = str(instance.error_count)
+        if "error_lock" in instance and instance.error_lock is not None:
+            span_attributes["dspy.evaluate.error_lock"] = str(instance.error_lock)
+        if "max_errors" in instance and instance.max_errors is not None:
+            span_attributes["dspy.evaluate.max_errors"] = str(instance.max_errors)
+        if args and len(args) > 0:
+            span_attributes["dspy.evaluate.args"] = str(args)
+
+        attributes = FrameworkSpanAttributes(**span_attributes)
+        with tracer.start_as_current_span(
+            operation_name, kind=SpanKind.CLIENT
+        ) as span:
+            _set_input_attributes(span, kwargs, attributes)
+
+            try:
+                result = wrapped(*args, **kwargs)
+                if result is not None:
+                    set_span_attribute(span, "dspy.evaluate.result", str(result))
+                    span.set_status(Status(StatusCode.OK))
+
+                span.end()
+                return result
+
+            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(Status(StatusCode.ERROR, str(err)))
+
+                # Reraise the exception to ensure it's not swallowed
+                raise
+
+    return traced_method
+
+
+@silently_fail
+def _set_input_attributes(span, kwargs, attributes):
+    for field, value in attributes.model_dump(by_alias=True).items():
+        set_span_attribute(span, field, value)

langtrace_python_sdk/instrumentation/openai/patch.py

@@ -275,6 +275,110 @@ def images_edit(original_method, version, tracer):
     return traced_method
 
 
+class StreamWrapper:
+    def __init__(self, stream, span, prompt_tokens, function_call=False, tool_calls=False):
+        self.stream = stream
+        self.span = span
+        self.prompt_tokens = prompt_tokens
+        self.function_call = function_call
+        self.tool_calls = tool_calls
+        self.result_content = []
+        self.completion_tokens = 0
+
+    def __enter__(self):
+        self.span.add_event(Event.STREAM_START.value)
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.span.add_event(Event.STREAM_END.value)
+        self.span.set_attribute(
+            "llm.token.counts",
+            json.dumps(
+                {
+                    "input_tokens": self.prompt_tokens,
+                    "output_tokens": self.completion_tokens,
+                    "total_tokens": self.prompt_tokens + self.completion_tokens,
+                }
+            ),
+        )
+        self.span.set_attribute(
+            "llm.responses",
+            json.dumps(
+                [
+                    {
+                        "role": "assistant",
+                        "content": "".join(self.result_content),
+                    }
+                ]
+            ),
+        )
+        self.span.set_status(StatusCode.OK)
+        self.span.end()
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        try:
+            chunk = next(self.stream)
+            self.process_chunk(chunk)
+            return chunk
+        except StopIteration:
+            raise
+
+    def process_chunk(self, chunk):
+        if hasattr(chunk, "model") and chunk.model is not None:
+            self.span.set_attribute("llm.model", chunk.model)
+        if hasattr(chunk, "choices") and chunk.choices is not None:
+            content = []
+            if not self.function_call and not self.tool_calls:
+                for choice in chunk.choices:
+                    if choice.delta and choice.delta.content is not None:
+                        token_counts = estimate_tokens(choice.delta.content)
+                        self.completion_tokens += token_counts
+                        content = [choice.delta.content]
+            elif self.function_call:
+                for choice in chunk.choices:
+                    if (
+                        choice.delta
+                        and choice.delta.function_call is not None
+                        and choice.delta.function_call.arguments is not None
+                    ):
+                        token_counts = estimate_tokens(
+                            choice.delta.function_call.arguments
+                        )
+                        self.completion_tokens += token_counts
+                        content = [choice.delta.function_call.arguments]
+            elif self.tool_calls:
+                for choice in chunk.choices:
+                    if choice.delta and choice.delta.tool_calls is not None:
+                        toolcalls = choice.delta.tool_calls
+                        content = []
+                        for tool_call in toolcalls:
+                            if (
+                                tool_call
+                                and tool_call.function is not None
+                                and tool_call.function.arguments is not None
+                            ):
+                                token_counts = estimate_tokens(
+                                    tool_call.function.arguments
+                                )
+                                self.completion_tokens += token_counts
+                                content.append(tool_call.function.arguments)
+            self.span.add_event(
+                Event.STREAM_OUTPUT.value,
+                {
+                    "response": (
+                        "".join(content)
+                        if len(content) > 0 and content[0] is not None
+                        else ""
+                    )
+                },
+            )
+            if content:
+                self.result_content.append(content[0])
+
+
 def chat_completions_create(original_method, version, tracer):
     """Wrap the `create` method of the `ChatCompletion` class to trace it."""
 
@@ -427,7 +531,7 @@ def chat_completions_create(original_method, version, tracer):
                             json.dumps(function), kwargs.get("model")
                         )
 
-                return handle_streaming_response(
+                return StreamWrapper(
                     result,
                     span,
                     prompt_tokens,
@@ -441,98 +545,6 @@ def chat_completions_create(original_method, version, tracer):
             span.end()
             raise
 
-    def handle_streaming_response(
-        result, span, prompt_tokens, function_call=False, tool_calls=False
-    ):
-        """Process and yield streaming response chunks."""
-        result_content = []
-        span.add_event(Event.STREAM_START.value)
-        completion_tokens = 0
-        try:
-            for chunk in result:
-                if hasattr(chunk, "model") and chunk.model is not None:
-                    span.set_attribute("llm.model", chunk.model)
-                if hasattr(chunk, "choices") and chunk.choices is not None:
-                    if not function_call and not tool_calls:
-                        for choice in chunk.choices:
-                            if choice.delta and choice.delta.content is not None:
-                                token_counts = estimate_tokens(choice.delta.content)
-                                completion_tokens += token_counts
-                                content = [choice.delta.content]
-                    elif function_call:
-                        for choice in chunk.choices:
-                            if (
-                                choice.delta
-                                and choice.delta.function_call is not None
-                                and choice.delta.function_call.arguments is not None
-                            ):
-                                token_counts = estimate_tokens(
-                                    choice.delta.function_call.arguments
-                                )
-                                completion_tokens += token_counts
-                                content = [choice.delta.function_call.arguments]
-                    elif tool_calls:
-                        for choice in chunk.choices:
-                            tool_call = ""
-                            if choice.delta and choice.delta.tool_calls is not None:
-                                toolcalls = choice.delta.tool_calls
-                                content = []
-                                for tool_call in toolcalls:
-                                    if (
-                                        tool_call
-                                        and tool_call.function is not None
-                                        and tool_call.function.arguments is not None
-                                    ):
-                                        token_counts = estimate_tokens(
-                                            tool_call.function.arguments
-                                        )
-                                        completion_tokens += token_counts
-                                        content = content + [
-                                            tool_call.function.arguments
-                                        ]
-                                    else:
-                                        content = content + []
-                else:
-                    content = []
-                span.add_event(
-                    Event.STREAM_OUTPUT.value,
-                    {
-                        "response": (
-                            "".join(content)
-                            if len(content) > 0 and content[0] is not None
-                            else ""
-                        )
-                    },
-                )
-                result_content.append(content[0] if len(content) > 0 else "")
-                yield chunk
-        finally:
-            # Finalize span after processing all chunks
-            span.add_event(Event.STREAM_END.value)
-            span.set_attribute(
-                "llm.token.counts",
-                json.dumps(
-                    {
-                        "input_tokens": prompt_tokens,
-                        "output_tokens": completion_tokens,
-                        "total_tokens": prompt_tokens + completion_tokens,
-                    }
-                ),
-            )
-            span.set_attribute(
-                "llm.responses",
-                json.dumps(
-                    [
-                        {
-                            "role": "assistant",
-                            "content": "".join(result_content),
-                        }
-                    ]
-                ),
-            )
-            span.set_status(StatusCode.OK)
-            span.end()
-
     # return the wrapped method
     return traced_method
 
@@ -687,7 +699,7 @@ def async_chat_completions_create(original_method, version, tracer):
                             json.dumps(function), kwargs.get("model")
                         )
 
-                return ahandle_streaming_response(
+                return StreamWrapper(
                     result,
                     span,
                     prompt_tokens,
@@ -701,99 +713,6 @@ def async_chat_completions_create(original_method, version, tracer):
             span.end()
             raise
 
-    async def ahandle_streaming_response(
-        result, span, prompt_tokens, function_call=False, tool_calls=False
-    ):
-        """Process and yield streaming response chunks."""
-        result_content = []
-        span.add_event(Event.STREAM_START.value)
-        completion_tokens = 0
-        try:
-            content = []
-            async for chunk in result:
-                if hasattr(chunk, "model") and chunk.model is not None:
-                    span.set_attribute("llm.model", chunk.model)
-                if hasattr(chunk, "choices") and chunk.choices is not None:
-                    if not function_call and not tool_calls:
-                        for choice in chunk.choices:
-                            if choice.delta and choice.delta.content is not None:
-                                token_counts = estimate_tokens(choice.delta.content)
-                                completion_tokens += token_counts
-                                content = [choice.delta.content]
-                    elif function_call:
-                        for choice in chunk.choices:
-                            if (
-                                choice.delta
-                                and choice.delta.function_call
-                                and choice.delta.function_call.arguments is not None
-                            ):
-                                token_counts = estimate_tokens(
-                                    choice.delta.function_call.arguments
-                                )
-                                completion_tokens += token_counts
-                                content = [choice.delta.function_call.arguments]
-                    elif tool_calls:
-                        for choice in chunk.choices:
-                            tool_call = ""
-                            if choice.delta and choice.delta.tool_calls is not None:
-                                toolcalls = choice.delta.tool_calls
-                                content = []
-                                for tool_call in toolcalls:
-                                    if (
-                                        tool_call
-                                        and tool_call.function is not None
-                                        and tool_call.function.arguments is not None
-                                    ):
-                                        token_counts = estimate_tokens(
-                                            tool_call.function.arguments
-                                        )
-                                        completion_tokens += token_counts
-                                        content = content + [
-                                            tool_call.function.arguments
-                                        ]
-                                    else:
-                                        content = content + []
-                else:
-                    content = []
-                span.add_event(
-                    Event.STREAM_OUTPUT.value,
-                    {
-                        "response": (
-                            "".join(content)
-                            if len(content) > 0 and content[0] is not None
-                            else ""
-                        )
-                    },
-                )
-                result_content.append(content[0] if len(content) > 0 else "")
-                yield chunk
-        finally:
-            # Finalize span after processing all chunks
-            span.add_event(Event.STREAM_END.value)
-            span.set_attribute(
-                "llm.token.counts",
-                json.dumps(
-                    {
-                        "input_tokens": prompt_tokens,
-                        "output_tokens": completion_tokens,
-                        "total_tokens": prompt_tokens + completion_tokens,
-                    }
-                ),
-            )
-            span.set_attribute(
-                "llm.responses",
-                json.dumps(
-                    [
-                        {
-                            "role": "assistant",
-                            "content": "".join(result_content),
-                        }
-                    ]
-                ),
-            )
-            span.set_status(StatusCode.OK)
-            span.end()
-
     # return the wrapped method
     return traced_method
 

langtrace_python_sdk/langtrace.py

@@ -40,6 +40,7 @@ from langtrace_python_sdk.instrumentation import (
     AnthropicInstrumentation,
     ChromaInstrumentation,
     CohereInstrumentation,
+    CrewAIInstrumentation,
     GroqInstrumentation,
     LangchainInstrumentation,
     LangchainCommunityInstrumentation,
@@ -51,6 +52,7 @@ from langtrace_python_sdk.instrumentation import (
     QdrantInstrumentation,
     WeaviateInstrumentation,
     OllamaInstrumentor,
+    DspyInstrumentation,
 )
 from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
 from colorama import Fore
@@ -108,6 +110,8 @@ def init(
         "weaviate": WeaviateInstrumentation(),
         "sqlalchemy": SQLAlchemyInstrumentor(),
         "ollama": OllamaInstrumentor(),
+        "dspy": DspyInstrumentation(),
+        "crewai": CrewAIInstrumentation(),
     }
 
     init_instrumentations(disable_instrumentations, all_instrumentations)

langtrace_python_sdk/version.py

@@ -1 +1 @@
-__version__ = "2.1.20"
+__version__ = "2.1.22"

{langtrace_python_sdk-2.1.20.dist-info → langtrace_python_sdk-2.1.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 2.1.20
+Version: 2.1.22
 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-2.1.20.dist-info → langtrace_python_sdk-2.1.22.dist-info}/RECORD

@@ -9,6 +9,11 @@ examples/cohere_example/chat_stream.py,sha256=daWGrj2yucN9sWKGiPzTw18clh23Grv-MI
 examples/cohere_example/embed.py,sha256=p9BJvOg09JVb8BfTCb63v3uh_wOsi_OyrCAJdXXrE6E,496
 examples/cohere_example/rerank.py,sha256=e7OU0A2FzfiQDuOmCy3Kg5LLNYGRmRIK5LqeLnTWlP4,1118
 examples/cohere_example/tools.py,sha256=a5uvS058tcwU6PJbF9EDO6LPVmPj2LoW4Vn8Web3Iq8,1656
+examples/crewai_example/basic.py,sha256=PBu4f8yQfZO1L_22UDm_ReU9lnEcycjZcGuy5UpgDJM,1948
+examples/dspy_example/math_problems_cot.py,sha256=Z98nB6myt8WJse2dWS6Ap7CFUhC27lBNb37R1Gg80VQ,1282
+examples/dspy_example/program_of_thought_basic.py,sha256=oEbtJdeKENMUbex25-zyStWwurRWW6OdP0KDs-jUkko,984
+examples/dspy_example/quiz_gen.py,sha256=OyGhepeX8meKOtLdmlYUjMD2ECk-ZQuQXUZif1hFQY4,3371
+examples/dspy_example/react.py,sha256=dmhO6AyO5K3w0WNkwe-Usd2cIgVmEPoWzusrLxXIfPo,1340
 examples/fastapi_example/__init__.py,sha256=INIfvJP7zC_KkJCtulS1qbh61-MJTPAHnzAgzeKi0yU,87
 examples/fastapi_example/basic_route.py,sha256=_IRXjkOtJQ-bTIGa1WbvUF_2LF4bjghjyXt4YrHaRvw,1170
 examples/hiveagent_example/basic.py,sha256=Sd7I5w8w5Xx7ODaydTY30yiq9HwJDMKHQywrZjgehP0,441
@@ -45,15 +50,15 @@ examples/qdrant_example/basic.py,sha256=DCMjHSuBZKkhEjCkwy5d5La9WMyW0lCWqtcZWiFC
 examples/weaviate_example/__init__.py,sha256=8JMDBsRSEV10HfTd-YC7xb4txBjD3la56snk-Bbg2Kw,618
 examples/weaviate_example/query_text.py,sha256=qz9o-fTDzX5AW5m8BJF-TfmBdokxh492NfnmnPUMU3s,64814
 langtrace_python_sdk/__init__.py,sha256=VZM6i71NR7pBQK6XvJWRelknuTYUhqwqE7PlicKa5Wg,1166
-langtrace_python_sdk/langtrace.py,sha256=WRgbBS7T1q3ZELvVZLVCKdqa00m64lozgeiCp6MOQn8,7352
-langtrace_python_sdk/version.py,sha256=1o03qONF3c4_EpFCJ6aUvh-e6t48L0nm4t4sDu21mEA,23
+langtrace_python_sdk/langtrace.py,sha256=pG_dWzzQxUP8r5SAMUwRScb6IopINcda1CZvJERjXBo,7486
+langtrace_python_sdk/version.py,sha256=8X_w-VRCyU1lQMWejIqkf5tmhnrgO7csLi27xV88LJs,23
 langtrace_python_sdk/constants/__init__.py,sha256=P8QvYwt5czUNDZsKS64vxm9Dc41ptGbuF1TFtAF6nv4,44
 langtrace_python_sdk/constants/exporter/langtrace_exporter.py,sha256=5MNjnAOg-4am78J3gVMH6FSwq5N8TOj72ugkhsw4vi0,46
 langtrace_python_sdk/constants/instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/constants/instrumentation/anthropic.py,sha256=YX3llt3zwDY6XrYk3CB8WEVqgrzRXEw_ffyk56JoF3k,126
 langtrace_python_sdk/constants/instrumentation/chroma.py,sha256=hiPGYdHS0Yj4Kh3eaYBbuCAl_swqIygu80yFqkOgdak,955
 langtrace_python_sdk/constants/instrumentation/cohere.py,sha256=tf9sDfb5K3qOAHChEE5o8eYWPZ1io58VsOjZDCZPxfw,577
-langtrace_python_sdk/constants/instrumentation/common.py,sha256=UyYObokJpNPOPft_TPmhP00WONV0KqKOkX6mvN3AH5w,806
+langtrace_python_sdk/constants/instrumentation/common.py,sha256=KodH_uGGjWGGP8rqTi7Ua-osjUwtPKslx69DJRbDiT4,850
 langtrace_python_sdk/constants/instrumentation/groq.py,sha256=VFXmIl4aqGY_fS0PAmjPj_Qm7Tibxbx7Ur_e7rQpqXc,134
 langtrace_python_sdk/constants/instrumentation/ollama.py,sha256=zFfSUKX5v1c612doKSxsmIwQeeQxSPkFp_ZzjWQSPNE,142
 langtrace_python_sdk/constants/instrumentation/openai.py,sha256=uEOH5UXapU2DSf2AdgXTRhhJEHGWXUNFkUGD5QafflM,1164
@@ -63,7 +68,7 @@ langtrace_python_sdk/constants/instrumentation/weaviate.py,sha256=Iytf2OpB_irZYE
 langtrace_python_sdk/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langtrace_python_sdk/extensions/langtrace_exporter.py,sha256=gWVRU2DlB4xjZ4ww7M63DaLiAN5zQ2k1HPrythmjEdo,4202
 langtrace_python_sdk/extensions/langtrace_filesystem.py,sha256=qpnkpkuTZ2yhGgpBK64QJLt0T1iL-1zpEMPz4quJ_ng,6925
-langtrace_python_sdk/instrumentation/__init__.py,sha256=18E7qZOIKmSm59ij7n-ytCv3qenjkDlNz9xPjapOLtY,1107
+langtrace_python_sdk/instrumentation/__init__.py,sha256=BYTzQSmHDbKAbtV98UDjxzV1UoNq_wtsWV7V4PZPzbc,1243
 langtrace_python_sdk/instrumentation/anthropic/__init__.py,sha256=donrurJAGYlxrSRA3BIf76jGeUcAx9Tq8CVpah68S0Y,101
 langtrace_python_sdk/instrumentation/anthropic/instrumentation.py,sha256=-srgE8qumAn0ulQYZxMa8ch-9IBH0XgBW_rfEnGk6LI,1684
 langtrace_python_sdk/instrumentation/anthropic/patch.py,sha256=52GRkW7fhF2VB9JvYGMaPwOvWH3Q5rsIEaVlnFm_Zz0,8548
@@ -73,6 +78,12 @@ langtrace_python_sdk/instrumentation/chroma/patch.py,sha256=HhIkXGbVfzpEB4edxzlG
 langtrace_python_sdk/instrumentation/cohere/__init__.py,sha256=sGUSLdTUyYf36Tm6L5jQflhzCqvmWrhnBOMYHjvp6Hs,95
 langtrace_python_sdk/instrumentation/cohere/instrumentation.py,sha256=YQFHZIBd7SSPD4b6Va-ZR0thf_AuBCqj5yzHLHJVWnM,2121
 langtrace_python_sdk/instrumentation/cohere/patch.py,sha256=uGjZm_c1-xpZilHD8ljGr4AqQB3UNU04SKl9s2alGzs,26726
+langtrace_python_sdk/instrumentation/crewai/__init__.py,sha256=_UBKfvQv7l0g2_wnmA5F6CdSAFH0atNOVPd49zsN3aM,88
+langtrace_python_sdk/instrumentation/crewai/instrumentation.py,sha256=W8PLTLzgEdrEx1DCo79wNs9xcuWK0YuxEICLavOESDw,1715
+langtrace_python_sdk/instrumentation/crewai/patch.py,sha256=Vnpip9Pbk4UFbTFHoUrHtAnDgsaihwSvZBgtUeOtLr8,6109
+langtrace_python_sdk/instrumentation/dspy/__init__.py,sha256=tM1srfi_QgyCzrde4izojMrRq2Wm7Dj5QUvVQXIJzkk,84
+langtrace_python_sdk/instrumentation/dspy/instrumentation.py,sha256=Y-_qcH5jCT4TbGvci6Iw0_OWUUlCmovMxnysj6NCnXI,2923
+langtrace_python_sdk/instrumentation/dspy/patch.py,sha256=0zBlrzvGmQEhJpb44L8fkTIhMH5i5pWOkYoSH9e8D6U,9216
 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=EKH9tjoDbwWavIAwUadaR5tFiy-S69h1IxxzH_1SSRg,26354
@@ -96,7 +107,7 @@ langtrace_python_sdk/instrumentation/ollama/instrumentation.py,sha256=jdsvkqUJAA
 langtrace_python_sdk/instrumentation/ollama/patch.py,sha256=CGLgt0qZg3WDr6XLn32qqs4D9USdMmeTmJxctbAsDeM,7908
 langtrace_python_sdk/instrumentation/openai/__init__.py,sha256=VPHRNCQEdkizIVP2d0Uw_a7t8XOTSTprEIB8oboJFbs,95
 langtrace_python_sdk/instrumentation/openai/instrumentation.py,sha256=A0BJHRLcZ74TNVg6I0I9M5YWvSpAtXwMmME6N5CEQ_M,2945
-langtrace_python_sdk/instrumentation/openai/patch.py,sha256=uUoeeZMAlH8PTZyIObjAI8kU2H5iHuZbPF09Gk70IKo,41103
+langtrace_python_sdk/instrumentation/openai/patch.py,sha256=-eKopJp6m56mg4553wrDr0ibGoCPpYH2iyNMh1lX9yc,36526
 langtrace_python_sdk/instrumentation/pinecone/__init__.py,sha256=DzXyGh9_MGWveJvXULkFwdkf7PbG2s3bAWtT1Dmz7Ok,99
 langtrace_python_sdk/instrumentation/pinecone/instrumentation.py,sha256=HDXkRITrVPwdQEoOYJOfMzZE_2-vDDvuqHTlD8W1lQw,1845
 langtrace_python_sdk/instrumentation/pinecone/patch.py,sha256=KiIRRz8kk47FllFT746Cb_w6F6M60AN_pcsguD979E4,5172
@@ -152,8 +163,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-2.1.20.dist-info/METADATA,sha256=0cem4DCsGpcKB8mDxKYrizbmBXNfjyD8tB6ZL3xg2Sk,13161
-langtrace_python_sdk-2.1.20.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
-langtrace_python_sdk-2.1.20.dist-info/entry_points.txt,sha256=1_b9-qvf2fE7uQNZcbUei9vLpFZBbbh9LrtGw95ssAo,70
-langtrace_python_sdk-2.1.20.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-langtrace_python_sdk-2.1.20.dist-info/RECORD,,
+langtrace_python_sdk-2.1.22.dist-info/METADATA,sha256=OBp1W_aK6Om6TkkaFfhhyo-7tSDZ3TC49Hdbs6KdFR0,13161
+langtrace_python_sdk-2.1.22.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+langtrace_python_sdk-2.1.22.dist-info/entry_points.txt,sha256=1_b9-qvf2fE7uQNZcbUei9vLpFZBbbh9LrtGw95ssAo,70
+langtrace_python_sdk-2.1.22.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+langtrace_python_sdk-2.1.22.dist-info/RECORD,,

{langtrace_python_sdk-2.1.20.dist-info → langtrace_python_sdk-2.1.22.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.24.2
+Generator: hatchling 1.25.0
 Root-Is-Purelib: true
 Tag: py3-none-any