streamlit-octostar-utils 0.4.2.dev15__tar.gz → 0.4.2.dev17__tar.gz

{streamlit_octostar_utils-0.4.2.dev15 → streamlit_octostar_utils-0.4.2.dev17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-octostar-utils
-Version: 0.4.2.dev15
+Version: 0.4.2.dev17
 Summary: 
 License: MIT
 License-File: LICENSE

{streamlit_octostar_utils-0.4.2.dev15 → streamlit_octostar_utils-0.4.2.dev17}/pyproject.toml

@@ -5,7 +5,7 @@ include = '\.pyi?$'
 
 [tool.poetry]
 name = "streamlit-octostar-utils"
-version = "0.4.2-dev.15"
+version = "0.4.2-dev.17"
 description = ""
 license = "MIT"
 authors = ["Octostar"]

{streamlit_octostar_utils-0.4.2.dev15 → streamlit_octostar_utils-0.4.2.dev17}/streamlit_octostar_utils/api_crafter/celery.py

@@ -28,7 +28,7 @@ logging.getLogger("pottery").setLevel(logging.WARNING)
 from celery.app.defaults import DEFAULTS as CELERY_DEFAULTS
 import urllib
 
-from .fastapi import Route, CommonModels, DefaultErrorRoute
+from .fastapi import Route, CommonModels, DefaultErrorRoute, RemoteTraceback
 
 
 class RedisFileLock:
@@ -700,7 +700,12 @@ class CeleryExecutor(object):
 
     async def get_task_result(self, task_id, remove=False):
         def _try_get_task_data(celery_app, task_id):
-            celery_app.AsyncResult(task_id).get()  # will raise if the task raised an exception
+            async_result = celery_app.AsyncResult(task_id)
+            if async_result.state in ("FAILURE", "RETRY", "REVOKED"):
+                exc = async_result.result
+                if not isinstance(exc, BaseException):
+                    exc = RuntimeError(str(exc))
+                raise exc from RemoteTraceback(async_result.traceback)
 
         def _read_task_data(out_folder, task_id):
             serialized_data = CelerySerialized(folder=out_folder, redis_client=self.redis_client)
@@ -800,7 +805,7 @@ class FastAPICeleryTaskRoute(Route):
                 or (state not in ["SUCCESS", "FAILURE", "RETRY", "REVOKED"])
             )
             if state in ["FAILURE", "RETRY", "REVOKED"]:
-                error_response = DefaultErrorRoute.format_error(exc, debug=True).body.decode("utf-8")
+                error_response = DefaultErrorRoute.format_error(exc, internal=True).body.decode("utf-8")
                 data = {
                     "task_state": state,
                     "task_id": task_id,
@@ -853,7 +858,8 @@ class CeleryErrorRoute(DefaultErrorRoute):
 
     def add_default_exceptions_handler(
         fs_app,
-        debug=False,
+        internal=False,
+        internal_prefixes=None,
         excs_to_status_codes=None,
         silenced_excs=None,
     ):
@@ -869,4 +875,6 @@ class CeleryErrorRoute(DefaultErrorRoute):
             **(silenced_excs or {}),
         }
 
-        super(CeleryErrorRoute, CeleryErrorRoute).add_default_exceptions_handler(fs_app, debug, status_codes, silenced)
+        super(CeleryErrorRoute, CeleryErrorRoute).add_default_exceptions_handler(
+            fs_app, internal, internal_prefixes, status_codes, silenced,
+        )

{streamlit_octostar_utils-0.4.2.dev15 → streamlit_octostar_utils-0.4.2.dev17}/streamlit_octostar_utils/api_crafter/fastapi.py

@@ -21,7 +21,6 @@ from octostar.client import make_client
 
 MAX_ERROR_MESSAGE_BYTES = 256
 MAX_ERROR_TRACEBACK_BYTES = 10240
-DEFAULT_PROCESSOR_SUFFIX = "main"
 
 
 class CommonParsers(object):
@@ -268,6 +267,11 @@ class ErrorLogFilter(logging.Filter):
         return True
 
 
+class RemoteTraceback(Exception):
+    """Holds a formatted traceback string from a remote worker process."""
+    pass
+
+
 class DefaultErrorRoute:
     DEFAULT_STATUS_CODE_MAPPINGS = {
         StarletteHTTPException: lambda exc: exc.status_code,
@@ -314,7 +318,7 @@ class DefaultErrorRoute:
         },
     }
 
