holmesgpt 0.14.0a0__py3-none-any.whl → 0.14.1__py3-none-any.whl

holmes/plugins/toolsets/datadog/toolset_datadog_logs.py

@@ -3,12 +3,13 @@ from enum import Enum
 import json
 import logging
 from typing import Any, Optional, Dict, Tuple, Set
+from urllib.parse import urlencode
 from holmes.core.tools import (
     CallablePrerequisite,
     ToolsetTag,
 )
 from pydantic import BaseModel, Field
-from holmes.core.tools import StructuredToolResult, ToolResultStatus
+from holmes.core.tools import StructuredToolResult, StructuredToolResultStatus
 from holmes.plugins.toolsets.consts import TOOLSET_CONFIG_MISSING_ERROR
 from holmes.plugins.toolsets.datadog.datadog_api import (
     DatadogBaseConfig,
@@ -16,6 +17,8 @@ from holmes.plugins.toolsets.datadog.datadog_api import (
     execute_paginated_datadog_http_request,
     get_headers,
     MAX_RETRY_COUNT_ON_RATE_LIMIT,
+    enhance_error_message,
+    preprocess_time_fields,
 )
 from holmes.plugins.toolsets.logging_utils.logging_api import (
     DEFAULT_TIME_SPAN_SECONDS,
@@ -99,23 +102,28 @@ def fetch_paginated_logs(
         "page": {"limit": calculate_page_size(params, dd_config, [])},
     }
 
+    # Preprocess time fields to ensure correct format
+    processed_payload = preprocess_time_fields(payload, "/api/v2/logs/events/search")
+
     logs, cursor = execute_paginated_datadog_http_request(
         url=url,
         headers=headers,
-        payload_or_params=payload,
+        payload_or_params=processed_payload,
         timeout=dd_config.request_timeout,
     )
 
     while cursor and len(logs) < limit:
-        payload["page"]["cursor"] = cursor
+        processed_payload["page"]["cursor"] = cursor
+        processed_payload["page"]["limit"] = calculate_page_size(
+            params, dd_config, logs
+        )
         new_logs, cursor = execute_paginated_datadog_http_request(
             url=url,
             headers=headers,
-            payload_or_params=payload,
+            payload_or_params=processed_payload,
             timeout=dd_config.request_timeout,
         )
         logs += new_logs
-        payload["page"]["limit"] = calculate_page_size(params, dd_config, logs)
 
     # logs are fetched descending order. Unified logging API follows the pattern of kubectl logs where oldest logs are first
     logs.reverse()
@@ -129,14 +137,73 @@ def format_logs(raw_logs: list[dict]) -> str:
     logs = []
 
     for raw_log_item in raw_logs:
+        # Extract timestamp - Datadog returns it in ISO format
+        timestamp = raw_log_item.get("attributes", {}).get("timestamp", "")
+        if not timestamp:
+            # Fallback to @timestamp if timestamp is not in attributes
+            timestamp = raw_log_item.get("attributes", {}).get("@timestamp", "")
+
+        # Extract message
         message = raw_log_item.get("attributes", {}).get(
             "message", json.dumps(raw_log_item)
         )
-        logs.append(message)
+
+        # Format as: [timestamp] message
+        if timestamp:
+            logs.append(f"[{timestamp}] {message}")
+        else:
+            logs.append(message)
 
     return "\n".join(logs)
 
 
+def generate_datadog_logs_url(
+    dd_config: DatadogLogsConfig,
+    params: FetchPodLogsParams,
+    storage_tier: DataDogStorageTier,
+) -> str:
+    """Generate a Datadog web UI URL for the logs query."""
+    from holmes.plugins.toolsets.utils import process_timestamps_to_int
+    from holmes.plugins.toolsets.datadog.datadog_api import convert_api_url_to_app_url
+
+    # Convert API URL to app URL using the shared helper
+    base_url = convert_api_url_to_app_url(dd_config.site_api_url)
+
+    # Build the query string
+    query = f"{dd_config.labels.namespace}:{params.namespace}"
+    query += f" {dd_config.labels.pod}:{params.pod_name}"
+    if params.filter:
+        filter = params.filter.replace('"', '\\"')
+        query += f' "{filter}"'
+
+    # Process timestamps - get Unix timestamps in seconds
+    (from_time_seconds, to_time_seconds) = process_timestamps_to_int(
+        start=params.start_time,
+        end=params.end_time,
+        default_time_span_seconds=DEFAULT_TIME_SPAN_SECONDS,
+    )
+
+    # Convert to milliseconds for Datadog web UI
+    from_time_ms = from_time_seconds * 1000
+    to_time_ms = to_time_seconds * 1000
+
+    # Build URL parameters matching Datadog's web UI format
+    url_params = {
+        "query": query,
+        "from_ts": str(from_time_ms),
+        "to_ts": str(to_time_ms),
+        "live": "true",
+        "storage": storage_tier.value,
+    }
+
+    # Add indexes if not default
+    if dd_config.indexes != ["*"]:
+        url_params["index"] = ",".join(dd_config.indexes)
+
+    # Construct the full URL
+    return f"{base_url}/logs?{urlencode(url_params)}"
+
+
 class DatadogLogsToolset(BasePodLoggingToolset):
     dd_config: Optional[DatadogLogsConfig] = None
 
@@ -167,7 +234,7 @@ class DatadogLogsToolset(BasePodLoggingToolset):
     def fetch_pod_logs(self, params: FetchPodLogsParams) -> StructuredToolResult:
         if not self.dd_config:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 data=TOOLSET_CONFIG_MISSING_ERROR,
                 params=params.model_dump(),
             )
@@ -181,29 +248,134 @@ class DatadogLogsToolset(BasePodLoggingToolset):
 
                 if raw_logs:
                     logs_str = format_logs(raw_logs)
+                    # Generate Datadog web UI URL
+                    datadog_url = generate_datadog_logs_url(
+                        self.dd_config, params, storage_tier
+                    )
+                    logs_with_link = f"{logs_str}\n\nView in Datadog: {datadog_url}"
                     return StructuredToolResult(
-                        status=ToolResultStatus.SUCCESS,
-                        data=logs_str,
+                        status=StructuredToolResultStatus.SUCCESS,
+                        data=logs_with_link,
+                        url=datadog_url,
                         params=params.model_dump(),
                     )
 
+            # Include detailed diagnostic context
+            query = f"{self.dd_config.labels.namespace}:{params.namespace} {self.dd_config.labels.pod}:{params.pod_name}"
+            if params.filter:
+                query += f' "{params.filter}"'
+
+            # Get actual time range used
+            (from_time, to_time) = process_timestamps_to_rfc3339(
+                start_timestamp=params.start_time,
+                end_timestamp=params.end_time,
+                default_time_span_seconds=DEFAULT_TIME_SPAN_SECONDS,
+            )
+
+            # Generate Datadog web UI URL for the last storage tier checked
+            datadog_url = generate_datadog_logs_url(
+                self.dd_config, params, self.dd_config.storage_tiers[-1]
+            )
+
+            # Build diagnostic information
+            diagnostics: Dict[str, Any] = {
+                "query_executed": query,
+                "time_range": f"{from_time} to {to_time}",
+                "indexes_searched": self.dd_config.indexes,
+                "storage_tiers_checked": [
+                    tier.value for tier in self.dd_config.storage_tiers
+                ],
+                "field_mappings": {
+                    "namespace_field": self.dd_config.labels.namespace,
+                    "pod_field": self.dd_config.labels.pod,
+                },
+                "limit": params.limit or self.dd_config.default_limit,
+                "datadog_url": datadog_url,
+            }
+
+            # Format diagnostic info as structured text
+            error_msg = (
+                f"No logs found.\n\n"
+                f"Diagnostic Information:\n"
+                f"----------------------\n"
+                f"Query executed: {diagnostics['query_executed']}\n"
+                f"Time range: {diagnostics['time_range']}\n"
+                f"Indexes searched: {diagnostics['indexes_searched']}\n"
+                f"Storage tiers checked: {', '.join(str(tier) for tier in diagnostics.get('storage_tiers_checked', []))}\n"
+                f"Field mappings:\n"
+                f"  - Namespace field: {diagnostics.get('field_mappings', {}).get('namespace_field', 'N/A')}\n"
+                f"  - Pod field: {diagnostics.get('field_mappings', {}).get('pod_field', 'N/A')}\n"
+                f"Limit: {diagnostics['limit']}\n\n"
+                f"View in Datadog: {diagnostics['datadog_url']}"
+            )
+
             return StructuredToolResult(
-                status=ToolResultStatus.NO_DATA,
+                status=StructuredToolResultStatus.NO_DATA,
+                error=error_msg,
+                url=datadog_url,
                 params=params.model_dump(),
             )
 
         except DataDogRequestError as e:
             logging.exception(e, exc_info=True)
 
+            # Always try to generate Datadog URL for debugging
+            try:
+                datadog_url = generate_datadog_logs_url(
+                    self.dd_config, params, self.dd_config.storage_tiers[0]
+                )
+            except Exception:
+                datadog_url = None
+
             # Provide more specific error message for rate limiting failures
             if e.status_code == 429:
                 error_msg = f"Datadog API rate limit exceeded. Failed after {MAX_RETRY_COUNT_ON_RATE_LIMIT} retry attempts."
+                if datadog_url:
+                    error_msg += f"\nView in Datadog: {datadog_url}"
+            elif e.status_code == 400:
+                # Use enhanced error message for validation errors
+                error_msg = enhance_error_message(
+                    e,
+                    "/api/v2/logs/events/search",
+                    "POST",
+                    str(self.dd_config.site_api_url),
+                )
+
+                # Add query context
+                query = f"{self.dd_config.labels.namespace}:{params.namespace} {self.dd_config.labels.pod}:{params.pod_name}"
+                if params.filter:
+                    query += f' "{params.filter}"'
+                error_msg += f"\n\nQuery attempted: {query}"
+
+                # Add Datadog web UI URL to error message
+                if datadog_url:
+                    error_msg += f"\nView in Datadog: {datadog_url}"
             else:
-                error_msg = f"Exception while querying Datadog: {str(e)}"
+                # Include full API error details and query context
+                error_msg = (
+                    f"Datadog API error (status {e.status_code}): {e.response_text}"
+                )
+                query = f"{self.dd_config.labels.namespace}:{params.namespace} {self.dd_config.labels.pod}:{params.pod_name}"
+                if params.filter:
+                    query += f' "{params.filter}"'
+                error_msg += f"\nQuery: {query}"
+
+                # Get actual time range used
+                (from_time, to_time) = process_timestamps_to_rfc3339(
+                    start_timestamp=params.start_time,
+                    end_timestamp=params.end_time,
+                    default_time_span_seconds=DEFAULT_TIME_SPAN_SECONDS,
+                )
+                error_msg += f"\nTime range: {from_time} to {to_time}"
+
+                # Add Datadog web UI URL to error message
+                if datadog_url:
+                    error_msg += f"\nView in Datadog: {datadog_url}"
 
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=error_msg,
+                url=datadog_url,
                 params=params.model_dump(),
                 invocation=json.dumps(e.payload),
             )
