chore: logger added and naming variable improved

Author: codeperfectplus

app.py

@@ -6,8 +6,8 @@
 from src import routes
 from src.utils import get_system_info_for_db
 from src.models import SystemInformation, ApplicationGeneralSettings
-from src.scripts.email_me import send_smpt_email
-from flask import current_app
+from sqlalchemy.exc import SQLAlchemyError
+from src.logger import logger
 
 def register_routes():
     app.register_blueprint(routes.dashboard_bp)
@@ -20,34 +20,65 @@ def register_routes():
     app.register_blueprint(routes.speedtest_bp)
     app.register_blueprint(routes.process_bp)
 
+
 def log_system_info():
-    with app.app_context():  # Ensure Flask app context is available
-        general_settings = ApplicationGeneralSettings.query.first()
-        is_logging_system_info = general_settings.is_logging_system_info
-        print("Is logging system info: ", is_logging_system_info)
-        if not is_logging_system_info:
-            return 
-        while True:
-                system_info = get_system_info_for_db()
-                info = SystemInformation(
-                    cpu_percent=system_info["cpu_percent"],
-                    memory_percent=system_info["memory_percent"],
-                    battery_percent=system_info["battery_percent"],
-                    network_sent=system_info["network_sent"],
-                    network_received=system_info["network_received"],
-                    timestamp=datetime.datetime.now(),
-                )
-                print("Logging system information")
-                db.session.add(info)
-                db.session.commit()  # Commit to save the data in the database
-                time.sleep(60)
+    """
+    Function to log system information at regular intervals if logging is enabled in the general settings.
+    """
+    with app.app_context():  # Push app context for this thread
+        try:
+            # Fetch general settings once at the beginning
+            general_settings = ApplicationGeneralSettings.query.first()
+            is_logging_system_info = general_settings.is_logging_system_info if general_settings else False
+
+            logger.info("Is logging system info: %s", is_logging_system_info)
+            if not is_logging_system_info:
+                logger.warning("Logging is disabled in the settings.")
+                return
+
+            while is_logging_system_info:
+                logger.debug("Fetching and logging system information.")
+                log_data()
+
+                # Sleep for 60 seconds before logging the next set of data
+                time.sleep(2)
+
+        except KeyboardInterrupt:
+            logger.info("Logging system info interrupted by user.")
+        except Exception as e:
+            logger.error(f"Error while logging system info: {e}", exc_info=True)
+
+
+def log_data():
+    """
+    Function to log system information to the database.
+    """
+    try:
+        system_info = get_system_info_for_db()
+        info = SystemInformation(
+            cpu_percent=system_info["cpu_percent"],
+            memory_percent=system_info["memory_percent"],
+            battery_percent=system_info["battery_percent"],
+            network_sent=system_info["network_sent"],
+            network_received=system_info["network_received"],
+            timestamp=datetime.datetime.now(),
+        )
+        db.session.add(info)
+        db.session.commit()
+        logger.info("System information logged successfully.")
+    except SQLAlchemyError as db_err:
+        logger.error(f"Database error: {db_err}")
+        db.session.rollback()  # Ensure DB rollback on failure
+    except Exception as e:
+        logger.error(f"Failed to log system info: {e}", exc_info=True)
+
 
 if __name__ == "__main__":
     register_routes()
 
-    # Start the memory-consuming program in a separate thread
+    # Start the system logging thread
     memory_thread = threading.Thread(target=log_system_info, daemon=True)
     memory_thread.start()
 
     # Run the Flask application
-    app.run(host="0.0.0.0", port=5000)
+    app.run(host="0.0.0.0", port=5000, debug=True)

src/logger.py

@@ -0,0 +1,33 @@
+import logging
+from logging.handlers import RotatingFileHandler
+import os
+
+# Create a logs directory if it doesn't exist
+if not os.path.exists('logs'):
+    os.makedirs('logs')
+
+# Log Formatter with datetime, log level, and message
+formatter = logging.Formatter(
+    '%(asctime)s - %(levelname)s - %(message)s', 
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+
+# File handler for logging to a file
+file_handler = RotatingFileHandler(
+    'logs/app_debug.log', 
+    maxBytes=10 * 1024 * 1024,  # 10 MB per log file
+    backupCount=5  # Keep up to 5 old log files
+)
+file_handler.setLevel(logging.DEBUG)
+file_handler.setFormatter(formatter)
+
+# Set up the logger
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)  # Log everything (DEBUG, INFO, WARNING, etc.)
+logger.addHandler(file_handler)
+
+# Optionally, add console output for real-time debugging (optional)
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.INFO)
+console_handler.setFormatter(formatter)
+logger.addHandler(console_handler)

src/models/__init__.py

@@ -8,7 +8,7 @@
 from src.models.network_speed_test_result import NetworkSpeedTestResult
 from src.models.system_information import SystemInformation
 from src.models.user_profile import UserProfile
-from src.models.ping import Website
+from src.models.monitored_website import MonitoredWebsite
 from flask_login import current_user
 from werkzeug.security import generate_password_hash
 import json

src/models/monitored_website.py

