holmesgpt 0.11.5__py3-none-any.whl

holmes/plugins/toolsets/rabbitmq/toolset_rabbitmq.py

@@ -0,0 +1,222 @@
+import os
+import logging
+from typing import Any, List, Optional, Tuple
+
+from pydantic import BaseModel
+from holmes.core.tools import (
+    CallablePrerequisite,
+    StructuredToolResult,
+    Tool,
+    ToolParameter,
+    ToolResultStatus,
+    Toolset,
+    ToolsetTag,
+)
+from requests import RequestException  # type: ignore
+from urllib.parse import urljoin
+
+from holmes.plugins.toolsets.rabbitmq.api import (
+    ClusterConnectionStatus,
+    RabbitMQClusterConfig,
+    get_cluster_status,
+    make_request,
+)
+
+
+class RabbitMQConfig(BaseModel):
+    clusters: List[RabbitMQClusterConfig]
+
+
+class BaseRabbitMQTool(Tool):
+    toolset: "RabbitMQToolset"
+
+    def _get_cluster_config(self, cluster_id: Optional[str]) -> RabbitMQClusterConfig:
+        if not self.toolset.config:
+            raise ValueError("RabbitMQ is not configured.")
+        cluster_ids = [c.id for c in self.toolset.config.clusters]
+        if not cluster_id and len(cluster_ids) == 1:
+            # cluster id is optional if there is only one configured
+            return self.toolset.config.clusters[0]
+        elif not cluster_id and len(cluster_ids) > 0:
+            raise ValueError(
+                f"No cluster is configured. Possible cluster_id values are: {', '.join(cluster_ids)}"
+            )
+        elif not cluster_id:
+            raise ValueError("No cluster is configured")
+
+        for cluster in self.toolset.config.clusters:
+            if cluster.id == cluster_id:
+                return cluster
+
+        raise ValueError(
+            f"Failed to find cluster_id={cluster_id} amongst configured clusters. Possible cluster_id values are: {', '.join(cluster_ids)}"
+        )
+
+
+class ListConfiguredClusters(BaseRabbitMQTool):
+    def __init__(self, toolset: "RabbitMQToolset"):
+        super().__init__(
+            name="list_configured_clusters",
+            description="List all configured clusters. Useful to get the id of a configured cluster (cluster_id) and pass as argument to other rabbitmq tool calls.",
+            parameters={},
+            toolset=toolset,
+        )
+
+    def _invoke(self, params: Any) -> StructuredToolResult:
+        if not self.toolset.config:
+            raise ValueError("RabbitMQ is not configured.")
+
+        available_clusters = [
+            {
+                "cluster_id": c.id,
+                "management_url": c.management_url,
+                "connection_status": c.connection_status,
+            }
+            for c in self.toolset.config.clusters
+            if c.connection_status == ClusterConnectionStatus.SUCCESS
+        ]
+        return StructuredToolResult(
+            status=ToolResultStatus.SUCCESS, data=available_clusters
+        )
+
+    def get_parameterized_one_liner(self, params) -> str:
+        return "list configured RabbitMQ clusters"
+
+
+class GetRabbitMQClusterStatus(BaseRabbitMQTool):
+    def __init__(self, toolset: "RabbitMQToolset"):
+        super().__init__(
+            name="get_rabbitmq_cluster_status",
+            description="Fetches the overall status of the RabbitMQ cluster, including node information, listeners, and partition details. Crucial for detecting split-brain scenarios",
+            parameters={
+                "cluster_id": ToolParameter(
+                    description="The id of the cluster obtained with list_configured_clusters. Only required if more than one rabbitmq cluster is configured.",
+                    type="string",
+                    required=False,
+                ),
+            },
+            toolset=toolset,
+        )
+
+    def _invoke(self, params: Any) -> StructuredToolResult:
+        try:
+            # Fetch node details which include partition info
+            cluster_config = self._get_cluster_config(
+                cluster_id=params.get("cluster_id")
+            )
+            result = get_cluster_status(cluster_config)
+            return StructuredToolResult(status=ToolResultStatus.SUCCESS, data=result)
+
+        except Exception as e:
+            logging.info("Failed to process RabbitMQ cluster status", exc_info=True)
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                error=f"Unexpected error fetching RabbitMQ cluster status: {str(e)}",
+                data=None,
+            )
+
+    def get_parameterized_one_liner(self, params) -> str:
+        return "get RabbitMQ cluster status and partition information"
+
+
+class RabbitMQToolset(Toolset):
+    def __init__(self):
+        super().__init__(
+            name="rabbitmq/core",
+            description="Provides tools to interact with RabbitMQ to diagnose cluster health, node status, and specifically network partitions (split-brain).",
+            docs_url="https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/rabbitmq.html",
+            icon_url="https://cdn.worldvectorlogo.com/logos/rabbitmq.svg",
+            prerequisites=[CallablePrerequisite(callable=self.prerequisites_callable)],
+            tools=[
+                ListConfiguredClusters(toolset=self),
+                GetRabbitMQClusterStatus(toolset=self),
+            ],
+            tags=[ToolsetTag.CORE],
+        )
+        self._reload_llm_instructions()
+
+    def _reload_llm_instructions(self):
+        # Load instructions from the jinja2 template file
+        template_file_path = os.path.abspath(
+            os.path.join(os.path.dirname(__file__), "rabbitmq_instructions.jinja2")
+        )
+        self._load_llm_instructions(jinja_template=f"file://{template_file_path}")
+
+    def prerequisites_callable(self, config: dict[str, Any]) -> Tuple[bool, str]:
+        if not config or not config.get("clusters"):
+            # Attempt to load from environment variables as fallback
+            env_url = os.environ.get("RABBITMQ_MANAGEMENT_URL")
+            env_user = os.environ.get("RABBITMQ_USERNAME", "guest")
+            env_pass = os.environ.get("RABBITMQ_PASSWORD", "guest")
+            if not env_url:
+                return (
+                    False,
+                    "RabbitMQ toolset is misconfigured. 'management_url' is required.",
+                )
+            config = {
+                "clusters": [
+                    {
+                        "id": "rabbitmq",
+                        "management_url": env_url,
+                        "username": env_user,
+                        "password": env_pass,
+                    }
+                ]
+            }
+            logging.info("Loaded RabbitMQ config from environment variables.")
+
+        try:
+            self.config = RabbitMQConfig(**config)
+        except Exception as e:
+            return (False, f"Failed to parse RabbitMQ configuration: {str(e)}")
+
+        return self._check_clusters_config(self.config)
+
+    def _check_clusters_config(self, config: RabbitMQConfig) -> Tuple[bool, str]:
+        errors = []
+        for cluster_config in config.clusters:
+            url = urljoin(cluster_config.management_url, "api/overview")
+
+            try:
+                data = make_request(
+                    config=cluster_config,
+                    method="GET",
+                    url=url,
+                )
+
+                if data:
+                    cluster_config.connection_status = ClusterConnectionStatus.SUCCESS
+                    self._reload_llm_instructions()
+                else:
+                    error_message = f"Failed to connect to RabbitMQ Management API for cluster with id={cluster_config.id} at {url}. No data returned"
+                    cluster_config.connection_status = ClusterConnectionStatus.ERROR
+                    errors.append(error_message)
+
+            except RequestException as e:
+                error_message = f"Toolset failed health check for cluster with id={cluster_config.id} at {url} due to a failed http request. Connection error: {str(e)}"
+                cluster_config.connection_status = ClusterConnectionStatus.ERROR
+                errors.append(error_message)
+            except Exception as e:
+                error_message = f"Toolset failed health check for cluster with id={cluster_config.id} at {url}: {str(e)}"
+                cluster_config.connection_status = ClusterConnectionStatus.ERROR
+                errors.append(error_message)
+
+        if errors:
+            if len(errors) == 1:
+                return (False, errors[0])
+            else:
+                return (False, "\n".join([f"- {error}" for error in errors]))
+        else:
+            return (True, "")
+
+    def get_example_config(self):
+        example_config = RabbitMQConfig(
+            clusters=[
+                RabbitMQClusterConfig(
+                    management_url="http://<your-rabbitmq-server-or-service>:15672",
+                    username="holmes_user",
+                    password="holmes_password",
+                )
+            ]
+        )
+        return example_config.model_dump()

