holmesgpt 0.11.5__py3-none-any.whl

holmes/plugins/toolsets/kubernetes_logs.yaml

@@ -0,0 +1,42 @@
+toolsets:
+  kubernetes/logs:
+    description: "Read pod logs"
+    docs_url: "https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/kubernetes.html#logs"
+    icon_url: "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRPKA-U9m5BxYQDF1O7atMfj9EMMXEoGu4t0Q&s"
+    tags:
+      - core
+    prerequisites:
+      - command: "kubectl version --client"
+
+    tools:
+      - name: "kubectl_previous_logs"
+        description: "Run `kubectl logs --previous` on a single Kubernetes pod. Used to fetch logs for a pod that crashed and see logs from before the crash. Never give a deployment name or a resource that is not a pod."
+        command: "kubectl logs {{pod_name}} -n {{ namespace }} --previous"
+
+      - name: "kubectl_previous_logs_all_containers"
+        description: "Run `kubectl logs --previous` on a single Kubernetes pod. Used to fetch logs for a pod that crashed and see logs from before the crash."
+        command: "kubectl logs {{pod_name}} -n {{ namespace }} --previous --all-containers"
+
+      - name: "kubectl_container_previous_logs"
+        description: "Run `kubectl logs --previous` on a single container of a Kubernetes pod. Used to fetch logs for a pod that crashed and see logs from before the crash."
+        command: "kubectl logs {{pod_name}} -c {{container_name}} -n {{ namespace }} --previous"
+
+      - name: "kubectl_logs"
+        description: "Run `kubectl logs` on a single Kubernetes pod. Never give a deployment name or a resource that is not a pod."
+        command: "kubectl logs {{pod_name}} -n {{ namespace }}"
+
+      - name: "kubectl_logs_all_containers"
+        description: "Run `kubectl logs` on all containers within a single Kubernetes pod."
+        command: "kubectl logs {{pod_name}} -n {{ namespace }} --all-containers"
+
+      - name: "kubectl_container_logs"
+        description: "Run `kubectl logs` on a single container within a Kubernetes pod. This is to get the logs of a specific container in a multi-container pod."
+        command: "kubectl logs {{pod_name}} -c {{container_name}} -n {{ namespace }} "
+
+      - name: "kubectl_logs_grep"
+        description: "Search for a specific term in the logs of a single Kubernetes pod. Only provide a pod name, not a deployment or other resource."
+        command: "kubectl logs {{ pod_name }} -n {{ namespace }} | grep {{ search_term }}"
+
+      - name: "kubectl_logs_all_containers_grep"
+        description: "Search for a specific term in the logs of a single Kubernetes pod across all of its containers. Only provide a pod name, not a deployment or other resource."
+        command: "kubectl logs {{pod_name}} -n {{ namespace }} --all-containers | grep {{ search_term }}"

holmes/plugins/toolsets/logging_utils/logging_api.py

