opentelemetry-instrumentation-crewai 0.36.0__py3-none-any.whl

opentelemetry/instrumentation/crewai/__init__.py

@@ -0,0 +1,5 @@
+"""OpenTelemetry CrewAI instrumentation"""
+from opentelemetry.instrumentation.crewai.version import __version__
+from opentelemetry.instrumentation.crewai.instrumentation import CrewAIInstrumentor
+
+__all__ = ["CrewAIInstrumentor", "__version__"]

opentelemetry/instrumentation/crewai/crewai_span_attributes.py

@@ -0,0 +1,150 @@
+from opentelemetry.trace import Span
+import json
+
+
+def set_span_attribute(span: Span, name, value):
+    if value is not None:
+        if value != "":
+            span.set_attribute(name, value)
+    return
+
+
+class CrewAISpanAttributes:
+    def __init__(self, span: Span, instance) -> None:
+        self.span = span
+        self.instance = instance
+        self.crew = {"tasks": [], "agents": [], "llms": []}
+        self.process_instance()
+
+    def process_instance(self):
+        instance_type = self.instance.__class__.__name__
+        method_mapping = {
+            "Crew": self._process_crew,
+            "Agent": self._process_agent,
+            "Task": self._process_task,
+            "LLM": self._process_llm,
+        }
+        method = method_mapping.get(instance_type)
+        if method:
+            method()
+
+    def _process_crew(self):
+        self._populate_crew_attributes()
+        for key, value in self.crew.items():
+            self._set_attribute(f"crewai.crew.{key}", value)
+
+    def _process_agent(self):
+        agent_data = self._populate_agent_attributes()
+        for key, value in agent_data.items():
+            self._set_attribute(f"crewai.agent.{key}", value)
+
+    def _process_task(self):
+        task_data = self._populate_task_attributes()
+        for key, value in task_data.items():
+            self._set_attribute(f"crewai.task.{key}", value)
+
+    def _process_llm(self):
+        llm_data = self._populate_llm_attributes()
+        for key, value in llm_data.items():
+            self._set_attribute(f"crewai.llm.{key}", value)
+
+    def _populate_crew_attributes(self):
+        for key, value in self.instance.__dict__.items():
+            if value is None:
+                continue
+            if key == "tasks":
+                self._parse_tasks(value)
+            elif key == "agents":
+                self._parse_agents(value)
+            elif key == "llms":
+                self._parse_llms(value)
+            else:
+                self.crew[key] = str(value)
+
+    def _populate_agent_attributes(self):
+        return self._extract_attributes(self.instance)
+
+    def _populate_task_attributes(self):
+        task_data = self._extract_attributes(self.instance)
+        if "agent" in task_data:
+            task_data["agent"] = self.instance.agent.role if self.instance.agent else None
+        return task_data
+
+    def _populate_llm_attributes(self):
+        return self._extract_attributes(self.instance)
+
+    def _parse_agents(self, agents):
+        self.crew["agents"] = [
+            self._extract_agent_data(agent) for agent in agents if agent is not None
+        ]
+
+    def _parse_tasks(self, tasks):
+        self.crew["tasks"] = [
+            {
+                "agent": task.agent.role if task.agent else None,
+                "description": task.description,
+                "async_execution": task.async_execution,
+                "expected_output": task.expected_output,
+                "human_input": task.human_input,
+                "tools": task.tools,
+                "output_file": task.output_file,
+            }
+            for task in tasks
+        ]
+
+    def _parse_llms(self, llms):
+        self.crew["tasks"] = [
+            {
+                "temperature": llm.temperature,
+                "max_tokens": llm.max_tokens,
+                "max_completion_tokens": llm.max_completion_tokens,
+                "top_p": llm.top_p,
+                "n": llm.n,
+                "seed": llm.seed,
+                "base_url": llm.base_url,
+                "api_version": llm.api_version, }
+            for llm in llms
+        ]
+
+    def _extract_agent_data(self, agent):
+        model = (
+            getattr(agent.llm, "model", None)
+            or getattr(agent.llm, "model_name", None)
+            or ""
+        )
+
+        return {
+            "id": str(agent.id),
+            "role": agent.role,
+            "goal": agent.goal,
+            "backstory": agent.backstory,
+            "cache": agent.cache,
+            "config": agent.config,
+            "verbose": agent.verbose,
+            "allow_delegation": agent.allow_delegation,
+            "tools": agent.tools,
+            "max_iter": agent.max_iter,
+            "llm": str(model), }
+
+    def _extract_attributes(self, obj):
+        attributes = {}
+        for key, value in obj.__dict__.items():
+            if value is None:
+                continue
+            if key == "tools":
+                attributes[key] = self._serialize_tools(value)
+            else:
+                attributes[key] = str(value)
+        return attributes
+
+    def _serialize_tools(self, tools):
+        return json.dumps(
+            [
+                {k: v for k, v in vars(tool).items() if v is not None and k in ["name", "description"]}
+                for tool in tools
+            ]
+        )
+
+    def _set_attribute(self, key, value):
+        if value:
+            set_span_attribute(self.span, key, str(value) if isinstance(value, list) else value)