holmes/plugins/toolsets/robusta/robusta.py

@@ -0,0 +1,235 @@
+import os
+
+import logging
+
+from typing import Optional, Dict, Any, List
+from holmes.core.supabase_dal import SupabaseDal
+from holmes.core.tools import (
+    StaticPrerequisite,
+    Tool,
+    ToolParameter,
+    Toolset,
+    ToolsetTag,
+)
+from holmes.core.tools import StructuredToolResult, ToolResultStatus
+
+PARAM_FINDING_ID = "id"
+START_TIME = "start_datetime"
+END_TIME = "end_datetime"
+NAMESPACE = "namespace"
+WORKLOAD = "workload"
+
+
+class FetchRobustaFinding(Tool):
+    _dal: Optional[SupabaseDal]
+
+    def __init__(self, dal: Optional[SupabaseDal]):
+        super().__init__(
+            name="fetch_finding_by_id",
+            description="Fetches a robusta finding. Findings are events, like a Prometheus alert or a deployment update",
+            parameters={
+                PARAM_FINDING_ID: ToolParameter(
+                    description="The id of the finding to fetch",
+                    type="string",
+                    required=True,
+                )
+            },
+        )
+        self._dal = dal
+
+    def _fetch_finding(self, finding_id: str) -> Optional[Dict]:
+        if self._dal and self._dal.enabled:
+            return self._dal.get_issue_data(finding_id)
+        else:
+            error = f"Failed to find a finding with finding_id={finding_id}: Holmes' data access layer is not enabled."
+            logging.error(error)
+            return {"error": error}
+
+    def _invoke(self, params: Dict) -> StructuredToolResult:
+        finding_id = params[PARAM_FINDING_ID]
+        try:
+            finding = self._fetch_finding(finding_id)
+            if finding:
+                return StructuredToolResult(
+                    status=ToolResultStatus.SUCCESS,
+                    data=finding,
+                    params=params,
+                )
+            else:
+                return StructuredToolResult(
+                    status=ToolResultStatus.NO_DATA,
+                    data=f"Could not find a finding with finding_id={finding_id}",
+                    params=params,
+                )
+        except Exception as e:
+            logging.error(e)
+            logging.error(
+                f"There was an internal error while fetching finding {finding_id}. {str(e)}"
+            )
+
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                data=f"There was an internal error while fetching finding {finding_id}",
+                params=params,
+            )
+
+    def get_parameterized_one_liner(self, params: Dict) -> str:
+        return "Fetch Alert Metadata"
+
+
+class FetchResourceRecommendation(Tool):
+    _dal: Optional[SupabaseDal]
+
+    def __init__(self, dal: Optional[SupabaseDal]):
+        super().__init__(
+            name="fetch_resource_recommendation",
+            description="Fetch workload recommendations for resources requests and limits. Returns the current configured resources, as well as recommendation based on actual historical usage.",
+            parameters={
+                "name": ToolParameter(
+                    description="The name of the kubernetes workload.",
+                    type="string",
+                    required=True,
+                ),
+                "namespace": ToolParameter(
+                    description="The namespace of the kubernetes resource.",
+                    type="string",
+                    required=True,
+                ),
+                "kind": ToolParameter(
+                    description="The kind of the kubernetes resource. Must be one of: [Deployment, StatefulSet, DaemonSet, Job].",
+                    type="string",
+                    required=True,
+                ),
+            },
+        )
+        self._dal = dal
+
+    def _resource_recommendation(self, params: Dict) -> Optional[List[Dict]]:
+        if self._dal and self._dal.enabled:
+            return self._dal.get_resource_recommendation(
+                name=params["name"],
+                namespace=params["namespace"],
+                kind=params["kind"],
+            )
+        return None
+
+    def _invoke(self, params: Dict) -> StructuredToolResult:
+        try:
+            recommendations = self._resource_recommendation(params)
+            if recommendations:
+                return StructuredToolResult(
+                    status=ToolResultStatus.SUCCESS,
+                    data=recommendations,
+                    params=params,
+                )
+            else:
+                return StructuredToolResult(
+                    status=ToolResultStatus.NO_DATA,
+                    data=f"Could not find recommendations for {params}",
+                    params=params,
+                )
+        except Exception as e:
+            msg = f"There was an internal error while fetching recommendations for {params}. {str(e)}"
+            logging.exception(msg)
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                data=msg,
+                params=params,
+            )
+
+    def get_parameterized_one_liner(self, params: Dict) -> str:
+        return f"Check Historical Resource Utilization: ({str(params)})"
+
+
+class FetchConfigurationChanges(Tool):
+    _dal: Optional[SupabaseDal]
+
+    def __init__(self, dal: Optional[SupabaseDal]):
+        super().__init__(
+            name="fetch_configuration_changes",
+            description="Fetch configuration changes in a given time range. By default, fetch all cluster changes. Can be filtered on a given namespace or a specific workload",
+            parameters={
+                START_TIME: ToolParameter(
+                    description="The starting time boundary for the search period. String in RFC3339 format.",
+                    type="string",
+                    required=True,
+                ),
+                END_TIME: ToolParameter(
+                    description="The starting time boundary for the search period. String in RFC3339 format.",
+                    type="string",
+                    required=True,
+                ),
+            },
+        )
+        self._dal = dal
+
+    def _fetch_change_history(self, params: Dict) -> Optional[List[Dict]]:
+        if self._dal and self._dal.enabled:
+            return self._dal.get_configuration_changes(
+                start_datetime=params["start_datetime"],
+                end_datetime=params["end_datetime"],
+            )
+        return None
+
+    def _invoke(self, params: Dict) -> StructuredToolResult:
+        try:
+            changes = self._fetch_change_history(params)
+            if changes:
+                return StructuredToolResult(
+                    status=ToolResultStatus.SUCCESS,
+                    data=changes,
+                    params=params,
+                )
+            else:
+                return StructuredToolResult(
+                    status=ToolResultStatus.NO_DATA,
+                    data=f"Could not find changes for {params}",
+                    params=params,
+                )
+        except Exception as e:
+            msg = f"There was an internal error while fetching changes for {params}. {str(e)}"
+            logging.exception(msg)
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                data=msg,
+                params=params,
+            )
+
+    def get_parameterized_one_liner(self, params: Dict) -> str:
+        return f"Search Change History: ({str(params)})"
+
+
+class RobustaToolset(Toolset):
+    def __init__(self, dal: Optional[SupabaseDal]):
+        dal_prereq = StaticPrerequisite(
+            enabled=True if dal else False,
+            disabled_reason="The data access layer is not available",
+        )
+        if dal:
+            dal_prereq = StaticPrerequisite(
+                enabled=dal.enabled, disabled_reason="Data access layer is disabled"
+            )
+
+        super().__init__(
+            icon_url="https://cdn.prod.website-files.com/633e9bac8f71dfb7a8e4c9a6/646be7710db810b14133bdb5_logo.svg",
+            description="Fetches alerts metadata and change history",
+            docs_url="https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/robusta.html",
+            name="robusta",
+            prerequisites=[dal_prereq],
+            tools=[
+                FetchRobustaFinding(dal),
+                FetchConfigurationChanges(dal),
+                FetchResourceRecommendation(dal),
+            ],
+            tags=[
+                ToolsetTag.CORE,
+            ],
+            is_default=True,
+        )
+        template_file_path = os.path.abspath(
+            os.path.join(os.path.dirname(__file__), "robusta_instructions.jinja2")
+        )
+        self._load_llm_instructions(jinja_template=f"file://{template_file_path}")
+
+    def get_example_config(self) -> Dict[str, Any]:
+        return {}

holmes/plugins/toolsets/robusta/robusta_instructions.jinja2

@@ -0,0 +1,24 @@
+# Configuration and alerts history
+* Use fetch_configuration_changes to get historical configuration changes
+* You must ALWAYS call fetch_configuration_changes when investigating an alert
+* Never respond without calling fetch_configuration_changes
+* When investigating an alert, look at historical configuration changes that happen 4 hours before the alert started
+* If you found a change that caused the alert, you MUST write: 'The issue was introduced by ...' with a short description of the change, and the date of it.
+For example:
+'The issue was introduced by a change in the environment variables, on 2025-03-28 10:56:00 << { "type": "diff", "evidence_id": "8a4d1369-0e98-4ff2-b180-699d5ff286ab", "title": "Change in environment variables" } >>'
+* Embed the related historical configuration changes only in the 'Conclusions and Possible Root Causes' section
+* Never add the same change more than once to the output
+* Embed it in with the evidence id and a title describing the change. Use this format:
+<< { "type": "diff", "evidence_id": "8a4d1369-0e98-4ff2-b180-699d5ff286ab", "title": "Image change on the DB workload" } >>
+
+# Resource and efficiency recommendations
+* Use fetch_resource_recommendation to get resource recommendations for a given kubernetes workload
+* Resource recommendations contains memory and cpu recommended request and limits for a given workload
+* When asked if a resource can be optimized, or if a resources is over utilized, use the fetch_resource_recommendation tool to answer
+* Right sizing of resources is a key to avoiding performance issues
+* Right sizing of resouces can also lead to cost savings
+
+# Investigating issues
+* If provided an issue id (a.k.a. a finding), use `fetch_finding_by_id` to get more information about that issue
+* You may be given an issue id in the following format: << { "type": "issue", "id": "<the id of the issue>" } >>
+* The issue ID may be inside this prompt if given as part of an investigation. In that case, do call the tool `fetch_finding_by_id` to make sure you have all the information

