openlit 1.34.30__py3-none-any.whl → 1.34.32__py3-none-any.whl

openlit/instrumentation/controlflow/__init__.py

@@ -6,12 +6,11 @@ import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.controlflow.controlflow import (
-    wrap_controlflow
-)
+from openlit.instrumentation.controlflow.controlflow import wrap_controlflow
 
 _instruments = ("controlflow >= 0.3.2",)
 
+
 class ControlFlowInstrumentor(BaseInstrumentor):
     """
     An instrumentor for controlflow's client library.
@@ -33,22 +32,49 @@ class ControlFlowInstrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "controlflow.agents.agent",
             "Agent.__init__",
-            wrap_controlflow("controlflow.create_agent", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            wrap_controlflow(
+                "controlflow.create_agent",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "controlflow.tasks.task",
             "Task.__init__",
-            wrap_controlflow("controlflow.create_task", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            wrap_controlflow(
+                "controlflow.create_task",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "controlflow",
             "run",
-            wrap_controlflow("controlflow.run", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            wrap_controlflow(
+                "controlflow.run",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
     def _uninstrument(self, **kwargs):

openlit/instrumentation/controlflow/controlflow.py

@@ -5,15 +5,29 @@ Module for monitoring controlflow.
 
 import logging
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    TELEMETRY_SDK_NAME,
+    DEPLOYMENT_ENVIRONMENT,
+)
 from openlit.__helpers import handle_exception
 from openlit.semcov import SemanticConvention
 
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 
-def wrap_controlflow(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def wrap_controlflow(
+    gen_ai_endpoint,
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Creates a wrapper around a function call to trace and log its execution metrics.
 
@@ -55,48 +69,67 @@ def wrap_controlflow(gen_ai_endpoint, version, environment, application_name,
         errors are handled and logged appropriately.
         """
 
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            gen_ai_endpoint, kind=SpanKind.CLIENT
+        ) as span:
             response = wrapped(*args, **kwargs)
 
             try:
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                   gen_ai_endpoint)
-                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,
-                                   SemanticConvention.GEN_AI_SYSTEM_CONTROLFLOW)
-                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
-                                   environment)
-                span.set_attribute(SERVICE_NAME,
-                                   application_name)
-                span.set_attribute(SemanticConvention.GEN_AI_OPERATION,
-                                   SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT)
+                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT, gen_ai_endpoint)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_SYSTEM,
+                    SemanticConvention.GEN_AI_SYSTEM_CONTROLFLOW,
+                )
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_OPERATION,
+                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+                )
 
                 if gen_ai_endpoint == "controlflow.create_agent":
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_ROLE,
-                                    instance.name)
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_INSTRUCTIONS,
-                                    kwargs.get("instructions", ""))
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_TOOLS,
-                                    str(kwargs.get("tools", "")))
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_ROLE, instance.name
+                    )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_INSTRUCTIONS,
+                        kwargs.get("instructions", ""),
+                    )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_TOOLS,
+                        str(kwargs.get("tools", "")),
+                    )
 
                     try:
-                        span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
-                                        instance.model.model_name)
+                        span.set_attribute(
+                            SemanticConvention.GEN_AI_REQUEST_MODEL,
+                            instance.model.model_name,
+                        )
                     except:
-                        span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
-                                        kwargs.get("model", "openai/gpt-4o-mini"))
+                        span.set_attribute(
+                            SemanticConvention.GEN_AI_REQUEST_MODEL,
+                            kwargs.get("model", "openai/gpt-4o-mini"),
+                        )
 
                 elif gen_ai_endpoint == "controlflow.create_task":
-                    if kwargs.get("objective","") == "":
-                        span.set_attribute(SemanticConvention.GEN_AI_AGENT_GOAL,
-                                           str(args[0]))
+                    if kwargs.get("objective", "") == "":
+                        span.set_attribute(
+                            SemanticConvention.GEN_AI_AGENT_GOAL, str(args[0])
+                        )
                     else:
-                        span.set_attribute(SemanticConvention.GEN_AI_AGENT_GOAL,
-                                           kwargs.get("objective",""))
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_INSTRUCTIONS,
-                                       kwargs.get("instructions", ""))
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_CONTEXT,
-                                       str(kwargs.get("context", "")))
+                        span.set_attribute(
+                            SemanticConvention.GEN_AI_AGENT_GOAL,
+                            kwargs.get("objective", ""),
+                        )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_INSTRUCTIONS,
+                        kwargs.get("instructions", ""),
+                    )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_CONTEXT,
+                        str(kwargs.get("context", "")),
+                    )
 
                 span.set_status(Status(StatusCode.OK))
 

