holmesgpt 0.13.2__py3-none-any.whl → 0.16.2a0__py3-none-any.whl

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 {}

holmes/plugins/toolsets/servicenow/install.md

@@ -1,37 +0,0 @@
-## Configuration
-
-[Full guide for reference](https://www.servicenow.com/docs/bundle/yokohama-platform-security/page/integrate/authentication/task/configure-api-key.html)
-
-### Create an inbound authentication profile.
-
- 1. Navigate to All > System Web Services > API Access Policies > Inbound Authentication Profiles.
- 2. Select New.
- 3. Select Create API Key authentication profiles
- 4. Auth Parameter > add x-sn-apikey: Auth Header
- 5. Submit the form.
-
-### Create a REST API key
-
- 1. Navigate to All > System Web Services > API Access Policies > REST API Key.
- 2. Select New.
- 3. Set name, description and user. Set expiry date if desired. > Submit.
- 4. Open the record that was created to view the token generated by the ServiceNow AI Platform for the user.
-
-### Create a REST API Access policy
-
- 1. Navigate to All > System Web Services > REST API Access Policies.
- 2. Select New.
- 3. REST API = Table API
- 4. Uncheck Apply to all tables > Select table > change_request
- 5. in select profile from step 1 (API Key)
-
-
-Use your `instance name` and `api_key` to set up Service Now configuration.
-```yaml
-toolsets:
-  ServiceNow:
-    enabled: true
-    config:
-      api_key: <api-token>
-      instance: <dev1234..>
-```

holmes/plugins/toolsets/servicenow/instructions.jinja2

@@ -1,3 +0,0 @@
-* ALWAYS fetch changes from servicenow, USE servicenow_return_changes_in_timerange to see changes in the relevant time range.
-* If you are investigating an issue on some subject , USE servicenow_return_changes_with_keyword with the object name to find related changes.
-* If you find a ServiceNow change that seems relevant to your investigation or the user question, USE servicenow_return_change_details with the change sys_id to get further information and improve your answer if possible.

holmes/plugins/toolsets/servicenow/servicenow.py

@@ -1,219 +0,0 @@
-import requests  # type: ignore
-import logging
-import os
-from typing import Any, Dict, Tuple, List
-from holmes.core.tools import (
-    CallablePrerequisite,
-    Tool,
-    ToolParameter,
-    Toolset,
-    ToolsetTag,
-)
-
-from pydantic import BaseModel, PrivateAttr
-from holmes.core.tools import StructuredToolResult, ToolResultStatus
-from holmes.plugins.toolsets.utils import (
-    process_timestamps_to_rfc3339,
-    standard_start_datetime_tool_param_description,
-    toolset_name_for_one_liner,
-)
-from holmes.plugins.toolsets.logging_utils.logging_api import (
-    DEFAULT_TIME_SPAN_SECONDS,
-)
-
-
-class ServiceNowConfig(BaseModel):
-    api_key: str
-    instance: str
-
-
-class ServiceNowToolset(Toolset):
-    name: str = "ServiceNow"
-    description: str = "Database containing changes information related to keys, workloads or any service."
-    tags: List[ToolsetTag] = [ToolsetTag.CORE]
-    _session: requests.Session = PrivateAttr(default=requests.Session())
-
-    def __init__(self):
-        super().__init__(
-            prerequisites=[CallablePrerequisite(callable=self.prerequisites_callable)],
-            experimental=True,
-            tools=[
-                ReturnChangesInTimerange(toolset=self),
-                ReturnChange(toolset=self),
-                ReturnChangesWithKeyword(toolset=self),
-            ],
-        )
-        instructions_filepath = os.path.abspath(
-            os.path.join(os.path.dirname(__file__), "instructions.jinja2")
-        )
-        self._load_llm_instructions(jinja_template=f"file://{instructions_filepath}")
-
-    def prerequisites_callable(self, config: dict[str, Any]) -> Tuple[bool, str]:
-        if not config:
-            return False, "Missing config credentials."
-
-        try:
-            self.config: Dict = ServiceNowConfig(**config).model_dump()
-            self._session.headers.update(
-                {
-                    "x-sn-apikey": self.config.get("api_key"),
-                }
-            )
-
-            url = f"https://{self.config.get('instance')}.service-now.com/api/now/v2/table/change_request"
-            response = self._session.get(url=url, params={"sysparm_limit": 1})
-
-            return response.ok, ""
-        except Exception as e:
-            logging.exception(
-                "Invalid ServiceNow config. Failed to set up ServiceNow toolset"
-            )
-            return False, f"Invalid ServiceNow config {e}"
-
-    def get_example_config(self) -> Dict[str, Any]:
-        example_config = ServiceNowConfig(
-            api_key="now_xxxxxxxxxxxxxxxx", instance="dev12345"
-        )
-        return example_config.model_dump()
-
-
-class ServiceNowBaseTool(Tool):
-    toolset: ServiceNowToolset
-
-    def return_result(
-        self, response: requests.Response, params: Any, field: str = "result"
-    ) -> StructuredToolResult:
-        response.raise_for_status()
-        res = response.json()
-        return StructuredToolResult(
-            status=ToolResultStatus.SUCCESS
-            if res.get(field, [])
-            else ToolResultStatus.NO_DATA,
-            data=res,
-            params=params,
-        )
-
-    def get_parameterized_one_liner(self, params) -> str:
-        # Default implementation - will be overridden by subclasses
-        return f"{toolset_name_for_one_liner(self.toolset.name)}: ServiceNow {self.name} {params}"
-
-
-class ReturnChangesInTimerange(ServiceNowBaseTool):
-    name: str = "servicenow_return_changes_in_timerange"
-    description: str = "Returns all changes requests from a specific time range. These changes tickets can apply to all components. default to changes from the last 1 hour."
-    parameters: Dict[str, ToolParameter] = {
-        "start": ToolParameter(
-            description=standard_start_datetime_tool_param_description(
-                DEFAULT_TIME_SPAN_SECONDS
-            ),
-            type="string",
-            required=False,
-        )
-    }
-
-    def get_parameterized_one_liner(self, params) -> str:
-        start = params.get("start", "last hour")
-        return f"{toolset_name_for_one_liner(self.toolset.name)}: Get Change Requests ({start})"
-
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
-        parsed_params = {}
-        try:
-            (start, _) = process_timestamps_to_rfc3339(
-                start_timestamp=params.get("start"),
-                end_timestamp=None,
-                default_time_span_seconds=DEFAULT_TIME_SPAN_SECONDS,
-            )
-
-            url = f"https://{self.toolset.config.get('instance')}.service-now.com/api/now/v2/table/change_request"
-            parsed_params.update(
-                {
-                    "sysparm_fields": "sys_id,number,short_description,type,active,sys_updated_on"
-                }
-            )
-            parsed_params.update({"sysparm_query": f"sys_updated_on>={start}"})
-
-            response = self.toolset._session.get(url=url, params=parsed_params)
-            return self.return_result(response, parsed_params)
-        except Exception as e:
-            logging.exception(self.get_parameterized_one_liner(params))
-            return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
-                data=f"Exception {self.name}: {str(e)}",
-                params=params,
-            )
-
-
-class ReturnChange(ServiceNowBaseTool):
-    name: str = "servicenow_return_change_details"
-    description: str = "Returns detailed information for one specific ServiceNow change"
-    parameters: Dict[str, ToolParameter] = {
-        "sys_id": ToolParameter(
-            description="The unique identifier of the change. Use servicenow_return_changes_in_timerange tool to fetch list of changes and use 'sys_id' for further information",
-            type="string",
-            required=True,
-        )
-    }
-
-    def get_parameterized_one_liner(self, params) -> str:
-        sys_id = params.get("sys_id", "")
-        return f"{toolset_name_for_one_liner(self.toolset.name)}: Get Change Details ({sys_id})"
-
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
-        try:
-            url = "https://{instance}.service-now.com/api/now/v2/table/change_request/{sys_id}".format(
-                instance=self.toolset.config.get("instance"),
-                sys_id=params.get("sys_id"),
-            )
-            response = self.toolset._session.get(url=url)
-            return self.return_result(response, params)
-        except Exception as e:
-            logging.exception(self.get_parameterized_one_liner(params))
-            return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
-                data=f"Exception {self.name}: {str(e)}",
-                params=params,
-            )
-
-
-class ReturnChangesWithKeyword(ServiceNowBaseTool):
-    name: str = "servicenow_return_changes_with_keyword"
-    description: str = "Returns all changes requests where a keyword is contained in the description. good for finding changes related to a key, workload or any object."
-    parameters: Dict[str, ToolParameter] = {
-        "keyword": ToolParameter(
-            description="key, workload or object name. Keyword that will filter service now changes that are related to this keyword or object.",
-            type="string",
-            required=True,
-        )
-    }
-
-    def get_parameterized_one_liner(self, params) -> str:
-        keyword = params.get("keyword", "")
-        return f"{toolset_name_for_one_liner(self.toolset.name)}: Search Changes ({keyword})"
-
-    def _invoke(
-        self, params: dict, user_approved: bool = False
-    ) -> StructuredToolResult:
-        parsed_params = {}
-        try:
-            url = f"https://{self.toolset.config.get('instance')}.service-now.com/api/now/v2/table/change_request"
-            parsed_params.update(
-                {
-                    "sysparm_fields": "sys_id,number,short_description,type,active,sys_updated_on"
-                }
-            )
-            parsed_params.update(
-                {"sysparm_query": f"short_descriptionLIKE{params.get('keyword')}"}
-            )
-            response = self.toolset._session.get(url=url, params=parsed_params)
-            return self.return_result(response, parsed_params)
-        except Exception as e:
-            logging.exception(self.get_parameterized_one_liner(params))
-            return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
-                data=f"Exception {self.name}: {str(e)}",
-                params=params,
-            )

holmesgpt-0.13.2.dist-info/LICENSE.txt

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Robusta Dev Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.