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

holmes/plugins/toolsets/datadog/toolset_datadog_traces.py

@@ -1,3 +1,5 @@
+"""Datadog Traces toolset for HolmesGPT."""
+
 import json
 import logging
 import os
@@ -20,12 +22,18 @@ from holmes.plugins.toolsets.datadog.datadog_api import (
     get_headers,
     MAX_RETRY_COUNT_ON_RATE_LIMIT,
 )
-from holmes.plugins.toolsets.utils import process_timestamps_to_int
+from holmes.plugins.toolsets.utils import (
+    process_timestamps_to_int,
+    toolset_name_for_one_liner,
+)
 from holmes.plugins.toolsets.datadog.datadog_traces_formatter import (
     format_traces_list,
     format_trace_hierarchy,
     format_spans_search,
 )
+from holmes.plugins.toolsets.logging_utils.logging_api import (
+    DEFAULT_TIME_SPAN_SECONDS,
+)
 
 
 class DatadogTracesConfig(DatadogBaseConfig):
@@ -200,8 +208,8 @@ class FetchDatadogTracesList(BaseDatadogTracesTool):
         if "min_duration" in params:
             filters.append(f"duration>{params['min_duration']}")
 
-        filter_str = " AND ".join(filters) if filters else "all traces"
-        return f"DataDog: fetch traces matching {filter_str}"
+        filter_str = ", ".join(filters) if filters else "all"
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Fetch Traces ({filter_str})"
 
     def _invoke(self, params: Any) -> StructuredToolResult:
         """Execute the tool to fetch traces."""
@@ -220,7 +228,7 @@ class FetchDatadogTracesList(BaseDatadogTracesTool):
             from_time_int, to_time_int = process_timestamps_to_int(
                 start=params.get("start_datetime"),
                 end=params.get("end_datetime"),
-                default_time_span_seconds=3600,  # Default to 1 hour
+                default_time_span_seconds=DEFAULT_TIME_SPAN_SECONDS,
             )
 
             # Convert to milliseconds for Datadog API
@@ -364,9 +372,8 @@ class FetchDatadogTraceById(BaseDatadogTracesTool):
 
     def get_parameterized_one_liner(self, params: dict) -> str:
         """Get a one-liner description of the tool invocation."""
-        return (
-            f"DataDog: fetch trace details for ID {params.get('trace_id', 'unknown')}"
-        )
+        trace_id = params.get("trace_id", "unknown")
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Fetch Trace Details ({trace_id})"
 
     def _invoke(self, params: Any) -> StructuredToolResult:
         """Execute the tool to fetch trace details."""
@@ -538,7 +545,7 @@ class FetchDatadogSpansByFilter(BaseDatadogTracesTool):
     def get_parameterized_one_liner(self, params: dict) -> str:
         """Get a one-liner description of the tool invocation."""
         if "query" in params:
-            return f"DataDog: search spans with query: {params['query']}"
+            return f"{toolset_name_for_one_liner(self.toolset.name)}: Search Spans ({params['query']})"
 
         filters = []
         if "service" in params:
@@ -546,8 +553,8 @@ class FetchDatadogSpansByFilter(BaseDatadogTracesTool):
         if "operation" in params:
             filters.append(f"operation={params['operation']}")
 
-        filter_str = " AND ".join(filters) if filters else "all spans"
-        return f"DataDog: search spans matching {filter_str}"
+        filter_str = ", ".join(filters) if filters else "all"
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Search Spans ({filter_str})"
 
     def _invoke(self, params: Any) -> StructuredToolResult:
         """Execute the tool to search spans."""
@@ -566,7 +573,7 @@ class FetchDatadogSpansByFilter(BaseDatadogTracesTool):
             from_time_int, to_time_int = process_timestamps_to_int(
                 start=params.get("start_datetime"),
                 end=params.get("end_datetime"),
-                default_time_span_seconds=3600,  # Default to 1 hour
+                default_time_span_seconds=DEFAULT_TIME_SPAN_SECONDS,
             )
 
             # Convert to milliseconds for Datadog API

