ueifu

app.py

@@ -14,7 +14,8 @@ from flask import Flask, request, jsonify, redirect, url_for, render_template_st
 from pathlib import Path
 import requests
 from typing import List, Dict
-
+import time
+from functools import wraps
 # Import RAG utilities
 from rag_utils import get_comprehensive_context, format_context_for_prompt
 
@@ -98,6 +99,8 @@ def init_db():
     """Initialize database tables - runs once when app starts"""
     con = sql.connect("swift_check.db")
     cur = con.cursor()
+    
+    # Existing tables
     cur.execute("""
     CREATE TABLE IF NOT EXISTS qc_requests (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -142,11 +145,161 @@ def init_db():
         FOREIGN KEY (request_id) REFERENCES qc_requests(id)
     )""")
     
+    # NEW: API Logs table
+    cur.execute("""
+    CREATE TABLE IF NOT EXISTS api_logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        request_id INTEGER,
+        endpoint TEXT NOT NULL,
+        method TEXT NOT NULL,
+        client_ip TEXT,
+        user_agent TEXT,
+        request_data TEXT,
+        response_data TEXT,
+        file_info TEXT,
+        processing_time_ms INTEGER,
+        status_code INTEGER,
+        error_message TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (request_id) REFERENCES qc_requests(id)
+    )""")
+    
     con.commit()
     con.close()
 
 init_db()
