holmesgpt 0.13.2__py3-none-any.whl → 0.18.4__py3-none-any.whl

holmes/plugins/toolsets/grafana/grafana_api.py

@@ -1,42 +0,0 @@
-import logging
-import requests  # type: ignore
-from typing import Tuple
-import backoff
-
-from holmes.plugins.toolsets.grafana.common import (
-    GrafanaConfig,
-    build_headers,
-    get_base_url,
-)
-
-
-@backoff.on_exception(
-    backoff.expo,  # Exponential backoff
-    requests.exceptions.RequestException,  # Retry on request exceptions
-    max_tries=5,  # Maximum retries
-    giveup=lambda e: isinstance(e, requests.exceptions.HTTPError)
-    and e.response.status_code < 500,
-)
-def grafana_health_check(config: GrafanaConfig) -> Tuple[bool, str]:
-    base_url = get_base_url(config)
-    url = f"{base_url}/{config.healthcheck}"
-    try:
-        headers_ = build_headers(api_key=config.api_key, additional_headers=None)
-
-        response = requests.get(url, headers=headers_, timeout=10)  # Added timeout
-        response.raise_for_status()
-        return True, ""
-    except Exception as e:
-        logging.error(f"Failed to fetch grafana health status at {url}", exc_info=True)
-        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/tempo_api.py

@@ -1,124 +0,0 @@
-import requests  # type: ignore
-from typing import Dict, List, Optional
-import backoff
-
-from holmes.plugins.toolsets.grafana.common import build_headers
-from holmes.plugins.toolsets.grafana.trace_parser import process_trace
-
-
-def execute_tempo_query_with_retry(
-    base_url: str,
-    api_key: Optional[str],
-    headers: Optional[Dict[str, str]],
-    query_params: dict,
-    retries: int = 3,
-    timeout: int = 5,
-):
-    """
-    Execute a Tempo API query through Grafana with retries and timeout.
-
-    Args:
-        tempo_datasource_uid: The UID of the Tempo datasource.
-        query_params: Query parameters for the API.
-        retries: Number of retries for the request.
-        timeout: Timeout for each request in seconds.
-
-    Returns:
-        List of trace results.
-    """
-    url = f"{base_url}/api/search"
-
-    @backoff.on_exception(
-        backoff.expo,  # Exponential backoff
-        requests.exceptions.RequestException,  # Retry on request exceptions
-        max_tries=retries,  # Maximum retries
-        giveup=lambda e: isinstance(e, requests.exceptions.HTTPError)
-        and e.response.status_code < 500,
-    )
-    def make_request():
-        response = requests.post(
-            url,
-            headers=build_headers(api_key=api_key, additional_headers=headers),
-            json=query_params,
-            timeout=timeout,  # Set timeout for the request
-        )
-        response.raise_for_status()  # Raise an error for non-2xx responses
-        return response.json()
-
-    try:
-        return make_request()
-    except requests.exceptions.RequestException as e:
-        raise Exception(f"Request to Tempo API failed after retries: {e}")
-
-
-def query_tempo_traces(
-    base_url: str,
-    api_key: Optional[str],
-    headers: Optional[Dict[str, str]],
-    query: Optional[str],
-    start: int,
-    end: int,
-    limit: int,
-) -> Dict:
-    query_params = {
-        "start": str(start),
-        "end": str(end),
-        "limit": str(limit),
-    }
-
-    if query:
-        query_params["q"] = query
-    data = execute_tempo_query_with_retry(
-        base_url=base_url,
-        api_key=api_key,
-        headers=headers,
-        query_params=query_params,
-    )
-    return data
-
-
-def query_tempo_trace_by_id(
-    base_url: str,
-    api_key: Optional[str],
-    headers: Optional[Dict[str, str]],
-    trace_id: str,
-    key_labels: List[str],
-    retries: int = 3,
-    timeout: int = 5,
-) -> str:
-    """
-    Query Tempo for a specific trace by its ID with retries and backoff.
-
-    Args:
-        tempo_datasource_id: The ID of the Tempo datasource.
-        trace_id: The trace ID to retrieve.
-        retries: Number of retries for the request.
-        timeout: Timeout for each request in seconds.
-
-    Returns:
-        A formatted trace details string
-    """
-    url = f"{base_url}/api/traces/{trace_id}"
-
-    @backoff.on_exception(
-        backoff.expo,
-        requests.exceptions.RequestException,
-        max_tries=retries,
-        giveup=lambda e: isinstance(e, requests.exceptions.HTTPError)
-        and e.response.status_code < 500,
-    )
-    def make_request():
-        response = requests.get(
-            url,
-            headers=build_headers(api_key=api_key, additional_headers=headers),
-            timeout=timeout,
-        )
-        response.raise_for_status()
-        return process_trace(response.json(), key_labels)
-
-    try:
-        return make_request()
-    except requests.exceptions.RequestException as e:
-        raise Exception(
-            f"Failed to retrieve trace by ID after retries: {e} \n for URL: {url}"
-        )

