holmesgpt 0.16.2a0__py3-none-any.whl → 0.18.4__py3-none-any.whl

holmes/plugins/toolsets/datadog/toolset_datadog_metrics.py

@@ -1,27 +1,40 @@
 import json
 import logging
 import os
-from typing import Any, Optional, Dict, Tuple
+from datetime import datetime
+from typing import Any, Dict, Optional, Tuple
+
+from pydantic import AnyUrl
+
 from holmes.core.tools import (
     CallablePrerequisite,
     StructuredToolResult,
+    StructuredToolResultStatus,
     Tool,
     ToolInvokeContext,
     ToolParameter,
-    StructuredToolResultStatus,
     Toolset,
     ToolsetTag,
 )
 from holmes.plugins.toolsets.consts import (
-    TOOLSET_CONFIG_MISSING_ERROR,
     STANDARD_END_DATETIME_TOOL_PARAM_DESCRIPTION,
+    TOOLSET_CONFIG_MISSING_ERROR,
 )
 from holmes.plugins.toolsets.datadog.datadog_api import (
-    DatadogBaseConfig,
+    MAX_RETRY_COUNT_ON_RATE_LIMIT,
     DataDogRequestError,
     execute_datadog_http_request,
     get_headers,
-    MAX_RETRY_COUNT_ON_RATE_LIMIT,
+)
+from holmes.plugins.toolsets.datadog.datadog_models import DatadogMetricsConfig
+from holmes.plugins.toolsets.datadog.datadog_url_utils import (
+    generate_datadog_metric_metadata_url,
+    generate_datadog_metric_tags_url,
+    generate_datadog_metrics_explorer_url,
+    generate_datadog_metrics_list_url,
+)
+from holmes.plugins.toolsets.logging_utils.logging_api import (
+    DEFAULT_TIME_SPAN_SECONDS,
 )
 from holmes.plugins.toolsets.utils import (
     get_param_or_raise,
@@ -29,18 +42,6 @@ from holmes.plugins.toolsets.utils import (
     standard_start_datetime_tool_param_description,
     toolset_name_for_one_liner,
 )
-from holmes.plugins.toolsets.logging_utils.logging_api import (
-    DEFAULT_TIME_SPAN_SECONDS,
-    DEFAULT_LOG_LIMIT,
-)
-
-from datetime import datetime
-
-from holmes.utils.keygen_utils import generate_random_key
-
-
-class DatadogMetricsConfig(DatadogBaseConfig):
-    default_limit: int = DEFAULT_LOG_LIMIT
 
 
 class BaseDatadogMetricsTool(Tool):
@@ -131,10 +132,18 @@ class ListActiveMetrics(BaseDatadogMetricsTool):
             for metric in sorted(metrics):
                 output.append(metric)
 
+            url = generate_datadog_metrics_list_url(
+                self.toolset.dd_config,
+                from_time,
+                params.get("host"),
+                params.get("tag_filter"),
+            )
+
             return StructuredToolResult(
                 status=StructuredToolResultStatus.SUCCESS,
                 data="\n".join(output),
                 params=params,
+                url=url,
             )
 
         except DataDogRequestError as e:
@@ -341,7 +350,6 @@ class QueryMetrics(BaseDatadogMetricsTool):
             response_data = {
                 "status": "success",
                 "error_message": None,
-                "random_key": generate_random_key(),
                 "tool_name": self.name,
                 "description": description,
                 "query": query,
@@ -352,11 +360,18 @@ class QueryMetrics(BaseDatadogMetricsTool):
                 "data": {"resultType": "matrix", "result": prometheus_result},
             }
 
-            data_str = json.dumps(response_data, indent=2)
+            url = generate_datadog_metrics_explorer_url(
+                self.toolset.dd_config,
+                query,
+                from_time,
+                to_time,
+            )
+
             return StructuredToolResult(
                 status=StructuredToolResultStatus.SUCCESS,
-                data=data_str,
+                data=response_data,
                 params=params,
+                url=url,
             )
 
         except DataDogRequestError as e:
@@ -461,10 +476,10 @@ class QueryMetricsMetadata(BaseDatadogMetricsTool):
 
             for metric_name in metric_names:
                 try:
-                    url = f"{self.toolset.dd_config.site_api_url}/api/v1/metrics/{metric_name}"
+                    api_url = f"{self.toolset.dd_config.site_api_url}/api/v1/metrics/{metric_name}"
 
                     data = execute_datadog_http_request(
-                        url=url,
+                        url=api_url,
                         headers=headers,
                         payload_or_params={},
                         timeout=self.toolset.dd_config.request_timeout,
@@ -493,18 +508,29 @@ class QueryMetricsMetadata(BaseDatadogMetricsTool):
                 "failed": len(errors),
             }
 
+            # Generate URL for the first metric (or a general metrics page if multiple)
+            if metric_names:
+                url = generate_datadog_metric_metadata_url(
+                    self.toolset.dd_config,
+                    metric_names[0],
+                )
+            else:
+                url = None
+
             if not results and errors:
                 return StructuredToolResult(
                     status=StructuredToolResultStatus.ERROR,
                     error="Failed to retrieve metadata for all metrics",
-                    data=json.dumps(response_data, indent=2),
+                    data=response_data,
                     params=params,
+                    url=url,
                 )
 
             return StructuredToolResult(
                 status=StructuredToolResultStatus.SUCCESS,
-                data=json.dumps(response_data, indent=2),
+                data=response_data,
                 params=params,
+                url=url,
             )
 
         except Exception as e:
@@ -552,27 +578,33 @@ class ListMetricTags(BaseDatadogMetricsTool):
                 params=params,
             )
 