+def log_api_request(endpoint, method, request_id=None, file_info=None, processing_time=None, 
+                   status_code=200, error_message=None, request_data=None, response_data=None):
+    """Log API request details to database"""
+    try:
+        con = sql.connect("swift_check.db")
+        cur = con.cursor()
+        
+        # Get client info
+        client_ip = request.remote_addr or 'unknown'
+        user_agent = request.headers.get('User-Agent', 'unknown')[:500]  # Limit length
+        
+        # Truncate large data
+        request_data_str = str(request_data)[:2000] if request_data else None
+        response_data_str = str(response_data)[:1000] if response_data else None
+        file_info_str = str(file_info)[:500] if file_info else None
+        
+        cur.execute("""
+            INSERT INTO api_logs 
+            (request_id, endpoint, method, client_ip, user_agent, request_data, 
+             response_data, file_info, processing_time_ms, status_code, error_message)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, (request_id, endpoint, method, client_ip, user_agent, request_data_str,
+              response_data_str, file_info_str, processing_time, status_code, error_message))
+        
+        con.commit()
+        con.close()
+        
+    except Exception as e:
+        print(f"❌ Failed to log API request: {str(e)}")
+
+def api_logger(endpoint_name):
+    """Decorator to automatically log API requests"""
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            start_time = time.time()
+            
+            try:
+                # Execute the original function
+                result = func(*args, **kwargs)
+                
+                # Calculate processing time
+                processing_time = int((time.time() - start_time) * 1000)
+                
+                # Extract request_id from result if it's a JSON response
+                request_id = None
+                if hasattr(result, 'get_json') and result.get_json():
+                    request_id = result.get_json().get('request_id')
+                elif isinstance(result, tuple) and len(result) > 0:
+                    if hasattr(result[0], 'get_json') and result[0].get_json():
+                        request_id = result[0].get_json().get('request_id')
+                
+                # Get file info if present
+                file_info = None
+                if hasattr(request, 'files') and request.files:
+                    uploaded_files = []
+                    for key, file in request.files.items():
+                        if file and file.filename:
+                            uploaded_files.append(f"{key}:{file.filename}")
+                    if uploaded_files:
+                        file_info = ", ".join(uploaded_files)
+                
+                # Log successful request
+                log_api_request(
+                    endpoint=endpoint_name,
+                    method=request.method,
+                    request_id=request_id,
+                    file_info=file_info,
+                    processing_time=processing_time,
+                    status_code=200,
+                    request_data=_get_safe_request_data(),
+                    response_data=_get_safe_response_data(result)
+                )
+                
+                return result
+                
+            except Exception as e:
+                # Calculate processing time for errors too
+                processing_time = int((time.time() - start_time) * 1000)
+                
+                # Log error
+                log_api_request(
+                    endpoint=endpoint_name,
+                    method=request.method,
+                    processing_time=processing_time,
+                    status_code=500,
+                    error_message=str(e),
+                    request_data=_get_safe_request_data()
+                )
+                
+                # Re-raise the exception
+                raise e
+                
+        return wrapper
+    return decorator
 
+def _get_safe_request_data():
+    """Safely extract request data for logging"""
+    try:
+        if request.content_type and 'application/json' in request.content_type:
+            data = request.get_json()
+            # Remove sensitive data
+            if isinstance(data, dict):
+                safe_data = {k: v for k, v in data.items() if k not in ['password', 'token', 'api_key']}
+                return safe_data
+        elif request.content_type and 'multipart/form-data' in request.content_type:
+            # Get form data but not file contents
+            safe_data = {}
+            for key, value in request.form.items():
+                safe_data[key] = value[:100] if len(str(value)) > 100 else value
+            return safe_data
+        return None
+    except:
+        return None
+
+def _get_safe_response_data(result):
+    """Safely extract response data for logging"""
+    try:
+        if hasattr(result, 'get_json'):
+            data = result.get_json()
+            if isinstance(data, dict):
+                # Keep only essential response fields
+                safe_data = {
+                    'success': data.get('success'),
+                    'request_id': data.get('request_id'),
+                    'parameters_count': data.get('parameters_count'),
+                    'message': data.get('message', '')[:200]  # Truncate message
+                }
+                return safe_data
+        return None
+    except:
+        return None
 def extract_top_level_json_array(text):
     """
     function to extract JSON array from text, handling both raw JSON and code blocks
@@ -1698,6 +1851,7 @@ def index():
     </html>
     """# UPDATED: refine endpoint to respect user requirements
 @app.route("/refine", methods=["POST"])
+@api_logger("/refine")
 def refine_parameters():
     """refine endpoint that respects user intent and requirements"""
     global global_parameters
@@ -1899,6 +2053,7 @@ def refine_parameters():
         return jsonify({"error": str(e)}), 500
 
 @app.route("/edit", methods=["POST"])
+@api_logger("/edit")
 def edit_parameters():
     """Edit endpoint that modifies existing templates precisely as commanded"""
     global global_parameters
@@ -2307,6 +2462,7 @@ def edit_parameters():
     
     
 @app.route("/validate", methods=["POST"])
+@api_logger("/validate")
 def validate_template():
     """Validate an existing template and get suggestions"""
     try:
@@ -2352,6 +2508,7 @@ def validate_template():
         return jsonify({"error": str(e)}), 500
     
 @app.route("/digitize", methods=["POST"])
+@api_logger("/digitize")
 def digitize_checklist():
     """digitization that preserves original document structure without adding extras"""
     print(">> /digitize route called <<")
@@ -2685,7 +2842,290 @@ def get_template_json(request_id):
     except Exception as e:
         print(f"❌ Error in /template/{request_id}: {str(e)}")
         return jsonify({"error": str(e)}), 500
+# ADD THIS NEW ENDPOINT after the existing endpoints
 
+@app.route("/logs", methods=["GET"])
+def view_logs():
+    """View API logs with filtering options"""
+    
+    # Get query parameters for filtering
+    request_id = request.args.get('request_id')
+    endpoint = request.args.get('endpoint')
+    limit = int(request.args.get('limit', 50))
+    
+    if request.headers.get('Accept') == 'application/json' or request.args.get('format') == 'json':
+        try:
+            con = sql.connect("swift_check.db")
+            cur = con.cursor()
+            
+            # Build query with filters
+            query = """
+                SELECT 
+                    l.id, l.request_id, l.endpoint, l.method, l.client_ip,
+                    l.file_info, l.processing_time_ms, l.status_code, 
+                    l.error_message, l.created_at,
+                    r.product_name, r.supplier_name, r.doc_type
+                FROM api_logs l
+                LEFT JOIN qc_requests r ON l.request_id = r.id
+                WHERE 1=1
+            """
+            params = []
+            
+            if request_id:
+                query += " AND l.request_id = ?"
+                params.append(request_id)
+            
+            if endpoint:
+                query += " AND l.endpoint LIKE ?"
+                params.append(f"%{endpoint}%")
+            
+            query += " ORDER BY l.created_at DESC LIMIT ?"
+            params.append(limit)
+            
+            cur.execute(query, params)
+            rows = cur.fetchall()
+            con.close()
+            
+            logs = []
+            for row in rows:
+                logs.append({
+                    "log_id": row[0],
+                    "request_id": row[1],
+                    "endpoint": row[2],
+                    "method": row[3],
+                    "client_ip": row[4],
+                    "file_info": row[5],
+                    "processing_time_ms": row[6],
+                    "status_code": row[7],
+                    "error_message": row[8],
+                    "created_at": row[9],
+                    "product_name": row[10],
+                    "supplier_name": row[11],
+                    "doc_type": row[12]
+                })
+            
+            return jsonify({
+                "success": True,
+                "logs": logs,
+                "total_logs": len(logs),
+                "filters_applied": {
+                    "request_id": request_id,
+                    "endpoint": endpoint,
+                    "limit": limit
+                }
+            })
+            
+        except Exception as e:
+            return jsonify({"error": str(e)}), 500
+    
+    # HTML view
+    try:
+        con = sql.connect("swift_check.db")
+        cur = con.cursor()
+        
+        # Get logs with request details
+        cur.execute("""
+            SELECT 
+                l.id, l.request_id, l.endpoint, l.method, l.client_ip,
+                l.file_info, l.processing_time_ms, l.status_code, 
+                l.error_message, l.created_at,
+                r.product_name, r.supplier_name, r.doc_type
+            FROM api_logs l
+            LEFT JOIN qc_requests r ON l.request_id = r.id
+            ORDER BY l.created_at DESC
+            LIMIT 100
+        """)
+        
+        rows = cur.fetchall()
+        
+        # Get summary statistics
+        cur.execute("""
+            SELECT 
+                endpoint,
+                COUNT(*) as total_requests,
+                AVG(processing_time_ms) as avg_time_ms,
+                COUNT(CASE WHEN status_code >= 400 THEN 1 END) as error_count
+            FROM api_logs
+            GROUP BY endpoint
+            ORDER BY total_requests DESC
+        """)
+        
+        stats = cur.fetchall()
+        con.close()
+        
+        html = """
+        <html>
+        <head>
+            <title>API Logs - Swift Check</title>
+            <style>
+                body { font-family: Arial, sans-serif; margin: 20px; background-color: #f8f9fa; }
+                .container { max-width: 1600px; margin: 0 auto; background: white; padding: 30px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
+                table { border-collapse: collapse; width: 100%; margin-top: 20px; font-size: 12px; }
+                th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+                th { background-color: #007bff; color: white; font-weight: bold; position: sticky; top: 0; }
+                tr:nth-child(even) { background-color: #f2f2f2; }
+                tr:hover { background-color: #e3f2fd; }
+                .success { color: #28a745; font-weight: bold; }
+                .error { color: #dc3545; font-weight: bold; }
+                .endpoint { padding: 3px 8px; border-radius: 12px; font-size: 10px; color: white; }
+                .refine { background: #28a745; }
+                .edit { background: #ffc107; color: black; }
+                .digitize { background: #17a2b8; }
+                .validate { background: #6c757d; }
+                .stats-section { margin: 20px 0; padding: 15px; background: #e8f4f8; border-radius: 8px; }
+                .stats-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; }
+                .stat-card { background: white; padding: 15px; border-radius: 8px; border-left: 4px solid #007bff; }
+                h1 { color: #333; text-align: center; margin-bottom: 30px; }
+                h2 { color: #007bff; }
+                .filter-section { margin: 20px 0; padding: 15px; background: #f8f9fa; border-radius: 8px; }
+                input, select { margin: 5px; padding: 8px; border: 1px solid #ddd; border-radius: 4px; }
+                button { background: #007bff; color: white; padding: 8px 15px; border: none; border-radius: 4px; cursor: pointer; }
+                .file-info { font-style: italic; color: #6c757d; }
+                .time-ms { color: #28a745; font-weight: bold; }
+                .error-msg { color: #dc3545; font-size: 11px; max-width: 200px; overflow: hidden; text-overflow: ellipsis; }
+            </style>
+            <script>
+                function filterLogs() {
+                    const endpoint = document.getElementById('endpointFilter').value;
+                    const status = document.getElementById('statusFilter').value;
+                    
+                    const rows = document.querySelectorAll('.log-row');
+                    rows.forEach(row => {
+                        const rowEndpoint = row.getAttribute('data-endpoint');
+                        const rowStatus = row.getAttribute('data-status');
+                        
+                        let show = true;
+                        if (endpoint && !rowEndpoint.includes(endpoint)) show = false;
+                        if (status && rowStatus !== status) show = false;
+                        
+                        row.style.display = show ? '' : 'none';
+                    });
+                }
+            </script>
+        </head>
+        <body>
+            <div class="container">
+                <h1>📊 API Logs Dashboard</h1>
+                
+                <div class="stats-section">
+                    <h2>📈 Endpoint Statistics</h2>
+                    <div class="stats-grid">
+        """
+        
+        for stat in stats:
+            endpoint, total, avg_time, errors = stat
+            success_rate = ((total - errors) / total * 100) if total > 0 else 0
+            html += f"""
+                        <div class="stat-card">
+                            <h3>{endpoint}</h3>
+                            <p><strong>Total Requests:</strong> {total}</p>
+                            <p><strong>Avg Time:</strong> {avg_time:.1f}ms</p>
+                            <p><strong>Success Rate:</strong> {success_rate:.1f}%</p>
+                            <p><strong>Errors:</strong> {errors}</p>
+                        </div>
+            """
+        
+        html += """
+                    </div>
+                </div>
+                
+                <div class="filter-section">
+                    <h3>🔍 Filter Logs</h3>
+                    <select id="endpointFilter" onchange="filterLogs()">
+                        <option value="">All Endpoints</option>
+                        <option value="refine">Refine</option>
+                        <option value="edit">Edit</option>
+                        <option value="digitize">Digitize</option>
+                        <option value="validate">Validate</option>
+                    </select>
+                    
+                    <select id="statusFilter" onchange="filterLogs()">
+                        <option value="">All Status</option>
+                        <option value="200">Success (200)</option>
+                        <option value="500">Error (500)</option>
+                    </select>
+                    
+                    <button onclick="window.location.reload()">🔄 Refresh</button>
+                    <button onclick="window.location.href='/logs?format=json'">📄 JSON Export</button>
+                </div>
+                
+                <table>
+                    <tr>
+                        <th>Log ID</th>
+                        <th>Request ID</th>
+                        <th>Endpoint</th>
+                        <th>Product</th>
+                        <th>Supplier</th>
+                        <th>File Info</th>
+                        <th>Time (ms)</th>
+                        <th>Status</th>
+                        <th>Client IP</th>
+                        <th>Error</th>
+                        <th>Created At</th>
+                        <th>Actions</th>
+                    </tr>
+        """
+        
+        for row in rows:
+            log_id, request_id, endpoint, method, client_ip, file_info, processing_time, status_code, error_message, created_at, product_name, supplier_name, doc_type = row
+            
+            # Style endpoint
+            endpoint_class = endpoint.replace('/', '').lower()
+            endpoint_badge = f'<span class="endpoint {endpoint_class}">{endpoint}</span>'
+            
+            # Style status
+            status_class = "success" if status_code == 200 else "error"
+            status_text = f'<span class="{status_class}">{status_code}</span>'
+            
+            # Format processing time
+            time_class = "time-ms"
+            if processing_time and processing_time > 5000:
+                time_class += " error"
+            elif processing_time and processing_time > 2000:
+                time_class += " warning"
+            
+            time_text = f'<span class="{time_class}">{processing_time or "N/A"}</span>'
+            
+            # Format file info
+            file_display = f'<span class="file-info">{file_info or "No file"}</span>'
+            
+            # Format error message
+            error_display = f'<span class="error-msg" title="{error_message or ""}">{(error_message or "")[:50]}{"..." if error_message and len(error_message) > 50 else ""}</span>'
+            
+            html += f"""
+                <tr class="log-row" data-endpoint="{endpoint}" data-status="{status_code}">
+                    <td>{log_id}</td>
+                    <td>{request_id or "N/A"}</td>
+                    <td>{endpoint_badge}</td>
+                    <td><strong>{product_name or "N/A"}</strong></td>
+                    <td>{supplier_name or "N/A"}</td>
+                    <td>{file_display}</td>
+                    <td>{time_text}</td>
+                    <td>{status_text}</td>
+                    <td>{client_ip}</td>
+                    <td>{error_display}</td>
+                    <td>{created_at}</td>
+                    <td>
+                        {f'<a href="/preview/{request_id}">Preview</a> <a href="/template/{request_id}">JSON</a>' if request_id else 'N/A'}
+                    </td>
+                </tr>
+            """
+        
+        html += """
+                </table>
+                
+                <div style="margin-top: 20px; text-align: center;">
+                    <button onclick="window.location.href='/history'">📋 View Request History</button>
+                    <button onclick="window.location.href='/'">🏠 Home</button>
+                </div>
+            </div>
+        </body>
+        </html>
+        """
+        return html
+        
+    except Exception as e:
+        return f"<h1>Error</h1><p>{str(e)}</p>", 500
 @app.route("/preview/<int:request_id>", methods=["GET"])
 def preview_page(request_id):
     """preview with better formatting and metadata"""