deepeval 3.6.6__py3-none-any.whl → 3.6.8__py3-none-any.whl

deepeval/integrations/pydantic_ai/instrumentator.py

@@ -1,14 +1,19 @@
 import json
 import logging
 import os
+from time import perf_counter
 from typing import Literal, Optional, List
 
 from deepeval.config.settings import get_settings
 from deepeval.confident.api import get_confident_api_key
+from deepeval.metrics.base_metric import BaseMetric
 from deepeval.prompt import Prompt
 from deepeval.tracing.context import current_trace_context
 from deepeval.tracing.types import Trace
 from deepeval.tracing.otel.utils import to_hex_string
+from deepeval.tracing.tracing import trace_manager
+from deepeval.tracing.otel.utils import normalize_pydantic_ai_messages
+from deepeval.tracing.otel.exporter import ConfidentSpanExporter
 
 
 logger = logging.getLogger(__name__)
@@ -21,6 +26,7 @@ try:
     from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
         OTLPSpanExporter,
     )
+    from opentelemetry.sdk.trace import ReadableSpan
 
     dependency_installed = True
 except ImportError as e:
@@ -48,24 +54,96 @@ def is_dependency_installed():
     return True
 
 
+from deepeval.tracing.types import AgentSpan
 from deepeval.confident.api import get_confident_api_key
 from deepeval.prompt import Prompt
 from deepeval.tracing.otel.test_exporter import test_exporter
 from deepeval.tracing.context import current_trace_context
 from deepeval.tracing.types import Trace
 from deepeval.tracing.otel.utils import to_hex_string
+from deepeval.tracing.types import TraceSpanStatus, ToolCall
+from deepeval.tracing.perf_epoch_bridge import init_clock_bridge
 
 # OTLP_ENDPOINT = "http://127.0.0.1:4318/v1/traces"
 OTLP_ENDPOINT = "https://otel.confident-ai.com/v1/traces"
+init_clock_bridge()  # initialize clock bridge for perf_counter() to epoch_nanos conversion
+
+
+class ConfidentInstrumentationSettings(InstrumentationSettings):
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        name: Optional[str] = None,
+        thread_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        metadata: Optional[dict] = None,
+        tags: Optional[List[str]] = None,
+        metric_collection: Optional[str] = None,
+        confident_prompt: Optional[Prompt] = None,
+        llm_metric_collection: Optional[str] = None,
+        agent_metric_collection: Optional[str] = None,
+        tool_metric_collection_map: Optional[dict] = None,
+        trace_metric_collection: Optional[str] = None,
+        is_test_mode: Optional[bool] = False,
+        agent_metrics: Optional[List[BaseMetric]] = None,
+    ):
+        is_dependency_installed()
+
+        _environment = os.getenv("CONFIDENT_TRACE_ENVIRONMENT", "development")
+        if _environment and _environment in [
+            "production",
+            "staging",
+            "development",
+            "testing",
+        ]:
+            self.environment = _environment
+
+        self.tool_metric_collection_map = tool_metric_collection_map or {}
+        self.name = name
+        self.thread_id = thread_id
+        self.user_id = user_id
+        self.metadata = metadata
+        self.tags = tags
+        self.metric_collection = metric_collection
+        self.confident_prompt = confident_prompt
+        self.llm_metric_collection = llm_metric_collection
+        self.agent_metric_collection = agent_metric_collection
+        self.trace_metric_collection = trace_metric_collection
+        self.is_test_mode = is_test_mode
+        self.agent_metrics = agent_metrics
+
+        if not api_key:
+            api_key = get_confident_api_key()
+            if not api_key:
+                raise ValueError("CONFIDENT_API_KEY is not set")
+
+        trace_provider = TracerProvider()
+
+        # Pass the entire settings instance instead of individual values
+        span_interceptor = SpanInterceptor(self)
+        trace_provider.add_span_processor(span_interceptor)
+
+        if is_test_mode:
+            trace_provider.add_span_processor(BatchSpanProcessor(test_exporter))
+        else:
+            trace_provider.add_span_processor(
+                BatchSpanProcessor(
+                    OTLPSpanExporter(
+                        endpoint=OTLP_ENDPOINT,
+                        headers={"x-confident-api-key": api_key},
+                    )
+                )
+            )
+        super().__init__(tracer_provider=trace_provider)
 
 
 class SpanInterceptor(SpanProcessor):
