feat(sentry): Enhance error tracking with operation context and 500 handler

ENHANCEMENTS:
- Generic 500 exception handler captures all unhandled errors
- Operation context tagging (indexing, search)
- Search errors now captured with query context
- track_background_task decorator for async jobs
- sentry_operation context manager for scoped tracking

NEW HELPERS:
- set_operation_context(): Tag current operation
- capture_http_exception(): For custom exception handlers
- track_background_task(): Decorator for async functions

All 49 tests passing.

Author: DevanshuNEU

backend/main.py

@@ -112,3 +112,18 @@ async def rate_limit_handler(request: Request, exc):
         status_code=429,
         content={"detail": "Rate limit exceeded. Please try again later."}
     )
+
+
+@app.exception_handler(Exception)
+async def generic_exception_handler(request: Request, exc: Exception):
+    """
+    Catch-all handler for unhandled exceptions.
+    Captures to Sentry and returns 500.
+    """
+    from services.sentry import capture_http_exception
+    capture_http_exception(request, exc, 500)
+    
+    return JSONResponse(
+        status_code=500,
+        content={"detail": "Internal server error"}
+    )

backend/services/indexer_optimized.py

@@ -194,6 +194,9 @@ def _extract_functions(self, tree_node, source_code: bytes) -> List[Dict]:
 
     async def index_repository(self, repo_id: str, repo_path: str):
         """Index all code in a repository - OPTIMIZED VERSION"""
+        from services.sentry import set_operation_context, capture_exception
+        
+        set_operation_context("indexing", repo_id=repo_id)
         start_time = time.time()
         print(f"\n🚀 Starting optimized indexing for repo: {repo_id}")
         print(f"📂 Path: {repo_path}")
@@ -386,6 +389,8 @@ async def semantic_search(
             return formatted_results[:max_results]
 
         except Exception as e:
+            from services.sentry import capture_exception
+            capture_exception(e, operation="search", repo_id=repo_id, query=query[:100])
             print(f"❌ Error searching: {e}")
             return []
 

backend/services/sentry.py

@@ -3,7 +3,13 @@
 Provides production error visibility and performance monitoring
 """
 import os
-from typing import Optional
+import functools
+from typing import Optional, Callable, Any
+from contextlib import contextmanager
+
+
+# Global flag to track if Sentry is initialized
+_sentry_initialized = False
 
 
 def init_sentry() -> bool:
@@ -13,6 +19,7 @@ def init_sentry() -> bool:
     Returns:
         bool: True if Sentry was initialized, False otherwise
     """
+    global _sentry_initialized
     sentry_dsn = os.getenv("SENTRY_DSN")
 
     if not sentry_dsn:
@@ -30,13 +37,13 @@ def init_sentry() -> bool:
             dsn=sentry_dsn,
             environment=environment,
 
-            # Performance monitoring - sample 10% of transactions in production
+            # Performance monitoring - sample 10% in production, 100% in dev
             traces_sample_rate=0.1 if environment == "production" else 1.0,
 
             # Profile 10% of sampled transactions
             profiles_sample_rate=0.1,
 
-            # Send PII like user IDs (we need this for debugging)
+            # Send PII like user IDs (needed for debugging)
             send_default_pii=True,
 
             # Integrations
@@ -48,10 +55,11 @@ def init_sentry() -> bool:
             # Filter out health check noise
             before_send=_filter_events,
 
-            # Don't send in debug mode
+            # Debug logging in development
             debug=environment == "development",
         )
 
+        _sentry_initialized = True
         print(f"✅ Sentry initialized (environment: {environment})")
         return True
 
@@ -64,58 +72,115 @@ def init_sentry() -> bool:
 
 
 def _filter_events(event, hint):
-    """
-    Filter out noisy events before sending to Sentry.
-    """
+    """Filter out noisy events before sending to Sentry."""
     # Don't send health check errors
-    if "health" in event.get("request", {}).get("url", ""):
+    request_url = event.get("request", {}).get("url", "")
+    if "/health" in request_url:
         return None
 
     # Don't send 404s for common bot paths
     if event.get("exception"):
-        exception_value = str(event["exception"].get("values", [{}])[0].get("value", ""))
-        bot_paths = ["/wp-admin", "/wp-login", "/.env", "/config", "/admin"]
-        if any(path in exception_value for path in bot_paths):
-            return None
+        values = event["exception"].get("values", [{}])
+        if values:
+            exception_value = str(values[0].get("value", ""))
+            bot_paths = ["/wp-admin", "/wp-login", "/.env", "/config", "/admin", "/phpmyadmin"]
+            if any(path in exception_value for path in bot_paths):
+                return None
 
     return event
 
 
+# ---------------------------------------------------------------------------
+# User Context
+# ---------------------------------------------------------------------------
+
 def set_user_context(user_id: Optional[str] = None, email: Optional[str] = None):
     """
     Set user context for error tracking.
-    Call this after authentication to attach user info to errors.
-    
-    Args:
-        user_id: The authenticated user's ID
-        email: The user's email (optional)
+    Call after authentication to attach user info to errors.
     """