@@ -213,7 +385,7 @@ class DatadogLogsToolset(BasePodLoggingToolset):
                 f"Failed to query Datadog logs for params: {params}", exc_info=True
             )
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=f"Exception while querying Datadog: {str(e)}",
                 params=params.model_dump(),
             )
@@ -224,7 +396,7 @@ class DatadogLogsToolset(BasePodLoggingToolset):
         Returns (success, error_message).
         """
         try:
-            logging.info("Performing Datadog configuration healthcheck...")
+            logging.debug("Performing Datadog configuration healthcheck...")
             healthcheck_params = FetchPodLogsParams(
                 namespace="*",
                 pod_name="*",
@@ -234,11 +406,11 @@ class DatadogLogsToolset(BasePodLoggingToolset):
 
             result = self.fetch_pod_logs(healthcheck_params)
 
-            if result.status == ToolResultStatus.ERROR:
+            if result.status == StructuredToolResultStatus.ERROR:
                 error_msg = result.error or "Unknown error during healthcheck"
                 logging.error(f"Datadog healthcheck failed: {error_msg}")
                 return False, f"Datadog healthcheck failed: {error_msg}"
-            elif result.status == ToolResultStatus.NO_DATA:
+            elif result.status == StructuredToolResultStatus.NO_DATA:
                 error_msg = "No logs were found in the last 48 hours using wildcards for pod and namespace. Is the configuration correct?"
                 logging.error(f"Datadog healthcheck failed: {error_msg}")
                 return False, f"Datadog healthcheck failed: {error_msg}"
@@ -254,7 +426,7 @@ class DatadogLogsToolset(BasePodLoggingToolset):
         if not config:
             return (
                 False,
-                TOOLSET_CONFIG_MISSING_ERROR,
+                "Datadog logs toolset requires configuration. Please provide: dd_api_key, dd_app_key, and site_api_url in your Holmes config. For more details, see https://holmesgpt.dev/data-sources/builtin-toolsets/datadog/",
             )
 
         try:

holmes/plugins/toolsets/datadog/toolset_datadog_metrics.py

@@ -7,7 +7,7 @@ from holmes.core.tools import (
     StructuredToolResult,
     Tool,
     ToolParameter,
-    ToolResultStatus,
+    StructuredToolResultStatus,
     Toolset,
     ToolsetTag,
 )
@@ -54,7 +54,7 @@ class ListActiveMetrics(BaseDatadogMetricsTool):
     def __init__(self, toolset: "DatadogMetricsToolset"):
         super().__init__(
             name="list_active_datadog_metrics",
-            description=f"List active metrics from Datadog for the last {ACTIVE_METRICS_DEFAULT_LOOK_BACK_HOURS} hours. This includes metrics that have actively reported data points, including from pods no longer in the cluster.",
+            description=f"[datadog/metrics toolset] List active metrics from Datadog for the last {ACTIVE_METRICS_DEFAULT_LOOK_BACK_HOURS} hours. This includes metrics that have actively reported data points, including from pods no longer in the cluster.",
             parameters={
                 "from_time": ToolParameter(
                     description=f"Start time for listing metrics. Can be an RFC3339 formatted datetime (e.g. '2023-03-01T10:30:00Z') or a negative integer for relative seconds from now (e.g. -86400 for 24 hours ago). Defaults to {ACTIVE_METRICS_DEFAULT_LOOK_BACK_HOURS} hours ago",
@@ -80,7 +80,7 @@ class ListActiveMetrics(BaseDatadogMetricsTool):
     ) -> StructuredToolResult:
         if not self.toolset.dd_config:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=TOOLSET_CONFIG_MISSING_ERROR,
                 params=params,
             )
@@ -121,7 +121,7 @@ class ListActiveMetrics(BaseDatadogMetricsTool):
             metrics = data.get("metrics", [])
             if not metrics:
                 return StructuredToolResult(
-                    status=ToolResultStatus.ERROR,
+                    status=StructuredToolResultStatus.ERROR,
                     data="Your filter returned no metrics. Change your filter and try again",
                     params=params,
                 )
@@ -133,7 +133,7 @@ class ListActiveMetrics(BaseDatadogMetricsTool):
                 output.append(metric)
 
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data="\n".join(output),
                 params=params,
             )
@@ -149,10 +149,30 @@ class ListActiveMetrics(BaseDatadogMetricsTool):
                     f"and 'timeseries_query' permissions. Error: {str(e)}"
                 )
             else:
-                error_msg = f"Exception while querying Datadog: {str(e)}"
+                # Include full API error details for better debugging
+                error_msg = (
+                    f"Datadog API error (status {e.status_code}): {e.response_text}"
+                )
+                if params:
+                    # ListActiveMetrics parameters: from_time, host, tag_filter
+                    if params.get("host"):
+                        error_msg += f"\nHost filter: {params.get('host')}"
+                    if params.get("tag_filter"):
+                        error_msg += f"\nTag filter: {params.get('tag_filter')}"
+
+                    from_time_param = params.get("from_time")
+                    if from_time_param:
+                        time_desc = from_time_param
+                    else:
+                        time_desc = f"default (last {ACTIVE_METRICS_DEFAULT_LOOK_BACK_HOURS} hours)"
+                    error_msg += f"\nTime range: {time_desc}"
+
+                    # Note: We cannot generate a Datadog Metrics Explorer URL for ListActiveMetrics
+                    # because the Metrics Explorer requires a specific metric query,
+                    # while ListActiveMetrics just lists available metrics without querying any specific one
 
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=error_msg,
                 params=params,
                 invocation=json.dumps({"url": url, "params": query_params})
@@ -165,7 +185,7 @@ class ListActiveMetrics(BaseDatadogMetricsTool):
                 f"Failed to query Datadog metrics for params: {params}", exc_info=True
             )
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=f"Exception while querying Datadog: {str(e)}",
                 params=params,
             )
@@ -184,7 +204,7 @@ class QueryMetrics(BaseDatadogMetricsTool):
     def __init__(self, toolset: "DatadogMetricsToolset"):
         super().__init__(
             name="query_datadog_metrics",
-            description="Query timeseries data from Datadog for a specific metric, including historical data for pods no longer in the cluster",
+            description="[datadog/metrics toolset] Query timeseries data from Datadog for a specific metric, including historical data for pods no longer in the cluster",
             parameters={
                 "query": ToolParameter(
                     description="The metric query string (e.g., 'system.cpu.user{host:myhost}')",
@@ -222,7 +242,7 @@ class QueryMetrics(BaseDatadogMetricsTool):
     ) -> StructuredToolResult:
         if not self.toolset.dd_config:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=TOOLSET_CONFIG_MISSING_ERROR,
                 params=params,
             )
@@ -261,9 +281,29 @@ class QueryMetrics(BaseDatadogMetricsTool):
             output_type = params.get("output_type", "Plain")
 
             if not series:
+                # Include detailed context in error message
+                from_time_param = params.get("from_time")
+                to_time_param = params.get("to_time")
+
+                if from_time_param:
+                    from_desc = from_time_param
+                else:
+                    from_desc = (
+                        f"default (last {DEFAULT_TIME_SPAN_SECONDS // 86400} days)"
+                    )
+
+                to_desc = to_time_param or "now"
+
+                error_msg = (
+                    f"The query returned no data.\n"
+                    f"Query: {params.get('query', 'not specified')}\n"
+                    f"Time range: {from_desc} to {to_desc}\n"
+                    f"Please check your query syntax and ensure data exists for this time range."
+                )
+
                 return StructuredToolResult(
-                    status=ToolResultStatus.NO_DATA,
-                    error="The query returned no data. Please check your query syntax and time range.",
+                    status=StructuredToolResultStatus.NO_DATA,
+                    error=error_msg,
                     params=params,
                 )
 
@@ -317,7 +357,7 @@ class QueryMetrics(BaseDatadogMetricsTool):
 
             data_str = json.dumps(response_data, indent=2)
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=data_str,
                 params=params,
             )
@@ -333,10 +373,28 @@ class QueryMetrics(BaseDatadogMetricsTool):
                     f"and 'timeseries_query' permissions. Error: {str(e)}"
                 )
             else:
-                error_msg = f"Exception while querying Datadog: {str(e)}"
+                # Include full API error details for better debugging
+                error_msg = (
+                    f"Datadog API error (status {e.status_code}): {e.response_text}"
+                )
+                if params:
+                    error_msg += f"\nQuery: {params.get('query', 'not specified')}"
+
+                    from_time_param = params.get("from_time")
+                    to_time_param = params.get("to_time")
+
+                    if from_time_param:
+                        from_desc = from_time_param
+                    else:
+                        from_desc = (
+                            f"default (last {DEFAULT_TIME_SPAN_SECONDS // 86400} days)"
+                        )
+
+                    to_desc = to_time_param or "now"
+                    error_msg += f"\nTime range: {from_desc} to {to_desc}"
 
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=error_msg,
                 params=params,
                 invocation=json.dumps({"url": url, "params": query_params})
@@ -350,7 +408,7 @@ class QueryMetrics(BaseDatadogMetricsTool):
             )
 
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=f"Exception while querying Datadog: {str(e)}",
                 params=params,
             )
@@ -364,7 +422,7 @@ class QueryMetricsMetadata(BaseDatadogMetricsTool):
     def __init__(self, toolset: "DatadogMetricsToolset"):
         super().__init__(
             name="get_datadog_metric_metadata",
-            description="Get metadata about one or more metrics including their type, description, unit, and other properties",
+            description="[datadog/metrics toolset] Get metadata about one or more metrics including their type, description, unit, and other properties",
             parameters={
                 "metric_names": ToolParameter(
                     description="Comma-separated list of metric names to get metadata for (e.g., 'system.cpu.user, system.mem.used')",
@@ -380,7 +438,7 @@ class QueryMetricsMetadata(BaseDatadogMetricsTool):
     ) -> StructuredToolResult:
         if not self.toolset.dd_config:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=TOOLSET_CONFIG_MISSING_ERROR,
                 params=params,
             )
@@ -396,7 +454,7 @@ class QueryMetricsMetadata(BaseDatadogMetricsTool):
 
             if not metric_names:
                 return StructuredToolResult(
-                    status=ToolResultStatus.ERROR,
+                    status=StructuredToolResultStatus.ERROR,
                     error="metric_names cannot be empty",
                     params=params,
                 )
@@ -442,14 +500,14 @@ class QueryMetricsMetadata(BaseDatadogMetricsTool):
 
             if not results and errors:
                 return StructuredToolResult(
-                    status=ToolResultStatus.ERROR,
+                    status=StructuredToolResultStatus.ERROR,
                     error="Failed to retrieve metadata for all metrics",
                     data=json.dumps(response_data, indent=2),
                     params=params,
                 )
 
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=json.dumps(response_data, indent=2),
                 params=params,
             )
@@ -461,7 +519,7 @@ class QueryMetricsMetadata(BaseDatadogMetricsTool):
             )
 
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=f"Exception while querying Datadog: {str(e)}",
                 params=params,
             )
@@ -480,7 +538,7 @@ class ListMetricTags(BaseDatadogMetricsTool):
     def __init__(self, toolset: "DatadogMetricsToolset"):
         super().__init__(
             name="list_datadog_metric_tags",
-            description="List all available tags and aggregations for a specific metric. This helps in building queries by showing what dimensions are available for filtering.",
+            description="[datadog/metrics toolset] List all available tags and aggregations for a specific metric. This helps in building queries by showing what dimensions are available for filtering.",
             parameters={
                 "metric_name": ToolParameter(
                     description="The name of the metric to get tags for (e.g., 'system.cpu.user', 'container.memory.usage')",
@@ -496,7 +554,7 @@ class ListMetricTags(BaseDatadogMetricsTool):
     ) -> StructuredToolResult:
         if not self.toolset.dd_config:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=TOOLSET_CONFIG_MISSING_ERROR,
                 params=params,
             )
@@ -519,7 +577,7 @@ class ListMetricTags(BaseDatadogMetricsTool):
             )
 
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=data,
                 params=params,
             )
@@ -537,10 +595,17 @@ class ListMetricTags(BaseDatadogMetricsTool):
                     f"permissions. Error: {str(e)}"
                 )
             else:
-                error_msg = f"Exception while querying Datadog: {str(e)}"
+                # Include full API error details for better debugging
+                error_msg = (
+                    f"Datadog API error (status {e.status_code}): {e.response_text}"
+                )
+                if params:
+                    error_msg += (
+                        f"\nMetric name: {params.get('metric_name', 'not specified')}"
+                    )
 
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=error_msg,
                 params=params,
                 invocation=json.dumps({"url": url, "params": query_params})
@@ -554,7 +619,7 @@ class ListMetricTags(BaseDatadogMetricsTool):
                 exc_info=True,
             )
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=f"Exception while querying Datadog: {str(e)}",
                 params=params,
             )
@@ -586,7 +651,7 @@ class DatadogMetricsToolset(Toolset):
 
     def _perform_healthcheck(self, dd_config: DatadogMetricsConfig) -> Tuple[bool, str]:
         try:
-            logging.info("Performing Datadog metrics configuration healthcheck...")
+            logging.debug("Performing Datadog metrics configuration healthcheck...")
 
             url = f"{dd_config.site_api_url}/api/v1/validate"
             headers = get_headers(dd_config)
@@ -615,7 +680,7 @@ class DatadogMetricsToolset(Toolset):
         if not config:
             return (
                 False,
-                TOOLSET_CONFIG_MISSING_ERROR,
+                "Datadog metrics toolset requires configuration. Please provide: dd_api_key, dd_app_key, and site_api_url in your Holmes config. For more details, see https://holmesgpt.dev/data-sources/builtin-toolsets/datadog/",
             )
 
         try: