Update app.py

app.py

@@ -1,13 +1,24 @@
 from flask import Flask, request, jsonify
-from transformers import pipeline
 import pandas as pd
 from datetime import datetime, timedelta
 import json
+import logging
+import sys
 
 app = Flask(__name__)
 
-# Initialize Hugging Face summarization pipeline
-summarizer = pipeline("text2text-generation", model="t5-small")
+# Configure logging to diagnose issues
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Try to load Hugging Face summarization pipeline with fallback
+try:
+    from transformers import pipeline
+    summarizer = pipeline("text2text-generation", model="t5-small", framework="pt")
+    logger.info("Hugging Face model 't5-small' loaded successfully.")
+except Exception as e:
+    logger.error(f"Failed to load Hugging Face model: {str(e)}")
+    summarizer = None  # Fallback to skip summarization if model fails
 
 # Helper function to calculate days until AMC expiry
 def days_until_expiry(expiry_date_str):
@@ -15,82 +26,110 @@ def days_until_expiry(expiry_date_str):
         expiry_date = datetime.strptime(expiry_date_str, "%Y-%m-%d")
         current_date = datetime.now()
         return (expiry_date - current_date).days
-    except ValueError:
+    except ValueError as e:
+        logger.warning(f"Invalid date format for AMC expiry: {expiry_date_str}, error: {str(e)}")
         return None
 
-# Helper function to detect anomalies (rule-based)
+# Helper function to detect anomalies (rule-based, simplified)
 def detect_anomalies(logs):
     anomalies = []
     for log in logs:
-        # Rule 1: Flag ERROR status as high severity
-        if log["status"] == "ERROR":
-            anomalies.append({
-                "device_id": log["device_id"],
-                "issue": "ERROR status detected",
-                "detected_on": log["timestamp"],
-                "severity": "high"
-            })
-        # Rule 2: Flag usage spikes (>7 hours as example threshold)
-        if log["usage_hours"] > 7:
-            anomalies.append({
-                "device_id": log["device_id"],
-                "issue": "Usage spike",
-                "detected_on": log["timestamp"],
-                "severity": "high"
-            })
-        # Rule 3: Flag downtime (usage_hours = 0 with DOWN status)
-        if log["status"] == "DOWN" and log["usage_hours"] == 0:
-            anomalies.append({
-                "device_id": log["device_id"],
-                "issue": "Unplanned downtime",
-                "detected_on": log["timestamp"],
-                "severity": "medium"
-            })
+        try:
+            # Rule 1: Flag ERROR status as high severity
+            if log.get("status") == "ERROR":
+                anomalies.append({
+                    "device_id": log.get("device_id", "Unknown"),
+                    "issue": "ERROR status detected",
+                    "detected_on": log.get("timestamp", "N/A"),
+                    "severity": "high"
+                })
+            # Rule 2: Flag usage spikes (>7 hours as example threshold)
+            if log.get("usage_hours", 0) > 7:
+                anomalies.append({
+                    "device_id": log.get("device_id", "Unknown"),
+                    "issue": "Usage spike",
+                    "detected_on": log.get("timestamp", "N/A"),
+                    "severity": "high"
+                })
+            # Rule 3: Flag downtime (usage_hours = 0 with DOWN status)
+            if log.get("status") == "DOWN" and log.get("usage_hours", 0) == 0:
+                anomalies.append({
+                    "device_id": log.get("device_id", "Unknown"),
+                    "issue": "Unplanned downtime",
+                    "detected_on": log.get("timestamp", "N/A"),
+                    "severity": "medium"
+                })
+        except Exception as e:
+            logger.error(f"Error processing log entry {log}: {str(e)}")
     return anomalies
 
 # Helper function to generate AMC reminders
 def generate_amc_reminders(logs):
     reminders = []
     for log in logs:
-        days_left = days_until_expiry(log["amc_expiry"])
-        if days_left is not None and 0 < days_left <= 30:
-            reminders.append({
-                "device_id": log["device_id"],
-                "amc_expiry": log["amc_expiry"],
-                "days_remaining": days_left,
-                "alert": f"AMC expires in {days_left} days"
-            })
+        try:
+            days_left = days_until_expiry(log.get("amc_expiry", ""))
+            if days_left is not None and 0 < days_left <= 30:
+                reminders.append({
+                    "device_id": log.get("device_id", "Unknown"),
+                    "amc_expiry": log.get("amc_expiry", "N/A"),
+                    "days_remaining": days_left,
+                    "alert": f"AMC expires in {days_left} days"
+                })
+        except Exception as e:
+            logger.error(f"Error processing AMC for log {log}: {str(e)}")
     return reminders
 
 # Helper function to summarize logs
 def summarize_logs(logs, prompt):