+    if not _sentry_initialized:
+        return
+    
     try:
         import sentry_sdk
         sentry_sdk.set_user({
             "id": user_id,
             "email": email,
         })
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Operation Context (for tagging operations like indexing, search)
+# ---------------------------------------------------------------------------
+
+@contextmanager
+def sentry_operation(operation: str, **tags):
+    """
+    Context manager to tag operations with context.
+    
+    Usage:
+        with sentry_operation("indexing", repo_id="abc", repo_name="zustand"):
+            # do indexing work
+            # any errors here will have repo_id and repo_name tags
+    """
+    if not _sentry_initialized:
+        yield
+        return
+    
+    try:
+        import sentry_sdk
+        with sentry_sdk.push_scope() as scope:
+            scope.set_tag("operation", operation)
+            for key, value in tags.items():
+                scope.set_tag(key, str(value))
+            yield
     except ImportError:
-        pass  # Sentry not installed
+        yield
 
 
+def set_operation_context(operation: str, **tags):
+    """
+    Set operation context without context manager.
+    Useful when you can't use 'with' statement.
+    """
+    if not _sentry_initialized:
+        return
+    
+    try:
+        import sentry_sdk
+        sentry_sdk.set_tag("operation", operation)
+        for key, value in tags.items():
+            sentry_sdk.set_tag(key, str(value))
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Exception Capture
+# ---------------------------------------------------------------------------
+
 def capture_exception(error: Exception, **extra_context):
     """
     Manually capture an exception with additional context.
     
     Args:
         error: The exception to capture
-        **extra_context: Additional context to attach
+        **extra_context: Additional context (repo_id, operation, etc.)
     """
+    if not _sentry_initialized:
+        return
+    
     try:
         import sentry_sdk
         with sentry_sdk.push_scope() as scope:
             for key, value in extra_context.items():
                 scope.set_extra(key, value)
             sentry_sdk.capture_exception(error)
-    except ImportError:
-        pass  # Sentry not installed
+    except Exception:
+        pass
 
 
 def capture_message(message: str, level: str = "info", **extra_context):
@@ -125,13 +190,116 @@ def capture_message(message: str, level: str = "info", **extra_context):
     Args:
         message: The message to capture
         level: Severity level (info, warning, error)
-        **extra_context: Additional context to attach
+        **extra_context: Additional context
     """
+    if not _sentry_initialized:
+        return
+    
     try:
         import sentry_sdk
         with sentry_sdk.push_scope() as scope:
             for key, value in extra_context.items():
                 scope.set_extra(key, value)
             sentry_sdk.capture_message(message, level=level)
-    except ImportError:
-        pass  # Sentry not installed
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Background Task Decorator
+# ---------------------------------------------------------------------------
+
+def track_background_task(operation: str):
+    """
+    Decorator to track background tasks and capture any errors.
+    
+    Usage:
+        @track_background_task("indexing")
+        async def index_repository(repo_id: str):
+            # any unhandled exception here will be captured with context
+    """
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs) -> Any:
+            if not _sentry_initialized:
+                return await func(*args, **kwargs)
+            
+            try:
+                import sentry_sdk
+                with sentry_sdk.push_scope() as scope:
+                    scope.set_tag("operation", operation)
+                    scope.set_tag("background_task", "true")
+                    # Add function args as context
+                    scope.set_extra("args", str(args)[:500])
+                    scope.set_extra("kwargs", str(kwargs)[:500])
+                    
+                    try:
+                        return await func(*args, **kwargs)
+                    except Exception as e:
+                        sentry_sdk.capture_exception(e)
+                        raise  # Re-raise so caller knows it failed
+            except ImportError:
+                return await func(*args, **kwargs)
+        
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs) -> Any:
+            if not _sentry_initialized:
+                return func(*args, **kwargs)
+            
+            try:
+                import sentry_sdk
+                with sentry_sdk.push_scope() as scope:
+                    scope.set_tag("operation", operation)
+                    scope.set_tag("background_task", "true")
+                    scope.set_extra("args", str(args)[:500])
+                    scope.set_extra("kwargs", str(kwargs)[:500])
+                    
+                    try:
+                        return func(*args, **kwargs)
+                    except Exception as e:
+                        sentry_sdk.capture_exception(e)
+                        raise
+            except ImportError:
+                return func(*args, **kwargs)
+        
+        # Return appropriate wrapper based on function type
+        if asyncio_iscoroutinefunction(func):
+            return async_wrapper
+        return sync_wrapper
+    
+    return decorator
+
+
+def asyncio_iscoroutinefunction(func):
+    """Check if function is async."""
+    import asyncio
+    return asyncio.iscoroutinefunction(func)
+
+
+# ---------------------------------------------------------------------------
+# HTTP Exception Handler Helper
+# ---------------------------------------------------------------------------
+
+def capture_http_exception(request, exc, status_code: int):
+    """
+    Capture HTTP exceptions that would otherwise be swallowed.
+    Call this from FastAPI exception handlers for 500+ errors.
+    
+    Args:
+        request: FastAPI request object
+        exc: The exception
+        status_code: HTTP status code being returned
+    """
+    # Only capture server errors (5xx)
+    if status_code < 500 or not _sentry_initialized:
+        return
+    
+    try:
+        import sentry_sdk
+        with sentry_sdk.push_scope() as scope:
+            scope.set_tag("http_status", str(status_code))
+            scope.set_extra("path", str(request.url.path))
+            scope.set_extra("method", request.method)
+            sentry_sdk.capture_exception(exc)
+    except Exception:
+        pass