holmesgpt 0.12.5__py3-none-any.whl → 0.13.0__py3-none-any.whl

holmes/plugins/toolsets/azure_sql/tools/get_top_log_io_queries.py

@@ -9,6 +9,7 @@ from holmes.plugins.toolsets.azure_sql.azure_base_toolset import (
 )
 from holmes.plugins.toolsets.azure_sql.apis.azure_sql_api import AzureSQLAPIClient
 from holmes.plugins.toolsets.azure_sql.utils import format_timing
+from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
 
 
 class GetTopLogIOQueries(BaseAzureSQLTool):
@@ -145,7 +146,7 @@ class GetTopLogIOQueries(BaseAzureSQLTool):
 
     def get_parameterized_one_liner(self, params: Dict) -> str:
         db_config = self.toolset.database_config()
-        return f"Fetch top log I/O consuming queries for database {db_config.server_name}/{db_config.database_name}"
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Get Top Log I/O Queries ({db_config.server_name}/{db_config.database_name})"
 
     @staticmethod
     def validate_config(

holmes/plugins/toolsets/coralogix/api.py

@@ -12,16 +12,16 @@ from holmes.plugins.toolsets.coralogix.utils import (
     parse_logs,
     CoralogixLogsMethodology,
 )
-from holmes.plugins.toolsets.logging_utils.logging_api import FetchPodLogsParams
+from holmes.plugins.toolsets.logging_utils.logging_api import (
+    FetchPodLogsParams,
+    DEFAULT_TIME_SPAN_SECONDS,
+    DEFAULT_LOG_LIMIT,
+)
 from holmes.plugins.toolsets.utils import (
     process_timestamps_to_rfc3339,
 )
 
 
-DEFAULT_TIME_SPAN_SECONDS = 86400
-DEFAULT_LOG_COUNT = 2000  # Coralogix's default is 2000
-
-
 class CoralogixTier(str, Enum):
     FREQUENT_SEARCH = "TIER_FREQUENT_SEARCH"
     ARCHIVE = "TIER_ARCHIVE"
@@ -62,7 +62,7 @@ def build_query_string(config: CoralogixConfig, params: FetchPodLogsParams) -> s
         query_filters.append(f'{config.labels.log_message}:"{params.filter}"')
 
     query_string = " AND ".join(query_filters)
-    query_string = f"source logs | lucene '{query_string}' | limit {params.limit or DEFAULT_LOG_COUNT}"
+    query_string = f"source logs | lucene '{query_string}' | limit {params.limit or DEFAULT_LOG_LIMIT}"
     return query_string
 
 

holmes/plugins/toolsets/coralogix/toolset_coralogix_logs.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, Tuple
+from typing import Any, Optional, Tuple, Set
 
 from holmes.core.tools import (
     CallablePrerequisite,
@@ -23,11 +23,17 @@ from holmes.plugins.toolsets.coralogix.utils import (
 from holmes.plugins.toolsets.logging_utils.logging_api import (
     BasePodLoggingToolset,
     FetchPodLogsParams,
+    LoggingCapability,
     PodLoggingTool,
 )
 
 
 class CoralogixLogsToolset(BasePodLoggingToolset):
+    @property
+    def supported_capabilities(self) -> Set[LoggingCapability]:
+        """Coralogix only supports substring matching, not regex or exclude filters"""
+        return set()  # No regex support, no exclude filter
+
     def __init__(self):
         super().__init__(
             name="coralogix/logs",

holmes/plugins/toolsets/datadog/datadog_api.py

@@ -126,6 +126,25 @@ class wait_for_retry_after_header(wait_base):
     ),
     reraise=True,
 )
+def execute_paginated_datadog_http_request(
+    url: str,
+    headers: dict,
+    payload_or_params: dict,
+    timeout: int,
+    method: str = "POST",
+) -> tuple[Any, Optional[str]]:
+    response_data = execute_datadog_http_request(
+        url=url,
+        headers=headers,
+        payload_or_params=payload_or_params,
+        timeout=timeout,
+        method=method,
+    )
+    cursor = extract_cursor(response_data)
+    data = response_data.get("data", [])
+    return data, cursor
+
+
 def execute_datadog_http_request(
     url: str,
     headers: dict,
@@ -143,14 +162,7 @@ def execute_datadog_http_request(
         )
 
     if response.status_code == 200:
-        response_data = response.json()
-
-        if method == "POST" and response_data and "data" in response_data:
-            cursor = extract_cursor(response_data)
-            data = response_data.get("data", [])
-            return data, cursor
-        else:
-            return response_data
+        return response.json()
 
     else:
         raise DataDogRequestError(

holmes/plugins/toolsets/datadog/datadog_metrics_instructions.jinja2

@@ -1,5 +1,13 @@
 ## Datadog Metrics Tools Usage Guide
 
+Before running metrics queries:
+
+** You are often (but not always) running in a kubernetes environment. So users might ask you questions about kubernetes workloads without explicitly stating their type.
+** When getting ambiguous questions, use kubectl_find_resource to find the resource you are being asked about!
+** Find the involved resource name and kind
+** If you can't figure out what is the type of the resource, ask the user for more information and don't guess
+
+
 When investigating metrics-related issues:
 
 1. **Start with `list_active_datadog_metrics`** to discover available metrics
@@ -8,7 +16,6 @@ When investigating metrics-related issues:
 
 2. **Use `query_datadog_metrics`** to fetch actual metric data
    - Query syntax: `metric_name{tag:value}`
-   - Example: `system.cpu.user{host:myhost}`
    - Returns timeseries data with timestamps and values
 
 3. **Use `get_datadog_metric_metadata`** to understand metric properties

holmes/plugins/toolsets/datadog/datadog_rds_instructions.jinja2

@@ -0,0 +1,82 @@
+## Datadog RDS Performance Analysis Instructions
+
+You have access to tools for analyzing RDS database performance and identifying problematic instances using Datadog metrics.
+
+### Available Tools:
+
+1. **datadog_rds_performance_report** - Generate comprehensive performance report for a specific RDS instance
+   - Analyzes latency, resource utilization, and storage metrics
+   - Identifies performance issues and bottlenecks
+   - Provides actionable recommendations
+   - Returns formatted report with executive summary
+
+2. **datadog_rds_top_worst_performing** - Get summary of worst performing RDS instances
+   - Analyzes all RDS instances in the environment
+   - Ranks by latency, CPU, or composite performance score
+   - Shows top N worst performers with their key metrics
+   - Helps prioritize optimization efforts
+
+### Usage Guidelines:
+
+**For investigating a specific RDS instance:**
+```
+Use datadog_rds_performance_report with:
+- db_instance_identifier: "instance-name"
+- start_time: "-3600" (last hour)
+```
+
+**For finding problematic instances across the fleet:**
+```
+Use datadog_rds_top_worst_performing with:
+- top_n: 10 (show top 10 worst)
+- sort_by: "latency" (or "cpu", "composite")
+- start_time: "-3600"
+```
+
+### Key Performance Thresholds:
+
+The tools automatically flag issues based on these thresholds:
+- **Latency**: >10ms average (warning), >50ms peak (critical)
+- **CPU**: >70% average (warning), >90% peak (critical)
+- **Memory**: <100MB freeable memory (warning)
+- **Burst Balance**: <30% (warning, indicates I/O constraints)
+- **Disk Queue Depth**: >5 average (indicates I/O bottleneck)
+
+### Common Scenarios:
+
+1. **Application experiencing slow database queries:**
+   - Generate performance report for the specific RDS instance
+   - Look for latency spikes and resource constraints
+   - Follow recommendations for optimization
+
+2. **Proactive performance monitoring:**
+   - Use top worst performing to identify problem instances
+   - Generate detailed reports for the worst performers
+   - Plan capacity upgrades based on findings
+
+3. **Capacity planning:**
+   - Analyze resource utilization trends
+   - Identify instances approaching limits
+   - Plan upgrades before performance degradation
+
+### Interpreting Results:
+
+**Performance Report Sections:**
+- **Executive Summary**: High-level assessment and severity
+- **Metrics Tables**: Statistical analysis of each metric
+- **Issues**: Specific problems detected with thresholds exceeded
+- **Recommendations**: Prioritized actions to resolve issues
+
+**Top Worst Performing Report:**
+- **Rankings**: Instances sorted by selected metric
+- **Key Metrics**: Latency, CPU, burst balance for each instance
+- **Summary**: Overall patterns across the fleet
+
+### Example Responses:
+
+When asked about database performance issues:
+1. First use `datadog_rds_top_worst_performing` to identify problem instances
+2. Then use `datadog_rds_performance_report` on the worst performers
+3. Summarize findings and provide prioritized recommendations
+
+Always consider the time range - recent data (last hour) for current issues, longer ranges (last 24 hours) for trends.

holmes/plugins/toolsets/datadog/toolset_datadog_logs.py

@@ -1,7 +1,7 @@
 from enum import Enum
 import json
 import logging
-from typing import Any, Optional, Dict, Tuple
+from typing import Any, Optional, Dict, Tuple, Set
 from holmes.core.tools import (
     CallablePrerequisite,
     ToolsetTag,
@@ -12,14 +12,16 @@ from holmes.plugins.toolsets.consts import TOOLSET_CONFIG_MISSING_ERROR
 from holmes.plugins.toolsets.datadog.datadog_api import (
     DatadogBaseConfig,
     DataDogRequestError,
-    execute_datadog_http_request,
+    execute_paginated_datadog_http_request,
     get_headers,
     MAX_RETRY_COUNT_ON_RATE_LIMIT,
 )
 from holmes.plugins.toolsets.logging_utils.logging_api import (
     DEFAULT_TIME_SPAN_SECONDS,
+    DEFAULT_LOG_LIMIT,
     BasePodLoggingToolset,
     FetchPodLogsParams,
+    LoggingCapability,
     PodLoggingTool,
 )
 from holmes.plugins.toolsets.utils import process_timestamps_to_rfc3339
@@ -47,7 +49,7 @@ class DatadogLogsConfig(DatadogBaseConfig):
     )
     labels: DataDogLabelsMapping = DataDogLabelsMapping()
     page_size: int = 300
-    default_limit: int = 1000
+    default_limit: int = DEFAULT_LOG_LIMIT
 
 
 def calculate_page_size(
@@ -96,7 +98,7 @@ def fetch_paginated_logs(
         "page": {"limit": calculate_page_size(params, dd_config, [])},
     }
 
-    logs, cursor = execute_datadog_http_request(
+    logs, cursor = execute_paginated_datadog_http_request(
         url=url,
         headers=headers,
         payload_or_params=payload,
@@ -105,7 +107,7 @@ def fetch_paginated_logs(
 
     while cursor and len(logs) < limit:
         payload["page"]["cursor"] = cursor
-        new_logs, cursor = execute_datadog_http_request(
+        new_logs, cursor = execute_paginated_datadog_http_request(
             url=url,
             headers=headers,
             payload_or_params=payload,
@@ -137,6 +139,11 @@ def format_logs(raw_logs: list[dict]) -> str:
 class DatadogLogsToolset(BasePodLoggingToolset):
     dd_config: Optional[DatadogLogsConfig] = None
 
+    @property
+    def supported_capabilities(self) -> Set[LoggingCapability]:
+        """Datadog logs API only supports substring matching, no exclude filter"""
+        return set()  # No regex support, no exclude filter
+
     def __init__(self):
         super().__init__(
             name="datadog/logs",

holmes/plugins/toolsets/datadog/toolset_datadog_metrics.py

@@ -26,16 +26,20 @@ from holmes.plugins.toolsets.utils import (
     get_param_or_raise,
     process_timestamps_to_int,
     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
 
-DEFAULT_TIME_SPAN_SECONDS = 3600
-
 
 class DatadogMetricsConfig(DatadogBaseConfig):
-    default_limit: int = 1000
+    default_limit: int = DEFAULT_LOG_LIMIT
 
 
 class BaseDatadogMetricsTool(Tool):
@@ -63,7 +67,7 @@ class ListActiveMetrics(BaseDatadogMetricsTool):
                     required=False,
                 ),
                 "tag_filter": ToolParameter(
-                    description="Filter metrics by tags in the format tag:value. pod tag is pod_name. namespace tag is kube_namespace.",
+                    description="Filter metrics by tags in the format tag:value.",
                     type="string",
                     required=False,
                 ),
@@ -113,6 +117,12 @@ class ListActiveMetrics(BaseDatadogMetricsTool):
             )
 
             metrics = data.get("metrics", [])
+            if not metrics:
+                return StructuredToolResult(
+                    status=ToolResultStatus.ERROR,
+                    data="Your filter returned no metrics. Change your filter and try again",
+                    params=params,
+                )
 
             output = ["Metric Name"]
             output.append("-" * 50)
@@ -164,8 +174,8 @@ class ListActiveMetrics(BaseDatadogMetricsTool):
             filters.append(f"host={params['host']}")
         if params.get("tag_filter"):
             filters.append(f"tag_filter={params['tag_filter']}")
-        filter_str = f" with filters: {', '.join(filters)}" if filters else ""
-        return f"List active Datadog metrics{filter_str}"
+        filter_str = f"{', '.join(filters)}" if filters else "all"
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: List Active Metrics ({filter_str})"
 
 
 class QueryMetrics(BaseDatadogMetricsTool):
@@ -342,9 +352,8 @@ class QueryMetrics(BaseDatadogMetricsTool):
             )
 
     def get_parameterized_one_liner(self, params) -> str:
-        query = params.get("query", "<no query>")
         description = params.get("description", "")
-        return f"Query Datadog metrics: query='{query}', description='{description}'"
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Query Metrics ({description})"
 
 
 class QueryMetricsMetadata(BaseDatadogMetricsTool):
@@ -455,10 +464,10 @@ class QueryMetricsMetadata(BaseDatadogMetricsTool):
         metric_names = params.get("metric_names", [])
         if isinstance(metric_names, list):
             if len(metric_names) == 1:
-                return f"Get Datadog metric metadata for: {metric_names[0]}"
+                return f"Get Metric Metadata ({metric_names[0]})"
             elif len(metric_names) > 1:
-                return f"Get Datadog metric metadata for {len(metric_names)} metrics"
-        return "Get Datadog metric metadata"
+                return f"{toolset_name_for_one_liner(self.toolset.name)}: Get Datadog metric metadata for {len(metric_names)} metrics"
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Get Datadog metric metadata"
 
 
 class ListMetricTags(BaseDatadogMetricsTool):