openlit/instrumentation/crawl4ai/__init__.py

@@ -6,15 +6,12 @@ import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.crawl4ai.crawl4ai import (
-    wrap_crawl
-)
-from openlit.instrumentation.crawl4ai.async_crawl4ai import (
-    async_wrap_crawl
-)
+from openlit.instrumentation.crawl4ai.crawl4ai import wrap_crawl
+from openlit.instrumentation.crawl4ai.async_crawl4ai import async_wrap_crawl
 
 _instruments = ("crawl4ai >= 0.4.0",)
 
+
 class Crawl4AIInstrumentor(BaseInstrumentor):
     """
     An instrumentor for crawl4ai's client library.
@@ -36,15 +33,33 @@ class Crawl4AIInstrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "crawl4ai.web_crawler",
             "WebCrawler.run",
-            wrap_crawl("crawl4ai.web_crawl", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            wrap_crawl(
+                "crawl4ai.web_crawl",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "crawl4ai.async_webcrawler",
             "AsyncWebCrawler.arun",
-            async_wrap_crawl("crawl4ai.web_crawl", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            async_wrap_crawl(
+                "crawl4ai.web_crawl",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
     def _uninstrument(self, **kwargs):

openlit/instrumentation/crawl4ai/async_crawl4ai.py

@@ -5,7 +5,11 @@ Module for monitoring Crawl4AI calls.
 
 import logging
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    TELEMETRY_SDK_NAME,
+    DEPLOYMENT_ENVIRONMENT,
+)
 from openlit.__helpers import (
     handle_exception,
 )
@@ -14,8 +18,18 @@ from openlit.semcov import SemanticConvention
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 
-def async_wrap_crawl(gen_ai_endpoint, version, environment, application_name,
-                     tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def async_wrap_crawl(
+    gen_ai_endpoint,
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for chat completions to collect metrics.
 
@@ -50,44 +64,77 @@ def async_wrap_crawl(gen_ai_endpoint, version, environment, application_name,
         """
 
         # pylint: disable=line-too-long
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            gen_ai_endpoint, kind=SpanKind.CLIENT
+        ) as span:
             response = await wrapped(*args, **kwargs)
 
             try:
                 # Set base span attribues
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,
-                                    SemanticConvention.GEN_AI_SYSTEM_CRAWL4AI)
-                span.set_attribute(SemanticConvention.GEN_AI_OPERATION,
-                                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT)
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(SERVICE_NAME,
-                                    application_name)
-                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
-                                    environment)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_TYPE,
-                                    SemanticConvention.GEN_AI_AGENT_TYPE_BROWSER)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_ENABLE_CACHE, not kwargs.get("disable_cache", False))
-
-                url = kwargs.get("url") if "url" in kwargs else str(args[0]) if args else None
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_SYSTEM,
+                    SemanticConvention.GEN_AI_SYSTEM_CRAWL4AI,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_OPERATION,
+                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+                )
+                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT, gen_ai_endpoint)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_TYPE,
+                    SemanticConvention.GEN_AI_AGENT_TYPE_BROWSER,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_ENABLE_CACHE,
+                    not kwargs.get("disable_cache", False),
+                )
+
+                url = (
+                    kwargs.get("url")
+                    if "url" in kwargs
+                    else str(args[0])
+                    if args
+                    else None
+                )
                 if url is not None:
                     span.set_attribute(SemanticConvention.GEN_AI_AGENT_BROWSE_URL, url)
 
-                extraction_strategy = kwargs.get("extraction_strategy", "NoExtractionStrategy")
-                extraction_name = extraction_strategy.name if hasattr(extraction_strategy, 'name') else extraction_strategy
-
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_STRATEGY, extraction_name)
-
-                if extraction_name == "LLMExtractionStrategy" and hasattr(extraction_strategy, 'provider'):
-                    _, llm_model = extraction_strategy.provider.split('/')
-                    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, llm_model)
+                extraction_strategy = kwargs.get(
+                    "extraction_strategy", "NoExtractionStrategy"
+                )
+                extraction_name = (
+                    extraction_strategy.name
+                    if hasattr(extraction_strategy, "name")
+                    else extraction_strategy
+                )
+
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_STRATEGY, extraction_name
+                )
+
+                if extraction_name == "LLMExtractionStrategy" and hasattr(
+                    extraction_strategy, "provider"
+                ):
+                    _, llm_model = extraction_strategy.provider.split("/")
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_REQUEST_MODEL, llm_model
+                    )
 
                 elif extraction_name == "CosineStrategy":