holmes/plugins/toolsets/runbook/runbook_fetcher.py

@@ -0,0 +1,78 @@
+import logging
+from typing import Any, Dict
+
+from holmes.core.tools import (
+    StructuredToolResult,
+    Tool,
+    ToolParameter,
+    ToolResultStatus,
+    Toolset,
+    ToolsetTag,
+)
+from holmes.plugins.runbooks import get_runbook_by_path
+
+
+# TODO(mainred): currently we support fetch runbooks hosted internally, in the future we may want to support fetching
+# runbooks from external sources as well.
+class RunbookFetcher(Tool):
+    toolset: "RunbookToolset"
+
+    def __init__(self, toolset: "RunbookToolset"):
+        super().__init__(
+            name="fetch_runbook",
+            description="Get runbook content by runbook link. Use this to get troubleshooting steps for incidents",
+            parameters={
+                # use link as a more generic term for runbook path, considering we may have external links in the future
+                "link": ToolParameter(
+                    description="The link to the runbook",
+                    type="string",
+                    required=True,
+                ),
+            },
+            toolset=toolset,  # type: ignore
+        )
+
+    def _invoke(self, params: Any) -> StructuredToolResult:
+        path: str = params["link"]
+
+        runbook_path = get_runbook_by_path(path)
+        try:
+            with open(runbook_path, "r") as file:
+                content = file.read()
+                return StructuredToolResult(
+                    status=ToolResultStatus.SUCCESS,
+                    data=content,
+                    params=params,
+                )
+        except Exception as e:
+            err_msg = f"Failed to read runbook {runbook_path}: {str(e)}"
+            logging.error(err_msg)
+            return StructuredToolResult(
+                status=ToolResultStatus.ERROR,
+                error=err_msg,
+                params=params,
+            )
+
+    def get_parameterized_one_liner(self, params) -> str:
+        path: str = params["link"]
+        return f"fetched runbook {path}"
+
+
+class RunbookToolset(Toolset):
+    def __init__(self):
+        super().__init__(
+            name="runbook",
+            description="Fetch runbooks",
+            icon_url="https://platform.robusta.dev/demos/runbook.svg",
+            tools=[
+                RunbookFetcher(self),
+            ],
+            docs_url="https://docs.robusta.dev/master/configuration/holmesgpt/toolsets/runbook.html",
+            tags=[
+                ToolsetTag.CORE,
+            ],
+            is_default=True,
+        )
+
+    def get_example_config(self) -> Dict[str, Any]:
+        return {}