opentelemetry/instrumentation/crewai/instrumentation.py

@@ -0,0 +1,127 @@
+from typing import Collection
+from wrapt import wrap_function_wrapper
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.trace import SpanKind, get_tracer
+from opentelemetry.trace.status import Status, StatusCode
+from opentelemetry.instrumentation.crewai.version import __version__
+from opentelemetry.semconv_ai import SpanAttributes, TraceloopSpanKindValues
+from .crewai_span_attributes import CrewAISpanAttributes, set_span_attribute
+
+_instruments = ("crewai >= 0.70.0",)
+
+
+class CrewAIInstrumentor(BaseInstrumentor):
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, __version__, tracer_provider)
+
+        wrap_function_wrapper("crewai.crew", "Crew.kickoff", wrap_kickoff(tracer))
+        wrap_function_wrapper("crewai.agent", "Agent.execute_task", wrap_agent_execute_task(tracer))
+        wrap_function_wrapper("crewai.task", "Task.execute_sync", wrap_task_execute(tracer))
+        wrap_function_wrapper("crewai.llm", "LLM.call", wrap_llm_call(tracer))
+
+    def _uninstrument(self, **kwargs):
+        pass
+
+
+def with_tracer_wrapper(func):
+    """Helper for providing tracer for wrapper functions."""
+
+    def _with_tracer(tracer):
+        def wrapper(wrapped, instance, args, kwargs):
+            return func(tracer, wrapped, instance, args, kwargs)
+        return wrapper
+    return _with_tracer
+
+
+@with_tracer_wrapper
+def wrap_kickoff(tracer, wrapped, instance, args, kwargs):
+    with tracer.start_as_current_span(
+        "crewai.workflow",
+        kind=SpanKind.INTERNAL,
+        attributes={
+        }
+    ) as span:
+        try:
+            CrewAISpanAttributes(span=span, instance=instance)
+            result = wrapped(*args, **kwargs)
+            if result:
+                class_name = instance.__class__.__name__
+                span.set_attribute(f"crewai.{class_name.lower()}.result", str(result))
+                span.set_status(Status(StatusCode.OK))
+                if class_name == "Crew":
+                    for attr in ["tasks_output", "token_usage", "usage_metrics"]:
+                        if hasattr(result, attr):
+                            span.set_attribute(f"crewai.crew.{attr}", str(getattr(result, attr)))
+            return result
+        except Exception as ex:
+            span.set_status(Status(StatusCode.ERROR, str(ex)))
+            raise
+
+
+@with_tracer_wrapper
+def wrap_agent_execute_task(tracer, wrapped, instance, args, kwargs):
+    agent_name = instance.role if hasattr(instance, "role") else "agent"
+    with tracer.start_as_current_span(
+        f"{agent_name}.agent",
+        kind=SpanKind.CLIENT,
+        attributes={
+            SpanAttributes.TRACELOOP_SPAN_KIND: TraceloopSpanKindValues.AGENT.value,
+        }
+    ) as span:
+        try:
+            CrewAISpanAttributes(span=span, instance=instance)
+            result = wrapped(*args, **kwargs)
+            set_span_attribute(span, SpanAttributes.LLM_REQUEST_MODEL, str(instance.llm.model))
+            span.set_status(Status(StatusCode.OK))
+            return result
+        except Exception as ex:
+            span.set_status(Status(StatusCode.ERROR, str(ex)))
+            raise
+
+
+@with_tracer_wrapper
+def wrap_task_execute(tracer, wrapped, instance, args, kwargs):
+    task_name = instance.description if hasattr(instance, "description") else "task"
+
+    with tracer.start_as_current_span(
+        f"{task_name}.task",
+        kind=SpanKind.CLIENT,
+        attributes={
+            SpanAttributes.TRACELOOP_SPAN_KIND: TraceloopSpanKindValues.TASK.value,
+        }
+    ) as span:
+        try:
+            CrewAISpanAttributes(span=span, instance=instance)
+            result = wrapped(*args, **kwargs)
+            set_span_attribute(span, SpanAttributes.TRACELOOP_ENTITY_OUTPUT, str(result))
+            span.set_status(Status(StatusCode.OK))
+            return result
+        except Exception as ex:
+            span.set_status(Status(StatusCode.ERROR, str(ex)))
+            raise
+
+
+@with_tracer_wrapper
+def wrap_llm_call(tracer, wrapped, instance, args, kwargs):
+    llm = instance.model if hasattr(instance, "model") else "llm"
+    with tracer.start_as_current_span(
+        f"{llm}.llm",
+        kind=SpanKind.CLIENT,
+        attributes={
+        }
+    ) as span:
+        try:
+            CrewAISpanAttributes(span=span, instance=instance)
+            result = wrapped(*args, **kwargs)
+            set_span_attribute(span, SpanAttributes.LLM_SYSTEM, "crewai")
+            set_span_attribute(span, SpanAttributes.LLM_REQUEST_MODEL, str(instance.model))
+            span.set_status(Status(StatusCode.OK))
+            return result
+        except Exception as ex:
+            span.set_status(Status(StatusCode.ERROR, str(ex)))
+            raise

