chore: website ping time in human readable format

Author: codeperfectplus

app.py

@@ -1,12 +1,10 @@
 from src.config import app
 from src import routes
-from src.thread_process import monitor_settings, start_website_monitoring
+from src.background_task import start_website_monitoring, monitor_settings
 
 # background thread to monitor system settings changes
-# monitor_settings()  # Starts monitoring for system logging changes
-# start_website_monitoring()  # Starts pinging active websites
+monitor_settings()  # Starts monitoring for system logging changes
+start_website_monitoring()  # Starts pinging active websites
 
 if __name__ == "__main__":
-
-    # Run the Flask application
-    app.run(host="0.0.0.0", port=5000, debug=True)
+    app.run(host="0.0.0.0", port=5000, debug=False)

src/background_task/__init__.py

@@ -0,0 +1,4 @@
+from src.background_task.monitor_website import start_website_monitoring
+from src.background_task.log_system_info import monitor_settings
+
+__all__ = ["start_website_monitoring", "monitor_settings"]

src/background_task/log_system_info.py

@@ -0,0 +1,107 @@
+import os
+import datetime
+from threading import Timer
+from src.config import app, db
+from src.utils import _get_system_info
+from src.logger import logger
+from src.models import GeneralSettings, SystemInformation
+from sqlalchemy.exc import SQLAlchemyError
+from src.logger import logger
+
+# Flag to check if logging is already scheduled
+is_logging_scheduled = False
+
+
+def log_system_info():
+    """
+    Logs system information at regular intervals based on the general settings.
+    This function checks if logging is still active before each logging event.
+    """
+    global is_logging_scheduled
+    with app.app_context():
+        try:
+            # Fetch the general settings to check if logging is enabled
+            general_settings = GeneralSettings.query.first()
+            is_logging_system_info = (
+                general_settings.is_logging_system_info if general_settings else False
+            )
+
+            if not is_logging_system_info:
+                logger.info("System info logging has been stopped.")
+                is_logging_scheduled = False  # Reset the flag if logging stops
+                return
+
+            log_system_info_to_db()
+            logger.debug("System information logged successfully.")
+
+            # Schedule the next log after 60 seconds
+            Timer(60, log_system_info).start()
+
+        except Exception as e:
+            logger.error(f"Error during system info logging: {e}", exc_info=True)
+            is_logging_scheduled = False  # Reset the flag in case of an error
+
+
+def log_system_info_to_db():
+    """
+    Fetches system information and logs it to the database.
+    """
+    with app.app_context():
+        try:
+            system_info = _get_system_info()
+            system_log = 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"],
+                dashboard_memory_usage=system_info["dashboard_memory_usage"],
+                cpu_frequency=system_info["cpu_frequency"],
+                current_temp=system_info["current_temp"],
+                timestamp=datetime.datetime.now(),
+            )
+            db.session.add(system_log)
+            db.session.commit()
+            logger.info("System information logged to database.")
+
+        except SQLAlchemyError as db_err:
+            logger.error(
+                f"Database error while logging system info: {db_err}", exc_info=True
+            )
+            db.session.rollback()
+        except Exception as e:
+            logger.error(f"Failed to log system information: {e}", exc_info=True)
+
+def monitor_settings():
+    """
+    Monitors application general settings for changes and controls system logging dynamically.
+    This function runs periodically to check for updates to logging settings.
+    """
+    global is_logging_scheduled
+    with app.app_context():
+        try:
+            # Fetch the general settings
+            general_settings = GeneralSettings.query.first()
+
+            # Check if logging should be active or not
+            is_logging_system_info = (
+                general_settings.is_logging_system_info if general_settings else False
+            )
+            if is_logging_system_info:
+                logger.info("System logging enabled. Starting system info logging.")
+
+                # Schedule logging only if not already scheduled
+                if not is_logging_scheduled:
+                    logger.debug("Scheduling system info logging.")
+                    Timer(0, log_system_info).start()
+                    is_logging_scheduled = True
+            else:
+                logger.info("System logging disabled. Stopping system info logging.")
+                is_logging_scheduled = False  # Reset the flag if logging is disabled
+
+            # Check settings periodically (every 10 seconds)
+            Timer(10, monitor_settings).start()
+
+        except SQLAlchemyError as db_err:
+            logger.error(f"Error fetching settings: {db_err}", exc_info=True)
+

