Update app.py

app.py

@@ -3,102 +3,226 @@ import requests
 import yaml
 import os
 import json
-from datetime import datetime
+from datetime import datetime, timedelta
 import threading
 import time
+import smtplib
+from email.message import EmailMessage
+import matplotlib.pyplot as plt
+import numpy as np
+from collections import defaultdict
 
 # Configuration
 CONFIG_FILE = "config.yaml"
 DATA_FILE = "/data/status.json"
+STATUS_HISTORY = 24 * 60 * 60  # 24 hours in seconds
 
-# Ensure the /data directory exists
-os.makedirs(os.path.dirname(DATA_FILE), exist_ok=True)
-
-def load_config():
-    with open(CONFIG_FILE, "r") as f:
-        return yaml.safe_load(f)["endpoints"]
-
-def load_data():
-    try:
-        with open(DATA_FILE, "r") as f:
-            return json.load(f)
-    except (FileNotFoundError, json.JSONDecodeError):
-        return {}
-
-def save_data(data):
-    try:
-        with open(DATA_FILE, "w") as f:
-            json.dump(data, f)
-    except PermissionError:
-        temp_file = "/tmp/status.json"
-        with open(temp_file, "w") as f:
-            json.dump(data, f)
-
-def check_status(endpoint):
-    try:
-        start = time.time()
-        response = requests.get(endpoint["url"], timeout=10)
-        return {
-            "status": "UP" if response.ok else "DOWN",
-            "response_time": time.time() - start,
-            "error": None
-        }
-    except Exception as e:
-        return {"status": "DOWN", "response_time": None, "error": str(e)}
-
-def update_dashboard():
-    endpoints = load_config()
-    data = load_data()
-    current_time = datetime.now().isoformat()
-    
-    for endpoint in endpoints:
-        result = check_status(endpoint)
-        key = endpoint["name"]
-        if key not in data:
-            data[key] = []
-        data[key].append({
-            "timestamp": current_time,
-            **result
-        })
-    
-    save_data(data)
-    return format_dashboard(data)
-
-def format_dashboard(data):
-    output = []
-    for name, history in data.items():
-        last_check = history[-1] if history else {}
-        uptime = sum(1 for h in history if h["status"] == "UP") / len(history) * 100 if history else 0
-        output.append(
-            f"**{name}**\n"
-            f"Status: {last_check.get('status', 'UNKNOWN')}\n"
-            f"Last Response: {last_check.get('response_time', 'N/A'):.2f}s\n"
-            f"Uptime: {uptime:.1f}%\n"
-        )
-    return "\n".join(output)
-
-def start_background_updates():
-    def worker():
-        while True:
-            update_dashboard()
-            time.sleep(60)
-    
-    thread = threading.Thread(target=worker, daemon=True)
-    thread.start()
+class Monitor:
+    def __init__(self):
+        self.config = self.load_config()
+        self.lock = threading.Lock()
+        self.last_status = {}
+        self.incidents = defaultdict(list)
+        
+    def load_config(self):
+        with open(CONFIG_FILE, "r") as f:
+            config = yaml.safe_load(f)
+        config.setdefault('settings', {})
+        config['settings'].setdefault('check_interval_seconds', 300)
+        return config
+
+    def load_data(self):
+        try:
+            with open(DATA_FILE, "r") as f:
+                return json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            return {}
+
+    def save_data(self, data):
+        with self.lock:
+            try:
+                with open(DATA_FILE, "w") as f:
+                    json.dump(data, f)
+            except Exception as e:
+                print(f"Error saving data: {e}")
+
+    def check_status(self, endpoint):
+        try:
+            start = time.time()
+            response = requests.get(
+                endpoint["url"],
+                timeout=10,
+                headers={'User-Agent': 'StatusMonitor/1.0'}
+            )
+            response_time = time.time() - start
+            return {
+                "status": "UP" if response.ok else "DOWN",
+                "response_time": response_time,
+                "error": None
+            }
+        except Exception as e:
+            return {"status": "DOWN", "response_time": None, "error": str(e)}
+
+    def send_alert(self, endpoint, result):
+        try:
+            msg = EmailMessage()
+            msg.set_content(
+                f"Website {endpoint['name']} is DOWN\n"
+                f"URL: {endpoint['url']}\n"
+                f"Time: {datetime.now().isoformat()}\n"
+                f"Error: {result['error'] or 'Unknown error'}"
+            )
+            msg['Subject'] = f"ALERT: {endpoint['name']} is DOWN"
+            msg['From'] = self.config['settings']['smtp']['from']
+            msg['To'] = ", ".join(self.config['settings']['alert_emails'])
+
+            with smtplib.SMTP(
+                self.config['settings']['smtp']['host'],
+                self.config['settings']['smtp']['port']
+            ) as server:
+                server.starttls()
+                server.login(
+                    self.config['settings']['smtp']['username'],
+                    self.config['settings']['smtp']['password']
+                )
+                server.send_message(msg)
+        except Exception as e:
+            print(f"Failed to send email: {e}")
 
