nv-ingest 2025.8.4.dev20250804__py3-none-any.whl → 2025.12.10.dev20251210__py3-none-any.whl

nv_ingest/framework/orchestration/ray/primitives/ray_pipeline.py

@@ -3,8 +3,6 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import multiprocessing
-import os
-import signal
 import threading
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
@@ -22,6 +20,7 @@ import logging
 import time
 
 from nv_ingest.framework.orchestration.ray.primitives.pipeline_topology import PipelineTopology, StageInfo
+from nv_ingest.framework.orchestration.process.termination import kill_pipeline_process_group
 from nv_ingest.framework.orchestration.ray.primitives.ray_stat_collector import RayStatsCollector
 from nv_ingest.framework.orchestration.ray.util.pipeline.pid_controller import PIDController, ResourceConstraintManager
 from nv_ingest.framework.orchestration.ray.util.pipeline.tools import wrap_callable_as_stage
@@ -120,24 +119,19 @@ class RayPipelineSubprocessInterface(PipelineInterface):
 
     def stop(self) -> None:
         """
-        Stops the subprocess pipeline. Tries terminate(), then escalates to SIGKILL on the process group if needed.
+        Stops the subprocess pipeline and its entire process group to ensure
+        any child processes (e.g., the simple message broker) are terminated.
         """
-        if not self._process.is_alive():
+        try:
+            pid = int(self._process.pid)
+        except Exception:
             return
 
+        # Always attempt to terminate the entire process group
         try:
-            self._process.terminate()
-            self._process.join(timeout=5.0)
+            kill_pipeline_process_group(pid)
         except Exception as e:
-            logger.warning(f"Failed to terminate process cleanly: {e}")
-
-        if self._process.is_alive():
-            try:
-                pgid = os.getpgid(self._process.pid)
-                os.killpg(pgid, signal.SIGKILL)
-            except Exception as e:
-                logger.error(f"Failed to force-kill process group: {e}")
-            self._process.join(timeout=3.0)
+            logger.warning(f"kill_pipeline_process_group failed: {e}")
 
 
 class RayPipelineInterface(PipelineInterface):
@@ -252,7 +246,7 @@ class RayPipeline(PipelineInterface):
             penalty_factor=self.scaling_config.pid_penalty_factor,
             error_boost_factor=self.scaling_config.pid_error_boost_factor,
         )
-        logger.info("PIDController initialized using ScalingConfig.")
+        logger.debug("PIDController initialized using ScalingConfig.")
 
         try:
             total_system_memory_bytes = psutil.virtual_memory().total
@@ -270,7 +264,7 @@ class RayPipeline(PipelineInterface):
             memory_threshold=absolute_memory_threshold_mb,
             memory_safety_buffer_fraction=self.scaling_config.rcm_memory_safety_buffer_fraction,
         )
-        logger.info("ResourceConstraintManager initialized using ScalingConfig.")
+        logger.debug("ResourceConstraintManager initialized using ScalingConfig.")
 
         # --- Instantiate Stats Collector ---
         self._stats_collection_interval_seconds = self.stats_config.collection_interval_seconds
@@ -282,7 +276,7 @@ class RayPipeline(PipelineInterface):
             ema_alpha=self.scaling_config.pid_ema_alpha,
         )
 
-        logger.info("RayStatsCollector initialized using StatsConfig.")
+        logger.debug("RayStatsCollector initialized using StatsConfig.")
 
     # --- Accessor Methods for Stat Collector (and internal use) ---
 
@@ -349,11 +343,11 @@ class RayPipeline(PipelineInterface):
         # Update constraint manager
         self.constraint_manager.max_replicas = total_max_replicas
 
-        logger.info(f"[Build-Configure] Autoscalers configured. Total Max Replicas: {total_max_replicas}")
+        logger.debug(f"[Build-Configure] Autoscalers configured. Total Max Replicas: {total_max_replicas}")
 
     def _instantiate_initial_actors(self) -> None:
         """Instantiates initial actors and updates topology."""