holmes/plugins/toolsets/grafana/toolset_grafana_loki.py

@@ -1,110 +0,0 @@
-from typing import Any, cast, Set
-from pydantic import BaseModel
-
-from holmes.core.tools import CallablePrerequisite
-from holmes.plugins.toolsets.grafana.common import (
-    GrafanaConfig,
-    format_log,
-    get_base_url,
-)
-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,
-)
-
-from holmes.plugins.toolsets.grafana.loki_api import (
-    query_loki_logs_by_label,
-)
-from holmes.core.tools import StructuredToolResult, ToolResultStatus
-
-
-class GrafanaLokiLabelsConfig(BaseModel):
-    pod: str = "pod"
-    namespace: str = "namespace"
-
-
-class GrafanaLokiConfig(GrafanaConfig):
-    labels: GrafanaLokiLabelsConfig = GrafanaLokiLabelsConfig()
-
-
-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",
-            description="Fetches kubernetes pods logs from Loki",
-            icon_url="https://grafana.com/media/docs/loki/logo-grafana-loki.png",
-            docs_url="https://holmesgpt.dev/data-sources/builtin-toolsets/grafanaloki/",
-            prerequisites=[CallablePrerequisite(callable=self.prerequisites_callable)],
-            tools=[],  # Initialize with empty tools first
-        )
-        # Now that parent is initialized and self.name exists, create the tool
-        self.tools = [PodLoggingTool(self)]
-
-    def prerequisites_callable(self, config: dict[str, Any]) -> tuple[bool, str]:
-        if not config:
-            return False, "Missing Loki configuration. Check your config."
-
-        self.config = GrafanaLokiConfig(**config)
-
-        return grafana_health_check(self.config)
-
-    def get_example_config(self):
-        example_config = GrafanaLokiConfig(
-            api_key="YOUR API KEY",
-            url="YOUR GRAFANA URL",
-            grafana_datasource_uid="<UID of the loki datasource to use>",
-        )
-        return example_config.model_dump()
-
-    @property
-    def grafana_config(self) -> GrafanaLokiConfig:
-        return cast(GrafanaLokiConfig, self.config)
-
-    def logger_name(self) -> str:
-        return "Loki"
-
-    def fetch_pod_logs(self, params: FetchPodLogsParams) -> StructuredToolResult:
-        (start, end) = process_timestamps_to_rfc3339(
-            start_timestamp=params.start_time,
-            end_timestamp=params.end_time,
-            default_time_span_seconds=DEFAULT_TIME_SPAN_SECONDS,
-        )
-
-        base_url = get_base_url(self.grafana_config)
-        logs = query_loki_logs_by_label(
-            base_url=base_url,
-            api_key=self.grafana_config.api_key,
-            headers=self.grafana_config.headers,
-            filter=params.filter,
-            namespace=params.namespace,
-            namespace_search_key=self.grafana_config.labels.namespace,
-            label=self.grafana_config.labels.pod,
-            label_value=params.pod_name,
-            start=start,
-            end=end,
-            limit=params.limit or 2000,
-        )
-        if logs:
-            logs.sort(key=lambda x: x["timestamp"])
-            return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
-                data="\n".join([format_log(log) for log in logs]),
-                params=params.model_dump(),
-            )
-        else:
-            return StructuredToolResult(
-                status=ToolResultStatus.NO_DATA,
-                params=params.model_dump(),
-            )

holmes/plugins/toolsets/newrelic.py

@@ -1,231 +0,0 @@
-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
-from holmes.plugins.toolsets.utils import get_param_or_raise, toolset_name_for_one_liner
-
-
-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: dict, user_approved: bool = False
-    ) -> 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:
-        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):
-    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: dict, user_approved: bool = False
-    ) -> 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 = get_param_or_raise(params, "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"]:
-            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):
-    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 {}