holmes/plugins/toolsets/git.py

@@ -13,6 +13,7 @@ from holmes.core.tools import (
     ToolsetTag,
     CallablePrerequisite,
 )
+from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
 
 
 class GitHubConfig(BaseModel):
@@ -277,7 +278,8 @@ class GitReadFileWithLineNumbers(Tool):
             )
 
     def get_parameterized_one_liner(self, params) -> str:
-        return "Reading git files"
+        filepath = params.get("filepath", "")
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Read Git File ({filepath})"
 
 
 class GitListFiles(Tool):
@@ -318,7 +320,7 @@ class GitListFiles(Tool):
             )
 
     def get_parameterized_one_liner(self, params) -> str:
-        return "listing git files"
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: List Git Files"
 
 
 class GitListOpenPRs(Tool):
@@ -357,7 +359,7 @@ class GitListOpenPRs(Tool):
             )
 
     def get_parameterized_one_liner(self, params) -> str:
-        return "Listing PR's"
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: List Open PRs"
 
 
 class GitExecuteChanges(Tool):
@@ -569,12 +571,11 @@ class GitExecuteChanges(Tool):
             return error(f"Unexpected error: {e}")
 
     def get_parameterized_one_liner(self, params) -> str:
-        return (
-            f"git execute_changes(line={params['line']}, filename='{params['filename']}', "
-            f"command='{params['command']}', code='{params.get('code', '')}', "
-            f"open_pr={params['open_pr']}, commit_pr='{params['commit_pr']}', "
-            f"dry_run={params['dry_run']}, commit_message='{params['commit_message']}')"
-        )
+        command = params.get("command", "")
+        filename = params.get("filename", "")
+        dry_run = params.get("dry_run", False)
+        mode = "(dry run)" if dry_run else ""
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Execute Git Changes ({command} in {filename}) {mode}".strip()
 
 
 class GitUpdatePR(Tool):
@@ -748,9 +749,8 @@ class GitUpdatePR(Tool):
             )
 
     def get_parameterized_one_liner(self, params) -> str:
-        return (
-            f"git update_pr(line={params['line']}, filename='{params['filename']}', "
-            f"command='{params['command']}', code='{params.get('code', '')}', "
-            f"pr_number={params['pr_number']}, dry_run={params['dry_run']}, "
-            f"commit_message='{params['commit_message']}')"
-        )
+        pr_number = params.get("pr_number", "")
+        command = params.get("command", "")
+        dry_run = params.get("dry_run", False)
+        mode = "(dry run)" if dry_run else ""
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Update PR #{pr_number} ({command}) {mode}".strip()

holmes/plugins/toolsets/grafana/grafana_api.py

@@ -28,4 +28,15 @@ def grafana_health_check(config: GrafanaConfig) -> Tuple[bool, str]:
         return True, ""
     except Exception as e:
         logging.error(f"Failed to fetch grafana health status at {url}", exc_info=True)
-        return False, f"Failed to fetch grafana health status at {url}. {str(e)}"
+        error_msg = f"Failed to fetch grafana health status at {url}. {str(e)}"
+
+        # Add helpful hint if this looks like a common misconfiguration
+        if config.grafana_datasource_uid and ":3100" in config.url:
+            error_msg += (
+                "\n\nPossible configuration issue: grafana_datasource_uid is set but URL contains port 3100 "
+                "(typically used for direct Loki connections). Please verify:\n"
+                "- If connecting directly to Loki: remove grafana_datasource_uid from config\n"
+                "- If connecting via Grafana proxy: ensure URL points to Grafana (usually port 3000)"
+            )
+
+        return False, error_msg

holmes/plugins/toolsets/grafana/toolset_grafana.py

@@ -5,6 +5,8 @@ from holmes.plugins.toolsets.grafana.base_grafana_toolset import BaseGrafanaTool
 import requests  # type: ignore
 import logging
 