holmes/plugins/toolsets/service_discovery.py

@@ -0,0 +1,92 @@
+import logging
+import os
+from typing import List, Optional
+
+from kubernetes import client  # type: ignore
+from kubernetes import config  # type: ignore
+from kubernetes.client import V1ServiceList  # type: ignore
+from kubernetes.client.models.v1_service import V1Service  # type: ignore
+
+CLUSTER_DOMAIN = os.environ.get("CLUSTER_DOMAIN", "cluster.local")
+
+try:
+    if os.getenv("KUBERNETES_SERVICE_HOST"):
+        config.load_incluster_config()
+    else:
+        config.load_kube_config()
+except config.config_exception.ConfigException as e:
+    logging.warning(f"Running without kube-config! e={e}")
+
+
+def find_service_url(label_selector):
+    """
+    Get the url of an in-cluster service with a specific label
+    """
+    # we do it this way because there is a weird issue with hikaru's ServiceList.listServiceForAllNamespaces()
+    try:
+        v1 = client.CoreV1Api()
+        svc_list: V1ServiceList = v1.list_service_for_all_namespaces(  # type: ignore
+            label_selector=label_selector
+        )
+        if not svc_list.items:
+            return None
+        svc: V1Service = svc_list.items[0]
+        name = svc.metadata.name
+        namespace = svc.metadata.namespace
+        port = svc.spec.ports[0].port
+        url = f"http://{name}.{namespace}.svc.{CLUSTER_DOMAIN}:{port}"
+        logging.info(
+            f"discovered service with label-selector: `{label_selector}` at url: `{url}`"
+        )
+        return url
+    except Exception:
+        logging.warning("Error finding url")
+        return None
+
+
+class ServiceDiscovery:
+    @classmethod
+    def find_url(cls, selectors: List[str], error_msg: str) -> Optional[str]:
+        """
+        Try to autodiscover the url of an in-cluster service
+        """
+
+        for label_selector in selectors:
+            service_url = find_service_url(label_selector)
+            if service_url:
+                return service_url
+
+        logging.debug(error_msg)
+        return None
+
+
+class PrometheusDiscovery(ServiceDiscovery):
+    @classmethod
+    def find_prometheus_url(cls) -> Optional[str]:
+        return super().find_url(
+            selectors=[
+                "app=kube-prometheus-stack-prometheus",
+                "app=prometheus,component=server,release!=kubecost",
+                "app=prometheus-server",
+                "app=prometheus-operator-prometheus",
+                "app=rancher-monitoring-prometheus",
+                "app=prometheus-prometheus",
+                "app.kubernetes.io/component=query,app.kubernetes.io/name=thanos",
+                "app.kubernetes.io/name=thanos-query",
+                "app=thanos-query",
+                "app=thanos-querier",
+            ],
+            error_msg="Prometheus url could not be found. Add 'prometheus_url' under your prometheus tools config",
+        )
+
+    @classmethod
+    def find_vm_url(cls) -> Optional[str]:
+        return super().find_url(
+            selectors=[
+                "app.kubernetes.io/name=vmsingle",
+                "app.kubernetes.io/name=victoria-metrics-single",
+                "app.kubernetes.io/name=vmselect",
+                "app=vmselect",
+            ],
+            error_msg="Victoria Metrics url could not be found. Add 'prometheus_url' under your prometheus tools config",
+        )