Refactor and modify the corresponding unit tests using genai 0.3b0;

Disable the eval function and modify some version information;
Add a changelog.

Author: whoIam0987

CHANGELOG-loongsuite.md

@@ -32,3 +32,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - `loongsuite-instrumentation-mem0`: add support for mem0
   ([#67](https://github.com/alibaba/loongsuite-python-agent/pull/67))
+
+- `loongsuite-instrumentation-crewai`: add support for crewai
+  ([#87](https://github.com/alibaba/loongsuite-python-agent/pull/87))

instrumentation-loongsuite/loongsuite-instrumentation-crewai/README.md

@@ -42,7 +42,7 @@ result = crew.kickoff()
 
 ## Supported Versions
 
-- CrewAI >= 0.70.0
+- CrewAI >= 0.80.0
 
 ## References
 

instrumentation-loongsuite/loongsuite-instrumentation-crewai/pyproject.toml

@@ -22,14 +22,16 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
 ]
 dependencies = [
-  "opentelemetry-api ~= 1.34.0",
+  "opentelemetry-api ~= 1.39.1",
+  "opentelemetry-instrumentation ~= 0.60b0",
+  "opentelemetry-semantic-conventions ~= 0.60b0",
   "wrapt >= 1.0.0, < 2.0.0",
-  "opentelemetry-util-genai ~= 0.1b0",
+  "opentelemetry-util-genai ~= 0.3b0",
 ]
 
 [project.optional-dependencies]
 instruments = [
-  "crewai >= 0.1.0",
+  "crewai >= 0.80.0",
 ]
 
 [project.entry-points.opentelemetry_instrumentor]

instrumentation-loongsuite/loongsuite-instrumentation-crewai/src/opentelemetry/instrumentation/crewai/utils.py

@@ -1,63 +1,25 @@
 import dataclasses
-import json
 import logging
-from base64 import b64encode
 from typing import Any, Dict, List, Optional
 
+from opentelemetry.semconv._incubating.attributes import gen_ai_attributes
 from opentelemetry.trace import Span
 from opentelemetry.util.genai.types import (
+    ContentCapturingMode,
     InputMessage,
     MessagePart,
     OutputMessage,
     Text,
     ToolCall,
 )
+from opentelemetry.util.genai.utils import (
+    gen_ai_json_dumps,
+    get_content_capturing_mode,
+    is_experimental_mode,
+)
 
 logger = logging.getLogger(__name__)
 
-MAX_MESSAGE_SIZE = 10000
-
-
-class _GenAiJsonEncoder(json.JSONEncoder):
-    def default(self, o: Any) -> Any:
-        if isinstance(o, bytes):
-            return b64encode(o).decode()
-        return super().default(o)
-
-
-def _safe_json_dumps(
-    obj: Any, default: str = "", max_size: int = MAX_MESSAGE_SIZE
-) -> str:
-    """
-    Safely serialize object to JSON string with size limit.
-    """
-    if obj is None:
-        return default
-
-    # Fast path for simple types
-    if isinstance(obj, (str, int, float, bool)):
-        result = str(obj)
-    else:
-        try:
-            result = json.dumps(
-                obj,
-                separators=(",", ":"),
-                cls=_GenAiJsonEncoder,
-                ensure_ascii=False,
-            )
-        except Exception as e:
-            logger.debug(f"Failed to serialize to JSON: {e}")
-            result = str(obj)
-
-    if len(result) > max_size:
-        return result[:max_size] + "...[truncated]"
-    return result
-
-
-GEN_AI_INPUT_MESSAGES = "gen_ai.input.messages"
-GEN_AI_OUTPUT_MESSAGES = "gen_ai.output.messages"
-GEN_AI_SYSTEM_INSTRUCTIONS = "gen_ai.system_instructions"
-
 OP_NAME_CREW = "crew.kickoff"
 OP_NAME_AGENT = "agent.execute"
 OP_NAME_TASK = "task.execute"
@@ -76,27 +38,41 @@ def on_completion(
         system_instructions: Optional[List[MessagePart]] = None,
         attributes: Optional[Dict[str, Any]] = None,
     ):
-        if self.capture_content and span.is_recording():
+        if not self.capture_content or not span.is_recording():
+            return
+
+        if not is_experimental_mode():
+            return
+
+        capturing_mode = get_content_capturing_mode()
+        should_capture_span = capturing_mode in (
+            ContentCapturingMode.SPAN_ONLY,
+            ContentCapturingMode.SPAN_AND_EVENT,
+        )
+
+        if should_capture_span:
             if inputs:
                 span.set_attribute(
-                    GEN_AI_INPUT_MESSAGES,
-                    _safe_json_dumps([dataclasses.asdict(i) for i in inputs]),
+                    gen_ai_attributes.GEN_AI_INPUT_MESSAGES,
+                    gen_ai_json_dumps([dataclasses.asdict(i) for i in inputs]),
                 )
             if outputs:
                 span.set_attribute(
-                    GEN_AI_OUTPUT_MESSAGES,
-                    _safe_json_dumps([dataclasses.asdict(o) for o in outputs]),
+                    gen_ai_attributes.GEN_AI_OUTPUT_MESSAGES,
+                    gen_ai_json_dumps(
+                        [dataclasses.asdict(o) for o in outputs]
+                    ),
                 )
             if system_instructions:
                 span.set_attribute(
-                    GEN_AI_SYSTEM_INSTRUCTIONS,
-                    _safe_json_dumps(
+                    gen_ai_attributes.GEN_AI_SYSTEM_INSTRUCTIONS,
+                    gen_ai_json_dumps(
                         [dataclasses.asdict(i) for i in system_instructions]
                     ),
                 )
 
-            if attributes:
-                span.set_attributes(attributes)
+        if attributes:
+            span.set_attributes(attributes)
 
 
 def to_input_message(role: str, content: Any) -> List[InputMessage]:
@@ -144,7 +120,7 @@ def extract_agent_inputs(
 
 def extract_tool_inputs(tool_name: str, arguments: Any) -> List[InputMessage]:
     args_str = (
-        json.dumps(arguments)
+        gen_ai_json_dumps(arguments)
         if isinstance(arguments, dict)
         else str(arguments)
     )

instrumentation-loongsuite/loongsuite-instrumentation-crewai/tests/test_agent_workflow.py

@@ -29,6 +29,17 @@
 from opentelemetry.instrumentation.crewai import CrewAIInstrumentor
 from opentelemetry.test.test_base import TestBase
 
+try:
+    from opentelemetry.instrumentation._semconv import (
+        _OpenTelemetrySemanticConventionStability,
+        _OpenTelemetryStabilitySignalType,
+        _StabilityMode,
+    )
+except ImportError:
+    _OpenTelemetrySemanticConventionStability = None
+    _OpenTelemetryStabilitySignalType = None
+    _StabilityMode = None
+
 sys.modules["sqlite3"] = pysqlite3
 
 
@@ -53,6 +64,20 @@ def setUp(self):
         )
 
         os.environ["CREWAI_TRACING_ENABLED"] = "false"
+        # Enable experimental mode and content capture for testing
+        os.environ["OTEL_SEMCONV_STABILITY_OPT_IN"] = "gen_ai"
+        os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = (
+            "span_only"
+        )
+
+        if _OpenTelemetrySemanticConventionStability:
+            try:
+                _OpenTelemetrySemanticConventionStability._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING[
+                    _OpenTelemetryStabilitySignalType.GEN_AI
+                ] = _StabilityMode.GEN_AI_LATEST_EXPERIMENTAL
+            except (AttributeError, KeyError):
+                pass
+
         self.instrumentor = CrewAIInstrumentor()
         self.instrumentor.instrument(tracer_provider=self.tracer_provider)
 

instrumentation-loongsuite/loongsuite-instrumentation-crewai/tests/test_error_scenarios.py

@@ -34,6 +34,17 @@
 from opentelemetry.test.test_base import TestBase
 from opentelemetry.trace import StatusCode
 
+try:
+    from opentelemetry.instrumentation._semconv import (
+        _OpenTelemetrySemanticConventionStability,
+        _OpenTelemetryStabilitySignalType,
+        _StabilityMode,
+    )
+except ImportError:
+    _OpenTelemetrySemanticConventionStability = None
+    _OpenTelemetryStabilitySignalType = None
+    _StabilityMode = None
+
 sys.modules["sqlite3"] = pysqlite3
 
 
@@ -60,6 +71,20 @@ def setUp(self):
         # Disable CrewAI's built-in tracing to avoid interference
         os.environ["CREWAI_TRACING_ENABLED"] = "false"
 
+        # Enable experimental mode and content capture for testing
+        os.environ["OTEL_SEMCONV_STABILITY_OPT_IN"] = "gen_ai"
+        os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = (
+            "span_only"
+        )
+
+        if _OpenTelemetrySemanticConventionStability:
+            try:
+                _OpenTelemetrySemanticConventionStability._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING[
+                    _OpenTelemetryStabilitySignalType.GEN_AI
+                ] = _StabilityMode.GEN_AI_LATEST_EXPERIMENTAL
+            except (AttributeError, KeyError):
+                pass
+
         self.instrumentor = CrewAIInstrumentor()
         self.instrumentor.instrument(tracer_provider=self.tracer_provider)
 

instrumentation-loongsuite/loongsuite-instrumentation-crewai/tests/test_flow_kickoff.py

@@ -22,6 +22,26 @@
 - Flow name extraction from instance
 """
 
+import os
+
+# Set environment variables for content capture
+os.environ["OTEL_SEMCONV_STABILITY_OPT_IN"] = "gen_ai"
+os.environ["OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT"] = "span_only"
+
+# Forcefully enable experimental mode in OpenTelemetry's internal mapping
+try:
+    from opentelemetry.instrumentation._semconv import (
+        _OpenTelemetrySemanticConventionStability,
+        _OpenTelemetryStabilitySignalType,
+        _StabilityMode,
+    )
+
+    _OpenTelemetrySemanticConventionStability._OTEL_SEMCONV_STABILITY_SIGNAL_MAPPING[
+        _OpenTelemetryStabilitySignalType.GEN_AI
+    ] = _StabilityMode.GEN_AI_LATEST_EXPERIMENTAL
+except (ImportError, AttributeError):
+    pass
+
 import json
 import unittest
 from unittest.mock import AsyncMock, MagicMock
@@ -30,7 +50,7 @@
     GenAIHookHelper,
     _FlowKickoffAsyncWrapper,
 )
-from opentelemetry.instrumentation.crewai.utils import _safe_json_dumps
+from opentelemetry.instrumentation.crewai.utils import gen_ai_json_dumps
 from opentelemetry.sdk.trace import TracerProvider
 
 # Use SDK tracer for testing
@@ -352,55 +372,41 @@ async def test_flow_kickoff_span_kind(self):
         self.assertEqual(span.kind, SpanKind.INTERNAL)
 
 
-class TestSafeJsonDumps(unittest.TestCase):
-    """Test _safe_json_dumps utility function."""
+class TestGenAiJsonDumps(unittest.TestCase):
+    """Test gen_ai_json_dumps utility function."""
 
     def test_simple_string(self):
         """Test with simple string input."""
-        result = _safe_json_dumps("hello")
-        self.assertEqual(result, "hello")
+        result = gen_ai_json_dumps("hello")
+        self.assertEqual(result, '"hello"')
 
     def test_simple_int(self):
         """Test with integer input."""
-        result = _safe_json_dumps(42)
+        result = gen_ai_json_dumps(42)
         self.assertEqual(result, "42")
 
     def test_simple_float(self):
         """Test with float input."""
-        result = _safe_json_dumps(3.14)
+        result = gen_ai_json_dumps(3.14)
         self.assertEqual(result, "3.14")
 
     def test_simple_bool(self):
         """Test with boolean input."""
-        result = _safe_json_dumps(True)
-        self.assertEqual(result, "True")
-
-    def test_none_returns_default(self):
-        """Test that None returns default value."""
-        result = _safe_json_dumps(None, default="default_value")
-        self.assertEqual(result, "default_value")
+        result = gen_ai_json_dumps(True)
+        self.assertEqual(result, "true")
 
     def test_dict_serialization(self):
         """Test dictionary serialization."""
         data = {"key": "value", "number": 123}
-        result = _safe_json_dumps(data)
-        self.assertIn("key", result)
-        self.assertIn("value", result)
-        self.assertIn("123", result)
+        result = gen_ai_json_dumps(data)
+        self.assertIn('"key":"value"', result)
+        self.assertIn('"number":123', result)
 
     def test_list_serialization(self):
         """Test list serialization."""
         data = [1, 2, 3, "four"]
-        result = _safe_json_dumps(data)
-        self.assertIn("1", result)
-        self.assertIn("four", result)
-
-    def test_truncation(self):
-        """Test that long strings are truncated."""
-        long_string = "a" * 20000
-        result = _safe_json_dumps(long_string, max_size=100)
-        self.assertLessEqual(len(result), 120)  # Allow for truncation suffix
-        self.assertIn("[truncated]", result)
+        result = gen_ai_json_dumps(data)
+        self.assertEqual(result, '[1,2,3,"four"]')
 
     def test_non_serializable_object(self):
         """Test handling of non-serializable objects."""
@@ -409,8 +415,11 @@ class CustomObject:
             def __str__(self):
                 return "CustomObject instance"
 
-        result = _safe_json_dumps(CustomObject())
-        self.assertIn("CustomObject", result)
+        # gen_ai_json_dumps uses standard json or partial json.dump
+        # which might raise TypeError if not supported.
+        # But our partial uses _GenAiJsonEncoder.
+        with self.assertRaises(TypeError):
+            gen_ai_json_dumps(CustomObject())
 
 
 if __name__ == "__main__":