tool-sidecar/src/unstract/tool_sidecar/log_processor.py (1)

226-259:Critical: Monitoring loop never checks shutdown flag.

Themonitor_logs() method'swhile True loop (starting at line 236) never checks the_shutdown_requested flag. Even after the signal handler sets this flag, the monitoring loop will continue running indefinitely. For graceful shutdown to work, you must check the flag within the loop.

Add a flag check in the monitoring loop:

         # Monitor the file for new content         with open(self.log_path) as f:             while True:+                # Check if shutdown was requested+                if _shutdown_requested:+                    logger.info("Shutdown requested - exiting monitoring loop gracefully")+                    self._update_tool_execution_status(+                        status=ToolExecutionStatus.STOPPED,+                        error="Shutdown signal received"+                    )+                    break+                 # Remember current position                 where = f.tell()                 line = f.readline()

Note: You may also want to check the flag at line 249 (during the sleep) to ensure more responsive shutdown during idle periods.

runner/src/unstract/runner/runner.py (1)

292-321:The generated shell script lacks signal handling for graceful shutdown.

The_get_container_command method builds a shell script that runs the tool command, but it doesn't include signal forwarding or trap handlers. With the removal ofdumb-init (line 458) andexec inentrypoint.sh, this shell script needs explicit signal management to enable graceful shutdown.

To support graceful shutdown after removingdumb-init, add signal forwarding to the generated shell script:

def _get_container_command(    self, shared_log_dir: str, shared_log_file: str, settings: dict[str, Any]):    """Returns the container command to run the tool."""    settings_json = json.dumps(settings).replace("'", "\\'")    # Prepare the tool execution command    tool_cmd = (        f"python main.py --command RUN "        f"--settings '{settings_json}' --log-level DEBUG"    )    if not self.sidecar_enabled:        return tool_cmd    # Shell script components+   signal_handling = (+       "trap 'kill -TERM $tool_pid 2>/dev/null' TERM INT; "+       "trap 'kill -HUP $tool_pid 2>/dev/null' HUP; "+   )    mkdir_cmd = f"mkdir -p {shared_log_dir}"    run_tool_fn = (        "run_tool() { "        f"{tool_cmd}; "        "exit_code=$?; "        f'echo "{LogFieldName.TOOL_TERMINATION_MARKER} with exit code $exit_code" '        f">> {shared_log_file}; "        "return $exit_code; "        "}"    )-   execute_cmd = f"run_tool > {shared_log_file} 2>&1"+   execute_cmd = f"run_tool > {shared_log_file} 2>&1 & tool_pid=$!; wait $tool_pid"    # Combine all commands-   shell_script = f"{mkdir_cmd} && {run_tool_fn}; {execute_cmd}"+   shell_script = f"{mkdir_cmd} && {signal_handling} {run_tool_fn}; {execute_cmd}"    return shell_script

This ensures signals are forwarded to the Python process for proper graceful shutdown handling.

unstract/sdk1/src/unstract/sdk1/tool/entrypoint.py (1)

16-25:Critical: Ignoring SIGTERM/SIGINT breaks container orchestration and prevents graceful shutdown.

The PR objectives state this change "Fixed graceful shutdown in tool container to ensure in-progress tasks complete", but settingsignal.SIG_IGN does the opposite—it tells the OS to ignore shutdown signals entirely. This creates several critical problems:

1. Container orchestration failure: Container platforms (Kubernetes, Docker) send SIGTERM to request graceful shutdown. If the process ignores SIGTERM, the platform waits for a grace period (typically 30s) then sends SIGKILL, forcefully terminating the container. This defeats the purpose of graceful shutdown.

2. Misleading behavior: The comment states "prevents the signal from interrupting the current operation," but the signal hasalready interrupted execution (that's why the handler was invoked). SettingSIG_IGN only affectsfuture signals, not the current one.

3. No actual shutdown logic: After the handler returns, control goes back to the interrupted code with no shutdown mechanism. The process continues indefinitely until force-killed.

For proper graceful shutdown in a container environment, you should:

• Let the signal handler set a flag or trigger shutdown logic
• Allow the current operation to complete naturally
• Exit the process cleanly so the container terminates with exit code 0

Apply this diff to implement proper graceful shutdown:

+# Global flag for graceful shutdown+_shutdown_requested = False+ class ToolEntrypoint:     """Class that contains methods for the entrypoint for a tool."""      @staticmethod     def _signal_handler(signum: int, _frame: types.FrameType | None) -> None:         """Handle SIGTERM and SIGINT signals."""+        global _shutdown_requested         sig = signal.Signals(signum)         signal_name = sig.name         logger.warning(f"RECEIVED SIGNAL: {signal_name}")-        logger.warning("Allowing tool to complete current operation...")--        # Ignore the signal to allow the process to continue-        # This prevents the signal from interrupting the current operation-        signal.signal(signum, signal.SIG_IGN)+        logger.warning("Initiating graceful shutdown after current operation...")+        _shutdown_requested = True

Then check the flag afterexecutor.execute(parsed_args) completes:

     parsed_args = ToolArgsParser.parse_args(args)     executor = ToolExecutor(tool=tool)     executor.execute(parsed_args)++    # Exit cleanly if shutdown was requested+    if _shutdown_requested:+        logger.info("Shutdown completed gracefully")+        sys.exit(0)

Additionally, the executor's long-running operations should periodically check_shutdown_requested and break/cleanup when set.