-                    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, "all-MiniLM-L6-v2")
-
-                elif extraction_name == "JsonCssExtractionStrategy" and hasattr(extraction_strategy, 'schema'):
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_SCHEMA, str(extraction_strategy.schema))
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_REQUEST_MODEL, "all-MiniLM-L6-v2"
+                    )
+
+                elif extraction_name == "JsonCssExtractionStrategy" and hasattr(
+                    extraction_strategy, "schema"
+                ):
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_SCHEMA,
+                        str(extraction_strategy.schema),
+                    )
 
                 span.set_status(Status(StatusCode.OK))
 

openlit/instrumentation/crawl4ai/crawl4ai.py

@@ -5,7 +5,11 @@ Module for monitoring Crawl4AI calls.
 
 import logging
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    TELEMETRY_SDK_NAME,
+    DEPLOYMENT_ENVIRONMENT,
+)
 from openlit.__helpers import (
     handle_exception,
 )
@@ -14,8 +18,18 @@ from openlit.semcov import SemanticConvention
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 
-def wrap_crawl(gen_ai_endpoint, version, environment, application_name,
-                     tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def wrap_crawl(
+    gen_ai_endpoint,
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for chat completions to collect metrics.
 
@@ -50,44 +64,77 @@ def wrap_crawl(gen_ai_endpoint, version, environment, application_name,
         """
 
         # pylint: disable=line-too-long
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            gen_ai_endpoint, kind=SpanKind.CLIENT
+        ) as span:
             response = wrapped(*args, **kwargs)
 
             try:
                 # Set base span attribues
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,
-                                    SemanticConvention.GEN_AI_SYSTEM_CRAWL4AI)
-                span.set_attribute(SemanticConvention.GEN_AI_OPERATION,
-                                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT)
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(SERVICE_NAME,
-                                    application_name)
-                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
-                                    environment)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_TYPE,
-                                    SemanticConvention.GEN_AI_AGENT_TYPE_BROWSER)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_ENABLE_CACHE, not kwargs.get("disable_cache", False))
-
-                url = kwargs.get("url") if "url" in kwargs else str(args[0]) if args else None
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_SYSTEM,
+                    SemanticConvention.GEN_AI_SYSTEM_CRAWL4AI,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_OPERATION,
+                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+                )
+                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT, gen_ai_endpoint)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_TYPE,
+                    SemanticConvention.GEN_AI_AGENT_TYPE_BROWSER,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_ENABLE_CACHE,
+                    not kwargs.get("disable_cache", False),
+                )
+
+                url = (
+                    kwargs.get("url")
+                    if "url" in kwargs
+                    else str(args[0])
+                    if args
+                    else None
+                )
                 if url is not None:
                     span.set_attribute(SemanticConvention.GEN_AI_AGENT_BROWSE_URL, url)
 
-                extraction_strategy = kwargs.get("extraction_strategy", "NoExtractionStrategy")
-                extraction_name = extraction_strategy.name if hasattr(extraction_strategy, 'name') else extraction_strategy
-
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_STRATEGY, extraction_name)
-
-                if extraction_name == "LLMExtractionStrategy" and hasattr(extraction_strategy, 'provider'):
-                    _, llm_model = extraction_strategy.provider.split('/')
-                    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, llm_model)
+                extraction_strategy = kwargs.get(
+                    "extraction_strategy", "NoExtractionStrategy"
+                )
+                extraction_name = (
+                    extraction_strategy.name
+                    if hasattr(extraction_strategy, "name")
+                    else extraction_strategy
+                )
+
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_STRATEGY, extraction_name
+                )
+
+                if extraction_name == "LLMExtractionStrategy" and hasattr(
+                    extraction_strategy, "provider"
+                ):
+                    _, llm_model = extraction_strategy.provider.split("/")
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_REQUEST_MODEL, llm_model
+                    )
 
                 elif extraction_name == "CosineStrategy":
-                    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL, "all-MiniLM-L6-v2")
-
-                elif extraction_name == "JsonCssExtractionStrategy" and hasattr(extraction_strategy, 'schema'):
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_SCHEMA, str(extraction_strategy.schema))
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_REQUEST_MODEL, "all-MiniLM-L6-v2"
+                    )
+
+                elif extraction_name == "JsonCssExtractionStrategy" and hasattr(
+                    extraction_strategy, "schema"
+                ):
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_SCHEMA,
+                        str(extraction_strategy.schema),
+                    )
 
                 span.set_status(Status(StatusCode.OK))
 

openlit/instrumentation/crewai/__init__.py

@@ -19,7 +19,6 @@ WORKFLOW_OPERATIONS = [
     ("crewai.crew", "Crew.kickoff_async", "crew_kickoff_async"),
     ("crewai.crew", "Crew.kickoff_for_each", "crew_kickoff_for_each"),
     ("crewai.crew", "Crew.kickoff_for_each_async", "crew_kickoff_for_each_async"),
-
     # High-level Agent and Task Operations
     ("crewai.agent", "Agent.execute_task", "agent_execute_task"),
     ("crewai.task", "Task.execute", "task_execute"),
@@ -33,19 +32,18 @@ COMPONENT_OPERATIONS = [
     ("crewai.tools.base", "BaseTool._run", "tool_run_internal"),
     ("crewai.memory.base", "BaseMemory.save", "memory_save"),
     ("crewai.memory.base", "BaseMemory.search", "memory_search"),
-
     # Process and Collaboration Operations
     ("crewai.process", "Process.kickoff", "process_kickoff"),
     ("crewai.agent", "Agent.delegate", "agent_delegate"),
     ("crewai.agent", "Agent.ask_question", "agent_ask_question"),
     ("crewai.task", "Task.callback", "task_callback"),
-
     # Internal Task Management
     # Instrument only the core task execution (remove the sync duplicate)
     # Task Operations (keep only core execution)
     ("crewai.task", "Task._execute_core", "task_execute_core"),
 ]
 
+
 class CrewAIInstrumentor(BaseInstrumentor):
     """
     Modern instrumentor for CrewAI framework with comprehensive coverage.
@@ -70,10 +68,19 @@ class CrewAIInstrumentor(BaseInstrumentor):
         for module, method, operation_type in WORKFLOW_OPERATIONS:
             try:
                 wrap_function_wrapper(
-                    module, method,
-                    general_wrap(operation_type, version, environment, application_name,
-                               tracer, pricing_info, capture_message_content,
-                               metrics, disable_metrics)
+                    module,
+                    method,
+                    general_wrap(
+                        operation_type,
+                        version,
+                        environment,
+                        application_name,
+                        tracer,
+                        pricing_info,
+                        capture_message_content,
+                        metrics,
+                        disable_metrics,
+                    ),
                 )
             except Exception:
                 # Graceful degradation for missing operations
@@ -84,10 +91,19 @@ class CrewAIInstrumentor(BaseInstrumentor):
             if "async" in operation_type:
                 try:
                     wrap_function_wrapper(
-                        module, method,
-                        async_general_wrap(operation_type, version, environment,
-                                         application_name, tracer, pricing_info,
-                                         capture_message_content, metrics, disable_metrics)
+                        module,
+                        method,
+                        async_general_wrap(
+                            operation_type,
+                            version,
+                            environment,
+                            application_name,
+                            tracer,
+                            pricing_info,
+                            capture_message_content,
+                            metrics,
+                            disable_metrics,
+                        ),
                     )
                 except Exception:
                     pass
@@ -97,10 +113,19 @@ class CrewAIInstrumentor(BaseInstrumentor):
             for module, method, operation_type in COMPONENT_OPERATIONS:
                 try:
                     wrap_function_wrapper(
-                        module, method,
-                        general_wrap(operation_type, version, environment,
-                                   application_name, tracer, pricing_info,
-                                   capture_message_content, metrics, disable_metrics)
+                        module,
+                        method,
+                        general_wrap(
+                            operation_type,
+                            version,
+                            environment,
+                            application_name,
+                            tracer,
+                            pricing_info,
+                            capture_message_content,
+                            metrics,
+                            disable_metrics,
+                        ),
                     )
                 except Exception:
                     pass