-        logger.info("[Build-Actors] Instantiating initial stage actors (min_replicas)...")
+        logger.debug("[Build-Actors] Instantiating initial stage actors (min_replicas)...")
         # Use topology accessor
         current_stages = self.topology.get_stages_info()
 
@@ -377,7 +371,7 @@ class RayPipeline(PipelineInterface):
                     )
                     try:
                         actor = stage.callable.options(name=actor_name, max_concurrency=1, max_restarts=0).remote(
-                            config=stage.config
+                            config=stage.config, stage_name=stage.name
                         )
                         replicas.append(actor)
                     except Exception as e:
@@ -388,7 +382,7 @@ class RayPipeline(PipelineInterface):
             self.topology.set_actors_for_stage(stage.name, replicas)
             logger.debug(f"[Build-Actors] Stage '{stage.name}' initial actors set in topology: count={len(replicas)}")
 
-        logger.info("[Build-Actors] Initial actor instantiation complete.")
+        logger.debug("[Build-Actors] Initial actor instantiation complete.")
 
     def _create_and_wire_edges(self) -> List[ray.ObjectRef]:
         """
@@ -399,7 +393,7 @@ class RayPipeline(PipelineInterface):
         List[ray.ObjectRef]
             A list of object references for the remote wiring calls.
         """
-        logger.info("[Build-Wiring] Creating and wiring edges...")
+        logger.debug("[Build-Wiring] Creating and wiring edges...")
         wiring_refs = []
         new_edge_queues: Dict[str, Tuple[Any, int]] = {}
 
@@ -628,7 +622,7 @@ class RayPipeline(PipelineInterface):
         Dict[str, List[Any]]
             A dictionary mapping stage names to lists of actor handles.
         """
-        logger.info("--- Starting Pipeline Build Process ---")
+        logger.debug("--- Starting Pipeline Build Process ---")
         try:
             if not self.topology.get_stages_info():
                 logger.error("Build failed: No stages defined in topology.")
@@ -640,7 +634,7 @@ class RayPipeline(PipelineInterface):
             wiring_futures = self._create_and_wire_edges()
             self._wait_for_wiring(wiring_futures)
 
-            logger.info("--- Pipeline Build Completed Successfully ---")
+            logger.debug("--- Pipeline Build Completed Successfully ---")
             return self.topology.get_stage_actors()  # Return actors from topology
 
         except RuntimeError as e:
@@ -673,7 +667,7 @@ class RayPipeline(PipelineInterface):
         logger.debug(f"[ScaleUtil] Creating new actor '{actor_name}' for stage '{stage_info.name}'")
         try:
             new_actor = stage_info.callable.options(name=actor_name, max_concurrency=1, max_restarts=0).remote(
-                config=stage_info.config
+                config=stage_info.config, stage_name=stage_info.name
             )
 
             return new_actor
@@ -861,7 +855,7 @@ class RayPipeline(PipelineInterface):
         # Select actors to remove (e.g., the most recently added)
         actors_to_remove = current_replicas[-num_to_remove:]
 
-        logger.info(f"[ScaleDown-{stage_name}] Selected {len(actors_to_remove)} actors for removal.")
+        logger.debug(f"[ScaleDown-{stage_name}] Selected {len(actors_to_remove)} actors for removal.")
 
         # Signal each actor to stop and mark it for removal by the topology.
         # The topology's cleanup thread will handle polling and final removal.
@@ -966,7 +960,7 @@ class RayPipeline(PipelineInterface):
             True if the pipeline drained successfully, False otherwise.
         """
         start_time = time.time()
-        logger.info(f"Waiting for pipeline drain (Timeout: {timeout_seconds}s)...")
+        logger.debug(f"Waiting for pipeline drain (Timeout: {timeout_seconds}s)...")
         last_in_flight = -1
         drain_check_interval = 1.0  # Check every second
 