opentelemetry/instrumentation/crewai/version.py

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

opentelemetry_instrumentation_crewai-0.36.0.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: opentelemetry-instrumentation-crewai
+Version: 0.36.0
+Summary: OpenTelemetry crewAI instrumentation
+Home-page: https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-crewai
+License: Apache-2.0
+Author: Gal Kleinman
+Author-email: gal@traceloop.com
+Requires-Python: >=3.10,<=3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: instruments
+Requires-Dist: opentelemetry-api (>=1.28.0,<2.0.0)
+Requires-Dist: opentelemetry-instrumentation (>=0.50b0)
+Requires-Dist: opentelemetry-semantic-conventions (>=0.50b0)
+Requires-Dist: opentelemetry-semantic-conventions-ai (==0.4.2)
+Project-URL: Repository, https://github.com/traceloop/openllmetry/tree/main/packages/opentelemetry-instrumentation-crewai
+Description-Content-Type: text/markdown
+
+# OpenTelemetry CrewAI Instrumentation
+
+<a href="https://pypi.org/project/opentelemetry-instrumentation-crewai/">
+    <img src="https://badge.fury.io/py/opentelemetry-instrumentation-crewai.svg">
+</a>
+
+This library allows tracing agentic workflows implemented with crewAI framework [crewAI library](https://github.com/crewAIInc/crewAI).
+
+## Installation
+
+```bash
+pip install opentelemetry-instrumentation-crewai
+```
+
+## Example usage
+
+```python
+from opentelemetry.instrumentation.crewai import CrewAIInstrumentor
+
+CrewAIInstrumentor().instrument()
+```
+
+## Privacy
+
+**By default, this instrumentation logs prompts, completions, and embeddings to span attributes**. This gives you a clear visibility into how your LLM application is working, and can make it easy to debug and evaluate the quality of the outputs.
+
+However, you may want to disable this logging for privacy reasons, as they may contain highly sensitive data from your users. You may also simply want to reduce the size of your traces.
+
+To disable logging, set the `TRACELOOP_TRACE_CONTENT` environment variable to `false`.
+
+```bash
+TRACELOOP_TRACE_CONTENT=false
+```
+

opentelemetry_instrumentation_crewai-0.36.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+opentelemetry/instrumentation/crewai/__init__.py,sha256=zdNyWV62d5IaueXR9clUD_c9F32MF39AIchZf66XI2c,245
+opentelemetry/instrumentation/crewai/crewai_span_attributes.py,sha256=9ax6fn0IT4dqH2iaRG8VIZ0SWTkxQrMTiF7DWUdwfy0,4945
+opentelemetry/instrumentation/crewai/instrumentation.py,sha256=_Y8dmgwYoSRkDAYSoR9zNkgQYAk1aqSTkDoQIsjV5DI,4867
+opentelemetry/instrumentation/crewai/version.py,sha256=ITH8IVCEQOekRajZpPo6sKNlMBNDRQRnzipIN0dqXoc,23
+opentelemetry_instrumentation_crewai-0.36.0.dist-info/METADATA,sha256=kiaD-n1C8INWdka9UjRmiOgtBK9jq4TIh4EG5txya04,2155
+opentelemetry_instrumentation_crewai-0.36.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+opentelemetry_instrumentation_crewai-0.36.0.dist-info/entry_points.txt,sha256=4Zs98MjB2HIaX8fk8evs41x1J1xBNfztvPN428bf_b8,93
+opentelemetry_instrumentation_crewai-0.36.0.dist-info/RECORD,,

opentelemetry_instrumentation_crewai-0.36.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

opentelemetry_instrumentation_crewai-0.36.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[opentelemetry_instrumentor]
+crewai=opentelemetry.instrumentation.crewai:CrewAIInstrumentor
+