-    # Convert logs to text for summarization
-    log_text = "\n".join([f"Device {log['device_id']} ({log['log_type']}): Status {log['status']}, Usage {log['usage_hours']} hours, Timestamp {log['timestamp']}, AMC Expiry {log['amc_expiry']}" for log in logs])
-    input_text = f"{prompt}\n\nLogs:\n{log_text}"
-    
-    # Use Hugging Face summarizer
-    summary = summarizer(input_text, max_length=150, min_length=50, do_sample=False)[0]["generated_text"]
-    return summary
+    try:
+        if summarizer is None:
+            logger.warning("Summarizer model not available, returning basic summary.")
+            return "Summary unavailable: Model not loaded. Please check logs for details."
+        
+        # Convert logs to text for summarization
+        log_text = "\n".join([f"Device {log.get('device_id', 'Unknown')} ({log.get('log_type', 'N/A')}): Status {log.get('status', 'N/A')}, Usage {log.get('usage_hours', 0)} hours, Timestamp {log.get('timestamp', 'N/A')}, AMC Expiry {log.get('amc_expiry', 'N/A')}" for log in logs])
+        input_text = f"{prompt}\n\nLogs:\n{log_text}"
+        
+        # Use Hugging Face summarizer
+        summary = summarizer(input_text, max_length=150, min_length=50, do_sample=False)[0]["generated_text"]
+        return summary
+    except Exception as e:
+        logger.error(f"Error generating summary: {str(e)}")
+        return f"Summary unavailable: {str(e)}"
 
 # API endpoint to process logs
 @app.route("/process-logs", methods=["POST"])
 def process_logs():
     try:
         data = request.get_json()
+        if not data or "logs" not in data:
+            logger.error("Invalid or missing logs in request.")
+            return jsonify({"error": "No logs provided in the request"}), 400
+
         logs = data.get("logs", [])
         prompt = data.get("prompt", "Summarize downtime and usage patterns for SmartLab-1 from May 1 to May 14")
 
         if not logs:
-            return jsonify({"error": "No logs provided"}), 400
+            logger.error("Empty logs list provided.")
+            return jsonify({"error": "Logs list is empty"}), 400
 
         # Convert logs to DataFrame for analysis
-        df = pd.DataFrame(logs)
-        
+        try:
+            df = pd.DataFrame(logs)
+        except Exception as e:
+            logger.error(f"Failed to convert logs to DataFrame: {str(e)}")
+            return jsonify({"error": f"Invalid log format: {str(e)}"}), 400
+
         # Calculate summary metrics
-        total_devices = len(df["device_id"].unique())
-        avg_uptime = len(df[df["status"] == "OK"]) / len(df) * 100 if len(df) > 0 else 0
-        downtime_events = len(df[df["status"] == "DOWN"])
-        most_used_device = df.groupby("device_id")["usage_hours"].sum().idxmax() if not df.empty else "N/A"
+        try:
+            total_devices = len(df["device_id"].unique())
+            avg_uptime = len(df[df["status"] == "OK"]) / len(df) * 100 if len(df) > 0 else 0
+            downtime_events = len(df[df["status"] == "DOWN"])
+            most_used_device = df.groupby("device_id")["usage_hours"].sum().idxmax() if not df.empty else "N/A"
+        except Exception as e:
+            logger.error(f"Error calculating summary metrics: {str(e)}")
+            total_devices, avg_uptime, downtime_events, most_used_device = 0, 0, 0, "N/A"
 
         # Generate outputs
         summary = {
@@ -124,6 +163,7 @@ Generated on: {datetime.now().strftime('%Y-%m-%d')}
 {text_summary}
 """
 
+        logger.info("Successfully processed logs and generated response.")
         return jsonify({
             "summary": summary,
             "anomalies": anomalies,
@@ -132,7 +172,9 @@ Generated on: {datetime.now().strftime('%Y-%m-%d')}
         })
 
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
+        logger.error(f"Unexpected error in process_logs: {str(e)}")
+        return jsonify({"error": f"Internal server error: {str(e)}"}), 500
 
 if __name__ == "__main__":
+    logger.info(f"Starting Flask app with Python version {sys.version}")
     app.run(debug=True, host="0.0.0.0", port=5000)