holmesgpt 0.12.6__py3-none-any.whl → 0.13.1__py3-none-any.whl

holmes/plugins/toolsets/logging_utils/logging_api.py

@@ -1,9 +1,10 @@
 from abc import ABC, abstractmethod
 from datetime import datetime, timedelta
 import logging
-from typing import Optional
+from typing import Optional, Set
+from enum import Enum
 
-from pydantic import BaseModel
+from pydantic import BaseModel, field_validator
 from datetime import timezone
 from holmes.core.tools import (
     StructuredToolResult,
@@ -14,12 +15,20 @@ from holmes.core.tools import (
 from holmes.plugins.toolsets.utils import get_param_or_raise
 
 # Default values for log fetching
-DEFAULT_LOG_LIMIT = 2000
-DEFAULT_TIME_SPAN_SECONDS = 3600
+DEFAULT_LOG_LIMIT = 100
+SECONDS_PER_DAY = 24 * 60 * 60
+DEFAULT_TIME_SPAN_SECONDS = 7 * SECONDS_PER_DAY  # 1 week in seconds
 
 POD_LOGGING_TOOL_NAME = "fetch_pod_logs"
 
 
+class LoggingCapability(str, Enum):
+    """Optional advanced logging capabilities"""
+
+    REGEX_FILTER = "regex_filter"  # If not supported, falls back to substring matching
+    EXCLUDE_FILTER = "exclude_filter"  # If not supported, parameter is not shown at all
+
+
 class LoggingConfig(BaseModel):
     """Base configuration for all logging backends"""
 
@@ -32,12 +41,27 @@ class FetchPodLogsParams(BaseModel):
     start_time: Optional[str] = None
     end_time: Optional[str] = None
     filter: Optional[str] = None
+    exclude_filter: Optional[str] = None
     limit: Optional[int] = None
 
+    @field_validator("start_time", mode="before")
+    @classmethod
+    def convert_start_time_to_string(cls, v):
+        """Convert integer start_time values to strings."""
+        if v is not None and isinstance(v, int):
+            return str(v)
+        return v
+
 
 class BasePodLoggingToolset(Toolset, ABC):
     """Base class for all logging toolsets"""
 
+    @property
+    @abstractmethod
+    def supported_capabilities(self) -> Set[LoggingCapability]:
+        """Return the set of optional capabilities supported by this provider"""
+        pass
+
     @abstractmethod
     def fetch_pod_logs(self, params: FetchPodLogsParams) -> StructuredToolResult:
         pass
@@ -50,42 +74,96 @@ class PodLoggingTool(Tool):
     """Common tool for fetching pod logs across different logging backends"""
 
     def __init__(self, toolset: BasePodLoggingToolset):
+        # Get parameters dynamically based on what the toolset supports
+        parameters = self._get_tool_parameters(toolset)
+
+        # Build description based on capabilities
+        description = "Fetch logs for a Kubernetes pod"
+        capabilities = toolset.supported_capabilities
+
+        if (
+            LoggingCapability.REGEX_FILTER in capabilities
+            and LoggingCapability.EXCLUDE_FILTER in capabilities
+        ):
+            description += " with support for regex filtering and exclusion patterns"
+        elif LoggingCapability.REGEX_FILTER in capabilities:
+            description += " with support for regex filtering"
+
+        # Add default information
+        description += f". Defaults: Fetches last {DEFAULT_TIME_SPAN_SECONDS // SECONDS_PER_DAY} days of logs, limited to {DEFAULT_LOG_LIMIT} most recent entries"
+
         super().__init__(
             name=POD_LOGGING_TOOL_NAME,
-            description="Fetch logs for a Kubernetes pod",
-            parameters={
-                "pod_name": ToolParameter(
-                    description="The exact kubernetes pod name",
-                    type="string",
-                    required=True,
-                ),
-                "namespace": ToolParameter(
-                    description="Kubernetes namespace", type="string", required=True
-                ),
-                "start_time": ToolParameter(
-                    description="Start time for logs. Can be an RFC3339 formatted datetime (e.g. '2023-03-01T10:30:00Z') for absolute time or a negative integer (e.g. -3600) for relative seconds before end_time.",
-                    type="string",
-                    required=False,
-                ),
-                "end_time": ToolParameter(
-                    description="End time for logs. Must be an RFC3339 formatted datetime (e.g. '2023-03-01T12:30:00Z'). If not specified, defaults to current time.",
-                    type="string",
-                    required=False,
-                ),
-                "limit": ToolParameter(
-                    description="Maximum number of logs to return",
-                    type="integer",
-                    required=False,
-                ),
-                "filter": ToolParameter(
-                    description="An optional keyword or sentence to filter the logs",
-                    type="string",
-                    required=False,
-                ),
-            },
+            description=description,
+            parameters=parameters,
         )
         self._toolset = toolset
 
+    def _get_tool_parameters(self, toolset: BasePodLoggingToolset) -> dict:
+        """Generate parameters based on what this provider supports"""
+        # Base parameters always available
+        params = {
+            "pod_name": ToolParameter(
+                description="The exact kubernetes pod name",
+                type="string",
+                required=True,
+            ),
+            "namespace": ToolParameter(
+                description="Kubernetes namespace", type="string", required=True
+            ),
+            "start_time": ToolParameter(
+                description=f"Start time for logs. Can be an RFC3339 formatted datetime (e.g. '2023-03-01T10:30:00Z') for absolute time or a negative string number (e.g. -3600) for relative seconds before end_time. Default: -{DEFAULT_TIME_SPAN_SECONDS} (last {DEFAULT_TIME_SPAN_SECONDS // SECONDS_PER_DAY} days)",
+                type="string",
+                required=False,
+            ),
+            "end_time": ToolParameter(
+                description="End time for logs. Must be an RFC3339 formatted datetime (e.g. '2023-03-01T12:30:00Z'). If not specified, defaults to current time.",
+                type="string",
+                required=False,
+            ),
+            "limit": ToolParameter(
+                description=f"Maximum number of logs to return. Default: {DEFAULT_LOG_LIMIT}",
+                type="integer",
+                required=False,
+            ),
+        }
+
+        # Add filter - description changes based on regex support
+        if LoggingCapability.REGEX_FILTER in toolset.supported_capabilities:
+            params["filter"] = ToolParameter(
+                description="""An optional filter for logs - can be a simple keyword/phrase or a regex pattern (case-insensitive).
+Examples of useful filters:
+- For errors: filter='err|error|fatal|critical|fail|exception|panic|crash'
+- For warnings: filter='warn|warning|caution'
+- For specific HTTP errors: filter='5[0-9]{2}|404|403'
+- For Java exceptions: filter='Exception|Error|Throwable|StackTrace'
+- For timeouts: filter='timeout|timed out|deadline exceeded'
+If you get no results with a filter, try a broader pattern or drop the filter.""",
+                type="string",
+                required=False,
+            )
+        else:
+            params["filter"] = ToolParameter(
+                description="An optional keyword to filter logs - matches logs containing this text (case-insensitive)",
+                type="string",
+                required=False,
+            )
+
+        # ONLY add exclude_filter if supported - otherwise it doesn't exist
+        if LoggingCapability.EXCLUDE_FILTER in toolset.supported_capabilities:
+            params["exclude_filter"] = ToolParameter(
+                description="""An optional exclusion filter - logs matching this pattern will be excluded. Can be a simple keyword or regex pattern (case-insensitive).
+Examples of useful exclude filters:
+- Exclude HTTP 200s: exclude_filter='GET.*200|POST.*200'
+- Exclude health/metrics: exclude_filter='health|metrics|ping|heartbeat'
+- Exclude specific log levels: exclude_filter='"level": "INFO"'
+If you hit the log limit and see lots of repetitive INFO logs, use exclude_filter to remove the noise and focus on what matters.""",
+                type="string",
+                required=False,
+            )
+
+        return params
+
     def _invoke(self, params: dict) -> StructuredToolResult:
         structured_params = FetchPodLogsParams(
             namespace=get_param_or_raise(params, "namespace"),
@@ -93,6 +171,7 @@ class PodLoggingTool(Tool):
             start_time=params.get("start_time"),
             end_time=params.get("end_time"),
             filter=params.get("filter"),
+            exclude_filter=params.get("exclude_filter"),
             limit=params.get("limit"),
         )
 
@@ -107,29 +186,10 @@ class PodLoggingTool(Tool):
         namespace = params.get("namespace", "unknown-namespace")
         pod_name = params.get("pod_name", "unknown-pod")
 
-        start_time = params.get("start_time")
-        end_time = params.get("end_time")
-        filter = params.get("filter")
-        limit = params.get("limit")
-
-        extra_params_str = ""
-
-        if start_time and not end_time:
-            extra_params_str += f" start_time={start_time}"
-        elif not start_time and end_time:
-            extra_params_str += f" end_time={end_time}"
-        elif start_time and end_time:
-            extra_params_str += f" time range={start_time}/{end_time}"
-
-        if filter:
-            extra_params_str += f" filter={filter}"
-        if limit:
-            extra_params_str += f" limit={limit}"
-
         logger_name = (
             f"{self._toolset.logger_name()}: " if self._toolset.logger_name() else ""
         )
-        return f"{logger_name}Fetching logs for pod {pod_name} in namespace {namespace}.{extra_params_str}"
+        return f"{logger_name}Fetch Logs (pod={pod_name}, namespace={namespace})"
 
 
 def process_time_parameters(

holmes/plugins/toolsets/mcp/toolset_mcp.py

@@ -83,7 +83,7 @@ class RemoteMCPTool(Tool):
         return parameters
 
     def get_parameterized_one_liner(self, params: Dict) -> str:
-        return f"Call mcp server {self.url} tool {self.name} with params {str(params)}"
+        return f"Call MCP Server ({self.url} - {self.name})"
 
 
 class RemoteMCPToolset(Toolset):

holmes/plugins/toolsets/newrelic.py

@@ -10,6 +10,7 @@ from holmes.core.tools import (
 )
 from pydantic import BaseModel
 from holmes.core.tools import StructuredToolResult, ToolResultStatus
+from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
 
 
 class BaseNewRelicTool(Tool):
@@ -89,7 +90,9 @@ class GetLogs(BaseNewRelicTool):
             return error(f"Error while fetching logs: {str(e)}")
 
     def get_parameterized_one_liner(self, params) -> str:
-        return f"newrelic GetLogs(app='{params.get('app')}', since='{params.get('since')}')"
+        app = params.get("app", "")
+        since = params.get("since", "")
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Get Logs ({app} - {since})"
 
 
 class GetTraces(BaseNewRelicTool):
@@ -171,8 +174,10 @@ class GetTraces(BaseNewRelicTool):
 
     def get_parameterized_one_liner(self, params) -> str:
         if "trace_id" in params and params["trace_id"]:
-            return f"newrelic GetTraces(trace_id='{params.get('trace_id')}')"
-        return f"newrelic GetTraces(duration={params.get('duration')})"
+            trace_id = params.get("trace_id", "")
+            return f"{toolset_name_for_one_liner(self.toolset.name)}: Get Trace Details ({trace_id})"
+        duration = params.get("duration", "")
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Get Traces (>{duration}s)"
 
 
 class NewrelicConfig(BaseModel):

holmes/plugins/toolsets/opensearch/opensearch.py

@@ -14,6 +14,7 @@ from holmes.core.tools import (
     ToolsetTag,
 )
 from holmes.plugins.toolsets.consts import TOOLSET_CONFIG_MISSING_ERROR
+from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
 
 
 class OpenSearchHttpAuth(BaseModel):
@@ -102,7 +103,8 @@ class ListShards(BaseOpenSearchTool):
         )
 
     def get_parameterized_one_liner(self, params: Dict) -> str:
-        return f"opensearch ListShards({params.get('host')})"
+        host = params.get("host", "")
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: List Shards ({host})"
 
 
 class GetClusterSettings(BaseOpenSearchTool):
@@ -132,7 +134,8 @@ class GetClusterSettings(BaseOpenSearchTool):
         )
 
     def get_parameterized_one_liner(self, params) -> str:
-        return f"opensearch GetClusterSettings({params.get('host')})"
+        host = params.get("host", "")
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Get Cluster Settings ({host})"
 
 
 class GetClusterHealth(BaseOpenSearchTool):
@@ -160,7 +163,8 @@ class GetClusterHealth(BaseOpenSearchTool):
         )
 
     def get_parameterized_one_liner(self, params) -> str:
