Improve auth redirects, AI moderation, and cache handling

Redirect authenticated users from login/register to dashboard. Increase AI moderator chunk size and add early exit on rejection for faster moderation. Expand result cache size and TTL, refine aggressive cleanup to only remove expired entries, and add warnings when cache is full but no expired entries are found.

Author: Bentlybro

app/routes/auth.py

@@ -13,6 +13,10 @@
 
 @auth_bp.route('/login', methods=['GET', 'POST'])
 async def login():
+    # Redirect to dashboard if already logged in
+    if current_user.is_authenticated:
+        return redirect(url_for('dashboard.index'))
+
     if request.method == 'POST':
         # Input validation and sanitization
         if request.is_json:
@@ -97,6 +101,10 @@ async def login():
 
 @auth_bp.route('/register', methods=['GET', 'POST'])
 async def register():
+    # Redirect to dashboard if already logged in
+    if current_user.is_authenticated:
+        return redirect(url_for('dashboard.index'))
+
     # Check if registration is enabled
     if not SystemSettings.is_registration_enabled():
         flash('Registration is currently disabled. Please contact an administrator.', 'error')

app/services/ai/ai_moderator.py

@@ -308,7 +308,8 @@ def moderate_content(self, content, content_type='text', custom_prompt=None):
             if custom_prompt:
                 # CRITICAL FIX: Hard limit on character count (tiktoken is broken for some content)
                 # Assume worst case: 1 char = 1 token for safety
-                MAX_CHARS_PER_CHUNK = 50000  # ~50k tokens worst case, safe for any prompt
+                # Increased from 50k to 100k for better performance (fewer chunks = faster)
+                MAX_CHARS_PER_CHUNK = 100000  # ~100k tokens worst case, safe for large context models
                 content_chars = len(content)
 
                 # Force chunking if content is too large BY CHARACTER COUNT
@@ -331,11 +332,25 @@ def moderate_content(self, content, content_type='text', custom_prompt=None):
                             for i, chunk in enumerate(chunks)
                         }
 
-                        # Collect results as they complete
+                        # Collect results as they complete with early exit on rejection
                         for future in as_completed(future_to_chunk):
                             result = future.result()
                             chunk_results.append(result)
 
+                            # Early exit: if any chunk is rejected, cancel remaining and return immediately
+                            if result.get('decision') == 'rejected':
+                                current_app.logger.info(
+                                    f"Early exit: Chunk rejected, cancelling {
+                                        len(future_to_chunk) - len(chunk_results)} remaining chunks")
+
+                                # Cancel all pending futures
+                                for f in future_to_chunk:
+                                    if not f.done():
+                                        f.cancel()
+
+                                # Return immediately with rejection
+                                return self._combine_chunk_results(chunk_results, len(content))
+
                     return self._combine_chunk_results(chunk_results, len(content))
                 else:
                     # Content is small enough, process normally
@@ -366,11 +381,26 @@ def moderate_content(self, content, content_type='text', custom_prompt=None):
                         for i, chunk in enumerate(chunks)
                     }
 
-                    # Collect results as they complete
+                    # Collect results as they complete with early exit on rejection
                     for future in as_completed(future_to_chunk):
                         result = future.result()
                         chunk_results.append(result)
 
+                        # Early exit: if any chunk is rejected, cancel remaining and return immediately
+                        if result.get('decision') == 'rejected':
+                            current_app.logger.info(
+                                f"Early exit: Chunk rejected, cancelling {
+                                    len(future_to_chunk) -
+                                    len(chunk_results)} remaining chunks")
+
+                            # Cancel all pending futures
+                            for f in future_to_chunk:
+                                if not f.done():
+                                    f.cancel()
+
+                            # Return immediately with rejection
+                            return self._combine_chunk_results(chunk_results, len(content))
+
                 return self._combine_chunk_results(chunk_results, len(content))
 
         except (openai.APIConnectionError, openai.APITimeoutError, openai.InternalServerError) as e:

app/services/ai/result_cache.py

@@ -13,10 +13,10 @@ class ResultCache:
     _shared_cache_ttl = 3600  # 1 hour
     _current_request_stores = 0  # Track stores per request
     _cache_lock = RLock()  # Thread-safe operations
-    _max_cache_size = 500  # Reduced from 1000 for high-volume deployments
-    _cleanup_threshold = 400  # Start cleanup earlier
+    _max_cache_size = 10000  # Maximum cache entries (increased to handle high volume)
+    _cleanup_threshold = 9000  # Start cleanup when reaching 90% capacity
     _last_cleanup_time = 0
-    _cleanup_interval = 180  # Cleanup every 3 minutes (more frequent)
+    _cleanup_interval = 900  # Check for expired entries every 15 minutes
 
     def __init__(self, cache_ttl=3600):  # 1 hour default
         self._cache_ttl = cache_ttl
@@ -144,24 +144,27 @@ def _cleanup_expired_entries(self):
             current_app.logger.info(f"Cleaned up {len(expired_keys)} expired cache entries")
 
     def _aggressive_cleanup(self):
-        """Perform aggressive cleanup when cache is full"""
+        """Perform aggressive cleanup when cache is full - ONLY remove expired entries"""
         current_time = time.time()
         entries_to_remove = []
 
-        # Remove entries older than 50% of TTL
+        # ONLY remove entries that are actually expired (>= 1 hour old)
+        # This guarantees all entries last at least the full TTL
         for key, data in list(ResultCache._shared_cache.items()):
-            if current_time - data['timestamp'] >= ResultCache._shared_cache_ttl * 0.5:
+            if current_time - data['timestamp'] >= ResultCache._shared_cache_ttl:
                 entries_to_remove.append((key, data['timestamp']))
 
-        # If not enough old entries, remove oldest 25%
-        if len(entries_to_remove) < len(ResultCache._shared_cache) * 0.25:
-            all_entries = [(key, data['timestamp']) for key, data in ResultCache._shared_cache.items()]
-            all_entries.sort(key=lambda x: x[1])  # Sort by timestamp
-            entries_to_remove.extend(all_entries[:len(ResultCache._shared_cache) // 4])
+        # If no expired entries and cache is full, log warning but don't remove valid entries
+        if not entries_to_remove:
+            current_app.logger.warning(
+                f"Cache full at {len(ResultCache._shared_cache)} entries with no expired entries. "
+                "Consider increasing max_cache_size or reducing TTL."
+            )
+            return
 
-        # Remove the entries
+        # Remove the entries (increased limit from 500 to 1000 for larger cache)
         removed_count = 0
-        for key, _ in entries_to_remove[:500]:  # Limit to prevent blocking
+        for key, _ in entries_to_remove[:1000]:  # Limit to prevent blocking
             if ResultCache._shared_cache.pop(key, None) is not None:
                 removed_count += 1