-        url = None
+        api_url = None
         query_params = None
 
         try:
             metric_name = get_param_or_raise(params, "metric_name")
 
-            url = f"{self.toolset.dd_config.site_api_url}/api/v2/metrics/{metric_name}/active-configurations"
+            api_url = f"{self.toolset.dd_config.site_api_url}/api/v2/metrics/{metric_name}/active-configurations"
             headers = get_headers(self.toolset.dd_config)
 
             data = execute_datadog_http_request(
-                url=url,
+                url=api_url,
                 headers=headers,
                 timeout=self.toolset.dd_config.request_timeout,
                 method="GET",
                 payload_or_params={},
             )
 
+            web_url = generate_datadog_metric_tags_url(
+                self.toolset.dd_config,
+                metric_name,
+            )
+
             return StructuredToolResult(
                 status=StructuredToolResultStatus.SUCCESS,
                 data=data,
                 params=params,
+                url=web_url,
             )
 
         except DataDogRequestError as e:
@@ -601,8 +633,8 @@ class ListMetricTags(BaseDatadogMetricsTool):
                 status=StructuredToolResultStatus.ERROR,
                 error=error_msg,
                 params=params,
-                invocation=json.dumps({"url": url, "params": query_params})
-                if url and query_params
+                invocation=json.dumps({"url": api_url, "params": query_params})
+                if api_url and query_params
                 else None,
             )
 
@@ -688,13 +720,12 @@ class DatadogMetricsToolset(Toolset):
             return (False, f"Failed to parse Datadog configuration: {str(e)}")
 
     def get_example_config(self) -> Dict[str, Any]:
-        return {
-            "dd_api_key": "your-datadog-api-key",
-            "dd_app_key": "your-datadog-application-key",
-            "site_api_url": "https://api.datadoghq.com",
-            "default_limit": 1000,
-            "request_timeout": 60,
-        }
+        example_config = DatadogMetricsConfig(
+            dd_api_key="<your_datadog_api_key>",
+            dd_app_key="<your_datadog_app_key>",
+            site_api_url=AnyUrl("https://api.datadoghq.com"),
+        )
+        return example_config.model_dump(mode="json")
 
     def _reload_instructions(self):
         """Load Datadog metrics specific troubleshooting instructions."""