corva-worker-python 2.0.0__py3-none-any.whl

worker/exceptions.py

@@ -0,0 +1,26 @@
+class CorvaException(Exception):
+    pass
+
+
+class Misconfigured(Exception):
+    pass
+
+
+class APIError(CorvaException):
+    pass
+
+
+class NotFound(CorvaException):
+    pass
+
+
+class Forbidden(CorvaException):
+    pass
+
+
+class MissingConfigError(Exception):
+    pass
+
+
+class EventFormatError(Exception):
+    pass

worker/mixins/logging.py

@@ -0,0 +1,119 @@
+import datetime
+import os
+
+from worker.data.operations import is_number
+
+
+class LoggingMixin(object):
+    LOGGING_LEVELS = [
+        "all",  # Show all messages
+        "debug",  # Show debug, info, warnings, errors, and fatal messages (Equal to all)
+        "info",  # Show info, warnings, errors, and fatal messages
+        "warn",  # Show warnings, errors, and fatal messages
+        "error",  # Show errors and fatal messages
+        "fatal",  # Show only fatal messages
+        "off",  # No messages
+    ]
+
+    def __init__(self, *args, **kwargs):
+        self.logging_level = os.getenv("LOGGING_LEVEL", "info").lower()
+        self.logging_asset_id = os.getenv("LOGGING_ASSET_ID", 0)
+
+        if self.logging_level not in self.LOGGING_LEVELS:
+            self.logging_level = "off"
+
+        if is_number(self.logging_asset_id):
+            self.logging_asset_id = int(self.logging_asset_id)
+
+        super().__init__(*args, **kwargs)
+
+    def all(self, asset_id, text):
+        self.call("all", asset_id, text)
+
+    def debug(self, asset_id, text):
+        self.call("debug", asset_id, text)
+
+    def info(self, asset_id, text):
+        self.call("info", asset_id, text)
+
+    def warn(self, asset_id, text):
+        self.call("warn", asset_id, text)
+
+    def error(self, asset_id, text):
+        self.call("error", asset_id, text)
+
+    def fatal(self, asset_id, text):
+        self.call("fatal", asset_id, text)
+
+    def off(self, asset_id, text):
+        pass
+
+    def call(self, method, asset_id, text):
+        if method == "off":
+            return
+
+        method_check = str(method) in self.LOGGING_LEVELS[self.LOGGING_LEVELS.index(self.logging_level) :]
+        if not method_check:
+            return
+
+        asset_id_check = (asset_id == self.logging_asset_id) or (self.logging_asset_id == "all")
+        if not asset_id_check:
+            return
+
+        self.log(asset_id, method, text)
+
+    @staticmethod
+    def log(asset_id, method="LOG", text=""):
+        if not method:
+            method = "LOG"
+
+        utc_time = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.%f")
+        print(f"{utc_time} | {method.upper()} | asset_id_{asset_id} | {text}")
+
+
+class Logger:
+    logger = None
+    asset_id = None
+
+    @classmethod
+    def set_asset_id(cls, asset_id):
+        cls.asset_id = asset_id
+
+    @classmethod
+    def get_logger(cls):
+        if cls.logger is None:
+            cls.logger = LoggingMixin()
+
+        return cls.logger
+
+    @classmethod
+    def all(cls, text):
+        cls.get_logger().call("all", cls.asset_id, text)
+
+    @classmethod
+    def debug(cls, text):
+        cls.get_logger().call("debug", cls.asset_id, text)
+
+    @classmethod
+    def info(cls, text):
+        cls.get_logger().call("info", cls.asset_id, text)
+
+    @classmethod
+    def warn(cls, text):
+        cls.get_logger().call("warn", cls.asset_id, text)
+
+    @classmethod
+    def error(cls, text):
+        cls.get_logger().call("error", cls.asset_id, text)
+
+    @classmethod
+    def fatal(cls, text):
+        cls.get_logger().call("fatal", cls.asset_id, text)
+
+    @classmethod
+    def off(cls, asset_id, text):
+        pass
+
+    @classmethod
+    def log(cls, text):
+        cls.get_logger().log(cls.asset_id, "LOG", text)

worker/mixins/rollbar.py

@@ -0,0 +1,87 @@
+import os
+import reprlib
+
+
+class RollbarMixin(object):
+    def __init__(self, *args, **kwargs):
+        self.rollbar = kwargs.pop("rollbar", None)
+        super().__init__(*args, **kwargs)
+
+    def is_rollbar(self) -> bool:
+        """
+        To check if rollbar is available or not
+        :return: if rollbar is available
+        """
+        return self.rollbar and self.rollbar.SETTINGS.get("enabled")
+
+    def track_message(self, message: str, level: str):
+        """
+        To send a message to rollbar
+        :param message:
+        :param level: any of the following levels:
+        ['critical', 'error', 'warning', 'info', 'debug', 'ignored']
+        :return:
+        """
+        # Levels:
+        if not self.is_rollbar():
+            print(f"{level} - {message}")
+            return
+
+        level = level.lower()
+
+        self.rollbar.report_message(message, level)
+
+    def track_error(self, message: str = None):
+        if not self.is_rollbar():
+            raise
+
+        self.rollbar.report_exc_info(extra_data=message, level="error")
+
+
+def payload_handler(payload: dict, **kw) -> dict:  # kw is currently unused
+    """
+    This is a rollbar payload handler which will be called on every payload being sent to rollbar
+    This handler has to be added to rollbar instance after init
+
+    Rollbar already applies a shortening transform to the payload using reprlib and custom sizes defined in rollbar init
+    But it somehow seems to miss nested lists which is a usual format in our apps using corva-worker-python
+    This payload handler applies the same reprlib to the lists missed by rollbar's shortener
+
+    Use like -> rollbar.events.add_payload_handler(payload_handler)
+    To pause trimming set REDUCED_ROLLBAR_PAYLOAD to False or false in env variables
+
+    :param payload: Payload automatically captured based on exc, args and locals
+    :param kw:
+    :return: Trimmed payload
+    """
+    reduced_rollbar_payload_flag = os.getenv("REDUCED_ROLLBAR_PAYLOAD", "true").lower()
+
+    # If REDUCED_ROLLBAR_PAYLOAD is set to False or false in env variables, trimming will be paused
+    if reduced_rollbar_payload_flag == "false":
+        return payload
+
+    try:
+        payload_frames = payload["data"]["body"]["trace"].pop("frames", [])
+    except KeyError:
+        return payload
+
+    # All the locals are nested inside frames.
+    # Smartly payload reduce size
+    for frame in payload_frames:
+        local_vars = frame.get("locals", {})
+
+        # Instantiating repr from reprlib. Using this to trim nested datasets
+        _repr = reprlib.Repr()
+
+        # Setting custom max sizes for dict and list
+        setattr(_repr, "maxdict", 10)
+        setattr(_repr, "maxlist", 2)
+
+        for key, value in local_vars.items():
+            # Applying trim to only dicts and lists.
+            # If there are other nested data types, they will be trimmed based on default repr limits
+            if isinstance(value, (dict, list)):
+                local_vars[key] = _repr.repr(value)
+
+    payload["data"]["body"]["trace"]["frames"] = payload_frames
+    return payload