upd: data is automatically collected into the database every 5 minutes

Author: Oget565

app/core/__pycache__/bot.cpython-312.pyc

@@ -3,14 +3,24 @@
 from aiogram import Bot, Dispatcher
 
 from app.handlers.basic import register_basic_handlers
+from app.services.metrics import wait_for_clock
 
 async def main():
     bot = Bot(token=os.getenv("BOT_TOKEN"))
     dp = Dispatcher()
 
     register_basic_handlers(dp)
 
-    await dp.start_polling(bot)
+    metrics_task = asyncio.create_task(wait_for_clock())
+
+    try:
+        await dp.start_polling(bot)
+    finally:
+        metrics_task.cancel()
+        try:
+            await metrics_task
+        except asyncio.CancelledError:
+            pass
 
 if __name__ == "__main__":
     asyncio.run(main())

app/core/bot.py

@@ -1,27 +1,48 @@
 import sqlite3
 import time
+from pathlib import Path
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+
+DB_PATH = Path(__file__).resolve().parent / 'server_metrics.db'
+DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+# Thread pool for async database operations
+_executor = ThreadPoolExecutor(max_workers=1)
+
+def _save_to_db_sync(data):
+    with sqlite3.connect(DB_PATH) as connection:
+        cursor = connection.cursor()
+
+        create_query = '''
+        CREATE TABLE IF NOT EXISTS Metrics (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp INTEGER NOT NULL,
+            mem_total REAL,
+            mem_used REAL,
+            mem_prcnt REAL,
+            cpu_prcnt REAL,
+            cpu_freq REAL,
+            cpu_temp REAL
+        );
+        '''
+        cursor.execute(create_query)
+
+        ts = int(time.time())
+
+        insert_query = '''
+        INSERT INTO Metrics (timestamp, mem_total, mem_used, mem_prcnt, cpu_prcnt, cpu_freq, cpu_temp)
+        VALUES (?, ?, ?, ?, ?, ?, ?);
+        '''
+        params = (ts, data['mem_total'], data['mem_used'], data['mem_prcnt'],
+                  data['cpu_prcnt'], data['cpu_freq'], data['cpu_temp'])
+        cursor.execute(insert_query, params)
+        connection.commit()
+
+    print("Success")
+
+async def save_to_db(data):
+    """Async wrapper for database operations to avoid blocking the event loop"""
+    loop = asyncio.get_event_loop()
+    await loop.run_in_executor(_executor, _save_to_db_sync, data)
 
-with sqlite3.connect('server_metrics.db') as connection:
-    cursor = connection.cursor()
-
-    create_query = '''
-    CREATE TABLE IF NOT EXISTS Metrics (
-        timestamp INTEGER PRIMARY KEY,
-        cpu REAL,
-        ram REAL,
-        temp REAL
-    );
-    '''
-    cursor.execute(create_query)
-
-    ts = int(time.time())
-    metrics = (ts, '23.5', '45.7', '43.2')
-
-    insert_query = '''
-    INSERT INTO Metrics (timestamp, cpu, ram, temp)
-    VALUES (?, ?, ?, ?);
-    '''
-    cursor.execute(insert_query, metrics)
-    connection.commit()
-
-print("Success")

app/database/database.py

@@ -0,0 +1,11 @@
+import asyncio
+
+class Clock:
+    clock_event = asyncio.Event()
+
+    async def five_min_clock(self):
+        while True:
+            self.clock_event.set()
+            await asyncio.sleep(0)
+            self.clock_event.clear()
+            await asyncio.sleep(300)

app/filters/__pycache__/owner.cpython-312.pyc

@@ -1,3 +1,6 @@
+import asyncio
+from app.services.clock import Clock
+from app.database.database import save_to_db
 import psutil
 p = psutil
 
@@ -23,7 +26,7 @@ async def get_resources(self):
                     self.cpu_temp = round(sum([c.current for c in cores]) / len(cores), 1)
                     break
 
-    async def pack_resources(self):
+    def pack_resources(self):
         resources = {
             'mem_total': self.mem_total,
             'mem_used': self.mem_used,
@@ -33,4 +36,18 @@ async def pack_resources(self):
             'cpu_temp': self.cpu_temp
         }
 
-        return resources
+        return resources
+
+async def wait_for_clock():
+    clock = Clock()
+    asyncio.create_task(clock.five_min_clock())
+
+    res = Resources()
+
+    while True:
+        await Clock.clock_event.wait()
+        Clock.clock_event.clear()  # Clear the event after processing
+        await res.get_resources()
+        data = res.pack_resources()
+        await save_to_db(data)
+        print("saved")