Refactor system info logging and metrics collection

- Refactor the `log_system_info` function to check if system info logging is enabled before scheduling the next log.
- Add a new function `is_logging_enabled` to check if system info logging is enabled in the general settings.
- Add a new function `schedule_next_log` to schedule the next logging event after a specified interval.
- Update the `log_system_info_to_db` function to also update Prometheus metrics with the latest system information.
- Add a new function `update_prometheus_metrics` to update Prometheus metrics with the latest system information.
- Add a new function `store_system_info_in_db` to store the collected system information into the database.
- Remove the unused `monitor_settings` function.

Fix memory info route and template

- Add the `dashboard_memory_usage` value to the `memory_info` dictionary in the `memory_usage` function.
- Update the `memory_info.html` template to include the `dashboard_memory` card component.

Remove unused code from Prometheus route

- Remove the unused code for collecting system metrics and updating Prometheus gauges.

Author: codeperfectplus

src/background_task/log_system_info.py

@@ -6,102 +6,142 @@
 from src.logger import logger
 from src.models import GeneralSettings, SystemInformation
 from sqlalchemy.exc import SQLAlchemyError
-from src.logger import logger
+from prometheus_client import Counter, Gauge
 
-# Flag to check if logging is already scheduled
+# Flag to track if logging is already scheduled
 is_logging_scheduled = False
 
+# Initialize Prometheus metrics
+metrics = {
+    'cpu_usage_metric': Gauge('cpu_usage_percentage', 'Current CPU usage percentage'),
+    'memory_usage_metric': Gauge('memory_usage_percentage', 'Current memory usage percentage'),
+    'disk_usage_metric': Gauge('disk_usage_percentage', 'Disk usage percentage'),
+    'network_sent_metric': Gauge('network_bytes_sent', 'Total network bytes sent'),
+    'network_recv_metric': Gauge('network_bytes_received', 'Total network bytes received'),
+    'cpu_temp_metric': Gauge('cpu_temperature', 'Current CPU temperature'),
+    'cpu_frequency_metric': Gauge('cpu_frequency', 'Current CPU frequency'),
+    'battery_percentage_metric': Gauge('battery_percentage', 'Current battery percentage'),
+    'dashboard_memory_usage_metric': Gauge('dashboard_memory_usage_percentage', 'Current memory usage percentage'),
+    'request_count': Counter('http_requests_total', 'Total HTTP requests made')
+}
 
 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.
+    This function checks if logging is enabled and schedules the next log if active.
     """
     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:
+            if not is_logging_enabled():
                 logger.info("System info logging has been stopped.")
-                is_logging_scheduled = False  # Reset the flag if logging stops
+                is_logging_scheduled = False
                 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()
+            schedule_next_log()
 
         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
+            is_logging_scheduled = False
+
+
+def is_logging_enabled():
+    """
+    Checks if system info logging is enabled in the general settings.
+    """
+    try:
+        general_settings = GeneralSettings.query.first()
+        return general_settings.is_logging_system_info if general_settings else False
+    except SQLAlchemyError as e:
+        logger.error(f"Error fetching general settings: {e}", exc_info=True)
+        return False
+
+
+def schedule_next_log(interval=60):
+    """
+    Schedules the next logging event after the specified interval (in seconds).
+    """
+    Timer(interval, log_system_info).start()
 
 
 def log_system_info_to_db():
     """