-        return f"opensearch GetClusterHealth({params.get('host')})"
+        host = params.get("host", "")
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Check Cluster Health ({host})"
 
 
 class ListOpenSearchHosts(BaseOpenSearchTool):
@@ -181,7 +185,7 @@ class ListOpenSearchHosts(BaseOpenSearchTool):
         )
 
     def get_parameterized_one_liner(self, params: Dict) -> str:
-        return "opensearch ListOpenSearchHosts()"
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: List OpenSearch Hosts"
 
 
 class OpenSearchToolset(Toolset):

holmes/plugins/toolsets/opensearch/opensearch_logs.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple, Set
 
 import requests  # type: ignore
 from requests import RequestException  # type: ignore
@@ -14,8 +14,10 @@ from holmes.core.tools import (
 from holmes.plugins.toolsets.logging_utils.logging_api import (
     BasePodLoggingToolset,
     FetchPodLogsParams,
+    LoggingCapability,
     PodLoggingTool,
     process_time_parameters,
+    DEFAULT_TIME_SPAN_SECONDS,
 )
 from holmes.plugins.toolsets.opensearch.opensearch_utils import (
     OpenSearchLoggingConfig,
@@ -31,6 +33,11 @@ LOGS_FIELDS_CACHE_KEY = "cached_logs_fields"
 class OpenSearchLogsToolset(BasePodLoggingToolset):
     """Implementation of the unified logging API for OpenSearch logs"""
 
+    @property
+    def supported_capabilities(self) -> Set[LoggingCapability]:
+        """OpenSearch only supports phrase matching, not regex or exclude filters"""
+        return set()  # No regex support, no exclude filter
+
     def __init__(self):
         super().__init__(
             name="opensearch/logs",
@@ -82,7 +89,7 @@ class OpenSearchLogsToolset(BasePodLoggingToolset):
             end_time = None
             if params.start_time or params.end_time:
                 start_time, end_time = process_time_parameters(
-                    params.start_time, params.end_time
+                    params.start_time, params.end_time, DEFAULT_TIME_SPAN_SECONDS
                 )
 
             query = build_query(

holmes/plugins/toolsets/opensearch/opensearch_traces.py

@@ -20,6 +20,7 @@ from holmes.plugins.toolsets.opensearch.opensearch_utils import (
     get_search_url,
 )
 from holmes.core.tools import StructuredToolResult, ToolResultStatus
+from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
 
 TRACES_FIELDS_CACHE_KEY = "cached_traces_fields"
 
@@ -108,7 +109,7 @@ class GetTracesFields(Tool):
             )
 
     def get_parameterized_one_liner(self, params) -> str:
-        return "list traces documents fields"
+        return f"{toolset_name_for_one_liner(self._toolset.name)}: List Trace Fields"
 
 
 class TracesSearchQuery(Tool):
@@ -184,7 +185,10 @@ class TracesSearchQuery(Tool):
             )
 
     def get_parameterized_one_liner(self, params) -> str:
-        return f'search traces: query="{params.get("query")}"'
+        query = params.get("query", "")
+        return (
+            f"{toolset_name_for_one_liner(self._toolset.name)}: Search Traces ({query})"
+        )
 
 
 class OpenSearchTracesToolset(BaseOpenSearchToolset):