@@ -1172,7 +1166,7 @@ class RayPipeline(PipelineInterface):
         force : bool, optional
             Whether to force the flush, by default False.
         """
-        logger.info(f"Manual queue flush requested (force={force}).")
+        logger.debug(f"Manual queue flush requested (force={force}).")
 
         if self.topology.get_is_flushing() or self._stopping:  # Check topology
             logger.warning("Flush already in progress or pipeline is stopping.")
@@ -1183,7 +1177,7 @@ class RayPipeline(PipelineInterface):
             # For now, run synchronously:
             self._execute_queue_flush()
         else:
-            logger.info("Manual flush denied: pipeline not quiet or interval not met.")
+            logger.debug("Manual flush denied: pipeline not quiet or interval not met.")
 
     def _gather_controller_metrics(
         self, current_stage_stats: Dict[str, Dict[str, int]], global_in_flight: int
@@ -1409,7 +1403,7 @@ class RayPipeline(PipelineInterface):
                 self._consecutive_quiet_cycles += 1
                 logger.debug(f"Pipeline is quiet. Consecutive quiet cycles: {self._consecutive_quiet_cycles}")
                 if self._consecutive_quiet_cycles >= self.consecutive_quiet_cycles_for_flush:
-                    logger.info(
+                    logger.debug(
                         f"Pipeline has been quiet for {self._consecutive_quiet_cycles} cycles. "
                         "Initiating queue flush."
                     )
@@ -1423,7 +1417,7 @@ class RayPipeline(PipelineInterface):
                     )
             else:
                 if self._consecutive_quiet_cycles > 0:
-                    logger.info(
+                    logger.debug(
                         f"Pipeline is no longer quiet. Resetting consecutive quiet cycle count "
                         f"from {self._consecutive_quiet_cycles} to 0."
                     )
@@ -1479,7 +1473,7 @@ class RayPipeline(PipelineInterface):
         interval : float
             The interval in seconds.
         """
-        logger.info(f"Scaling loop started. Interval: {interval}s")
+        logger.debug(f"Scaling loop started. Interval: {interval}s")
         while self._scaling_monitoring:
             try:
                 self._perform_scaling_and_maintenance()
@@ -1490,7 +1484,7 @@ class RayPipeline(PipelineInterface):
             if not self._scaling_monitoring:
                 break
             time.sleep(sleep_time)
-        logger.info("Scaling loop finished.")
+        logger.debug("Scaling loop finished.")
 
     def _start_scaling(self, poll_interval: float = 10.0) -> None:
         """
@@ -1505,7 +1499,7 @@ class RayPipeline(PipelineInterface):
             self._scaling_monitoring = True
             self._scaling_thread = threading.Thread(target=self._scaling_loop, args=(poll_interval,), daemon=True)
             self._scaling_thread.start()
-            logger.info(f"Scaling/Maintenance thread launched (Interval: {poll_interval}s).")
+            logger.debug(f"Scaling/Maintenance thread launched (Interval: {poll_interval}s).")
 
     def _stop_scaling(self) -> None:
         """
@@ -1519,7 +1513,7 @@ class RayPipeline(PipelineInterface):
                 if self._scaling_thread.is_alive():
                     logger.warning("Scaling thread did not exit cleanly.")
             self._scaling_thread = None
-            logger.info("Scaling/Maintenance stopped.")
+            logger.debug("Scaling/Maintenance stopped.")
 
     # --- Pipeline Start/Stop ---
     def start(self, monitor_poll_interval: float = 5.0, scaling_poll_interval: float = 30.0) -> None:
@@ -1548,7 +1542,7 @@ class RayPipeline(PipelineInterface):
             logger.debug(f"Waiting for {len(start_futures)} actors to start...")
             try:
                 ray.get(start_futures, timeout=60.0)
-                logger.info(f"{len(start_futures)} actors started.")
+                logger.debug(f"{len(start_futures)} actors started.")
             except Exception as e:
                 logger.error(f"Error/Timeout starting actors: {e}", exc_info=True)
                 self.stop()  # Attempt cleanup
@@ -1593,7 +1587,7 @@ class RayPipeline(PipelineInterface):
                     logger.warning(
                         f"Timeout waiting for {len(not_ready)} actors to stop. " f"Proceeding with shutdown."
                     )