-    def __init__(self, settings_instance):
+    def __init__(self, settings_instance: ConfidentInstrumentationSettings):
         # Keep a reference to the settings instance instead of copying values
-        self.settings: ConfidentInstrumentationSettings = settings_instance
+        self.settings = settings_instance
 
     def on_start(self, span, parent_context):
-
         # set trace uuid
         _current_trace_context = current_trace_context.get()
         if _current_trace_context and isinstance(_current_trace_context, Trace):
@@ -151,85 +229,56 @@ class SpanInterceptor(SpanProcessor):
                 )
 
     def on_end(self, span):
-        pass
-
+        if self.settings.is_test_mode:
+            if span.attributes.get("confident.span.type") == "agent":
 
-class ConfidentInstrumentationSettings(InstrumentationSettings):
-
-    name: Optional[str] = None
-    thread_id: Optional[str] = None
-    user_id: Optional[str] = None
-    metadata: Optional[dict] = None
-    tags: Optional[List[str]] = None
-    environment: Literal["production", "staging", "development", "testing"] = (
-        None
-    )
-    metric_collection: Optional[str] = None
-    confident_prompt: Optional[Prompt] = None
-    llm_metric_collection: Optional[str] = None
-    agent_metric_collection: Optional[str] = None
-    tool_metric_collection_map: dict = {}
-    trace_metric_collection: Optional[str] = None
+                def create_agent_span_for_evaluation(
+                    span: ReadableSpan,
+                ) -> AgentSpan:
 
-    def __init__(
-        self,
-        api_key: Optional[str] = None,
-        name: Optional[str] = None,
-        thread_id: Optional[str] = None,
-        user_id: Optional[str] = None,
-        metadata: Optional[dict] = None,
-        tags: Optional[List[str]] = None,
-        metric_collection: Optional[str] = None,
-        confident_prompt: Optional[Prompt] = None,
-        llm_metric_collection: Optional[str] = None,
-        agent_metric_collection: Optional[str] = None,
-        tool_metric_collection_map: Optional[dict] = None,
-        trace_metric_collection: Optional[str] = None,
-        is_test_mode: Optional[bool] = False,
-    ):
-        is_dependency_installed()
+                    agent_span = (
+                        ConfidentSpanExporter.prepare_boilerplate_base_span(
+                            span
+                        )
+                    )
 
-        _environment = os.getenv("CONFIDENT_TRACE_ENVIRONMENT", "development")
-        if _environment and _environment in [
-            "production",
-            "staging",
-            "development",
-            "testing",
-        ]:
-            self.environment = _environment
+                    # tools called
+                    normalized_messages = normalize_pydantic_ai_messages(span)
+                    tools_called = []
 
-        self.tool_metric_collection_map = tool_metric_collection_map or {}
-        self.name = name
-        self.thread_id = thread_id
-        self.user_id = user_id
-        self.metadata = metadata
-        self.tags = tags
-        self.metric_collection = metric_collection
-        self.confident_prompt = confident_prompt
-        self.llm_metric_collection = llm_metric_collection
-        self.agent_metric_collection = agent_metric_collection
-        self.trace_metric_collection = trace_metric_collection
+                    for message in normalized_messages:
+                        for part in message.get("parts", []):
+                            if part.get("type") == "tool_call":
+                                name = part.get("name")
+                                try:
+                                    input_parameters = json.loads(
+                                        part.get("arguments")
+                                    )
+                                except Exception:
+                                    input_parameters = {}
 
-        if not api_key:
-            api_key = get_confident_api_key()
-            if not api_key:
-                raise ValueError("CONFIDENT_API_KEY is not set")
+                                tools_called.append(
+                                    ToolCall(
+                                        name=name,
+                                        input_parameters=input_parameters,
+                                    )
+                                )
 
-        trace_provider = TracerProvider()
+                    # agent_span.tools_called = tools_called
+                    return agent_span
 
-        # Pass the entire settings instance instead of individual values
-        span_interceptor = SpanInterceptor(self)
-        trace_provider.add_span_processor(span_interceptor)
+                agent_span = create_agent_span_for_evaluation(span)
+                agent_span.metrics = self.settings.agent_metrics
 
