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

holmes/plugins/toolsets/opensearch/opensearch_utils.py

@@ -1,166 +0,0 @@
-import json
-import logging
-from typing import Optional, Any, cast
-from urllib.parse import urljoin
-
-from pydantic import BaseModel
-import requests  # type: ignore
-
-from holmes.core.tools import Toolset
-
-
-class OpenSearchLoggingLabelsConfig(BaseModel):
-    pod: str = "kubernetes.pod_name"
-    namespace: str = "kubernetes.namespace_name"
-    timestamp: str = "@timestamp"
-    message: str = "message"
-
-
-class BaseOpenSearchConfig(BaseModel):
-    opensearch_url: str
-    index_pattern: str
-    opensearch_auth_header: Optional[str] = None
-    # Setting to None will disable the cache
-    fields_ttl_seconds: Optional[int] = 14400  # 4 hours
-
-
-class OpenSearchLoggingConfig(BaseOpenSearchConfig):
-    labels: OpenSearchLoggingLabelsConfig = OpenSearchLoggingLabelsConfig()
-
-
-def add_auth_header(auth_header: Optional[str]) -> dict[str, Any]:
-    results = {}
-    if auth_header:
-        results["Authorization"] = auth_header
-    return results
-
-
-def get_search_url(config: BaseOpenSearchConfig) -> str:
-    return urljoin(config.opensearch_url, f"/{config.index_pattern}/_search")
-
-
-def opensearch_health_check(config: BaseOpenSearchConfig) -> tuple[bool, str]:
-    url = get_search_url(config)
-    try:
-        headers = {"Content-Type": "application/json"}
-        headers.update(add_auth_header(config.opensearch_auth_header))
-        health_response = requests.get(
-            url=url,
-            verify=True,
-            data=json.dumps({"size": 1}),
-            headers=headers,
-        )
-        health_response.raise_for_status()
-        return True, ""
-    except Exception as e:
-        logging.info("Failed to initialize opensearch toolset", exc_info=True)
-        return False, f"Failed to initialize opensearch toolset. url={url}. {str(e)}"
-
-
-def format_log_to_json(log_line: Any) -> str:
-    try:
-        return json.dumps(log_line)
-    except Exception:
-        # Handle potential serialization errors (e.g., non-serializable objects)
-        return str(log_line)
-
-
-def format_logs(
-    logs: list[dict[str, Any]],
-    config: OpenSearchLoggingConfig,
-) -> str:
-    if not logs or not isinstance(logs, list):
-        return ""
-
-    # Get field names from config or use defaults
-    message_field = config.labels.message
-
-    formatted_lines = []
-
-    for hit in logs:
-        # Ensure hit is a dictionary and has _source
-        if not isinstance(hit, dict):
-            formatted_lines.append(format_log_to_json(hit))
-            continue
-        source = hit.get("_source")
-        if not isinstance(source, dict):
-            formatted_lines.append(format_log_to_json(hit))
-            continue
-
-        message = source.get(message_field, None)
-
-        if message and not isinstance(message, str):
-            message = str(message)  # Convert non-strings
-
-        if message:
-            formatted_lines.append(message)
-        else:
-            # fallback displaying the logs line as-is
-            formatted_lines.append(format_log_to_json(hit))
-
-    return "\n".join(formatted_lines)
-
-
-def build_query(
-    config: OpenSearchLoggingConfig,
-    namespace: str,
-    pod_name: str,
-    start_time: Optional[str] = None,
-    end_time: Optional[str] = None,
-    match: Optional[str] = None,
-    limit: Optional[int] = None,
-) -> dict[str, Any]:
-    size = limit if limit else 5000
-
-    pod_field = config.labels.pod
-    namespace_field = config.labels.namespace
-    timestamp_field = config.labels.timestamp
-    message_field = config.labels.message
-
-    must_constraints: list[dict] = [
-        {"term": {f"{pod_field}.keyword": pod_name}},
-        {"term": {f"{namespace_field}.keyword": namespace}},
-    ]
-
-    query = {
-        "size": size,
-        "sort": [{timestamp_field: {"order": "asc"}}],
-        "query": {"bool": {"must": must_constraints}},
-    }
-
-    # Add timestamp range if provided
-    if start_time or end_time:
-        range_query: dict = {"range": {timestamp_field: {}}}
-        if start_time:
-            range_query["range"][timestamp_field]["gte"] = start_time
-        if end_time:
-            range_query["range"][timestamp_field]["lte"] = end_time
-
-        must_constraints.append(range_query)
-
-    # Add message filter if provided
-    if match:
-        must_constraints.append({"match_phrase": {message_field: match}})
-
-    return query
-
-
-class BaseOpenSearchToolset(Toolset):
-    def get_example_config(self) -> dict[str, Any]:
-        example_config = BaseOpenSearchConfig(
-            opensearch_url="YOUR OPENSEARCH URL",
-            index_pattern="YOUR OPENSEARCH INDEX NAME",
-            opensearch_auth_header="YOUR OPENSEARCH AUTH HEADER (Optional)",
-        )
-        return example_config.model_dump()
-
-    def prerequisites_callable(self, config: dict[str, Any]) -> tuple[bool, str]:
-        if not config:
-            return False, "Missing opensearch traces URL. Check your config"
-        else:
-            self.config = BaseOpenSearchConfig(**config)
-            return opensearch_health_check(self.config)
-
-    @property
-    def opensearch_config(self) -> BaseOpenSearchConfig:
-        return cast(BaseOpenSearchConfig, self.config)

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,
-            )

holmes/utils/keygen_utils.py

@@ -1,6 +0,0 @@
-import random
-import string
-
-
-def generate_random_key():
-    return "".join(random.choices(string.ascii_letters + string.digits, k=4))

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.