+from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
+
 
 class ListAndBuildGrafanaDashboardURLs(Tool):
     def __init__(self, toolset: BaseGrafanaToolset):
@@ -86,7 +88,9 @@ class ListAndBuildGrafanaDashboardURLs(Tool):
             return f"Error fetching dashboards: {str(e)}"
 
     def get_parameterized_one_liner(self, params: Dict) -> str:
-        return f"Lists Grafana dashboards and builds URLs with parameters: {params}"
+        return (
+            f"{toolset_name_for_one_liner(self._toolset.name)}: List Grafana Dashboards"
+        )
 
 
 class GrafanaToolset(BaseGrafanaToolset):

holmes/plugins/toolsets/grafana/toolset_grafana_loki.py

@@ -1,4 +1,4 @@
-from typing import Any, cast
+from typing import Any, cast, Set
 from pydantic import BaseModel
 
 from holmes.core.tools import CallablePrerequisite
@@ -11,7 +11,9 @@ from holmes.plugins.toolsets.grafana.grafana_api import grafana_health_check
 from holmes.plugins.toolsets.logging_utils.logging_api import (
     BasePodLoggingToolset,
     FetchPodLogsParams,
+    LoggingCapability,
     PodLoggingTool,
+    DEFAULT_TIME_SPAN_SECONDS,
 )
 from holmes.plugins.toolsets.utils import (
     process_timestamps_to_rfc3339,
@@ -22,8 +24,6 @@ from holmes.plugins.toolsets.grafana.loki_api import (
 )
 from holmes.core.tools import StructuredToolResult, ToolResultStatus
 
-DEFAULT_TIME_SPAN_SECONDS = 3600
-
 
 class GrafanaLokiLabelsConfig(BaseModel):
     pod: str = "pod"
@@ -35,6 +35,11 @@ class GrafanaLokiConfig(GrafanaConfig):
 
 
 class GrafanaLokiToolset(BasePodLoggingToolset):
+    @property
+    def supported_capabilities(self) -> Set[LoggingCapability]:
+        """Loki only supports substring matching, not regex or exclude filters"""
+        return set()  # No regex support, no exclude filter
+
     def __init__(self):
         super().__init__(
             name="grafana/loki",
@@ -49,7 +54,7 @@ class GrafanaLokiToolset(BasePodLoggingToolset):
 
     def prerequisites_callable(self, config: dict[str, Any]) -> tuple[bool, str]:
         if not config:
-            return False, "Missing Grafana Loki configuration. Check your config."
+            return False, "Missing Loki configuration. Check your config."
 
         self.config = GrafanaLokiConfig(**config)
 

holmes/plugins/toolsets/grafana/toolset_grafana_tempo.py

@@ -23,7 +23,14 @@ from holmes.plugins.toolsets.grafana.tempo_api import (
     query_tempo_traces,
 )
 from holmes.plugins.toolsets.grafana.trace_parser import format_traces_list
-from holmes.plugins.toolsets.utils import get_param_or_raise, process_timestamps_to_int
+from holmes.plugins.toolsets.logging_utils.logging_api import (
+    DEFAULT_TIME_SPAN_SECONDS,
+)
+from holmes.plugins.toolsets.utils import (
+    get_param_or_raise,
+    process_timestamps_to_int,
+    toolset_name_for_one_liner,
+)
 
 TEMPO_LABELS_ADD_PREFIX = load_bool("TEMPO_LABELS_ADD_PREFIX", True)
 
@@ -144,7 +151,7 @@ class GetTempoTraces(Tool):
         start, end = process_timestamps_to_int(
             params.get("start_datetime"),
             params.get("end_datetime"),
-            default_time_span_seconds=3600,
+            default_time_span_seconds=DEFAULT_TIME_SPAN_SECONDS,
         )
 
         prefix = ""
@@ -190,7 +197,7 @@ class GetTempoTraces(Tool):
         )
 
     def get_parameterized_one_liner(self, params: Dict) -> str:
-        return f"Fetched Tempo traces with min_duration={params.get('min_duration')} ({str(params)})"
+        return f"{toolset_name_for_one_liner(self._toolset.name)}: Fetched Tempo Traces (min_duration={params.get('min_duration')})"
 
 
 class GetTempoTags(Tool):
@@ -244,7 +251,7 @@ class GetTempoTags(Tool):
             )
 
     def get_parameterized_one_liner(self, params: Dict) -> str:
-        return f"Fetched Tempo tags ({str(params)})"
+        return f"{toolset_name_for_one_liner(self._toolset.name)}: Fetched Tempo tags"
 
 
 class GetTempoTraceById(Tool):
@@ -281,7 +288,7 @@ class GetTempoTraceById(Tool):
         )
 
     def get_parameterized_one_liner(self, params: Dict) -> str:
-        return f"Fetched Tempo trace with trace_id={params.get('trace_id')} ({str(params)})"
+        return f"{toolset_name_for_one_liner(self._toolset.name)}: Fetched Tempo Trace (trace_id={params.get('trace_id')})"
 
 
 class GrafanaTempoToolset(BaseGrafanaTempoToolset):

holmes/plugins/toolsets/internet/internet.py

@@ -16,6 +16,7 @@ from bs4 import BeautifulSoup
 
 import requests  # type: ignore
 from holmes.core.tools import StructuredToolResult, ToolResultStatus
+from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
 
 
 # TODO: change and make it holmes
@@ -215,7 +216,7 @@ class FetchWebpage(Tool):
 
     def get_parameterized_one_liner(self, params) -> str:
         url: str = params.get("url", "<missing url>")
-        return f"fetched webpage {url}"
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Fetch Webpage {url}"
 
 
 class InternetBaseToolset(Toolset):

holmes/plugins/toolsets/internet/notion.py

@@ -15,6 +15,7 @@ from holmes.core.tools import (
     StructuredToolResult,
     ToolResultStatus,
 )
+from holmes.plugins.toolsets.utils import toolset_name_for_one_liner
 
 
 class FetchNotion(Tool):
@@ -108,7 +109,7 @@ class FetchNotion(Tool):
 
     def get_parameterized_one_liner(self, params) -> str:
         url: str = params["url"]
-        return f"fetched notion webpage {url}"
+        return f"{toolset_name_for_one_liner(self.toolset.name)}: Fetch Webpage {url}"
 
 
 class NotionToolset(InternetBaseToolset):

holmes/plugins/toolsets/investigator/core_investigation.py