-        if is_test_mode:
-            trace_provider.add_span_processor(BatchSpanProcessor(test_exporter))
-        else:
-            trace_provider.add_span_processor(
-                BatchSpanProcessor(
-                    OTLPSpanExporter(
-                        endpoint=OTLP_ENDPOINT,
-                        headers={"x-confident-api-key": api_key},
+                # create a trace for evaluation
+                trace = trace_manager.get_trace_by_uuid(agent_span.trace_uuid)
+                if not trace:
+                    trace = trace_manager.start_new_trace(
+                        trace_uuid=agent_span.trace_uuid
                     )
-                )
-            )
-        super().__init__(tracer_provider=trace_provider)
+
+                trace.root_spans.append(agent_span)
+                trace.status = TraceSpanStatus.SUCCESS
+                trace.end_time = perf_counter()
+                trace_manager.traces_to_evaluate.append(trace)
+                test_exporter.clear_span_json_list()

deepeval/metrics/__init__.py

@@ -27,6 +27,12 @@ from .tool_correctness.tool_correctness import ToolCorrectnessMetric
 from .json_correctness.json_correctness import JsonCorrectnessMetric
 from .prompt_alignment.prompt_alignment import PromptAlignmentMetric
 from .task_completion.task_completion import TaskCompletionMetric
+from .topic_adherence.topic_adherence import TopicAdherenceMetric
+from .step_efficiency.step_efficiency import StepEfficiencyMetric
+from .plan_adherence.plan_adherence import PlanAdherenceMetric
+from .plan_quality.plan_quality import PlanQualityMetric
+from .tool_use.tool_use import ToolUseMetric
+from .goal_accuracy.goal_accuracy import GoalAccuracyMetric
 from .argument_correctness.argument_correctness import ArgumentCorrectnessMetric
 from .mcp.mcp_task_completion import MCPTaskCompletionMetric
 from .mcp.multi_turn_mcp_use_metric import MultiTurnMCPUseMetric
@@ -98,6 +104,13 @@ __all__ = [
     "TaskCompletionMetric",
     "ArgumentCorrectnessMetric",
     "KnowledgeRetentionMetric",
+    # Agentic metrics
+    "TopicAdherenceMetric",
+    "StepEfficiencyMetric",
+    "PlanAdherenceMetric",
+    "PlanQualityMetric",
+    "ToolUseMetric",
+    "GoalAccuracyMetric",
     # Conversational metrics
     "TurnRelevancyMetric",
     "ConversationCompletenessMetric",

deepeval/metrics/answer_relevancy/answer_relevancy.py

@@ -16,6 +16,7 @@ from deepeval.models import DeepEvalBaseLLM
 from deepeval.metrics.answer_relevancy.template import AnswerRelevancyTemplate
 from deepeval.metrics.indicator import metric_progress_indicator
 from deepeval.metrics.answer_relevancy.schema import *
+from deepeval.metrics.api import metric_data_manager
 
 
 class AnswerRelevancyMetric(BaseMetric):
@@ -50,8 +51,8 @@ class AnswerRelevancyMetric(BaseMetric):
         test_case: LLMTestCase,
         _show_indicator: bool = True,
         _in_component: bool = False,
+        _log_metric_to_confident: bool = True,
     ) -> float:
-
         check_llm_test_case_params(test_case, self._required_params, self)
 
         self.evaluation_cost = 0 if self.using_native_model else None
@@ -65,6 +66,7 @@ class AnswerRelevancyMetric(BaseMetric):
                         test_case,
                         _show_indicator=False,
                         _in_component=_in_component,
+                        _log_metric_to_confident=_log_metric_to_confident,
                     )
                 )
             else:
@@ -85,6 +87,10 @@ class AnswerRelevancyMetric(BaseMetric):
                         f"Score: {self.score}\nReason: {self.reason}",
                     ],
                 )
+                if _log_metric_to_confident:
+                    metric_data_manager.post_metric_if_enabled(
+                        self, test_case=test_case
+                    )
 
             return self.score
 
@@ -93,8 +99,8 @@ class AnswerRelevancyMetric(BaseMetric):
         test_case: LLMTestCase,
         _show_indicator: bool = True,
         _in_component: bool = False,
+        _log_metric_to_confident: bool = True,
     ) -> float:
-
         check_llm_test_case_params(test_case, self._required_params, self)
 
         self.evaluation_cost = 0 if self.using_native_model else None
@@ -121,7 +127,10 @@ class AnswerRelevancyMetric(BaseMetric):
                     f"Score: {self.score}\nReason: {self.reason}",
                 ],
             )