-                logger.info(f"{len(ready)} actors confirmed stop.")
+                logger.debug(f"{len(ready)} actors confirmed stop.")
             except Exception as e:
                 logger.error(f"An unexpected error occurred during actor shutdown: {e}", exc_info=True)
 

nv_ingest/framework/orchestration/ray/primitives/ray_stat_collector.py

@@ -72,7 +72,7 @@ class RayStatsCollector:
         self._cumulative_stats: Dict[str, Dict[str, int]] = defaultdict(lambda: {"processed": 0})
         self.ema_memory_per_replica: Dict[str, float] = {}  # EMA of memory per replica
 
-        logger.info(
+        logger.debug(
             f"RayStatsCollector initialized (Interval: {self._interval}s, "
             f"Actor Timeout: {self._actor_timeout}s, Queue Timeout: {self._queue_timeout}s, "
             f"EMA Alpha: {self.ema_alpha})"
@@ -111,7 +111,7 @@ class RayStatsCollector:
             self._running = False  # Correct inconsistent state
 
         if not self._running:
-            logger.info("Starting stats collector thread...")
+            logger.debug("Starting stats collector thread...")
             self._running = True
             with self._lock:
                 self._last_update_successful = False  # Mark as stale until first collection
@@ -129,7 +129,7 @@ class RayStatsCollector:
     def stop(self) -> None:
         """Signals the background stats collection thread to stop and waits for it."""
         if self._running:
-            logger.info("Stopping stats collector thread...")
+            logger.debug("Stopping stats collector thread...")
             self._running = False  # Signal loop to stop
 
             if self._thread is not None:
@@ -150,7 +150,7 @@ class RayStatsCollector:
             with self._lock:
                 self._last_update_successful = False
                 self._collected_stats = {}  # Clear last collected stats
-            logger.info("Stats collector thread stopped.")
+            logger.debug("Stats collector thread stopped.")
         else:
             logger.debug("Stats collector thread already stopped or never started.")
 
@@ -230,7 +230,7 @@ class RayStatsCollector:
             # but time.sleep is simpler for now.
             time.sleep(sleep_time)
 
-        logger.info("Stats collector loop finished.")
+        logger.debug("Stats collector loop finished.")
 
     def collect_stats_now(self) -> Tuple[Dict[str, Dict[str, int]], int, bool]:
         """

nv_ingest/framework/orchestration/ray/stages/extractors/audio_extractor.py

@@ -4,7 +4,7 @@
 
 
 import logging
-
+from typing import Optional
 import ray
 
 from nv_ingest.framework.orchestration.ray.stages.meta.ray_actor_stage_base import RayActorStage
@@ -16,6 +16,9 @@ from nv_ingest_api.internal.schemas.extract.extract_audio_schema import AudioExt
 from nv_ingest_api.util.exception_handlers.decorators import (
     nv_ingest_node_failure_try_except,
 )
+from nv_ingest_api.util.logging.sanitize import sanitize_for_logging
+
+from nv_ingest.framework.util.flow_control.udf_intercept import udf_intercept_hook
 
 logger = logging.getLogger(__name__)
 
@@ -31,8 +34,8 @@ class AudioExtractorStage(RayActorStage):
       3. Updates the message payload with the extracted text DataFrame.
     """
 
-    def __init__(self, config: AudioExtractorSchema) -> None:
-        super().__init__(config, log_to_stdout=False)
+    def __init__(self, config: AudioExtractorSchema, stage_name: Optional[str] = None) -> None:
+        super().__init__(config, log_to_stdout=False, stage_name=stage_name)
         try:
             self.validated_config = config
             self._logger.info("AudioExtractorStage configuration validated successfully.")
@@ -40,9 +43,10 @@ class AudioExtractorStage(RayActorStage):
             self._logger.exception(f"Error validating Audio Extractor config: {e}")
             raise
 
-    @traceable("audio_extractor")
+    @nv_ingest_node_failure_try_except()
+    @traceable()
+    @udf_intercept_hook()
     @filter_by_task(required_tasks=[("extract", {"document_type": "regex:^(mp3|wav)$"})])
-    @nv_ingest_node_failure_try_except(annotation_id="audio_extractor", raise_on_failure=False)
     def on_data(self, control_message: IngestControlMessage) -> IngestControlMessage:
         """
         Process the control message by extracting text from audio.
@@ -62,10 +66,9 @@ class AudioExtractorStage(RayActorStage):
         # Extract the DataFrame payload.
         df_ledger = control_message.payload()
         self._logger.debug("Extracted payload with %d rows.", len(df_ledger))
-
         # Remove the "audio_data_extract" task from the message to obtain task-specific configuration.
         task_config = remove_task_by_type(control_message, "extract")
-        self._logger.debug("Extracted task config: %s", task_config)
+        self._logger.debug("Extracted task config: %s", sanitize_for_logging(task_config))
 
         # Perform audio text extraction.
         new_df, extraction_info = extract_text_from_audio_internal(

nv_ingest/framework/orchestration/ray/stages/extractors/chart_extractor.py

@@ -3,19 +3,21 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
-from typing import Any
+from typing import Any, Optional
 
 import ray
-
-from nv_ingest.framework.orchestration.ray.stages.meta.ray_actor_stage_base import RayActorStage
-from nv_ingest.framework.util.flow_control import filter_by_task
 from nv_ingest_api.internal.extract.image.chart_extractor import extract_chart_data_from_image_internal
 from nv_ingest_api.internal.primitives.ingest_control_message import remove_task_by_type
+from nv_ingest_api.internal.primitives.tracing.tagging import set_trace_timestamps_with_parent_context
+from nv_ingest.framework.util.flow_control import filter_by_task
+from nv_ingest.framework.util.flow_control.udf_intercept import udf_intercept_hook
 from nv_ingest_api.internal.primitives.tracing.tagging import traceable
 from nv_ingest_api.internal.schemas.extract.extract_chart_schema import ChartExtractorSchema
+from nv_ingest.framework.orchestration.ray.stages.meta.ray_actor_stage_base import RayActorStage
 from nv_ingest_api.util.exception_handlers.decorators import (
     nv_ingest_node_failure_try_except,
 )
+from nv_ingest_api.util.logging.sanitize import sanitize_for_logging
 
 logger = logging.getLogger(__name__)
 
@@ -31,8 +33,8 @@ class ChartExtractorStage(RayActorStage):
     and annotates the message metadata with extraction info.
     """
 
-    def __init__(self, config: ChartExtractorSchema) -> None:
-        super().__init__(config)
+    def __init__(self, config: ChartExtractorSchema, stage_name: Optional[str] = None) -> None:
+        super().__init__(config, stage_name=stage_name)
         try:
             self.validated_config = config
             # logger.warning(
@@ -42,9 +44,10 @@ class ChartExtractorStage(RayActorStage):
             logger.exception("Error validating chart extractor config")
             raise e
 
-    @traceable("chart_extraction")
+    @nv_ingest_node_failure_try_except()
+    @traceable()
+    @udf_intercept_hook()
     @filter_by_task(required_tasks=["chart_data_extract"])
-    @nv_ingest_node_failure_try_except(annotation_id="chart_extraction", raise_on_failure=False)
     def on_data(self, control_message: Any) -> Any:
         """
         Process the control message by extracting chart data.
@@ -59,14 +62,14 @@ class ChartExtractorStage(RayActorStage):
         IngestControlMessage
             The updated message with the extracted chart data and extraction info in metadata.
         """
-        logger.info("ChartExtractorStage.on_data: Starting chart extraction.")
+        logger.debug("ChartExtractorStage.on_data: Starting chart extraction.")
         # Extract the DataFrame payload.
         df_payload = control_message.payload()
         logger.debug("ChartExtractorStage: Extracted payload with %d rows.", len(df_payload))
 
         # Remove the "chart_data_extract" task to obtain task-specific configuration.
         task_config = remove_task_by_type(control_message, "chart_data_extract")
-        logger.debug("ChartExtractorStage: Task config extracted: %s", task_config)
+        logger.debug("ChartExtractorStage: Task config extracted: %s", sanitize_for_logging(task_config))
 
         # Perform chart data extraction.
         execution_trace_log = {}
@@ -76,17 +79,17 @@ class ChartExtractorStage(RayActorStage):
             extraction_config=self.validated_config,
             execution_trace_log=execution_trace_log,
         )
-        logger.info("ChartExtractorStage: Chart extraction completed. New payload has %d rows.", len(new_df))
+        logger.debug("ChartExtractorStage: Chart extraction completed. New payload has %d rows.", len(new_df))
 
         # Update the control message with the new DataFrame.
         control_message.payload(new_df)
         # Annotate the message with extraction info.
         control_message.set_metadata("chart_extraction_info", extraction_info)
-        logger.info("ChartExtractorStage: Metadata injection complete. Returning updated control message.")
+        logger.debug("ChartExtractorStage: Metadata injection complete. Returning updated control message.")
 
         do_trace_tagging = control_message.get_metadata("config::add_trace_tagging") is True
         if do_trace_tagging and execution_trace_log:
-            for key, ts in execution_trace_log.items():
-                control_message.set_timestamp(key, ts)
+            parent_name = self.stage_name if self.stage_name else "chart_extractor"
+            set_trace_timestamps_with_parent_context(control_message, execution_trace_log, parent_name, logger)
 
         return control_message

nv_ingest/framework/orchestration/ray/stages/extractors/docx_extractor.py

@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+from typing import Optional
 
 import ray
 
@@ -15,6 +16,9 @@ from nv_ingest_api.internal.schemas.extract.extract_docx_schema import DocxExtra
 from nv_ingest_api.util.exception_handlers.decorators import (
     nv_ingest_node_failure_try_except,
 )
+from nv_ingest_api.util.logging.sanitize import sanitize_for_logging
+
+from nv_ingest.framework.util.flow_control.udf_intercept import udf_intercept_hook
 
 logger = logging.getLogger(__name__)
 
@@ -26,12 +30,12 @@ class DocxExtractorStage(RayActorStage):
 
     It expects an IngestControlMessage containing a DataFrame with DOCX document data. It then:
       1. Removes the "docx-extract" task from the message.
-      2. Calls the DOCX extraction logic (via extract_primitives_from_docx_internal) using a validated configuration.
+      2. Calls the DOCX extraction logic (via extract_docx_internal) using a validated configuration.
       3. Updates the message payload with the extracted content DataFrame.
     """
 
-    def __init__(self, config: DocxExtractorSchema) -> None:
-        super().__init__(config, log_to_stdout=False)
+    def __init__(self, config: DocxExtractorSchema, stage_name: Optional[str] = None) -> None:
+        super().__init__(config, log_to_stdout=False, stage_name=stage_name)
         try:
             self.validated_config = config
             logger.info("DocxExtractorStage configuration validated successfully.")
@@ -39,9 +43,10 @@ class DocxExtractorStage(RayActorStage):
             logger.exception(f"Error validating DOCX Extractor config: {e}")
             raise
 
-    @traceable("docx_extractor")
+    @nv_ingest_node_failure_try_except()
+    @traceable()
+    @udf_intercept_hook()
     @filter_by_task(required_tasks=[("extract", {"document_type": "docx"})])
-    @nv_ingest_node_failure_try_except(annotation_id="docx_extractor", raise_on_failure=True)
     def on_data(self, control_message: IngestControlMessage) -> IngestControlMessage:
         """
         Process the control message by extracting content from DOCX documents.
@@ -64,7 +69,7 @@ class DocxExtractorStage(RayActorStage):
 
         # Remove the "docx-extract" task from the message to obtain task-specific configuration.
         task_config = remove_task_by_type(control_message, "extract")
-        self._logger.debug("Extracted task config: %s", task_config)
+        self._logger.debug("Extracted task config: %s", sanitize_for_logging(task_config))
 
         # Perform DOCX content extraction.
         new_df, extraction_info = extract_primitives_from_docx_internal(

nv_ingest/framework/orchestration/ray/stages/extractors/html_extractor.py

@@ -4,6 +4,7 @@
 
 
 import logging
+from typing import Optional
 
 import ray
 
@@ -16,6 +17,9 @@ from nv_ingest_api.internal.schemas.extract.extract_html_schema import HtmlExtra
 from nv_ingest_api.util.exception_handlers.decorators import (
     nv_ingest_node_failure_try_except,
 )
+from nv_ingest_api.util.logging.sanitize import sanitize_for_logging
+
+from nv_ingest.framework.util.flow_control.udf_intercept import udf_intercept_hook
 
 logger = logging.getLogger(__name__)
 
@@ -31,8 +35,8 @@ class HtmlExtractorStage(RayActorStage):
       3. Updates the message payload with the extracted text DataFrame.
     """
 
-    def __init__(self, config: HtmlExtractorSchema) -> None:
-        super().__init__(config, log_to_stdout=False)
+    def __init__(self, config: HtmlExtractorSchema, stage_name: Optional[str] = None) -> None:
+        super().__init__(config, log_to_stdout=False, stage_name=stage_name)
         try:
             self.validated_config = config
             self._logger.info("HtmlExtractorStage configuration validated successfully.")
@@ -40,9 +44,10 @@ class HtmlExtractorStage(RayActorStage):
             self._logger.exception(f"Error validating Html Extractor config: {e}")
             raise
 
-    @traceable("html_extractor")
+    @nv_ingest_node_failure_try_except()
+    @traceable()
+    @udf_intercept_hook()
     @filter_by_task(required_tasks=[("extract", {"document_type": "html"})])
-    @nv_ingest_node_failure_try_except(annotation_id="html_extractor", raise_on_failure=False)
     def on_data(self, control_message: IngestControlMessage) -> IngestControlMessage:
         """
         Process the control message by extracting content from html.
@@ -65,7 +70,7 @@ class HtmlExtractorStage(RayActorStage):
 
         # Remove the "html_content_extract" task from the message to obtain task-specific configuration.
         task_config = remove_task_by_type(control_message, "extract")
-        self._logger.debug("Extracted task config: %s", task_config)
+        self._logger.debug("Extracted task config: %s", sanitize_for_logging(task_config))
 
         # Perform html content extraction.
         new_df, extraction_info = extract_markdown_from_html_internal(

nv_ingest/framework/orchestration/ray/stages/extractors/image_extractor.py

@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+from typing import Optional
 
 import ray
 
@@ -15,6 +16,9 @@ from nv_ingest_api.internal.schemas.extract.extract_image_schema import ImageExt
 from nv_ingest_api.util.exception_handlers.decorators import (
     nv_ingest_node_failure_try_except,
 )
+from nv_ingest_api.util.logging.sanitize import sanitize_for_logging
+
+from nv_ingest.framework.util.flow_control.udf_intercept import udf_intercept_hook
 
 logger = logging.getLogger(__name__)
 
@@ -30,18 +34,19 @@ class ImageExtractorStage(RayActorStage):
       3. Updates the message payload with the extracted primitives DataFrame.
     """
 
-    def __init__(self, config: ImageExtractorSchema) -> None:
-        super().__init__(config)
+    def __init__(self, config: ImageExtractorSchema, stage_name: Optional[str] = None) -> None:
+        super().__init__(config, log_to_stdout=False, stage_name=stage_name)
         try:
             self.validated_config = config
-            logger.info("ImageExtractorStage configuration validated successfully.")
+            self._logger.info("ImageExtractorStage configuration validated successfully.")
         except Exception as e:
-            logger.exception(f"Error validating Image Extractor config: {e}")
+            self._logger.exception(f"Error validating Image Extractor config: {e}")
             raise
 
-    @traceable("image_extraction")
+    @nv_ingest_node_failure_try_except()
+    @traceable()
+    @udf_intercept_hook()
     @filter_by_task(required_tasks=[("extract", {"document_type": "regex:^(png|jpeg|jpg|tiff|bmp)$"})])
-    @nv_ingest_node_failure_try_except(annotation_id="image_extractor", raise_on_failure=False)
     def on_data(self, control_message: IngestControlMessage) -> IngestControlMessage:
         """
         Process the control message by extracting primitives from images.
@@ -64,7 +69,7 @@ class ImageExtractorStage(RayActorStage):
 
             # Remove the "extract" task from the message to obtain task-specific configuration.
             task_config = remove_task_by_type(control_message, "extract")
-            logger.debug("Extracted task config: %s", task_config)
+            logger.debug("Extracted task config: %s", sanitize_for_logging(task_config))
 
             # Perform image primitives extraction.
             new_df, extraction_info = extract_primitives_from_image_internal(

nv_ingest/framework/orchestration/ray/stages/extractors/infographic_extractor.py

@@ -5,32 +5,44 @@
 import logging
 import ray
 
-from nv_ingest_api.internal.schemas.extract.extract_infographic_schema import InfographicExtractorSchema
 from nv_ingest.framework.orchestration.ray.stages.meta.ray_actor_stage_base import RayActorStage
 from nv_ingest.framework.util.flow_control import filter_by_task
 from nv_ingest_api.internal.extract.image.infographic_extractor import extract_infographic_data_from_image_internal
 from nv_ingest_api.internal.primitives.ingest_control_message import IngestControlMessage, remove_task_by_type
-from nv_ingest_api.internal.primitives.tracing.tagging import traceable
+from nv_ingest_api.internal.primitives.tracing.tagging import traceable, set_trace_timestamps_with_parent_context
+from nv_ingest_api.internal.schemas.extract.extract_infographic_schema import InfographicExtractorSchema
 from nv_ingest_api.util.exception_handlers.decorators import nv_ingest_node_failure_try_except
+from typing import Optional
+
+from nv_ingest.framework.util.flow_control.udf_intercept import udf_intercept_hook
 
 logger = logging.getLogger(__name__)
 
 
 @ray.remote
 class InfographicExtractorStage(RayActorStage):
-    def __init__(self, config: InfographicExtractorSchema) -> None:
-        super().__init__(config)
+    """
+    A Ray actor stage that extracts infographic data from image content.
+
+    It expects an IngestControlMessage containing a DataFrame with image data. It then:
+      1. Removes the "infographic_data_extract" task from the message.
+      2. Calls the infographic extraction logic using a validated configuration.
+      3. Updates the message payload with the extracted infographic DataFrame.
+    """
 
+    def __init__(self, config: InfographicExtractorSchema, stage_name: Optional[str] = None) -> None:
+        super().__init__(config, log_to_stdout=False, stage_name=stage_name)
         try:
             self.validated_config = config
-            logger.info("ImageExtractorStage configuration validated successfully.")
+            self._logger.info("InfographicExtractorStage configuration validated successfully.")
         except Exception as e:
-            logger.exception(f"Error validating Image Extractor config: {e}")
+            self._logger.exception(f"Error validating Infographic extractor config: {e}")
             raise
 
-    @traceable("infographic_extraction")
+    @nv_ingest_node_failure_try_except()
+    @traceable()
+    @udf_intercept_hook()
     @filter_by_task(required_tasks=["infographic_data_extract"])
-    @nv_ingest_node_failure_try_except(annotation_id="infographic_extraction", raise_on_failure=False)
     def on_data(self, control_message: IngestControlMessage) -> IngestControlMessage:
         # Extract DataFrame payload
         df_ledger = control_message.payload()
@@ -51,7 +63,7 @@ class InfographicExtractorStage(RayActorStage):
 
         do_trace_tagging = control_message.get_metadata("config::add_trace_tagging") is True
         if do_trace_tagging and execution_trace_log:
-            for key, ts in execution_trace_log.items():
-                control_message.set_timestamp(key, ts)
+            parent_name = self.stage_name if self.stage_name else "infographic_extractor"
+            set_trace_timestamps_with_parent_context(control_message, execution_trace_log, parent_name, logger)
 
         return control_message