src/background_task/monitor_website.py

@@ -0,0 +1,147 @@
+import os
+import datetime
+from threading import Timer
+from flask import url_for
+from src.config import app, db
+from src.utils import _get_system_info
+from src.logger import logger
+from src.models import MonitoredWebsite, GeneralSettings, SystemInformation
+from sqlalchemy.exc import SQLAlchemyError
+import requests
+from src.scripts.email_me import send_smtp_email
+from src.logger import logger
+from src.utils import render_template_from_file, ROOT_DIR
+from src.config import get_app_info
+
+# Dictionary to track the last known status of each website
+website_status = {}
+
+def send_mail(website_name, status, email_adress, email_alerts_enabled):
+    """
+    Dummy function to simulate sending an email.
+
+    Args:
+        website_name (str): The name or URL of the website.
+        status (str): The status of the website, either 'DOWN' or 'UP'.
+    """
+    # This is a dummy function, so no real email is sent.
+    if email_alerts_enabled:
+        context = {
+            "website_status": status,  # UP/DOWN
+            "website_name": website_name,
+            "checked_time": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "message": f"{website_name} is now {status}",
+            "title": get_app_info()["title"],
+        }
+        website_status_template = os.path.join(
+            ROOT_DIR, "src/templates/email_templates/website_monitor_status.html"
+        )
+        email_subject = f"{website_name} is now {status}"
+        email_body = render_template_from_file(website_status_template, **context)
+        send_smtp_email(email_adress, email_subject, email_body, is_html=True)
+
+
+def update_website_status(website, status):
+    """
+    Updates the status of the website and sends an email notification if the status has changed.
+
+    Args:
+        website (MonitoredWebsite): The website object to update.
+        status (str): The new status of the website.
+    """
+    global website_status
+
+    if website.id not in website_status:
+        website_status[website.id] = "UP"  # Initialize with UP status if not present
+
+    if website_status[website.id] != status:
+        send_mail(
+            website.name, status, website.email_address, website.email_alerts_enabled
+        )
+        website_status[website.id] = status
+
+
+def ping_website(website):
+    """
+    Pings a single website and updates its status in the database.
+
+    Args:
+        website (MonitoredWebsite): The website object to ping.
+    """
+    with app.app_context():
+        try:
+            # Check if the website is still active
+            updated_website = MonitoredWebsite.query.get(website.id)
+            if not updated_website or not updated_website.is_ping_active:
+                logger.info(
+                    f"Website {website.name} is no longer active. Stopping monitoring."
+                )
+                return
+
+            logger.info(
+                f"Pinging {website.name} (Interval: {website.ping_interval}s)..."
+            )
+            response = requests.get(website.name, timeout=10)
+            updated_website.last_ping_time = datetime.datetime.now()
+            updated_website.ping_status_code = response.status_code
+
+            new_status = "UP" if response.status_code == 200 else "DOWN"
+            updated_website.ping_status = new_status
+
+            # Update the website status
+            db.session.commit()
+            logger.info(f"Website {website.name} updated successfully.")
+
+            # Determine if an email should be sent
+            update_website_status(website, new_status)
+
+        except requests.RequestException as req_err:
+            updated_website.ping_status = "DOWN"
+            logger.error(f"Failed to ping {website.name}: {req_err}", exc_info=True)
+            db.session.rollback()
+
+        except SQLAlchemyError as db_err:
+            logger.error(
+                f"Database commit error for {website.name}: {db_err}", exc_info=True
+            )
+            db.session.rollback()
+
+        finally:
+            # Add more detailed logging for debugging
+            if db.session.new or db.session.dirty:
+                logger.warning(
+                    f"Database transaction not committed properly for {website.name}."
+                )
+
+            # Schedule the next ping for this website
+            Timer(
+                updated_website.ping_interval, ping_website, args=[updated_website]
+            ).start()
+
+def start_website_monitoring():
+    """
+    Periodically pings monitored websites based on individual ping intervals.
+    """
+    with app.app_context():
+        try:
+            while True:
+                active_websites = MonitoredWebsite.query.filter_by(
+                    is_ping_active=True
+                ).all()
+                if not active_websites:
+                    logger.info("No active websites to monitor.")
+                else:
+                    for website in active_websites:
+                        # Start pinging each website individually based on its ping interval
+                        Timer(0, ping_website, args=[website]).start()
+
+                # Check for active websites periodically (every 30 seconds)
+                Timer(30, start_website_monitoring).start()
+                break  # Break out of the loop to avoid creating a new thread infinitely
+
+        except SQLAlchemyError as db_err:
+            logger.error(
+                f"Database error during website monitoring: {db_err}", exc_info=True
+            )
+        except Exception as e:
+            logger.error(f"Error during website monitoring: {e}", exc_info=True)