-
+            if _log_metric_to_confident:
+                metric_data_manager.post_metric_if_enabled(
+                    self, test_case=test_case
+                )
             return self.score
 
     async def _a_generate_reason(self, input: str) -> str:

deepeval/metrics/api.py

@@ -0,0 +1,281 @@
+from typing import Optional, Set, Any, Dict, List, Union
+import threading
+import asyncio
+import queue
+import atexit
+from time import perf_counter
+from enum import Enum
+from pydantic import Field
+from rich.console import Console
+
+from deepeval.confident.api import Api, HttpMethods, Endpoints, is_confident
+from deepeval.constants import (
+    CONFIDENT_METRIC_LOGGING_FLUSH,
+    CONFIDENT_METRIC_LOGGING_VERBOSE,
+)
+from deepeval.metrics.base_metric import BaseConversationalMetric, BaseMetric
+from deepeval.test_case.conversational_test_case import ConversationalTestCase
+from deepeval.test_case.llm_test_case import LLMTestCase
+from deepeval.test_case.api import create_api_test_case
+from deepeval.test_run.api import LLMApiTestCase, ConversationalApiTestCase
+from deepeval.tracing.api import MetricData
+from deepeval.config.settings import get_settings
+
+
+class MetricWorkerStatus(Enum):
+    SUCCESS = "success"
+    FAILURE = "failure"
+    WARNING = "warning"
+
+
+class ApiMetricData(MetricData):
+    llm_test_case: Optional[LLMApiTestCase] = Field(None, alias="llmTestCase")
+    conversational_test_case: Optional[ConversationalApiTestCase] = Field(
+        None, alias="conversationalTestCase"
+    )
+
+
+class MetricDataManager:
+    """Manager for posting metric data asynchronously in background thread."""
+
+    def __init__(self):
+        settings = get_settings()
+        # Initialize queue and worker thread for metric posting
+        self._metric_queue = queue.Queue()
+        self._worker_thread = None
+        self._min_interval = 0.2  # Minimum time between API calls (seconds)
+        self._last_post_time = 0
+        self._in_flight_tasks: Set[asyncio.Task[Any]] = set()
+        self._flush_enabled = bool(settings.CONFIDENT_METRIC_LOGGING_FLUSH)
+        self._daemon = not self._flush_enabled
+        self._thread_lock = threading.Lock()
+        self.metric_logging_enabled = bool(
+            settings.CONFIDENT_METRIC_LOGGING_ENABLED
+        )
+
+        # Register an exit handler to warn about unprocessed metrics
+        atexit.register(self._warn_on_exit)
+
+    def post_metric_if_enabled(
+        self,
+        metric: Union[BaseMetric, BaseConversationalMetric],
+        test_case: Optional[Union[LLMTestCase, ConversationalTestCase]] = None,
+    ):
+        """Post metric data asynchronously in a background thread."""
+        if not self.metric_logging_enabled or not is_confident():
+            return
+
+        from deepeval.evaluate.utils import create_metric_data
+
+        metric_data = create_metric_data(metric)
+        api_metric_data = ApiMetricData(
+            **metric_data.model_dump(by_alias=True, exclude_none=True)
+        )
+
+        if isinstance(test_case, LLMTestCase):
+            api_metric_data.llm_test_case = create_api_test_case(test_case)
+        elif isinstance(test_case, ConversationalTestCase):
+            api_metric_data.conversational_test_case = create_api_test_case(
+                test_case
+            )
+
+        self._ensure_worker_thread_running()
+        self._metric_queue.put(api_metric_data)
+
+    def _warn_on_exit(self):
+        """Warn if there are unprocessed metrics on exit."""
+        queue_size = self._metric_queue.qsize()
+        in_flight = len(self._in_flight_tasks)
+        remaining_tasks = queue_size + in_flight
+
+        if not self._flush_enabled and remaining_tasks > 0:
+            self._print_metric_data_status(
+                metric_worker_status=MetricWorkerStatus.WARNING,
+                message=f"Exiting with {queue_size + in_flight} abandoned metric(s).",
+                description=f"Set {CONFIDENT_METRIC_LOGGING_FLUSH}=1 as an environment variable to flush remaining metrics to Confident AI.",
+            )
+
+    def _ensure_worker_thread_running(self):
+        """Ensure the background worker thread is running."""
+        with self._thread_lock:
+            if (
+                self._worker_thread is None
+                or not self._worker_thread.is_alive()
+            ):
+                self._worker_thread = threading.Thread(
+                    target=self._process_metric_queue,
+                    daemon=self._daemon,
+                )
+                self._worker_thread.start()
+
+    def _print_metric_data_status(
+        self,
+        metric_worker_status: MetricWorkerStatus,
+        message: str,
+        description: Optional[str] = None,
+    ):
+        """Print metric data worker status messages."""
+        if getattr(get_settings(), CONFIDENT_METRIC_LOGGING_VERBOSE, False):
+            console = Console()
+            message_prefix = "[dim][Confident AI Metric Data Log][/dim]"
+            if metric_worker_status == MetricWorkerStatus.SUCCESS:
+                message = f"[green]{message}[/green]"
+            elif metric_worker_status == MetricWorkerStatus.FAILURE:
+                message = f"[red]{message}[/red]"
+            elif metric_worker_status == MetricWorkerStatus.WARNING:
+                message = f"[yellow]{message}[/yellow]"
+
+            if bool(CONFIDENT_METRIC_LOGGING_VERBOSE):
+                if description:
+                    message += f": {description}"
+
+                console.print(
+                    message_prefix,
+                    message,
+                    f"\nTo disable dev logging, set {CONFIDENT_METRIC_LOGGING_VERBOSE}=0 as an environment variable.",
+                )
+
+    def _process_metric_queue(self):
+        """Worker thread function that processes the metric queue."""
+        import threading
+
+        main_thr = threading.main_thread()
+
+        # Create a new event loop
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        # Buffer for payloads that need to be sent after main exits
+        remaining_metric_request_bodies: List[Dict[str, Any]] = []
+
+        async def _a_send_metric(metric_data: ApiMetricData):
+            nonlocal remaining_metric_request_bodies
+            try:
+                # Build API object & payload
+                try:
+                    body = metric_data.model_dump(
+                        by_alias=True,
+                        exclude_none=True,
+                    )
+                except AttributeError:
+                    # Pydantic version below 2.0
+                    body = metric_data.dict(by_alias=True, exclude_none=True)
+
+                # If the main thread is still alive, send now
+                if main_thr.is_alive():
+                    api = Api()
+                    _, _ = await api.a_send_request(
+                        method=HttpMethods.POST,
+                        endpoint=Endpoints.METRIC_DATA_ENDPOINT,
+                        body=body,
+                    )
+                    queue_size = self._metric_queue.qsize()
+                    in_flight = len(self._in_flight_tasks)
+                    status = f"({queue_size} metric{'s' if queue_size!=1 else ''} remaining in queue, {in_flight} in flight)"
+                    self._print_metric_data_status(
+                        metric_worker_status=MetricWorkerStatus.SUCCESS,
+                        message=f"Successfully posted metric data {status}",
+                    )
+                elif self._flush_enabled:
+                    # Main thread gone → to be flushed
+                    remaining_metric_request_bodies.append(body)
+
+            except Exception as e:
+                queue_size = self._metric_queue.qsize()
+                in_flight = len(self._in_flight_tasks)
+                status = f"({queue_size} metric{'s' if queue_size!=1 else ''} remaining in queue, {in_flight} in flight)"
+                self._print_metric_data_status(
+                    metric_worker_status=MetricWorkerStatus.FAILURE,
+                    message=f"Error posting metric data {status}",
+                    description=str(e),
+                )
+            finally:
+                task = asyncio.current_task()
+                if task:
+                    self._in_flight_tasks.discard(task)
+
+        async def async_worker():
+            # Continue while user code is running or work remains
+            while (
+                main_thr.is_alive()
+                or not self._metric_queue.empty()
+                or self._in_flight_tasks
+            ):
+                try:
+                    metric_data = self._metric_queue.get(
+                        block=True, timeout=1.0
+                    )
+
+                    # Rate-limit
+                    now = perf_counter()
+                    elapsed = now - self._last_post_time
+                    if elapsed < self._min_interval:
+                        await asyncio.sleep(self._min_interval - elapsed)
+                    self._last_post_time = perf_counter()
+
+                    # Schedule async send
+                    task = asyncio.create_task(_a_send_metric(metric_data))
+                    self._in_flight_tasks.add(task)
+                    self._metric_queue.task_done()
+
+                except queue.Empty:
+                    await asyncio.sleep(0.1)
+                    continue
+                except Exception as e:
+                    self._print_metric_data_status(
+                        message="Error in metric worker",
+                        metric_worker_status=MetricWorkerStatus.FAILURE,
+                        description=str(e),
+                    )
+                    await asyncio.sleep(1.0)
+
+        try:
+            loop.run_until_complete(async_worker())
+        finally:
+            # Drain any pending tasks
+            pending = asyncio.all_tasks(loop=loop)
+            if pending:
+                loop.run_until_complete(
+                    asyncio.gather(*pending, return_exceptions=True)
+                )
+            self._flush_metrics(remaining_metric_request_bodies)
+            loop.run_until_complete(loop.shutdown_asyncgens())
+            loop.close()
+
+    def _flush_metrics(
+        self, remaining_metric_request_bodies: List[Dict[str, Any]]
+    ):
+        """Flush remaining metrics synchronously."""
+        if not remaining_metric_request_bodies:
+            return
+
+        self._print_metric_data_status(
+            MetricWorkerStatus.WARNING,
+            message=f"Flushing {len(remaining_metric_request_bodies)} remaining metric(s)",
+        )
+
+        for body in remaining_metric_request_bodies:
+            try:
+                api = Api()
+                _, link = api.send_request(
+                    method=HttpMethods.POST,
+                    endpoint=Endpoints.METRIC_DATA_ENDPOINT,
+                    body=body,
+                )
+                qs = self._metric_queue.qsize()
+                self._print_metric_data_status(
+                    metric_worker_status=MetricWorkerStatus.SUCCESS,
+                    message=f"Successfully posted metric data ({qs} metrics remaining in queue, 1 in flight)",
+                    description=link,
+                )
+            except Exception as e:
+                qs = self._metric_queue.qsize()
+                self._print_metric_data_status(
+                    metric_worker_status=MetricWorkerStatus.FAILURE,
+                    message="Error flushing remaining metric(s)",
+                    description=str(e),
+                )
+
+
+# Global metric manager instance
+metric_data_manager = MetricDataManager()

