insightconnect-plugin-runtime 5.4.8__tar.gz → 5.5.0__tar.gz

{insightconnect_plugin_runtime-5.4.8/insightconnect_plugin_runtime.egg-info → insightconnect_plugin_runtime-5.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: insightconnect-plugin-runtime
-Version: 5.4.8
+Version: 5.5.0
 Summary: InsightConnect Plugin Runtime
 Home-page: https://github.com/rapid7/komand-plugin-sdk-python
 Author: Rapid7 Integrations Alliance
@@ -12,7 +12,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Topic :: Software Development :: Build Tools
 Description-Content-Type: text/markdown
-Requires-Dist: requests==2.31.0
+Requires-Dist: requests==2.32.0
 Requires-Dist: python_jsonschema_objects==0.5.2
 Requires-Dist: jsonschema==4.21.1
 Requires-Dist: certifi==2024.2.2
@@ -211,6 +211,8 @@ contributed. Black is installed as a test dependency and the hook can be initial
 after cloning this repository.
 
 ## Changelog
+* 5.5.0 - Updated helper class to add `make_request`, `response_handler`, `extract_json`, and `request_error_handling` for HTTP requests, and `hash_sha1` and `compare_and_dedupe_hashes` to provide support for hash comparisons | Add `METHOD_NOT_ALLOWED`, `CONFLICT`, `REDIRECT_ERROR`, and `CONNECTION_ERROR` to PluginException presets
+* 5.4.9 - Updated aws_client to clean assume role json object to remove any none or empty string values.
 * 5.4.8 - Address vulnerabilities within `gunicorn` and `idna` python packages.
 * 5.4.7 - Address vulnerabilities within `insightconnect-python-3-plugin` image.
 * 5.4.6 - Updated our cloud loggers to include the request path | Updated slim image to remediate vulnerabilities.

{insightconnect_plugin_runtime-5.4.8 → insightconnect_plugin_runtime-5.5.0}/README.md

@@ -182,6 +182,8 @@ contributed. Black is installed as a test dependency and the hook can be initial
 after cloning this repository.
 
 ## Changelog
+* 5.5.0 - Updated helper class to add `make_request`, `response_handler`, `extract_json`, and `request_error_handling` for HTTP requests, and `hash_sha1` and `compare_and_dedupe_hashes` to provide support for hash comparisons | Add `METHOD_NOT_ALLOWED`, `CONFLICT`, `REDIRECT_ERROR`, and `CONNECTION_ERROR` to PluginException presets
+* 5.4.9 - Updated aws_client to clean assume role json object to remove any none or empty string values.
 * 5.4.8 - Address vulnerabilities within `gunicorn` and `idna` python packages.
 * 5.4.7 - Address vulnerabilities within `insightconnect-python-3-plugin` image.
 * 5.4.6 - Updated our cloud loggers to include the request path | Updated slim image to remediate vulnerabilities.

{insightconnect_plugin_runtime-5.4.8 → insightconnect_plugin_runtime-5.5.0}/insightconnect_plugin_runtime/api/endpoints.py

@@ -83,7 +83,17 @@ def handle_errors(error: HTTPException):
 
 
 class Endpoints:
-    def __init__(self, logger, plugin, spec, debug, workers, threads, master_pid, config_options=None):
+    def __init__(
+        self,
+        logger,
+        plugin,
+        spec,
+        debug,
+        workers,
+        threads,
+        master_pid,
+        config_options=None,
+    ):
         self.plugin = plugin
         self.logger = structlog.get_logger("plugin")
         self.spec = spec
@@ -167,7 +177,9 @@ class Endpoints:
             Endpoints.validate_action_trigger_task_name(input_message, name, "task")
             # No validation on the plugin custom config to leave this as configurable as possible.
             # `add_plugin_custom_config` will pass any available values to the plugin for interpretation.
-            input_message = self.add_plugin_custom_config(input_message, request.headers.get(ORG_ID))
+            input_message = self.add_plugin_custom_config(
+                input_message, request.headers.get(ORG_ID)
+            )
             output = self.run_action_trigger_task(input_message)
             self.logger.info("Plugin task finished execution...")
             return output
@@ -750,7 +762,9 @@ class Endpoints:
 
         return version
 
-    def add_plugin_custom_config(self, input_data: Dict[str, Any], org_id: str) -> Dict[str, Any]:
+    def add_plugin_custom_config(
+        self, input_data: Dict[str, Any], org_id: str
+    ) -> Dict[str, Any]:
         """
         Using the retrieved configs pulled from komand-props, pass the configuration that matches the requesting
         Org ID which is passed to the task via a header (`X-IPIMS-ORGID`) from the plugin sidecar.
@@ -763,17 +777,27 @@ class Endpoints:
         - all orgs for default runs will poll back 12 hours.
         - all orgs in lookback mode will be 100 hours (task triggered with no state).
         """
-        additional_config = self.config_options.get(org_id) or self.config_options.get("*")
+        additional_config = self.config_options.get(org_id) or self.config_options.get(
+            "*"
+        )
         if additional_config:
-            self.logger.info("Found config options; adding this to the request parameters...")
-            additional_config = additional_config.copy()  # copy to preserve the referenced value in self.config_options
+            self.logger.info(
+                "Found config options; adding this to the request parameters..."
+            )
+            additional_config = (
+                additional_config.copy()
+            )  # copy to preserve the referenced value in self.config_options
             # As a safeguard we only pass the lookback config params if the plugin has no state
             # This means we still need to manually delete the state for plugins on a per org basis.
             # This also means first time customers for their 'initial' lookup would get the lookback value passed in.
-            if input_data.get("body", {}).get("state") and additional_config.get("lookback"):
-                self.logger.info("Found an existing plugin state, not passing lookback value...")
+            if input_data.get("body", {}).get("state") and additional_config.get(
+                "lookback"
+            ):
+                self.logger.info(
+                    "Found an existing plugin state, not passing lookback value..."
+                )
                 del additional_config["lookback"]
-            input_data.get("body", {}).update({'custom_config': additional_config})
+            input_data.get("body", {}).update({"custom_config": additional_config})
             self.logger.info(f"Custom config being sent to plugin: {additional_config}")
 
         return input_data

{insightconnect_plugin_runtime-5.4.8 → insightconnect_plugin_runtime-5.5.0}/insightconnect_plugin_runtime/clients/aws_client.py

@@ -15,6 +15,7 @@ from botocore.exceptions import ClientError
 import insightconnect_plugin_runtime
 from insightconnect_plugin_runtime.action import Action
 from insightconnect_plugin_runtime.exceptions import PluginException
+from insightconnect_plugin_runtime.helper import clean
 
 REGION = "region"
 EXTERNAL_ID = "external_id"
@@ -541,9 +542,13 @@ class AWSAction(Action):
         sts_client = boto3.client("sts", **auth_params)
         try:
             assumed_role_object = sts_client.assume_role(
-                RoleArn=assume_role_params.get(ROLE_ARN),
-                RoleSessionName=session_name,
-                ExternalId=assume_role_params.get(EXTERNAL_ID),
+                **clean(
+                    {
+                        "RoleArn": assume_role_params.get(ROLE_ARN),
+                        "RoleSessionName": session_name,
+                        "ExternalId": assume_role_params.get(EXTERNAL_ID),
+                    }
+                )
             )
         except ClientError as error:
             raise PluginException(

{insightconnect_plugin_runtime-5.4.8 → insightconnect_plugin_runtime-5.5.0}/insightconnect_plugin_runtime/exceptions.py

@@ -1,6 +1,56 @@
 # -*- coding: utf-8 -*-
-import structlog
-logger = structlog.get_logger("plugin")
+class ResponseExceptionData:
+    RESPONSE_TEXT = "response_text"
+    RESPONSE_JSON = "response_json"
+    RESPONSE = "response"
+    EXCEPTION = "exception"
+
+
+class HTTPStatusCodes:
+
+    # 4xx Client Errors
+    BAD_REQUEST = 400
+    UNAUTHORIZED = 401
+    PAYMENT_REQUIRED = 402
+    FORBIDDEN = 403
+    NOT_FOUND = 404
+    METHOD_NOT_ALLOWED = 405
+    NOT_ACCEPTABLE = 406
+    PROXY_AUTHENTICATION_REQUIRED = 407
+    REQUEST_TIMEOUT = 408
+    CONFLICT = 409
+    GONE = 410
+    LENGTH_REQUIRED = 411
+    PRECONDITION_FAILED = 412
+    PAYLOAD_TOO_LARGE = 413
+    URI_TOO_LONG = 414
+    UNSUPPORTED_MEDIA_TYPE = 415
+    RANGE_NOT_SATISFIABLE = 416
+    EXPECTATION_FAILED = 417
+    I_AM_A_TEAPOT = 418
+    MISDIRECTED_REQUEST = 421
+    UNPROCESSABLE_ENTITY = 422
+    LOCKED = 423
+    FAILED_DEPENDENCY = 424
+    TOO_EARLY = 425
+    UPGRADE_REQUIRED = 426
+    PRECONDITION_REQUIRED = 428
+    TOO_MANY_REQUESTS = 429
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451
+
+    # 5xx Server Errors
+    INTERNAL_SERVER_ERROR = 500
+    NOT_IMPLEMENTED = 501
+    BAD_GATEWAY = 502
+    SERVICE_UNAVAILABLE = 503
+    GATEWAY_TIMEOUT = 504
+    HTTP_VERSION_NOT_SUPPORTED = 505
+    VARIANT_ALSO_NEGOTIATES = 506
+    INSUFFICIENT_STORAGE = 507
+    LOOP_DETECTED = 508
+    NOT_EXTENDED = 510
+    NETWORK_AUTHENTICATION_REQUIRED = 511
 
 
 class ClientException(Exception):
@@ -65,6 +115,10 @@ class ConnectionTestException(Exception):
         TIMEOUT = "timeout"
         BAD_REQUEST = "bad_request"
         INVALID_CREDENTIALS = "invalid_credentials"
+        METHOD_NOT_ALLOWED = "method_not_allowed"
+        CONFLICT = "conflict"
+        CONNECTION_ERROR = "connection_error"
+        REDIRECT_ERROR = "redirect_error"
 
     # Dictionary of cause messages
     causes = {
@@ -82,6 +136,10 @@ class ConnectionTestException(Exception):
         Preset.TIMEOUT: "The connection timed out.",
         Preset.BAD_REQUEST: "The server is unable to process the request.",
         Preset.INVALID_CREDENTIALS: "Authentication failed: invalid credentials.",
+        Preset.METHOD_NOT_ALLOWED: "The request method is not allowed for this resource.",
+        Preset.CONFLICT: "Request cannot be completed due to a conflict with the current state of the resource.",
+        Preset.CONNECTION_ERROR: "Failed to connect to the server.",
+        Preset.REDIRECT_ERROR: "Request redirected more than the set limit for the server.",
     }
 
     # Dictionary of assistance/remediation messages
@@ -103,6 +161,10 @@ class ConnectionTestException(Exception):
         Preset.BAD_REQUEST: "Verify your plugin input is correct and not malformed and try again. "
         "If the issue persists, please contact support.",
         Preset.INVALID_CREDENTIALS: "Please verify the credentials for your account and try again.",
+        Preset.METHOD_NOT_ALLOWED: "Please try a supported method for this resource.",
+        Preset.CONFLICT: "Please check your request, and try again.",
+        Preset.CONNECTION_ERROR: "Please check your network connection and try again.",
+        Preset.REDIRECT_ERROR: "Please check your request and try again.",
     }
 
     def __init__(self, cause=None, assistance=None, data=None, preset=None):
@@ -124,12 +186,6 @@ class ConnectionTestException(Exception):
 
         self.data = str(data) if data else ""
 
-        # Safeguard to ensure the exception is logged across all plugins even if the plugin
-        # itself does not call `self.logger.error(<error info>)`
-        params = ["cause", "assistance", "data", "preset"]
-        info_log = ", ".join([f"{atr}='{getattr(self, atr)}'" for atr in params if getattr(self, atr)])
-        logger.error(f"Plugin exception instantiated. {info_log}")
-
     def __str__(self):
         if self.data:
             return "Connection test failed!\n\n{cause} {assistance} Response was: {data}".format(

{insightconnect_plugin_runtime-5.4.8 → insightconnect_plugin_runtime-5.5.0}/insightconnect_plugin_runtime/helper.py

@@ -12,18 +12,276 @@ from datetime import datetime, timedelta
 from io import IOBase
 from typing import Any, Callable, Dict, List, Union
 from urllib import request
+from hashlib import sha1
+from json import JSONDecodeError
 
 import requests
 
-from insightconnect_plugin_runtime.exceptions import PluginException
+from insightconnect_plugin_runtime.exceptions import (
+    PluginException,
+    HTTPStatusCodes,
+    ResponseExceptionData,
+)
 
 CAMEL_CASE_REGEX = r"\b[a-z0-9]+([A-Z][a-z]+[0-9]*)*\b"
 CAMEL_CASE_ACRONYM_REGEX = r"\b[a-z0-9]+([A-Z]+[0-9]*)*\b"
 PASCAL_CASE_REGEX = r"\b[A-Z][a-z]+[0-9]*([A-Z][a-z]+[0-9]*)*\b"
+ENCODE_TYPE = "utf-8"
 
 DEFAULTS_HOURS_AGO = 24
 
 
+def hash_sha1(log: dict) -> str:
+    """
+    Iterate through a dictionary and hash each value.
+    :param log: Dictionary to be hashed.
+    :type dict:
+    :return: Hex digest of hash.
+    :rtype: str
+    """
+    hash_ = sha1()  # nosec B303
+    for key, value in log.items():
+        hash_.update(f"{key}{value}".encode(ENCODE_TYPE))
+    return hash_.hexdigest()
+
+
+def compare_and_dedupe_hashes(
+    previous_logs_hashes: list, new_logs: list
+) -> tuple[list, list]:
+    """
+    Iterate through two lists of values, hashing each. Compare hash value to a list of existing hash values.
+    If the hash exists, return both it and the value in separate lists once iterated.
+    :param previous_logs_hashes: List of existing hashes to compare against.
+    :type list:
+    :param new_logs: New values to hash and compare to existing list of hashes.
+    :type list:
+    :return: Hex digest of hash.
+    :rtype: tuple[list, list]
+    """
+    new_logs_hashes = []
+    logs_to_return = []
+    for log in new_logs:
+        hash_ = hash_sha1(log)
+        if hash_ not in previous_logs_hashes:
+            new_logs_hashes.append(hash_)
+            logs_to_return.append(log)
+    logging.info(
+        f"Original number of logs:{len(new_logs)}. Number of logs after de-duplication:{len(logs_to_return)}"
+    )
+    return logs_to_return, new_logs_hashes
+
+
+def make_request(
+    _request: requests.Request,
+    timeout: int = 60,
+    verify: bool = True,
+    cert: Union[str, tuple]=None,
+    stream: bool = False,
+    allow_redirects: bool = True,
+    exception_custom_configs: Dict[int, Exception]={},
+    exception_data_location: str = None,
+    allowed_status_codes: list[str] = [],
+) -> tuple[requests.Response, dict]:
+    """
+    Makes a HTTP request while checking for RequestErrors and JSONDecodeErrors
+    Returns the request response and the response JSON if required.
+    :param _request: Request object to utilize in request
+    :type Request:
+    :param timeout: Requests timeout paramater
+    :type int:
+    :param verify: Whether to verify the server's TLS certificate
+    :type bool:
+    :param cert: Certificate to include with request, str location or key/value pair
+    :type Union[str, dict]:
+    :param stream: Whether to immediately download the response content
+    :type bool:
+    :param allow_redirects: Set to true by default
+    :type bool:
+    :param exception_custom_configs: Custom exception values to be raised per HTTPStatusCode.
+    :type Dict[str, Exception]:
+    :param exception_data_location: Where the returned data should be retrieved. Can provide ResponseExceptionData values.
+    :type str:
+    :param allowed_status_codes: Status codes that will not raise an exception.
+    :type list[str]:
+
+    :return: The request response and the response JSON.
+    :rtype: tuple[Response, dict]
+    """
+    try:
+        with requests.Session() as session:
+            prepared_request = session.prepare_request(request=_request)
+            response = session.send(
+                prepared_request,
+                verify=verify,
+                timeout=timeout,
+                allow_redirects=allow_redirects,
+                cert=cert,
+                stream=stream,
+            )
+    except requests.exceptions.Timeout as exception:
+        raise PluginException(
+            preset=PluginException.Preset.TIMEOUT, data=str(exception)
+        )
+    except requests.exceptions.ConnectionError as exception:
+        raise PluginException(
+            preset=PluginException.Preset.CONNECTION_ERROR, data=str(exception)
+        )
+    except requests.exceptions.TooManyRedirects as exception:
+        raise PluginException(
+            preset=PluginException.Preset.REDIRECT_ERROR, data=str(exception)
+        )
+    except requests.exceptions.RequestException as exception:
+        if not isinstance(exception, requests.exceptions.HTTPError):
+            raise PluginException(
+                preset=PluginException.Preset.UNKNOWN, data=str(exception)
+            )
+    response_handler(response, exception_custom_configs, exception_data_location, allowed_status_codes)
+    return response
+
+
+def extract_json(response: requests.Response) -> dict:
+    """Extract JSON from a request object while error handling a JSONDecodeError.
+    :param response: Response object ot utilize in extract
+    :type Response:
+    :returns: Dictionary of response JSON
+    :rtype: Dict
+    """
+    try:
+        response_json = response.json()
+        return response_json
+    except JSONDecodeError as exception:
+        raise PluginException(
+            preset=PluginException.Preset.INVALID_JSON, data=str(exception)
+        )
+
+
+def request_error_handling() -> Union[Any, None]:
+    """request_error_handling. This decorator allows a method that makes a request to complete with error handling.
+    A plugin exception will be raised whenever an error is caught. Response.raise_for_status() must be called in the
+    wrapped method to handle HTTPErrors.
+
+    :returns: API call function data or None.
+    :rtype: Union[Any, None]
+    """
+
+    def _decorate(func: Callable):
+        def _wrapper(self, *args, **kwargs):
+            try:
+                return func(self, *args, **kwargs)
+            except requests.exceptions.Timeout as exception:
+                raise PluginException(
+                    preset=PluginException.Preset.TIMEOUT, data=str(exception)
+                )
+            except requests.exceptions.ConnectionError as exception:
+                raise PluginException(
+                    preset=PluginException.Preset.CONNECTION_ERROR, data=str(exception)
+                )
+            except requests.exceptions.TooManyRedirects as exception:
+                raise PluginException(
+                    preset=PluginException.Preset.REDIRECT_ERROR, data=str(exception)
+                )
+            except requests.exceptions.RequestException as exception:
+                if isinstance(exception, requests.exceptions.HTTPError):
+                    response_handler(exception.response)
+                else:
+                    raise PluginException(
+                        preset=PluginException.Preset.UNKNOWN, data=str(exception)
+                    )
+
+        return _wrapper
+
+    return _decorate
+
+
+def response_handler(
+    response: requests.Response,
+    custom_configs: Dict[int, Exception]={},
+    data_location: str = None,
+    allowed_status_codes: list[str] = [],
+) -> None:
+    """
+    Check response status codes and return a generic PluginException preset if a HTTPError is raised.
+    Excetion cause, assistance, and data can be overwritten by supplied parameters.
+
+    :param response: Response object whose status should be checked.
+    :type Response:
+    :param custom_configs: Custom exception values to be raised per HTTPStatusCode.
+    :type Dict[str, Exception]:
+    :param data_location: Where the returned data should be retrieved. Can provide ResponseExceptionData values.
+    :type str:
+    :param allowed_status_codes: Status codes that will not raise an exception.
+    :type list[str]:
+
+    :return: None.
+    :rtype: None
+    """
+    try:
+        response.raise_for_status()
+    except requests.exceptions.HTTPError as exception:
+
+        data = _return_response_data(response, exception, data_location)
+        status_code = response.status_code
+        if status_code in allowed_status_codes:
+            return
+        status_code_presets = {
+            HTTPStatusCodes.BAD_REQUEST: PluginException.Preset.BAD_REQUEST,
+            HTTPStatusCodes.UNAUTHORIZED: PluginException.Preset.INVALID_CREDENTIALS,
+            HTTPStatusCodes.FORBIDDEN: PluginException.Preset.UNAUTHORIZED,
+            HTTPStatusCodes.NOT_FOUND: PluginException.Preset.NOT_FOUND,
+            HTTPStatusCodes.METHOD_NOT_ALLOWED: PluginException.Preset.METHOD_NOT_ALLOWED,
+            HTTPStatusCodes.REQUEST_TIMEOUT: PluginException.Preset.TIMEOUT,
+            HTTPStatusCodes.CONFLICT: PluginException.Preset.CONFLICT,
+            HTTPStatusCodes.TOO_MANY_REQUESTS: PluginException.Preset.RATE_LIMIT,
+            HTTPStatusCodes.INTERNAL_SERVER_ERROR: PluginException.Preset.SERVER_ERROR,
+            HTTPStatusCodes.SERVICE_UNAVAILABLE: PluginException.Preset.SERVICE_UNAVAILABLE,
+        }
+        status_code_preset = status_code_presets.get(status_code)
+        exception = PluginException(preset=PluginException.Preset.UNKNOWN, data=data)
+        logging.info(f"Request to {response.url} failed. Status code: {status_code}")
+        if status_code in custom_configs.keys():
+            exception = custom_configs.get(status_code)
+            if hasattr(exception, "data") and data is not None:
+                exception.data = data
+        elif status_code_preset:
+            exception = PluginException(preset=status_code_preset, data=data)
+
+        raise exception
+
+
+def _return_response_data(
+    response: requests.Response,
+    exception: requests.HTTPError,
+    data_location: str = None,
+) -> str:
+    """
+    Retrieve data from HTTP Error given a provided data location
+
+    :param response: Response object whose status should be checked.
+    :type Response:
+    :param exception: HTTPError exception to retrieve data.
+    :type HTTPError:
+    :param data_location: Where the returned data should be retrieved. Can provide ResponseExceptionData values.
+    :type str:
+
+    :return: Exception data.
+    :rtype: str
+    """
+    data = None
+    if data_location == ResponseExceptionData.EXCEPTION:
+        data = str(exception)
+    elif data_location == ResponseExceptionData.RESPONSE:
+        data = response
+    elif data_location == ResponseExceptionData.RESPONSE_TEXT:
+        data = response.text
+    elif data_location == ResponseExceptionData.RESPONSE_JSON:
+        try:
+            data = response.json()
+        except JSONDecodeError:
+            # Return full exception if JSON cannot be resolved
+            data = exception
+    return data
+
+
 def extract_value(begin, key, end, s):
     """
     Returns a string from a given key/pattern using provided regular expressions.

{insightconnect_plugin_runtime-5.4.8 → insightconnect_plugin_runtime-5.5.0}/insightconnect_plugin_runtime/plugin.py

@@ -18,7 +18,12 @@ from insightconnect_plugin_runtime.exceptions import (
     PluginException,
 )
 from insightconnect_plugin_runtime.metrics import MetricsBuilder
-from insightconnect_plugin_runtime.util import is_running_in_cloud, flush_logging_handlers
+from insightconnect_plugin_runtime.util import (
+    is_running_in_cloud,
+    flush_logging_handlers,
+)
+
+logger = structlog.get_logger("plugin")
 
 message_output_type = {
     "action_start": "action_event",
@@ -222,7 +227,9 @@ class Plugin(object):
         if status_code is not None:
             output_message["status_code"] = status_code
 
-        if error_object is not None and isinstance(error_object, (ConnectionTestException, PluginException)):
+        if error_object is not None and isinstance(
+            error_object, (ConnectionTestException, PluginException)
+        ):
             output_message["exception"] = {
                 "cause": error_object.cause,
                 "assistance": error_object.assistance,
@@ -236,6 +243,9 @@ class Plugin(object):
 
             if ex:
                 if isinstance(ex, ConnectionTestException):
+                    error_data = ex.data if ex.data else None
+                    info_log = f"cause={ex.cause}, assistance={ex.assistance}, data={error_data}"
+                    logger.error(f"Plugin exception raised. {info_log}")
                     output_message["exception"] = {
                         "cause": ex.cause,
                         "assistance": ex.assistance,
@@ -441,7 +451,13 @@ class Plugin(object):
                         is_debug,
                     )
                 else:
-                    output, state, has_more_pages, status_code, error_object = self.start_step(
+                    (
+                        output,
+                        state,
+                        has_more_pages,
+                        status_code,
+                        error_object,
+                    ) = self.start_step(
                         input_message["body"],
                         "task",
                         struct_logger,
@@ -571,7 +587,9 @@ class Plugin(object):
                     if step_key == "task":
                         state = message_body["state"]
                         step.state.validate(state)
-                        custom_config = message_body.get("custom_config", {})  # we don't validate this for now
+                        custom_config = message_body.get(
+                            "custom_config", {}
+                        )  # we don't validate this for now
 
                     # Validate required inputs
                     # Step inputs will be checked against schema for required properties existence
@@ -611,7 +629,9 @@ class Plugin(object):
             parameters = inspect.signature(func)
             if len(parameters.parameters) > 0:
                 if step_key == "task" and not is_test:
-                    output, state, has_more_pages, status_code, error_object = func(params, state, custom_config)
+                    output, state, has_more_pages, status_code, error_object = func(
+                        params, state, custom_config
+                    )
                 else:
                     output = func(params)
             else:

{insightconnect_plugin_runtime-5.4.8 → insightconnect_plugin_runtime-5.5.0}/insightconnect_plugin_runtime/server.py

@@ -14,7 +14,13 @@ from gunicorn.arbiter import Arbiter
 import structlog
 from pythonjsonlogger.jsonlogger import JsonFormatter
 from requests import get as request_get
-from requests.exceptions import HTTPError, MissingSchema, Timeout, JSONDecodeError, ConnectionError
+from requests.exceptions import (
+    HTTPError,
+    MissingSchema,
+    Timeout,
+    JSONDecodeError,
+    ConnectionError,
+)
 from time import sleep
 from werkzeug.utils import secure_filename
 
@@ -43,8 +49,12 @@ OPEN_API_VERSION = "2.0"
 VERSION_MAPPING = {"legacy": "/", "v1": "/api/v1"}
 CPS_RETRY = 5
 RETRY_SLEEP = 10
-CPS_ENDPOINT = os.getenv("CPS_ENDPOINT")  # endpoint to retrieve plugin custom configs (set in cloud deployments.tf)
-DEFAULT_SCHEDULE_INTERVAL_MINUTES = 3  # default to 3 as most integrations run on 5 minute interval
+CPS_ENDPOINT = os.getenv(
+    "CPS_ENDPOINT"
+)  # endpoint to retrieve plugin custom configs (set in cloud deployments.tf)
+DEFAULT_SCHEDULE_INTERVAL_MINUTES = (
+    3  # default to 3 as most integrations run on 5 minute interval
+)
 
 
 class PluginServer(gunicorn.app.base.BaseApplication):
@@ -185,32 +195,48 @@ class PluginServer(gunicorn.app.base.BaseApplication):
         # Call out to komand-props to get configurations related to only the plugin pod running.
         if is_running_in_cloud() and self.plugin.tasks:
             for attempt in range(1, CPS_RETRY + 1):
-                self.logger.info(f"Getting plugin configuration information... (attempt {attempt}/{CPS_RETRY})")
+                self.logger.info(
+                    f"Getting plugin configuration information... (attempt {attempt}/{CPS_RETRY})"
+                )
                 try:
                     request_response = request_get(CPS_ENDPOINT, timeout=30)
                     resp_json = request_response.json()
-                    plugin = self.plugin.name.lower().replace(" ", "_")  # match how we name our images
+                    plugin = self.plugin.name.lower().replace(
+                        " ", "_"
+                    )  # match how we name our images
                     plugin_config = resp_json.get("plugins", {}).get(plugin, {})
 
                     self.config_options = plugin_config
                     self.logger.info("Plugin configuration successfully retrieved...")
                     return
                 except MissingSchema as missing_schema:
-                    self.logger.error(f"Invalid URL being requested: {CPS_ENDPOINT}, error={missing_schema}")
+                    self.logger.error(
+                        f"Invalid URL being requested: {CPS_ENDPOINT}, error={missing_schema}"
+                    )
                 except Timeout as timeout:
-                    self.logger.error(f"Connection timeout hit. CPS={CPS_ENDPOINT}, error={timeout}")
+                    self.logger.error(
+                        f"Connection timeout hit. CPS={CPS_ENDPOINT}, error={timeout}"
+                    )
                 except HTTPError as http_error:
-                    self.logger.error(f"Connection error when trying to reach CPS. CPS={CPS_ENDPOINT}, error={http_error}")
+                    self.logger.error(
+                        f"Connection error when trying to reach CPS. CPS={CPS_ENDPOINT}, error={http_error}"
+                    )
                 except JSONDecodeError as bad_json:
-                    self.logger.error(f"Got bad JSON back. Response content={request_response.content}, error={bad_json}")
+                    self.logger.error(
+                        f"Got bad JSON back. Response content={request_response.content}, error={bad_json}"
+                    )
                 except ConnectionError as http_connection_pool_error:
                     self.logger.info(
                         "Connection refused when trying to reach CPS, retrying as the connection is still establishing."
                     )
                 except Exception as error:
-                    self.logger.error(f"Hit an unexpected error when retrieving plugin custom configs, error={error}")
+                    self.logger.error(
+                        f"Hit an unexpected error when retrieving plugin custom configs, error={error}"
+                    )
                 sleep(RETRY_SLEEP)
-            self.logger.error(f"Unable to reach CPS after {CPS_RETRY} attempts. CPS={CPS_ENDPOINT}")
+            self.logger.error(
+                f"Unable to reach CPS after {CPS_RETRY} attempts. CPS={CPS_ENDPOINT}"
+            )
 
     def register_api_spec(self):
         """Register all swagger schema definitions and path objects"""