src/thread_process.py renamed to src/background_task/thread_process.py

@@ -1,3 +1,5 @@
+# deprecated file
+
 import os
 import datetime
 from threading import Timer
@@ -121,6 +123,33 @@ def ping_website(website):
                 updated_website.ping_interval, ping_website, args=[updated_website]
             ).start()
 
+def start_website_monitoring():
+    """
+    Periodically pings monitored websites based on individual ping intervals.
+    """
+    with app.app_context():
+        try:
+            while True:
+                active_websites = MonitoredWebsite.query.filter_by(
+                    is_ping_active=True
+                ).all()
+                if not active_websites:
+                    logger.info("No active websites to monitor.")
+                else:
+                    for website in active_websites:
+                        # Start pinging each website individually based on its ping interval
+                        Timer(0, ping_website, args=[website]).start()
+
+                # Check for active websites periodically (every 30 seconds)
+                Timer(30, start_website_monitoring).start()
+                break  # Break out of the loop to avoid creating a new thread infinitely
+
+        except SQLAlchemyError as db_err:
+            logger.error(
+                f"Database error during website monitoring: {db_err}", exc_info=True
+            )
+        except Exception as e:
+            logger.error(f"Error during website monitoring: {e}", exc_info=True)
 
 def monitor_settings():
     """
@@ -217,30 +246,3 @@ def log_system_info_to_db():
             logger.error(f"Failed to log system information: {e}", exc_info=True)
 
 
-def start_website_monitoring():
-    """
-    Periodically pings monitored websites based on individual ping intervals.
-    """
-    with app.app_context():
-        try:
-            while True:
-                active_websites = MonitoredWebsite.query.filter_by(
-                    is_ping_active=True
-                ).all()
-                if not active_websites:
-                    logger.info("No active websites to monitor.")
-                else:
-                    for website in active_websites:
-                        # Start pinging each website individually based on its ping interval
-                        Timer(0, ping_website, args=[website]).start()
-
-                # Check for active websites periodically (every 30 seconds)
-                Timer(30, start_website_monitoring).start()
-                break  # Break out of the loop to avoid creating a new thread infinitely
-
-        except SQLAlchemyError as db_err:
-            logger.error(
-                f"Database error during website monitoring: {db_err}", exc_info=True
-            )
-        except Exception as e:
-            logger.error(f"Error during website monitoring: {e}", exc_info=True)

src/routes/ping.py

@@ -8,11 +8,40 @@
 
 ping_bp = blueprints.Blueprint('ping', __name__)
 
+def time_ago(ping_time, current_time):
+    """
+    Calculate the time difference between the current time and the ping time.
+    Return a human-readable format like '1 min ago' or '30 seconds ago'.
+    
+    Args:
+        ping_time (datetime): The last ping time.
+        current_time (datetime): The current time.
+    
+    Returns:
+        str: A formatted string representing the time ago.
+    """
+    if not ping_time:
+        return "Never"
+
+    # Calculate the difference in seconds
+    time_diff = (current_time - ping_time).total_seconds()
+    
+    if time_diff <= 120:  # Less than or equal to 2 minutes
+        if time_diff <= 60:
+            return f"{int(time_diff)} seconds ago"
+        return f"{int(time_diff // 60)} min ago"
+    
+    # Fallback to formatted datetime if over 2 minutes
+    return ping_time.strftime('%Y-%m-%d %H:%M:%S')
+
 # Route to view and add websites
 @app.route('/monitor_websites')
 @login_required
 def monitor_websites():
     websites = MonitoredWebsite.query.all()
+    current_time = datetime.datetime.now()
+    for website in websites:
+        website.last_ping_time_ago = time_ago(website.last_ping_time, current_time)
     return render_template('ping/ping.html', websites=websites)
 
 # Route to add a website