@@ -0,0 +1,157 @@
+import logging
+import os
+from typing import Any, Dict
+
+from uuid import uuid4
+from holmes.core.todo_manager import (
+    get_todo_manager,
+)
+
+from holmes.core.tools import (
+    Toolset,
+    ToolsetTag,
+    ToolParameter,
+    Tool,
+    StructuredToolResult,
+    ToolResultStatus,
+)
+from holmes.plugins.toolsets.investigator.model import Task, TaskStatus
+
+
+class TodoWriteTool(Tool):
+    name: str = "TodoWrite"
+    description: str = "Save investigation tasks to break down complex problems into manageable sub-tasks. ALWAYS provide the COMPLETE list of all tasks, not just the ones being updated."
+    parameters: Dict[str, ToolParameter] = {
+        "todos": ToolParameter(
+            description="COMPLETE list of ALL tasks on the task list. Each task should have: id (string), content (string), status (pending/in_progress/completed)",
+            type="array",
+            required=True,
+            items=ToolParameter(
+                type="object",
+                properties={
+                    "id": ToolParameter(type="string", required=True),
+                    "content": ToolParameter(type="string", required=True),
+                    "status": ToolParameter(type="string", required=True),
+                },
+            ),
+        ),
+        "investigation_id": ToolParameter(
+            description="This investigation identifier. This is a uuid that represents the investigation session id.",
+            type="string",
+            required=True,
+        ),
+    }
+
+    # Print a nice table to console/log
+    def print_tasks_table(self, tasks):
+        if not tasks:
+            logging.info("No tasks in the investigation plan.")
+            return
+
+        status_icons = {
+            "pending": "[ ]",
+            "in_progress": "[~]",
+            "completed": "[✓]",
+        }
+
+        max_id_width = max(len(str(task.id)) for task in tasks)
+        max_content_width = max(len(task.content) for task in tasks)
+        max_status_display_width = max(
+            len(f"{status_icons[task.status.value]} {task.status.value}")
+            for task in tasks
+        )
+
+        id_width = max(max_id_width, len("ID"))
+        content_width = max(max_content_width, len("Content"))
+        status_width = max(max_status_display_width, len("Status"))
+
+        # Build table
+        separator = f"+{'-' * (id_width + 2)}+{'-' * (content_width + 2)}+{'-' * (status_width + 2)}+"
+        header = f"| {'ID':<{id_width}} | {'Content':<{content_width}} | {'Status':<{status_width}} |"
+
+        # Log the table
+        logging.info("Updated Investigation Tasks:")
+        logging.info(separator)
+        logging.info(header)
+        logging.info(separator)
+
+        for task in tasks:
+            status_display = f"{status_icons[task.status.value]} {task.status.value}"
+            row = f"| {task.id:<{id_width}} | {task.content:<{content_width}} | {status_display:<{status_width}} |"
+            logging.info(row)
+
+        logging.info(separator)
+
+    def _invoke(self, params: Dict) -> StructuredToolResult:
+        try:
+            todos_data = params.get("todos", [])
+
+            tasks = []
+
+            for todo_item in todos_data:
+                if isinstance(todo_item, dict):
+                    task = Task(
+                        id=todo_item.get("id", str(uuid4())),
+                        content=todo_item.get("content", ""),
+                        status=TaskStatus(todo_item.get("status", "pending")),
+                    )
+                    tasks.append(task)
+
+            logging.info(f"Tasks: {len(tasks)}")
+
+            # Store tasks in session storage
+            todo_manager = get_todo_manager()
+            session_id = params.get("investigation_id", "")
+            todo_manager.update_session_tasks(session_id, tasks)
+
+            self.print_tasks_table(tasks)
+
+            formatted_tasks = todo_manager.format_tasks_for_prompt(session_id)
+
+            response_data = f"✅ Investigation plan updated with {len(tasks)} tasks. Tasks are now stored in session and will appear in subsequent prompts.\n\n"
+            if formatted_tasks:
+                response_data += formatted_tasks
+            else:
+                response_data += "No tasks currently in the investigation plan."
+
+            return StructuredToolResult(
+                status=ToolResultStatus.SUCCESS,
+                data=response_data,
+                params=params,
+            )
+
+        except Exception as e:
+            logging.exception("error using todowrite tool")
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                error=f"Failed to process tasks: {str(e)}",
+                params=params,
+            )
+
+    def get_parameterized_one_liner(self, params: Dict) -> str:
+        todos = params.get("todos", [])
+        return f"Write {todos} investigation tasks"
+
+
+class CoreInvestigationToolset(Toolset):
+    """Core toolset for investigation management and task planning."""
+
+    def __init__(self):
+        super().__init__(
+            name="core_investigation",
+            description="Core investigation tools for task management and planning",
+            enabled=True,
+            tools=[TodoWriteTool()],
+            tags=[ToolsetTag.CORE],
+            is_default=True,
+        )
+        logging.info("Core investigation toolset loaded")
+
+    def get_example_config(self) -> Dict[str, Any]:
+        return {}
+
+    def _reload_instructions(self):
+        template_file_path = os.path.abspath(
+            os.path.join(os.path.dirname(__file__), "investigator_instructions.jinja2")
+        )
+        self._load_llm_instructions(jinja_template=f"file://{template_file_path}")