deepeval/metrics/argument_correctness/argument_correctness.py

@@ -19,6 +19,7 @@ from deepeval.metrics.argument_correctness.template import (
 )
 from deepeval.metrics.indicator import metric_progress_indicator
 from deepeval.metrics.argument_correctness.schema import *
+from deepeval.metrics.api import metric_data_manager
 
 
 class ArgumentCorrectnessMetric(BaseMetric):
@@ -53,6 +54,7 @@ class ArgumentCorrectnessMetric(BaseMetric):
         test_case: LLMTestCase,
         _show_indicator: bool = True,
         _in_component: bool = False,
+        _log_metric_to_confident: bool = True,
     ) -> float:
 
         check_llm_test_case_params(test_case, self._required_params, self)
@@ -68,6 +70,7 @@ class ArgumentCorrectnessMetric(BaseMetric):
                         test_case,
                         _show_indicator=False,
                         _in_component=_in_component,
+                        _log_metric_to_confident=_log_metric_to_confident,
                     )
                 )
             else:
@@ -91,7 +94,10 @@ class ArgumentCorrectnessMetric(BaseMetric):
                         f"Score: {self.score}\nReason: {self.reason}",
                     ],
                 )
-
+                if _log_metric_to_confident:
+                    metric_data_manager.post_metric_if_enabled(
+                        self, test_case=test_case
+                    )
             return self.score
 
     async def a_measure(
@@ -99,6 +105,7 @@ class ArgumentCorrectnessMetric(BaseMetric):
         test_case: LLMTestCase,
         _show_indicator: bool = True,
         _in_component: bool = False,
+        _log_metric_to_confident: bool = True,
     ) -> float:
 
         check_llm_test_case_params(test_case, self._required_params, self)
@@ -130,7 +137,10 @@ class ArgumentCorrectnessMetric(BaseMetric):
                     f"Score: {self.score}\nReason: {self.reason}",
                 ],
             )
-
+            if _log_metric_to_confident:
+                metric_data_manager.post_metric_if_enabled(
+                    self, test_case=test_case
+                )
             return self.score
 
     async def _a_generate_reason(self, input: str) -> str:

deepeval/metrics/base_metric.py

@@ -27,6 +27,7 @@ class BaseMetric:
     evaluation_cost: Optional[float] = None
     verbose_logs: Optional[str] = None
     skipped = False
+    requires_trace: bool = False
     model = Optional[DeepEvalBaseLLM]
     using_native_model = Optional[bool]