@@ -0,0 +1,217 @@
+from abc import ABC, abstractmethod
+from datetime import datetime, timedelta
+import logging
+from typing import Optional
+
+from pydantic import BaseModel
+from datetime import timezone
+from holmes.core.tools import (
+    StructuredToolResult,
+    Tool,
+    ToolParameter,
+    Toolset,
+)
+from holmes.plugins.toolsets.utils import get_param_or_raise
+
+# Default values for log fetching
+DEFAULT_LOG_LIMIT = 2000
+DEFAULT_TIME_SPAN_SECONDS = 3600
+
+POD_LOGGING_TOOL_NAME = "fetch_pod_logs"
+
+
+class LoggingConfig(BaseModel):
+    """Base configuration for all logging backends"""
+
+    pass
+
+
+class FetchPodLogsParams(BaseModel):
+    namespace: str
+    pod_name: str
+    start_time: Optional[str] = None
+    end_time: Optional[str] = None
+    filter: Optional[str] = None
+    limit: Optional[int] = None
+
+
+class BasePodLoggingToolset(Toolset, ABC):
+    """Base class for all logging toolsets"""
+
+    @abstractmethod
+    def fetch_pod_logs(self, params: FetchPodLogsParams) -> StructuredToolResult:
+        pass
+
+
+class PodLoggingTool(Tool):
+    """Common tool for fetching pod logs across different logging backends"""
+
+    def __init__(self, toolset: BasePodLoggingToolset):
+        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 timestamp (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 timestamp (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,
+                ),
+            },
+        )
+        self._toolset = toolset
+
+    def _invoke(self, params: dict) -> StructuredToolResult:
+        structured_params = FetchPodLogsParams(
+            namespace=get_param_or_raise(params, "namespace"),
+            pod_name=get_param_or_raise(params, "pod_name"),
+            start_time=params.get("start_time"),
+            end_time=params.get("end_time"),
+            filter=params.get("filter"),
+            limit=params.get("limit"),
+        )
+
+        result = self._toolset.fetch_pod_logs(
+            params=structured_params,
+        )
+
+        return result
+
+    def get_parameterized_one_liner(self, params: dict) -> str:
+        """Generate a one-line description of this tool invocation"""
+        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}"
+
+        return f"Fetching logs for pod {pod_name} in namespace {namespace}.{extra_params_str}"
+
+
+def process_time_parameters(
+    start_time: Optional[str],
+    end_time: Optional[str],
+    default_span_seconds: int = DEFAULT_TIME_SPAN_SECONDS,
+) -> tuple[Optional[str], Optional[str]]:
+    """
+    Convert time parameters to standard RFC3339 format
+
+    Args:
+        start_time: Either RFC3339 timestamp or negative integer (seconds before end)
+        end_time: RFC3339 timestamp or None (defaults to now)
+        default_span_seconds: Default time span if start_time not provided
+
+    Returns:
+        Tuple of (start_time, end_time) both in RFC3339 format or None
+    """
+    # Process end time first (as start might depend on it)
+    now = datetime.now(timezone.utc)
+
+    # Handle end_time
+    processed_end_time = None
+    if end_time:
+        try:
+            # Check if it's already in RFC3339 format
+            processed_end_time = end_time
+            datetime.fromisoformat(end_time.replace("Z", "+00:00"))
+        except (ValueError, TypeError):
+            # If not a valid RFC3339, log the error and use current time
+            logging.warning(f"Invalid end_time format: {end_time}, using current time")
+            processed_end_time = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+    else:
+        # Default to current time
+        processed_end_time = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    # Handle start_time
+    processed_start_time = None
+    if start_time:
+        try:
+            # Check if it's a negative integer (relative time)
+            if isinstance(start_time, int) or (
+                isinstance(start_time, str)
+                and start_time.startswith("-")
+                and start_time[1:].isdigit()
+            ):
+                # Convert to seconds before end_time
+                seconds_before = abs(int(start_time))
+
+                # Parse end_time
+                if processed_end_time:
+                    end_datetime = datetime.fromisoformat(
+                        processed_end_time.replace("Z", "+00:00")
+                    )
+                else:
+                    end_datetime = now
+
+                # Calculate start_time
+                start_datetime = end_datetime - timedelta(seconds=seconds_before)
+                processed_start_time = start_datetime.strftime("%Y-%m-%dT%H:%M:%SZ")
+            else:
+                # Assume it's RFC3339
+                processed_start_time = start_time
+                datetime.fromisoformat(start_time.replace("Z", "+00:00"))
+        except (ValueError, TypeError):
+            # If not a valid format, use default
+            logging.warning(
+                f"Invalid start_time format: {start_time}, using default time span"
+            )
+            if processed_end_time:
+                end_datetime = datetime.fromisoformat(
+                    processed_end_time.replace("Z", "+00:00")
+                )
+            else:
+                end_datetime = now
+
+            start_datetime = end_datetime - timedelta(seconds=default_span_seconds)
+            processed_start_time = start_datetime.strftime("%Y-%m-%dT%H:%M:%SZ")
+    else:
+        # Default to default_span_seconds before end_time
+        if processed_end_time:
+            end_datetime = datetime.fromisoformat(
+                processed_end_time.replace("Z", "+00:00")
+            )
+        else:
+            end_datetime = now
+
+        start_datetime = end_datetime - timedelta(seconds=default_span_seconds)
+        processed_start_time = start_datetime.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    return processed_start_time, processed_end_time

holmes/plugins/toolsets/mcp/toolset_mcp.py