-# Start background updates when app launches
-start_background_updates()
+    def update_status(self):
+        endpoints = self.config['endpoints']
+        data = self.load_data()
+        current_time = datetime.now().isoformat()
+        
+        for endpoint in endpoints:
+            key = endpoint["name"]
+            result = self.check_status(endpoint)
+            
+            # Track incidents
+            if result['status'] != self.last_status.get(key, 'UP'):
+                if result['status'] == 'DOWN':
+                    self.incidents[key].append({
+                        'start': current_time,
+                        'end': None,
+                        'duration': None
+                    })
+                else:
+                    if self.incidents[key] and not self.incidents[key][-1]['end']:
+                        self.incidents[key][-1]['end'] = current_time
+                        start_time = datetime.fromisoformat(self.incidents[key][-1]['start'])
+                        end_time = datetime.fromisoformat(current_time)
+                        self.incidents[key][-1]['duration'] = (end_time - start_time).total_seconds()
+            
+            # Update last status and check if need to send alert
+            if self.last_status.get(key) == 'UP' and result['status'] == 'DOWN':
+                self.send_alert(endpoint, result)
+            self.last_status[key] = result['status']
+            
+            # Update data
+            if key not in data:
+                data[key] = []
+            data[key].append({
+                "timestamp": current_time,
+                **result
+            })
+            
+            # Trim old data
+            cutoff = datetime.now() - timedelta(seconds=STATUS_HISTORY)
+            data[key] = [entry for entry in data[key] 
+                        if datetime.fromisoformat(entry['timestamp']) > cutoff]
 
-# Create Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# Website Status Monitor")
-    status_output = gr.Markdown()
+        self.save_data(data)
+        return data
+
+    def get_metrics(self, data):
+        metrics = {}
+        for name, history in data.items():
+            if not history:
+                continue
+                
+            uptime = sum(1 for h in history if h["status"] == "UP") / len(history)
+            response_times = [h["response_time"] for h in history if h["response_time"] is not None]
+            
+            metrics[name] = {
+                "uptime": uptime,
+                "response_times": response_times,
+                "current_status": history[-1]["status"],
+                "incidents": self.incidents.get(name, [])
+            }
+        return metrics
+
+    def create_plots(self, metrics):
+        plots = {}
+        for name, metric in metrics.items():
+            # Response time plot
+            plt.figure(figsize=(8, 3))
+            plt.plot(metric['response_times'])
+            plt.title(f"{name} Response Times")
+            plt.ylabel("Seconds")
+            plt.xlabel("Last 24h checks")
+            plt.tight_layout()
+            plots[f"{name}_response"] = plt.gcf()
+            plt.close()
+
+            # Uptime plot
+            plt.figure(figsize=(3, 3))
+            plt.pie([metric['uptime'], 1-metric['uptime']],
+                    labels=['Uptime', 'Downtime'],
+                    autopct='%1.1f%%',
+                    colors=['#4CAF50', '#F44336'])
+            plt.title(f"{name} Uptime")
+            plots[f"{name}_uptime"] = plt.gcf()
+            plt.close()
+            
+        return plots
+
+monitor = Monitor()
+
+def background_updates():
+    while True:
+        monitor.update_status()
+        time.sleep(monitor.config['settings']['check_interval_seconds'])
+
+threading.Thread(target=background_updates, daemon=True).start()
+
+with gr.Blocks(title="Website Status Monitor") as demo:
+    gr.Markdown("# 🚦 Website Status Monitor")
+    
+    def update_ui():
+        data = monitor.load_data()
+        metrics = monitor.get_metrics(data)
+        plots = monitor.create_plots(metrics)
+        
+        elements = []
+        for name, metric in metrics.items():
+            with gr.Row():
+                with gr.Column(scale=1):
+                    status_color = "#4CAF50" if metric['current_status'] == 'UP' else "#F44336"
+                    gr.Markdown(f"### {name}\n"
+                               f"**Status:** <span style='color: {status_color}'>"
+                               f"{metric['current_status']}</span>\n"
+                               f"**Last Response:** {np.mean(metric['response_times'][-5:]):.2f}s\n"
+                               f"**24h Uptime:** {metric['uptime']*100:.1f}%")
+                
+                with gr.Column(scale=2):
+                    gr.Plot(plots[f"{name}_response"], label="Response Times")
+                
+                with gr.Column(scale=1):
+                    gr.Plot(plots[f"{name}_uptime"], label="Uptime")
+            
+            with gr.Accordion("Incident History", open=False):
+                if not metric['incidents']:
+                    gr.Markdown("No incidents in past 24 hours")
+                else:
+                    for incident in metric['incidents'][-5:]:
+                        duration = incident['duration'] or "Ongoing"
+                        gr.Markdown(f"**Start:** {incident['start']}\n"
+                                    f"**End:** {incident['end'] or 'Still down'}\n"
+                                    f"**Duration:** {duration}s\n")
+        
+        return elements
     
-    # Initial load
-    demo.load(
-        fn=update_dashboard,
-        outputs=status_output
-    )
+    demo.load(update_ui, outputs=gr.get_all_components())
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT", 7860)))