-    Fetches system information and logs it to the database.
+    Fetches system information and logs it to the database and updates Prometheus metrics.
     """
     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()
+
+            # Update Prometheus metrics
+            update_prometheus_metrics(system_info)
+
+            # Store system information in the database
+            store_system_info_in_db(system_info)
             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
-            )
+            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 update_prometheus_metrics(system_info):
+    """
+    Updates Prometheus metrics with the latest system information.
+    """
+    metrics['cpu_usage_metric'].set(system_info['cpu_percent'])
+    metrics['memory_usage_metric'].set(system_info['memory_percent'])
+    metrics['disk_usage_metric'].set(system_info['disk_percent'])
+    metrics['network_sent_metric'].set(system_info['network_sent'])
+    metrics['network_recv_metric'].set(system_info['network_received'])
+    metrics['cpu_temp_metric'].set(system_info['current_temp'])
+    metrics['cpu_frequency_metric'].set(system_info['cpu_frequency'])
+    metrics['battery_percentage_metric'].set(system_info['battery_percent'])
+    metrics['dashboard_memory_usage_metric'].set(system_info['dashboard_memory_usage'])
+    metrics['request_count'].inc()
+
+
+def store_system_info_in_db(system_info):
+    """
+    Stores the collected system information into the database.
+    """
+    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()
+
+
 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:
+            if is_logging_enabled():
                 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
+                is_logging_scheduled = False
 
-            # Check settings periodically (every 10 seconds)
+            # Recheck settings 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/routes/memory_info.py

@@ -2,7 +2,7 @@
 from flask_login import login_required
 
 from src.config import app
-from src.utils import get_cached_value, get_memory_percent, get_memory_available, get_memory_used, get_swap_memory_info
+from src.utils import get_cached_value, get_memory_percent, get_memory_available, get_memory_used, get_swap_memory_info, get_flask_memory_usage
 from src.routes.helper.common_helper import check_page_toggle
 
 memory_info_bp = blueprints.Blueprint("memory_usage", __name__)
@@ -17,6 +17,7 @@ def memory_usage():
         "memory_percent": get_memory_percent(),
         "memory_available": memory_available,
         "memory_used": get_memory_used(),
+        'dashboard_memory_usage': get_flask_memory_usage(),
     }
 
     swap_info = get_swap_memory_info()

src/routes/prometheus.py

@@ -1,60 +1,10 @@
 from flask import Blueprint, Response
-from prometheus_client import Counter, Gauge, generate_latest
-import threading
-import time
+from prometheus_client import generate_latest
 from src.config import app
-from src.utils import _get_system_info
 
 # Define the Prometheus Blueprint
 prometheus_bp = Blueprint('prometheus', __name__)
 
-# Initialize Prometheus metrics
-cpu_usage_metric = Gauge('cpu_usage_percentage', 'Current CPU usage percentage')
-memory_usage_metric = Gauge('memory_usage_percentage', 'Current memory usage percentage')
-disk_usage_metric = Gauge('disk_usage_percentage', 'Disk usage percentage')
-network_sent_metric = Gauge('network_bytes_sent', 'Total network bytes sent')
-network_recv_metric = Gauge('network_bytes_received', 'Total network bytes received')
-request_count = Counter('http_requests_total', 'Total HTTP requests made')
-cpu_temp_metric = Gauge('cpu_temperature', 'Current CPU temperature')
-cpu_frequency_metric = Gauge('cpu_frequency', 'Current CPU frequency')
-battery_percentage_metric = Gauge('battery_percentage', 'Current battery percentage')
-dashboard_memory_usage_metric = Gauge('dashboard_memory_usage_percentage', 'Current memory usage percentage')
-
-
-def collect_metrics():
-    """
-    Collect system metrics and update Prometheus Gauges.
-    Runs in a separate thread and updates metrics every 5 seconds.
-    """
-    while True:
-        try:
-            # Gather system information
-            system_info = _get_system_info()
-
-            # Update Prometheus metrics
-            cpu_usage_metric.set(system_info['cpu_percent'])
-            memory_usage_metric.set(system_info['memory_percent'])
-            disk_usage_metric.set(system_info['disk_percent'])
-            network_sent_metric.set(system_info['network_sent'])
-            network_recv_metric.set(system_info['network_received'])
-            cpu_temp_metric.set(system_info['current_temp'])
-            cpu_frequency_metric.set(system_info['cpu_frequency'])
-            battery_percentage_metric.set(system_info['battery_percent'])
-            dashboard_memory_usage_metric.set(system_info['dashboard_memory_usage'])
-
-
-            # Increment HTTP request counter
-            request_count.inc()
-        except Exception as e:
-            print(f"Error collecting metrics: {e}")
-
-        # Sleep for 5 seconds before the next collection
-        time.sleep(10)
-
-# Start the metrics collection in a background thread
-metrics_thread = threading.Thread(target=collect_metrics, daemon=True)
-metrics_thread.start()
-
 # Define a route to serve Prometheus metrics
 @app.route('/metrics')
 def metrics():

src/templates/info_pages/memory_info.html

@@ -14,6 +14,9 @@ <h2 class="my-4">Memory
     <div class="col-md-6 col-lg-4 mb-4">
         {% include 'card_comp/memory/used.html' %}
     </div>
+    <div class="col-md-6 col-lg-4 mb-4">
+        {% include 'card_comp/memory/dashboard_memory.html' %}
+    </div>
     <div class="col-md-6 col-lg-4 mb-4">
         {% include 'card_comp/memory/swap_total.html' %}
     </div>