@@ -0,0 +1,135 @@
+from holmes.core.tools import (
+    Toolset,
+    Tool,
+    ToolParameter,
+    StructuredToolResult,
+    ToolResultStatus,
+    CallablePrerequisite,
+)
+
+from typing import Dict, Any, List, Optional
+from mcp.client.session import ClientSession
+from mcp.client.sse import sse_client
+
+from mcp.types import Tool as MCP_Tool
+from mcp.types import CallToolResult
+
+import asyncio
+from pydantic import Field, AnyUrl, field_validator
+from typing import Tuple
+import logging
+
+
+class RemoteMCPTool(Tool):
+    url: str
+    headers: Optional[Dict[str, str]] = None
+
+    def _invoke(self, params: Dict) -> StructuredToolResult:
+        try:
+            return asyncio.run(self._invoke_async(params))
+        except Exception as e:
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                error=str(e.args),
+                params=params,
+                invocation=f"MCPtool {self.name} with params {params}",
+            )
+
+    async def _invoke_async(self, params: Dict) -> StructuredToolResult:
+        async with sse_client(self.url, self.headers) as (read_stream, write_stream):
+            async with ClientSession(read_stream, write_stream) as session:
+                _ = await session.initialize()
+                tool_result: CallToolResult = await session.call_tool(self.name, params)
+
+                merged_text = " ".join(
+                    c.text for c in tool_result.content if c.type == "text"
+                )
+                return StructuredToolResult(
+                    status=(
+                        ToolResultStatus.ERROR
+                        if tool_result.isError
+                        else ToolResultStatus.SUCCESS
+                    ),
+                    data=merged_text,
+                    params=params,
+                    invocation=f"MCPtool {self.name} with params {params}",
+                )
+
+    @classmethod
+    def create(cls, url: str, tool: MCP_Tool, headers: Optional[Dict[str, str]] = None):
+        parameters = cls.parse_input_schema(tool.inputSchema)
+        return cls(
+            url=url,
+            name=tool.name,
+            description=tool.description or "",
+            parameters=parameters,
+            headers=headers,
+        )
+
+    @classmethod
+    def parse_input_schema(
+        cls, input_schema: dict[str, Any]
+    ) -> Dict[str, ToolParameter]:
+        required_list = input_schema.get("required", [])
+        schema_params = input_schema.get("properties", {})
+        parameters = {}
+        for key, val in schema_params.items():
+            parameters[key] = ToolParameter(
+                description=val.get("description"),
+                type=val.get("type", "string"),
+                required=key in required_list,
+            )
+
+        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)}"
+
+
+class RemoteMCPToolset(Toolset):
+    url: AnyUrl
+    tools: List[RemoteMCPTool] = Field(default_factory=list)  # type: ignore
+    icon_url: str = "https://registry.npmmirror.com/@lobehub/icons-static-png/1.46.0/files/light/mcp.png"
+
+    def model_post_init(self, __context: Any) -> None:
+        self.prerequisites = [CallablePrerequisite(callable=self.init_server_tools)]
+
+    def get_headers(self) -> Optional[Dict[str, str]]:
+        return self.config and self.config.get("headers")
+
+    @field_validator("url", mode="before")
+    def append_sse_if_missing(cls, v):
+        if isinstance(v, str) and not v.rstrip("/").endswith("/sse"):
+            v = v.rstrip("/") + "/sse"
+        return v
+
+    # used as a CallablePrerequisite, config added for that case.
+    def init_server_tools(self, config: dict[str, Any]) -> Tuple[bool, str]:
+        try:
+            tools_result = asyncio.run(self._get_server_tools())
+            self.tools = [
+                RemoteMCPTool.create(str(self.url), tool, self.get_headers())
+                for tool in tools_result.tools
+            ]
+
+            if not self.tools:
+                logging.warning(f"mcp server {self.name} loaded 0 tools.")
+            return (True, "")
+        except Exception as e:
+            # using e.args, the asyncio wrapper could stack another exception this helps printing them all.
+            return (
+                False,
+                f"Failed to load mcp server {self.name} {self.url} {str(e.args)}",
+            )
+
+    async def _get_server_tools(self):
+        async with sse_client(str(self.url), headers=self.get_headers()) as (
+            read_stream,
+            write_stream,
+        ):
+            async with ClientSession(read_stream, write_stream) as session:
+                _ = await session.initialize()
+                return await session.list_tools()
+
+    def get_example_config(self) -> Dict[str, Any]:
+        return {}

holmes/plugins/toolsets/newrelic.py