@@ -0,0 +1,15 @@
+from src.config import db
+
+
+class MonitoredWebsite(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(255), nullable=False)
+    ping_interval = db.Column(db.Integer, nullable=False)  # in seconds
+    is_ping_active = db.Column(db.Boolean, default=True)  # True: ping the site, False: do not ping
+    ping_status = db.Column(db.String(50), nullable=True)  # Stores 'UP' or 'DOWN'
+    ping_status_code = db.Column(db.Integer, nullable=True)
+    last_ping_time = db.Column(db.DateTime, nullable=True)
+    email_alerts_enabled = db.Column(db.Boolean, default=False)
+
+    def __repr__(self):
+        return f'<Website {self.name} - Ping Every {self.ping_interval}s>'

src/models/ping.py

@@ -2,75 +2,90 @@
 from threading import Timer
 from flask import render_template, request, redirect, url_for, blueprints, flash
 from src.config import app, db
-from src.models.ping import Website
+from src.models.monitored_website import MonitoredWebsite
+from flask_login import login_required
 import requests
 
 ping_bp = blueprints.Blueprint('ping', __name__)
 
 # Route to view and add websites
-@app.route('/ping')
-def ping_website():
-    websites = Website.query.all()
+@app.route('/monitor_websites')
+@login_required
+def monitor_websites():
+    websites = MonitoredWebsite.query.all()
     return render_template('ping/ping.html', websites=websites)
 
 # Route to add a website
-@app.route('/add_website', methods=['POST'])
+@app.route('/add_monitored_website', methods=['POST'])
+@login_required
 def add_website():
     name = request.form['name']
-    ping_period = int(request.form['ping_period'])
-    website = Website(name=name, ping_period=ping_period, is_ping=True)
+    ping_interval = int(request.form['ping_interval'])
+    email_alerts_enabled = request.form.get('email_alerts_enabled') == 'on'
+    website = MonitoredWebsite(name=name, ping_interval=ping_interval, is_ping_active=True, email_alerts_enabled=email_alerts_enabled)
     db.session.add(website)
     db.session.commit()
-    return redirect(url_for('ping_website'))
+    return redirect(url_for('monitor_websites'))
 
-@app.route('/remove_website/<int:website_id>', methods=['POST'])
+@app.route('/delete_monitored_website/<int:website_id>', methods=['POST'])
+@login_required
 def remove_website(website_id):
-    website = Website.query.get_or_404(website_id)
+    website = MonitoredWebsite.query.get_or_404(website_id)
     db.session.delete(website)
     db.session.commit()
     flash('Website removed successfully!', 'danger')
-    return redirect(url_for('ping_website'))
+    return redirect(url_for('monitor_websites'))
 
-@app.route('/edit_website/<int:website_id>', methods=['GET', 'POST'])
+@app.route('/edit_monitored_website/<int:website_id>', methods=['GET', 'POST'])
 def edit_website(website_id):
-    website = Website.query.get_or_404(website_id)
+    website = MonitoredWebsite.query.get_or_404(website_id)
     if request.method == 'POST':
         website.name = request.form['name']
-        website.ping_period = int(request.form['ping_period'])
+        website.ping_interval = int(request.form['ping_interval'])
         db.session.commit()
         flash('Website updated successfully!', 'success')
-        return redirect(url_for('ping_website'))
+        return redirect(url_for('monitor_websites'))
     return render_template('ping/edit_website.html', website=website)
 
 # Route to toggle pinging status
-@app.route('/toggle_ping/<int:website_id>')
+@app.route('/toggle_ping_status/<int:website_id>')
+@login_required
 def toggle_ping(website_id):
-    website = Website.query.get_or_404(website_id)
-    website.is_ping = not website.is_ping
+    website = MonitoredWebsite.query.get_or_404(website_id)
+    website.is_ping_active = not website.is_ping_active
     db.session.commit()
-    return redirect(url_for('ping_website'))
+    return redirect(url_for('monitor_websites'))
+
+@app.route('/toggle_email_alerts/<int:website_id>')
+@login_required
+def toggle_emaail_alerts(website_id):
+    website = MonitoredWebsite.query.get_or_404(website_id)
+    website.email_alerts_enabled = not website.email_alerts_enabled
+    db.session.commit()
+    return redirect(url_for('monitor_websites'))
 
 # Function to ping websites periodically
-def ping_websites():
+def start_website_monitoring():
     with app.app_context():
-        websites = Website.query.filter_by(is_ping=True).all()
+        websites = MonitoredWebsite.query.filter_by(is_ping_active=True).all()
         for website in websites:
             print(f'Pinging {website.name}...')
             try:
                 response = requests.get(website.name, timeout=10)
-                website.last_ping_timestamp = datetime.datetime.now()
+                website.last_ping_time = datetime.datetime.now()
+                website.ping_status_code = response.status_code
                 if response.status_code == 200:
-                    website.last_status = 'UP'
+                    website.ping_status = 'UP'
                 else:
-                    website.last_status = 'DOWN'
+                    website.ping_status = 'DOWN'
             except requests.RequestException:
-                website.last_status = 'Something went wrong'
+                website.ping_status = 'Something went wrong'
 
             db.session.commit()
 
         # Schedule next ping after the minimum interval period
-        min_interval = min([w.ping_period for w in websites]) if websites else 60
-        Timer(min_interval, ping_websites).start()
+        min_interval = min([w.ping_interval for w in websites]) if websites else 60
+        Timer(min_interval, monitor_websites).start()
 
 # Start pinging periodically after server starts
-ping_websites()
+start_website_monitoring()