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

{insightconnect_plugin_runtime-5.4.9/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.9
+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,7 @@ 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.

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

@@ -182,6 +182,7 @@ 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.

{insightconnect_plugin_runtime-5.4.9 → 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.9 → insightconnect_plugin_runtime-5.5.0}/insightconnect_plugin_runtime/clients/aws_client.py

@@ -29,13 +29,13 @@ class PaginationHelper:
     """
 
     def __init__(
-            self,
-            input_token: List[str],
-            output_token: List[str],
-            result_key: List[str],
-            limit_key: str = None,
-            more_results: str = None,
-            non_aggregate_keys: List[str] = None,
+        self,
+        input_token: List[str],
+        output_token: List[str],
+        result_key: List[str],
+        limit_key: str = None,
+        more_results: str = None,
+        non_aggregate_keys: List[str] = None,
     ):
         self.input_token = input_token
         self.output_token = output_token
@@ -70,9 +70,9 @@ class PaginationHelper:
         is_paginated = False
 
         if (
-                self.more_results
-                and self.more_results in output.keys()
-                and output[self.more_results]
+            self.more_results
+            and self.more_results in output.keys()
+            and output[self.more_results]
         ):
             is_paginated = True
 
@@ -84,10 +84,10 @@ class PaginationHelper:
         return is_paginated
 
     def merge_responses(
-            self,
-            input_: Dict[str, Any],
-            response_1: Dict[str, Any],
-            response_2: Dict[str, Any],
+        self,
+        input_: Dict[str, Any],
+        response_1: Dict[str, Any],
+        response_2: Dict[str, Any],
     ) -> Tuple[Dict[str, Any], bool]:
         """
         Merges two output dictionaries together.
@@ -112,7 +112,8 @@ class PaginationHelper:
                 if len(response_1[response]) >= input_[self.limit_key]:
                     max_hit = True
                     response_1[response] = response_1[response][
-                                           : input_[self.limit_key]]
+                        : input_[self.limit_key]
+                    ]
 
         return response_1, max_hit
 
@@ -302,7 +303,7 @@ class ActionHelper:
 
     @classmethod
     def format_output(
-            cls, output_schema: Union[Dict[str, Any], None], output: Dict[str, Any]
+        cls, output_schema: Union[Dict[str, Any], None], output: Dict[str, Any]
     ) -> Any:
         """
         Formats a botocore response into a correct Komand response.
@@ -333,14 +334,14 @@ class AWSAction(Action):
     """
 
     def __init__(
-            self,
-            name: str,
-            description: str,
-            input_: insightconnect_plugin_runtime.Input,
-            output: insightconnect_plugin_runtime.Output,
-            aws_service: str,
-            aws_command: str,
-            pagination_helper: PaginationHelper = None,
+        self,
+        name: str,
+        description: str,
+        input_: insightconnect_plugin_runtime.Input,
+        output: insightconnect_plugin_runtime.Output,
+        aws_service: str,
+        aws_command: str,
+        pagination_helper: PaginationHelper = None,
     ):
         """
 
@@ -362,7 +363,7 @@ class AWSAction(Action):
         self.pagination_helper = pagination_helper
 
     def _handle_botocore_function(
-            self, client_function: Callable, params: Dict
+        self, client_function: Callable, params: Dict
     ) -> Dict:
         try:
             response = client_function(**params)
@@ -480,11 +481,11 @@ class AWSAction(Action):
             client_function = getattr(client, self.aws_command)
         except AttributeError:
             error_message = (
-                    'Unable to find the command "'
-                    + self.aws_service
-                    + " "
-                    + self.aws_command
-                    + '"'
+                'Unable to find the command "'
+                + self.aws_service
+                + " "
+                + self.aws_command
+                + '"'
             )
             self.logger.error(error_message)
             raise PluginException(cause=error_message)
@@ -533,17 +534,21 @@ class AWSAction(Action):
 
     @staticmethod
     def try_to_assume_role(
-            service_name: str,
-            assume_role_params: Dict[str, str],
-            auth_params: Dict[str, str],
+        service_name: str,
+        assume_role_params: Dict[str, str],
+        auth_params: Dict[str, str],
     ):
         session_name = str(uuid.uuid1())
         sts_client = boto3.client("sts", **auth_params)
         try:
             assumed_role_object = sts_client.assume_role(
-                **clean({"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.9 → 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.9 → 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.