langtrace-python-sdk 2.1.21__tar.gz → 2.1.22__tar.gz

{langtrace_python_sdk-2.1.21 → langtrace_python_sdk-2.1.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 2.1.21
+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.22/src/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()

{langtrace_python_sdk-2.1.21 → langtrace_python_sdk-2.1.22}/src/langtrace_python_sdk/constants/instrumentation/common.py

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

{langtrace_python_sdk-2.1.21 → langtrace_python_sdk-2.1.22}/src/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,12 +13,13 @@ from .pinecone import PineconeInstrumentation
 from .qdrant import QdrantInstrumentation
 from .weaviate import WeaviateInstrumentation
 from .ollama import OllamaInstrumentor
-from .dspy import DspyInstrumentor
+from .dspy import DspyInstrumentation
 
 __all__ = [
     "AnthropicInstrumentation",
     "ChromaInstrumentation",
     "CohereInstrumentation",
+    "CrewAIInstrumentation",
     "GroqInstrumentation",
     "LangchainInstrumentation",
     "LangchainCommunityInstrumentation",
@@ -29,5 +31,5 @@ __all__ = [
     "QdrantInstrumentation",
     "WeaviateInstrumentation",
     "OllamaInstrumentor",
-    "DspyInstrumentor",
+    "DspyInstrumentation",
 ]

langtrace_python_sdk-2.1.22/src/langtrace_python_sdk/instrumentation/crewai/__init__.py

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

langtrace_python_sdk-2.1.22/src/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-2.1.22/src/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-2.1.22/src/langtrace_python_sdk/instrumentation/dspy/__init__.py

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

{langtrace_python_sdk-2.1.21 → langtrace_python_sdk-2.1.22}/src/langtrace_python_sdk/instrumentation/dspy/instrumentation.py

@@ -22,7 +22,7 @@ from importlib_metadata import version as v
 from .patch import patch_bootstrapfewshot_optimizer, patch_signature, patch_evaluate
 
 
-class DspyInstrumentor(BaseInstrumentor):
+class DspyInstrumentation(BaseInstrumentor):
     """
     The DspyInstrumentor class represents the DSPy instrumentation"""
 

{langtrace_python_sdk-2.1.21 → langtrace_python_sdk-2.1.22}/src/langtrace_python_sdk/instrumentation/dspy/patch.py

@@ -37,24 +37,24 @@ def patch_bootstrapfewshot_optimizer(operation_name, version, tracer):
                     "signature": str(args[0].prog.signature) if args[0].prog.signature else None,
                 }
                 span_attributes["dspy.optimizer.module.prog"] = json.dumps(prog)
-        if instance.metric:
+        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 instance.metric_threshold:
+        if "metric_threshold" in instance and instance.metric_threshold:
             config["metric_threshold"] = instance.metric_threshold
-        if instance.teacher_settings:
+        if "teacher_settings" in instance and instance.teacher_settings:
             config["teacher_settings"] = instance.teacher_settings
-        if instance.max_bootstrapped_demos:
+        if "max_bootstrapped_demos" in instance and instance.max_bootstrapped_demos:
             config["max_bootstrapped_demos"] = instance.max_bootstrapped_demos
-        if instance.max_labeled_demos:
+        if "max_labeled_demos" in instance and instance.max_labeled_demos:
             config["max_labeled_demos"] = instance.max_labeled_demos
-        if instance.max_rounds:
+        if "max_rounds" in instance and instance.max_rounds:
             config["max_rounds"] = instance.max_rounds
-        if instance.max_errors:
+        if "max_errors" in instance and instance.max_errors:
             config["max_errors"] = instance.max_errors
-        if instance.error_count:
+        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)
@@ -149,25 +149,25 @@ def patch_evaluate(operation_name, version, tracer):
             **(extra_attributes if extra_attributes is not None else {}),
         }
 
-        if instance.devset is not None:
+        if "devset" in instance and instance.devset is not None:
             span_attributes["dspy.evaluate.devset"] = str(instance.devset)
-        if instance.display is not None:
+        if "display" in instance and instance.display is not None:
             span_attributes["dspy.evaluate.display"] = str(instance.display)
-        if instance.num_threads is not None:
+        if "num_threads" in instance and instance.num_threads is not None:
             span_attributes["dspy.evaluate.num_threads"] = str(instance.num_threads)
-        if instance.return_outputs is not None:
+        if "return_outputs" in instance and instance.return_outputs is not None:
             span_attributes["dspy.evaluate.return_outputs"] = str(instance.return_outputs)
-        if instance.display_table is not None:
+        if "display_table" in instance and instance.display_table is not None:
             span_attributes["dspy.evaluate.display_table"] = str(instance.display_table)
-        if instance.display_progress is not None:
+        if "display_progress" in instance and instance.display_progress is not None:
             span_attributes["dspy.evaluate.display_progress"] = str(instance.display_progress)
-        if instance.metric is not None:
+        if "metric" in instance and instance.metric is not None:
             span_attributes["dspy.evaluate.metric"] = instance.metric.__name__
-        if instance.error_count is not None:
+        if "error_count" in instance and instance.error_count is not None:
             span_attributes["dspy.evaluate.error_count"] = str(instance.error_count)
-        if instance.error_lock is not None:
+        if "error_lock" in instance and instance.error_lock is not None:
             span_attributes["dspy.evaluate.error_lock"] = str(instance.error_lock)
-        if instance.max_errors is not None:
+        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)