nv-ingest-api 2025.5.11.dev20250511__py3-none-any.whl → 2025.5.13.dev20250513__py3-none-any.whl

nv_ingest_api/internal/transform/embed_text.py

@@ -230,28 +230,35 @@ def _async_runner(
 def _add_embeddings(row, embeddings, info_msgs):
     """
     Updates a DataFrame row with embedding data and associated error info.
+    Ensures the 'embedding' field is always present, even if None.
 
     Parameters
     ----------
     row : pandas.Series
         A row of the DataFrame.
-    embeddings : list
-        List of embeddings corresponding to DataFrame rows.
-    info_msgs : list
-        List of info message dictionaries corresponding to DataFrame rows.
+    embeddings : dict
+        Dictionary mapping row indices to embeddings.
+    info_msgs : dict
+        Dictionary mapping row indices to info message dicts.
 
     Returns
     -------
     pandas.Series
-        The updated row with embedding and info message metadata added.
+        The updated row with 'embedding', 'info_message_metadata', and
+        '_contains_embeddings' appropriately set.
     """
-    row["metadata"]["embedding"] = embeddings[row.name]
-    if info_msgs[row.name] is not None:
-        row["metadata"]["info_message_metadata"] = info_msgs[row.name]
+    embedding = embeddings.get(row.name, None)
+    info_msg = info_msgs.get(row.name, None)
+
+    # Always set embedding, even if None
+    row["metadata"]["embedding"] = embedding
+
+    if info_msg:
+        row["metadata"]["info_message_metadata"] = info_msg
         row["document_type"] = ContentTypeEnum.INFO_MSG
         row["_contains_embeddings"] = False
     else:
-        row["_contains_embeddings"] = True
+        row["_contains_embeddings"] = embedding is not None
 
     return row
 
@@ -287,7 +294,7 @@ def _get_pandas_table_content(row):
     str
         The table/chart content from the row.
     """
-    return row["table_metadata"]["table_content"]
+    return row.get("table_metadata", {}).get("table_content")
 
 
 def _get_pandas_image_content(row):
@@ -304,7 +311,14 @@ def _get_pandas_image_content(row):
     str
         The image caption from the row.
     """
-    return row["image_metadata"]["caption"]
+    return row.get("image_metadata", {}).get("caption")
+
+
+def _get_pandas_audio_content(row):
+    """
+    A pandas UDF used to select extracted audio transcription to be used to create embeddings.
+    """
+    return row.get("audio_metadata", {}).get("audio_transcript")
 
 
 # ------------------------------------------------------------------------------
@@ -352,13 +366,6 @@ def _generate_batches(prompts: List[str], batch_size: int = 100) -> List[str]:
     return [batch for batch in _batch_generator(prompts, batch_size)]
 
 
-def _get_pandas_audio_content(row):
-    """
-    A pandas UDF used to select extracted audio transcription to be used to create embeddings.
-    """
-    return row["audio_metadata"]["audio_transcript"]
-
-
 # ------------------------------------------------------------------------------
 # DataFrame Concatenation Utility
 # ------------------------------------------------------------------------------
@@ -408,17 +415,20 @@ def transform_create_text_embeddings_internal(
     execution_trace_log: Optional[Dict] = None,
 ) -> Tuple[pd.DataFrame, Dict]:
     """
-    Generates text embeddings for supported content types (TEXT, STRUCTURED, IMAGE)
+    Generates text embeddings for supported content types (TEXT, STRUCTURED, IMAGE, AUDIO)
     from a pandas DataFrame using asynchronous requests.
 
+    This function ensures that even if the extracted content is empty or None,
+    the embedding field is explicitly created and set to None.
+
     Parameters
     ----------
     df_transform_ledger : pd.DataFrame
         The DataFrame containing content for embedding extraction.
     task_config : Dict[str, Any]
         Dictionary containing task properties (e.g., filter error flag).
-    transform_config : Any
-        Validated configuration for text embedding extraction (EmbedExtractionsSchema).
+    transform_config : TextEmbeddingSchema, optional
+        Validated configuration for text embedding extraction.
     execution_trace_log : Optional[Dict], optional
         Optional trace information for debugging or logging (default is None).
 
@@ -429,24 +439,20 @@ def transform_create_text_embeddings_internal(
             - The updated DataFrame with embeddings applied.
             - A dictionary with trace information.
     """
-
-    # Retrieve configuration values with fallback to transform_config defaults.
-    api_key: str = task_config.get("api_key") or transform_config.api_key
-    endpoint_url: str = task_config.get("endpoint_url") or transform_config.embedding_nim_endpoint
-    model_name: str = task_config.get("model_name") or transform_config.embedding_model
+    api_key = task_config.get("api_key") or transform_config.api_key
+    endpoint_url = task_config.get("endpoint_url") or transform_config.embedding_nim_endpoint
+    model_name = task_config.get("model_name") or transform_config.embedding_model
 
     if execution_trace_log is None:
         execution_trace_log = {}
         logger.debug("No trace_info provided. Initialized empty trace_info dictionary.")
 
-    # TODO(Devin)
     if df_transform_ledger.empty:
         return df_transform_ledger, {"trace_info": execution_trace_log}
 
     embedding_dataframes = []
-    content_masks = []  # List of pandas boolean Series
+    content_masks = []
 
-    # Define pandas content extractors for supported content types.
     pandas_content_extractor = {
         ContentTypeEnum.TEXT: _get_pandas_text_content,
         ContentTypeEnum.STRUCTURED: _get_pandas_table_content,
@@ -455,49 +461,62 @@ def transform_create_text_embeddings_internal(
         ContentTypeEnum.VIDEO: lambda x: None,  # Not supported yet.
     }
 
-    logger.debug("Generating text embeddings for supported content types: TEXT, STRUCTURED, IMAGE.")
-
     def _content_type_getter(row):
         return row["content_metadata"]["type"]
 
-    # Process each supported content type.
     for content_type, content_getter in pandas_content_extractor.items():
         if not content_getter:
             logger.debug(f"Skipping unsupported content type: {content_type}")
             continue
 
+        # Get rows matching the content type
         content_mask = df_transform_ledger["metadata"].apply(_content_type_getter) == content_type.value
         if not content_mask.any():
             continue
 
-        # Extract content from metadata and filter out rows with empty content.
-        extracted_content = df_transform_ledger.loc[content_mask, "metadata"].apply(content_getter)
-        non_empty_mask = extracted_content.notna() & (extracted_content.str.strip() != "")
-        final_mask = content_mask & non_empty_mask
-        if not final_mask.any():
-            continue
+        # Always include all content_mask rows and prepare them
+        df_content = df_transform_ledger.loc[content_mask].copy().reset_index(drop=True)
 
-        df_content = df_transform_ledger.loc[final_mask].copy().reset_index(drop=True)
-        filtered_content = df_content["metadata"].apply(content_getter)
-        filtered_content_batches = _generate_batches(filtered_content.tolist(), batch_size=transform_config.batch_size)
-        content_embeddings = _async_runner(
-            filtered_content_batches,
-            api_key,
-            endpoint_url,
-            model_name,
-            transform_config.encoding_format,
-            transform_config.input_type,
-            transform_config.truncate,
-            False,
+        # Extract content and normalize empty or non-str to None
+        extracted_content = (
+            df_content["metadata"]
+            .apply(content_getter)
+            .apply(lambda x: x.strip() if isinstance(x, str) and x.strip() else None)
         )
-        # Apply the embeddings (and any error info) to each row.
-        df_content[["metadata", "document_type", "_contains_embeddings"]] = df_content.apply(
-            _add_embeddings, **content_embeddings, axis=1
-        )[["metadata", "document_type", "_contains_embeddings"]]
-        df_content["_content"] = filtered_content
+        df_content["_content"] = extracted_content
+
+        # Prepare batches for only valid (non-None) content
+        valid_content_mask = df_content["_content"].notna()
+        if valid_content_mask.any():
+            filtered_content_batches = _generate_batches(
+                df_content.loc[valid_content_mask, "_content"].tolist(), batch_size=transform_config.batch_size
+            )
+            content_embeddings = _async_runner(
+                filtered_content_batches,
+                api_key,
+                endpoint_url,
+                model_name,
+                transform_config.encoding_format,
+                transform_config.input_type,
+                transform_config.truncate,
+                False,
+            )
+            # Build a simple row index -> embedding map
+            embeddings_dict = dict(
+                zip(df_content.loc[valid_content_mask].index, content_embeddings.get("embeddings", []))
+            )
+            info_msgs_dict = dict(
+                zip(df_content.loc[valid_content_mask].index, content_embeddings.get("info_msgs", []))
+            )
+        else:
+            embeddings_dict = {}
+            info_msgs_dict = {}
+
+        # Apply embeddings or None to all rows
+        df_content = df_content.apply(_add_embeddings, embeddings=embeddings_dict, info_msgs=info_msgs_dict, axis=1)
 
         embedding_dataframes.append(df_content)
-        content_masks.append(final_mask)
+        content_masks.append(content_mask)
 
     combined_df = _concatenate_extractions_pandas(df_transform_ledger, embedding_dataframes, content_masks)
     return combined_df, {"trace_info": execution_trace_log}

nv_ingest_api/util/exception_handlers/converters.py

@@ -66,7 +66,7 @@ def datetools_exception_handler(func: Callable, **kwargs: Dict[str, Any]) -> Cal
             return func(*args, **kwargs)
         except Exception as e:
             log_error_message = f"Invalid date format: {e}"
-            logger.warning(log_error_message)
+            logger.debug(log_error_message)
             return datetools.remove_tz(datetime.now(timezone.utc)).isoformat()
 
     return inner_function

nv_ingest_api/util/exception_handlers/decorators.py

@@ -2,77 +2,321 @@
 # All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
+import asyncio
 import logging
 import functools
 import inspect
 import re
-import typing
+from typing import Any, Optional, Callable, Tuple
 from functools import wraps
 
 from nv_ingest_api.internal.primitives.ingest_control_message import IngestControlMessage
 from nv_ingest_api.internal.primitives.tracing.logging import TaskResultStatus, annotate_task_result
 from nv_ingest_api.util.control_message.validators import cm_ensure_payload_not_null, cm_set_failure
 
-
 logger = logging.getLogger(__name__)
 
 
-# TODO(Devin): move back to framework
+def nv_ingest_node_failure_try_except(  # New name to distinguish
+    annotation_id: str,
+    payload_can_be_empty: bool = False,
+    raise_on_failure: bool = False,
+    skip_processing_if_failed: bool = True,
+    forward_func: Optional[Callable[[Any], Any]] = None,
+) -> Callable:
+    """
+    Decorator that wraps function execution in a try/except block to handle
+    failures by annotating an IngestControlMessage. Replaces the context
+    manager approach for potentially simpler interaction with frameworks like Ray.
+
+    Parameters are the same as nv_ingest_node_failure_context_manager.
+    """
+
+    def extract_message_and_prefix(args: Tuple) -> Tuple[Any, Tuple]:
+        """Extracts control_message and potential 'self' prefix."""
+        # (Keep the implementation from the original decorator)
+        if args and hasattr(args[0], "get_metadata"):
+            return args[0], ()
+        elif len(args) >= 2 and hasattr(args[1], "get_metadata"):
+            return args[1], (args[0],)
+        else:
+            # Be more specific in error if possible
+            arg_types = [type(arg).__name__ for arg in args]
+            raise ValueError(f"No IngestControlMessage found in first or second argument. Got types: {arg_types}")
+
+    def decorator(func: Callable) -> Callable:
+        func_name = func.__name__  # Get function name for logging/errors
+
+        # --- ASYNC WRAPPER ---
+        if asyncio.iscoroutinefunction(func):
+
+            @functools.wraps(func)
+            async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+                logger.debug(f"async_wrapper for {func_name}: Entering.")
+                try:
+                    control_message, prefix = extract_message_and_prefix(args)
+                except ValueError as e:
+                    logger.error(f"async_wrapper for {func_name}: Failed to extract control message. Error: {e}")
+                    raise  # Cannot proceed without the message
+
+                # --- Skip logic ---
+                is_failed = control_message.get_metadata("cm_failed", False)
+                if is_failed and skip_processing_if_failed:
+                    logger.debug(f"async_wrapper for {func_name}: Skipping processing, message already marked failed.")
+                    if forward_func:
+                        logger.debug("async_wrapper: Forwarding skipped message.")
+                        # Await forward_func if it's async
+                        if asyncio.iscoroutinefunction(forward_func):
+                            return await forward_func(control_message)
+                        else:
+                            return forward_func(control_message)
+                    else:
+                        logger.debug("async_wrapper: Returning skipped message as is.")
+                        return control_message
+
+                # --- Main execution block ---
+                result = None
+                try:
+                    # Payload check
+                    if not payload_can_be_empty:
+                        cm_ensure_payload_not_null(control_message)
+
+                    # Rebuild args and call original async function
+                    new_args = prefix + (control_message,) + args[len(prefix) + 1 :]
+                    logger.debug(f"async_wrapper for {func_name}: Calling await func...")
+                    result = await func(*new_args, **kwargs)
+                    logger.debug(f"async_wrapper for {func_name}: func call completed.")
+
+                    # Success annotation
+                    logger.debug(f"async_wrapper for {func_name}: Annotating success.")
+                    annotate_task_result(
+                        control_message=result if result is not None else control_message,
+                        # Annotate result if func returns it, else original message
+                        result=TaskResultStatus.SUCCESS,
+                        task_id=annotation_id,
+                    )
+                    logger.debug(f"async_wrapper for {func_name}: Success annotation done. Returning result.")
+                    return result
+
+                except Exception as e:
+                    # --- Failure Handling ---
+                    error_message = f"Error in {func_name}: {e}"
+                    logger.error(f"async_wrapper for {func_name}: Caught exception: {error_message}", exc_info=True)
+
+                    # Annotate failure on the original message object
+                    try:
+                        cm_set_failure(control_message, error_message)
+                        annotate_task_result(
+                            control_message=control_message,
+                            result=TaskResultStatus.FAILURE,
+                            task_id=annotation_id,
+                            message=error_message,
+                        )
+                        logger.debug(f"async_wrapper for {func_name}: Failure annotation complete.")
+                    except Exception as anno_err:
+                        # Log error during annotation but proceed based on raise_on_failure
+                        logger.exception(
+                            f"async_wrapper for {func_name}: CRITICAL - Error during failure annotation: {anno_err}"
+                        )
+
+                    # Decide whether to raise or return annotated message
+                    if raise_on_failure:
+                        logger.debug(f"async_wrapper for {func_name}: Re-raising exception as configured.")
+                        raise e  # Re-raise the original exception
+                    else:
+                        logger.debug(
+                            f"async_wrapper for {func_name}: Suppressing exception and returning annotated message."
+                        )
+                        # Return the original control_message, now annotated with failure
+                        return control_message
+
+            return async_wrapper
+
+        # --- SYNC WRAPPER ---
+        else:
+
+            @functools.wraps(func)
+            def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+                logger.debug(f"sync_wrapper for {func_name}: Entering.")
+                try:
+                    control_message, prefix = extract_message_and_prefix(args)
+                except ValueError as e:
+                    logger.error(f"sync_wrapper for {func_name}: Failed to extract control message. Error: {e}")
+                    raise
+
+                # --- Skip logic ---
+                is_failed = control_message.get_metadata("cm_failed", False)
+                if is_failed and skip_processing_if_failed:
+                    logger.warning(f"sync_wrapper for {func_name}: Skipping processing, message already marked failed.")
+                    if forward_func:
+                        logger.debug("sync_wrapper: Forwarding skipped message.")
+                        return forward_func(control_message)  # Assume forward_func is sync here
+                    else:
+                        logger.debug("sync_wrapper: Returning skipped message as is.")
+                        return control_message
+
+                # --- Main execution block ---
+                result = None
+                try:
+                    # Payload check
+                    if not payload_can_be_empty:
+                        cm_ensure_payload_not_null(control_message)
+
+                    # Rebuild args and call original sync function
+                    new_args = prefix + (control_message,) + args[len(prefix) + 1 :]
+                    logger.debug(f"sync_wrapper for {func_name}: Calling func...")
+                    result = func(*new_args, **kwargs)
+                    logger.debug(f"sync_wrapper for {func_name}: func call completed.")
+
+                    # Success annotation
+                    logger.debug(f"sync_wrapper for {func_name}: Annotating success.")
+                    annotate_task_result(
+                        control_message=result if result is not None else control_message,
+                        # Annotate result or original message
+                        result=TaskResultStatus.SUCCESS,
+                        task_id=annotation_id,
+                    )
+                    logger.debug(f"sync_wrapper for {func_name}: Success annotation done. Returning result.")
+                    return result
+
+                except Exception as e:
+                    # --- Failure Handling ---
+                    error_message = f"Error in {func_name}: {e}"
+                    logger.error(f"sync_wrapper for {func_name}: Caught exception: {error_message}", exc_info=True)
+
+                    # Annotate failure on the original message object
+                    try:
+                        cm_set_failure(control_message, error_message)
+                        annotate_task_result(
+                            control_message=control_message,
+                            result=TaskResultStatus.FAILURE,
+                            task_id=annotation_id,
+                            message=error_message,
+                        )
+                        logger.debug(f"sync_wrapper for {func_name}: Failure annotation complete.")
+                    except Exception as anno_err:
+                        logger.exception(
+                            f"sync_wrapper for {func_name}: CRITICAL - Error during failure annotation: {anno_err}"
+                        )
+
+                    # Decide whether to raise or return annotated message
+                    if raise_on_failure:
+                        logger.debug(f"sync_wrapper for {func_name}: Re-raising exception as configured.")
+                        raise e  # Re-raise the original exception
+                    else:
+                        logger.debug(
+                            f"sync_wrapper for {func_name}: Suppressing exception and returning annotated message."
+                        )
+                        # Return the original control_message, now annotated with failure
+                        return control_message
+
+            return sync_wrapper
+
+    return decorator
+
+
 def nv_ingest_node_failure_context_manager(
     annotation_id: str,
     payload_can_be_empty: bool = False,
     raise_on_failure: bool = False,
     skip_processing_if_failed: bool = True,
-    forward_func=None,
-) -> typing.Callable:
+    forward_func: Optional[Callable[[Any], Any]] = None,
+) -> Callable:
     """
-    A decorator that applies a default failure context manager around a function to manage
-    the execution and potential failure of operations involving IngestControlMessages.
+    Decorator that applies a failure context manager around a function processing an IngestControlMessage.
+    Works with both synchronous and asynchronous functions, and supports class methods (with 'self').
 
     Parameters
     ----------
     annotation_id : str
-        A unique identifier used for annotating the task's result.
+        A unique identifier for annotation.
     payload_can_be_empty : bool, optional
-        If False, the payload of the IngestControlMessage will be checked to ensure it's not null,
-        raising an exception if it is null. Defaults to False, enforcing payload presence.
+        If False, the message payload must not be null.
     raise_on_failure : bool, optional
-        If True, an exception is raised if the decorated function encounters an error.
-        Otherwise, the error is handled silently by annotating the IngestControlMessage. Defaults to False.
+        If True, exceptions are raised; otherwise, they are annotated.
     skip_processing_if_failed : bool, optional
-        If True, skips the processing of the decorated function if the control message has already
-        been marked as failed. If False, the function will be processed regardless of the failure
-        status of the IngestControlMessage. Defaults to True.
-    forward_func : callable, optional
-        A function to forward the IngestControlMessage if it has already been marked as failed.
+        If True, skip processing if the message is already marked as failed.
+    forward_func : Optional[Callable[[Any], Any]]
+        If provided, a function to forward the message when processing is skipped.
 
     Returns
     -------
     Callable
-        A decorator that wraps the given function with failure handling logic.
+        The decorated function.
     """
 
-    def decorator(func):
-        @wraps(func)
-        def wrapper(control_message: IngestControlMessage, *args, **kwargs):
-            # Quick return if the IngestControlMessage has already failed
-            is_failed = control_message.get_metadata("cm_failed", False)
-            if not is_failed or not skip_processing_if_failed:
-                with CMNVIngestFailureContextManager(
-                    control_message=control_message,
-                    annotation_id=annotation_id,
-                    raise_on_failure=raise_on_failure,
-                    func_name=func.__name__,
-                ) as ctx_mgr:
-                    if not payload_can_be_empty:
-                        cm_ensure_payload_not_null(control_message=control_message)
-                    control_message = func(ctx_mgr.control_message, *args, **kwargs)
-            else:
-                if forward_func:
-                    control_message = forward_func(control_message)
-            return control_message
+    def extract_message_and_prefix(args: Tuple) -> Tuple[Any, Tuple]:
+        """
+        Determines if the function is a method (first argument is self) or a standalone function.
+        Returns a tuple (control_message, prefix) where prefix is a tuple of preceding arguments to be preserved.
+        """
+        if args and hasattr(args[0], "get_metadata"):
+            # Standalone function: first argument is the message.
+            return args[0], ()
+        elif len(args) >= 2 and hasattr(args[1], "get_metadata"):
+            # Method: first argument is self, second is the message.
+            return args[1], (args[0],)
+        else:
+            raise ValueError("No IngestControlMessage found in the first or second argument.")
 
-        return wrapper
+    def decorator(func: Callable) -> Callable:
+        if asyncio.iscoroutinefunction(func):
+
+            @functools.wraps(func)
+            async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+                control_message, prefix = extract_message_and_prefix(args)
+                is_failed = control_message.get_metadata("cm_failed", False)
+                if not is_failed or not skip_processing_if_failed:
+                    ctx_mgr = CMNVIngestFailureContextManager(
+                        control_message=control_message,
+                        annotation_id=annotation_id,
+                        raise_on_failure=raise_on_failure,
+                        func_name=func.__name__,
+                    )
+                    try:
+                        ctx_mgr.__enter__()
+                        if not payload_can_be_empty:
+                            cm_ensure_payload_not_null(control_message)
+                        # Rebuild argument list preserving any prefix (e.g. self).
+                        new_args = prefix + (ctx_mgr.control_message,) + args[len(prefix) + 1 :]
+                        result = await func(*new_args, **kwargs)
+                    except Exception as e:
+                        ctx_mgr.__exit__(type(e), e, e.__traceback__)
+                        raise
+                    else:
+                        ctx_mgr.__exit__(None, None, None)
+                        return result
+                else:
+                    if forward_func:
+                        return await forward_func(control_message)
+                    else:
+                        return control_message
+
+            return async_wrapper
+        else:
+
+            @functools.wraps(func)
+            def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+                control_message, prefix = extract_message_and_prefix(args)
+                is_failed = control_message.get_metadata("cm_failed", False)
+                if not is_failed or not skip_processing_if_failed:
+                    with CMNVIngestFailureContextManager(
+                        control_message=control_message,
+                        annotation_id=annotation_id,
+                        raise_on_failure=raise_on_failure,
+                        func_name=func.__name__,
+                    ) as ctx_mgr:
+                        if not payload_can_be_empty:
+                            cm_ensure_payload_not_null(control_message)
+                        new_args = prefix + (ctx_mgr.control_message,) + args[len(prefix) + 1 :]
+                        return func(*new_args, **kwargs)
+                else:
+                    if forward_func:
+                        return forward_func(control_message)
+                    else:
+                        return control_message
+
+            return sync_wrapper
 
     return decorator
 
@@ -81,7 +325,7 @@ def nv_ingest_source_failure_context_manager(
     annotation_id: str,
     payload_can_be_empty: bool = False,
     raise_on_failure: bool = False,
-) -> typing.Callable:
+) -> Callable:
     """
     A decorator that ensures any function's output is treated as a IngestControlMessage for annotation.
     It applies a context manager to handle success and failure annotations based on the function's execution.
@@ -209,15 +453,29 @@ class CMNVIngestFailureContextManager:
 
 
 def unified_exception_handler(func):
-    @functools.wraps(func)
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except Exception as e:
-            # Use the function's name in the error message
-            func_name = func.__name__
-            err_msg = f"{func_name}: error: {e}"
-            logger.exception(err_msg, exc_info=True)
-            raise type(e)(err_msg) from e
-
-    return wrapper
+    if asyncio.iscoroutinefunction(func):
+
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except Exception as e:
+                func_name = func.__name__
+                err_msg = f"{func_name}: error: {e}"
+                logger.exception(err_msg, exc_info=True)
+                raise type(e)(err_msg) from e
+
+        return async_wrapper
+    else:
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                func_name = func.__name__
+                err_msg = f"{func_name}: error: {e}"
+                logger.exception(err_msg, exc_info=True)
+                raise type(e)(err_msg) from e
+
+        return sync_wrapper