Print curl command on embedding timeout with DEBUG mode and proper thread cleanup (#11)

Co-authored-by: Mte90 <[email protected]>
Co-authored-by: copilot-swe-agent[bot] <[email protected]>

Author: Copilot

.env.example

@@ -40,3 +40,7 @@ FILE_WATCHER_INTERVAL=10
 
 # Debounce time in seconds before processing detected changes (default: 5, minimum: 1)
 FILE_WATCHER_DEBOUNCE=5
+
+# Debug configuration
+# Enable debug mode to generate bash scripts with curl commands on timeout (default: false)
+DEBUG=false

ai/openai.py

@@ -136,6 +136,68 @@ def __init__(self,
             self.session.headers.update({"Authorization": f"Bearer {self.api_key}"})
         self.session.headers.update({"Content-Type": "application/json"})
 
+    def _generate_curl_command(self, url: str, headers: Dict[str, str], payload: Dict[str, Any]) -> str:
+        """
+        Generate a curl command for debugging purposes.
+        Masks the API key for security.
+        """
+        # Start with basic curl command
+        curl_parts = ["curl", "-X", "POST", f"'{url}'"]
+        
+        # Add headers
+        for key, value in headers.items():
+            if key.lower() == "authorization" and value:
+                # Mask the API key for security
+                if value.startswith("Bearer "):
+                    masked_value = f"Bearer <API_KEY_MASKED>"
+                else:
+                    masked_value = "<API_KEY_MASKED>"
+                curl_parts.append(f"-H '{key}: {masked_value}'")
+            else:
+                curl_parts.append(f"-H '{key}: {value}'")
+        
+        # Add data payload
+        payload_json = json.dumps(payload)
+        # Escape single quotes in the JSON for shell compatibility
+        payload_json_escaped = payload_json.replace("'", "'\\''")
+        curl_parts.append(f"-d '{payload_json_escaped}'")
+        
+        return " \\\n  ".join(curl_parts)
+
+    def _save_curl_script(self, curl_command: str, request_id: str, file_path: str, chunk_index: int) -> Optional[str]:
+        """
+        Save curl command to a bash script in /tmp for debugging.
+        Returns the path to the generated script, or None if save failed.
+        """
+        try:
+            import tempfile
+            # Create a unique filename based on request_id
+            script_name = f"embedding_debug_{request_id[:8]}.sh"
+            script_path = os.path.join("/tmp", script_name)
+            
+            # Generate script content with shebang and comments
+            script_content = f"""#!/bin/bash
+# Embedding request debug script
+# Request ID: {request_id}
+# File: {file_path}
+# Chunk: {chunk_index}
+# Generated: {time.strftime('%Y-%m-%d %H:%M:%S')}
+
+{curl_command}
+"""
+            
+            with open(script_path, 'w') as f:
+                f.write(script_content)
+            
+            # Make the script executable
+            os.chmod(script_path, 0o755)
+            
+            return script_path
+        except Exception as e:
+            _embedding_logger.warning(f"Failed to save curl debug script: {e}")
+            return None
+
+
     def _log_request_start(self, request_id: str, file_path: str, chunk_index: int, chunk_len: int):
         _embedding_logger.debug(
             "Embedding request START",
@@ -244,7 +306,38 @@ def embed_text(self, text: str, file_path: str = "<unknown>", chunk_index: int =
             except requests.Timeout as e:
                 elapsed = time.perf_counter() - start
                 err_msg = f"Timeout after {elapsed:.2f}s: {e}"
-                _embedding_logger.error("Embedding API Timeout", extra={"request_id": request_id, "error": str(e)})
+                
+                # Generate curl command for debugging
+                curl_command = self._generate_curl_command(self.api_url, dict(self.session.headers), payload)
+                
+                # Save to bash script in /tmp if DEBUG is enabled
+                script_path = None
+                if CFG.get("debug"):
+                    script_path = self._save_curl_script(curl_command, request_id, file_path, chunk_index)
+                
+                _embedding_logger.error(
+                    "Embedding API Timeout",
+                    extra={
+                        "request_id": request_id,
+                        "error": str(e),
+                        "elapsed_s": elapsed,
+                        "curl_command": curl_command,
+                        "debug_script": script_path
+                    }
+                )
+                
+                # Print to console for easy debugging
+                print(f"\n{'='*80}")
+                print(f"Embedding request timed out after {elapsed:.2f}s")
+                print(f"Request ID: {request_id}")
+                print(f"File: {file_path}, Chunk: {chunk_index}")
+                if script_path:
+                    print(f"\nDebug script saved to: {script_path}")
+                    print(f"Run with: bash {script_path}")
+                else:
+                    print(f"\nDebug with this curl command:")
+                    print(curl_command)
+                print(f"{'='*80}\n")
             except requests.RequestException as e:
                 elapsed = time.perf_counter() - start
                 err_msg = f"RequestException after {elapsed:.2f}s: {e}\n{traceback.format_exc()}"

db/db_writer.py

@@ -22,7 +22,7 @@ def __init__(self, database_path, timeout_seconds=30):
         self.database_path = database_path
         self._q = queue.Queue()
         self._stop = threading.Event()
-        self._thread = threading.Thread(target=self._worker, daemon=True, name=f"DBWriter-{database_path}")
+        self._thread = threading.Thread(target=self._worker, daemon=False, name=f"DBWriter-{database_path}")
         self._timeout_seconds = timeout_seconds
         self._thread.start()
         _LOG.info(f"DBWriter started for database: {database_path}")

main.py

@@ -9,9 +9,12 @@
 import sys
 import tempfile
 import uvicorn
+import signal
+import atexit
 
 from db import operations as db_operations
 from db.operations import get_or_create_project
+from db.db_writer import stop_all_writers
 from utils.config import CFG
 from utils.logger import get_logger
 from endpoints.project_endpoints import router as project_router
@@ -25,6 +28,42 @@
 _file_watcher = None
 
 
+def cleanup_on_exit():
+    """Cleanup function called on exit or error."""
+    global _file_watcher
+    
+    logger.info("Cleaning up resources...")
+    
+    # Stop FileWatcher
+    if _file_watcher:
+        try:
+            _file_watcher.stop(timeout=2.0)
+            _file_watcher = None
+            logger.info("FileWatcher stopped")
+        except Exception as e:
+            logger.error(f"Error stopping FileWatcher: {e}")
+    
+    # Stop all database writers
+    try:
+        stop_all_writers()
+        logger.info("Database writers stopped")
+    except Exception as e:
+        logger.error(f"Error stopping database writers: {e}")
+
+
+def signal_handler(signum, frame):
+    """Handle termination signals."""
+    logger.info(f"Received signal {signum}, shutting down...")
+    cleanup_on_exit()
+    sys.exit(0)
+
+
+# Register cleanup handlers
+atexit.register(cleanup_on_exit)
+signal.signal(signal.SIGINT, signal_handler)
+signal.signal(signal.SIGTERM, signal_handler)
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Application lifespan handler."""
@@ -96,7 +135,8 @@ async def lifespan(app: FastAPI):
 
     yield
 
-    # Stop FileWatcher on shutdown
+    # Cleanup is handled by atexit and signal handlers
+    # Just ensure FileWatcher stops gracefully here
     if _file_watcher:
         try:
             _file_watcher.stop()

utils/config.py

@@ -42,4 +42,7 @@ def _bool_env(name, default):
     "file_watcher_enabled": _bool_env("FILE_WATCHER_ENABLED", True),
     "file_watcher_interval": _int_env("FILE_WATCHER_INTERVAL", 10),
     "file_watcher_debounce": _int_env("FILE_WATCHER_DEBOUNCE", 5),
+    
+    # Debug configuration
+    "debug": _bool_env("DEBUG", False),
 }

utils/file_watcher.py

@@ -123,7 +123,7 @@ def start(self) -> None:
         self._thread = threading.Thread(
             target=self._watch_loop,
             name="FileWatcher",
-            daemon=True
+            daemon=False
         )
         self._thread.start()
         self.logger.info("FileWatcher started")