@@ -0,0 +1,222 @@
+import requests  # type: ignore
+import logging
+from typing import Any, Optional, Dict
+from holmes.core.tools import (
+    CallablePrerequisite,
+    Tool,
+    ToolParameter,
+    Toolset,
+    ToolsetTag,
+)
+from pydantic import BaseModel
+from holmes.core.tools import StructuredToolResult, ToolResultStatus
+
+
+class BaseNewRelicTool(Tool):
+    toolset: "NewRelicToolset"
+
+
+class GetLogs(BaseNewRelicTool):
+    def __init__(self, toolset: "NewRelicToolset"):
+        super().__init__(
+            name="newrelic_get_logs",
+            description="Retrieve logs from New Relic",
+            parameters={
+                "app": ToolParameter(
+                    description="The application name to filter logs",
+                    type="string",
+                    required=True,
+                ),
+                "since": ToolParameter(
+                    description="Time range to fetch logs (e.g., '1 hour ago')",
+                    type="string",
+                    required=True,
+                ),
+            },
+            toolset=toolset,
+        )
+
+    def _invoke(self, params: Any) -> StructuredToolResult:
+        def success(msg: Any) -> StructuredToolResult:
+            return StructuredToolResult(
+                status=ToolResultStatus.SUCCESS,
+                data=msg,
+                params=params,
+            )
+
+        def error(msg: str) -> StructuredToolResult:
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                data=msg,
+                params=params,
+            )
+
+        app = params.get("app")
+        since = params.get("since")
+
+        query = {
+            "query": f"""
+            {{
+                actor {{
+                    account(id: {self.toolset.nr_account_id}) {{
+                        nrql(query: \"SELECT * FROM Log WHERE app = '{app}' SINCE {since}\") {{
+                            results
+                        }}
+                    }}
+                }}
+            }}
+            """
+        }
+
+        url = "https://api.newrelic.com/graphql"
+        headers = {
+            "Content-Type": "application/json",
+            "Api-Key": self.toolset.nr_api_key,
+        }
+
+        try:
+            logging.info(f"Getting New Relic logs for app {app} since {since}")
+            response = requests.post(url, headers=headers, json=query)
+
+            if response.status_code == 200:
+                return success(response.json())
+            else:
+                return error(
+                    f"Failed to fetch logs. Status code: {response.status_code}\n{response.text}"
+                )
+        except Exception as e:
+            logging.exception("Exception while fetching logs")
+            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')}')"
+
+
+class GetTraces(BaseNewRelicTool):
+    def __init__(self, toolset: "NewRelicToolset"):
+        super().__init__(
+            name="newrelic_get_traces",
+            description="Retrieve traces from New Relic",
+            parameters={
+                "duration": ToolParameter(
+                    description="Minimum trace duration in seconds",
+                    type="number",
+                    required=True,
+                ),
+                "trace_id": ToolParameter(
+                    description="Specific trace ID to fetch details (optional)",
+                    type="string",
+                    required=False,
+                ),
+            },
+            toolset=toolset,
+        )
+
+    def _invoke(self, params: Any) -> StructuredToolResult:
+        def success(msg: Any) -> StructuredToolResult:
+            return StructuredToolResult(
+                status=ToolResultStatus.SUCCESS,
+                data=msg,
+                params=params,
+            )
+
+        def error(msg: str) -> StructuredToolResult:
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                data=msg,
+                params=params,
+            )
+
+        duration = params.get("duration")
+        trace_id = params.get("trace_id")
+
+        if trace_id:
+            query_string = f"SELECT * FROM Span WHERE trace.id = '{trace_id}' and duration.ms > {duration * 1000} and span.kind != 'internal'"
+        else:
+            query_string = f"SELECT * FROM Span WHERE duration.ms > {duration * 1000} and span.kind != 'internal'"
+
+        query = {
+            "query": f"""
+            {{
+                actor {{
+                    account(id: {self.toolset.nr_account_id}) {{
+                        nrql(query: \"{query_string}\") {{
+                            results
+                        }}
+                    }}
+                }}
+            }}
+            """
+        }
+
+        url = "https://api.newrelic.com/graphql"
+        headers = {
+            "Content-Type": "application/json",
+            "Api-Key": self.toolset.nr_api_key,
+        }
+
+        try:
+            logging.info(f"Getting New Relic traces with duration > {duration}s")
+            response = requests.post(url, headers=headers, json=query)
+
+            if response.status_code == 200:
+                return success(response.json())
+            else:
+                return error(
+                    f"Failed to fetch traces. Status code: {response.status_code}\n{response.text}"
+                )
+        except Exception as e:
+            logging.exception("Exception while fetching traces")
+            return error(f"Error while fetching traces: {str(e)}")
+
+    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')})"
+
+
+class NewrelicConfig(BaseModel):
+    nr_api_key: Optional[str] = None
+    nr_account_id: Optional[str] = None
+
+
+class NewRelicToolset(Toolset):
+    nr_api_key: Optional[str] = None
+    nr_account_id: Optional[str] = None
+
+    def __init__(self):
+        super().__init__(
+            name="newrelic",
+            description="Toolset for interacting with New Relic to fetch logs and traces",
+            docs_url="https://docs.newrelic.com/docs/apis/nerdgraph-api/",
+            icon_url="https://companieslogo.com/img/orig/NEWR-de5fcb2e.png?t=1720244493",
+            prerequisites=[CallablePrerequisite(callable=self.prerequisites_callable)],
+            tools=[
+                GetLogs(self),
+                GetTraces(self),
+            ],
+            experimental=True,
+            tags=[ToolsetTag.CORE],
+        )
+
+    def prerequisites_callable(
+        self, config: dict[str, Any]
+    ) -> tuple[bool, Optional[str]]:
+        if not config:
+            return False, "No configuration provided"
+
+        try:
+            nr_config = NewrelicConfig(**config)
+            self.nr_account_id = nr_config.nr_account_id
+            self.nr_api_key = nr_config.nr_api_key
+
+            if not self.nr_account_id or not self.nr_api_key:
+                return False, "New Relic account ID or API key is missing"
+
+            return True, None
+        except Exception as e:
+            logging.exception("Failed to set up New Relic toolset")
+            return False, str(e)
+
+    def get_example_config(self) -> Dict[str, Any]:
+        return {}