-    def format_error(exc, body=b"", debug=False, excs_to_status_codes=DEFAULT_STATUS_CODE_MAPPINGS):
+    def format_error(exc, body=b"", internal=False, excs_to_status_codes=DEFAULT_STATUS_CODE_MAPPINGS):
         """Generic Error Handler"""
         status_code = 500
         for exc_type, handler in excs_to_status_codes.items():
@@ -325,27 +329,33 @@ class DefaultErrorRoute:
             message = exc.message
         except:
             message = str(exc)
-        if debug:
+        if internal:
             message += "\n" + str(body)
         if len(message) > MAX_ERROR_MESSAGE_BYTES:
             message = message[-MAX_ERROR_MESSAGE_BYTES:]
         try:
-            tcbk = "\n".join(traceback.format_exception(exc))
+            remote_cause = getattr(exc, "__cause__", None)
+            if isinstance(remote_cause, RemoteTraceback):
+                tcbk = str(remote_cause)
+            else:
+                tcbk = "\n".join(traceback.format_exception(exc))
             if len(tcbk) > MAX_ERROR_TRACEBACK_BYTES:
                 tcbk = tcbk[-MAX_ERROR_TRACEBACK_BYTES:]
         except:
             tcbk = None
         response_content = {"message": message, "status": "error"}
-        if debug:
+        if internal:
+            response_content["exception_class"] = f"python.{type(exc).__module__}.{type(exc).__qualname__}"
             response_content["traceback"] = tcbk
         return JSONResponse(status_code=status_code, content=response_content)
 
-    async def handle_error(body: bytes, exc: Exception, debug: bool, excs_to_status_codes: dict):
-        return DefaultErrorRoute.format_error(exc, body, debug, excs_to_status_codes)
+    async def handle_error(body: bytes, exc: Exception, internal: bool, excs_to_status_codes: dict):
+        return DefaultErrorRoute.format_error(exc, body, internal, excs_to_status_codes)
 
     def add_default_exceptions_handler(
             fs_app,
-            debug=False,
+            internal=False,
+            internal_prefixes=None,
             excs_to_status_codes=None,
             silenced_excs=None,
     ):
@@ -353,9 +363,13 @@ class DefaultErrorRoute:
             excs_to_status_codes = DefaultErrorRoute.DEFAULT_STATUS_CODE_MAPPINGS
         if silenced_excs is None:
             silenced_excs = DefaultErrorRoute.DEFAULT_SILENCED_EXCEPTIONS
+        internal_prefixes = tuple(internal_prefixes or [])
 
         async def _async_handle_error(request: Request, exc: Exception):
-            return await DefaultErrorRoute.handle_error(b"", exc, debug, excs_to_status_codes)
+            is_internal = internal or (
+                internal_prefixes and request.url.path.startswith(internal_prefixes)
+            )
+            return await DefaultErrorRoute.handle_error(b"", exc, is_internal, excs_to_status_codes)
 
         # Added all three since FastAPI seems to intercept some exceptions before Exception
         fs_app.add_exception_handler(RequestValidationError, _async_handle_error)

{streamlit_octostar_utils-0.4.2.dev15 → streamlit_octostar_utils-0.4.2.dev17}/streamlit_octostar_utils/api_crafter/nifi.py

@@ -385,9 +385,12 @@ class NifiContextManager(object):
         return [entity for entity in self.jsonify(self.out_entities)["content"]]
 
     def raise_exception(self, entity, exc):
-        error_response = DefaultErrorRoute.format_error(exc)
+        error_response = DefaultErrorRoute.format_error(exc, internal=True)
+        error_body = json.loads(error_response.body)
         entity.request["exception"]["code"] = error_response.status_code
-        entity.request["exception"]["body"] = json.loads(error_response.body)["message"]
+        entity.request["exception"]["body"] = error_body["message"]
+        entity.request["exception"]["exception_class"] = error_body.get("exception_class")
+        entity.request["exception"]["traceback"] = error_body.get("traceback")
         travel_dict(entity.request["nifi_attributes"], ["invokehttp", "response", "body"], "w")(
             entity.request["exception"]["body"]
         )