feat: add memory monitoring script and documentation

- Introduced a new Python script for monitoring system memory
  usage and alerting users when specific thresholds are exceeded.
- Added a .gitignore file to exclude unnecessary files from version
  control.
- Created a README file with documentation on usage, features,
  requirements, and configuration options.

Author: asrul10

.gitignore

@@ -0,0 +1,29 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Logs
+*.log
+
+# Virtual environments
+venv/
+.venv/
+env/
+ENV/
+
+# OS specific files
+.DS_Store
+Thumbs.db
+
+# Project specific
+*.bak

main.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+
+import logging
+import time
+
+import psutil
+
+
+def main():
+    setup_logging()
+
+    # Track how long memory has been high
+    high_memory_min_duration = 120
+    high_memory_threshold = 80
+
+    print("Memory Monitor Started...")
+    print("Monitoring for:")
+    print(
+        f"  - Memory usage > {high_memory_threshold}% for {high_memory_min_duration // 60} minutes"
+    )
+    print("  - Swap memory usage")
+    print("  - OOM kill events")
+
+    high_memory_start_time = None
+
+    while True:
+        try:
+            check_memory_usage(
+                high_memory_start_time,
+                duration=high_memory_min_duration,
+                threshold=high_memory_threshold,
+            )
+            check_swap_usage()
+            check_oom_kills()
+            time.sleep(10)  # Check every 10 seconds
+        except KeyboardInterrupt:
+            print("Memory monitoring stopped.")
+            break
+        except Exception as e:
+            logging.error(f"Error during monitoring: {e}")
+
+
+def setup_logging():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(levelname)s - %(message)s",
+        filename="memory_monitor.log",
+    )
+
+
+def check_memory_usage(high_memory_start_time, **kwargs):
+    mem = psutil.virtual_memory()
+    mem_percent = mem.percent
+    duration = kwargs.get("duration", 120)
+    threshold = kwargs.get("threshold", 80)
+
+    if mem_percent > threshold:
+        if high_memory_start_time is None:
+            high_memory_start_time = time.time()
+            logging.warning(f"Memory usage high: {mem_percent:.1f}%")
+        else:
+            duration = time.time() - high_memory_start_time
+            if duration >= duration:
+                logging.critical(
+                    f"HIGH MEMORY ALERT: {mem_percent:.1f}% for {duration:.0f} seconds"
+                )
+    else:
+        if high_memory_start_time is not None:
+            logging.info(f"Memory usage returned to normal: {mem_percent:.1f}%")
+            high_memory_start_time = None
+
+    return high_memory_start_time
+
+
+def check_swap_usage():
+    swap = psutil.swap_memory()
+    if swap.used > 0:
+        swap_percent = swap.percent
+        logging.warning(
+            f"Swap memory in use: {swap.used / (1024**3):.2f} GB ({swap_percent:.1f}%)"
+        )
+        print(
+            f"ALERT: Swap memory in use: {swap.used / (1024**3):.2f} GB ({swap_percent:.1f}%)"
+        )
+
+
+def check_oom_kills():
+    try:
+        with open("/proc/vmstat", "r") as f:
+            for line in f:
+                if "oom_kill" in line:
+                    parts = line.strip().split()
+                    if len(parts) >= 2 and int(parts[1]) > 0:
+                        logging.critical(f"OOM kill detected: {parts[1]} occurrences")
+    except Exception as e:
+        logging.error(f"Error checking OOM kills: {e}")
+
+
+if __name__ == "__main__":
+    main()

readme.md

@@ -0,0 +1,57 @@
+# Memory Monitor
+
+A lightweight Python utility that monitors system memory usage and alerts when memory thresholds are exceeded.
+
+## Features
+
+- Monitors system memory usage in real-time
+- Alerts when memory usage exceeds configurable thresholds for extended periods
+- Detects and reports swap memory usage
+- Monitors for OOM (Out Of Memory) kill events
+- Logs all events to a log file for later analysis
+
+## Requirements
+
+- Python 3.6+
+- psutil library
+
+## Installation
+
+1. Clone this repository or download the script:
+
+```bash
+git clone https://github.com/asrul10/simple-memory-monitor.git
+cd simple-memory-monitor
+```
+
+2. Install the required dependencies:
+
+```bash
+pip install psutil
+```
+
+## Usage
+
+Run the script with Python:
+
+```bash
+python main.py
+```
+
+The script will start monitoring your system memory and provide alerts when:
+- Memory usage exceeds 80% for 2 minutes or more
+- Any swap memory is being used
+- OOM kill events are detected
+
+All alerts are displayed in the console and also logged to `memory_monitor.log`.
+
+## Configuration
+
+You can modify the following variables in the `main()` function to adjust monitoring thresholds:
+
+- `high_memory_threshold`: Percentage of memory usage that triggers an alert (default: 80%)
+- `high_memory_min_duration`: Minimum duration in seconds that memory must remain high to trigger an alert (default: 120 seconds)
+
+## Log File
+
+The script creates a log file named `memory_monitor.log` in the same directory. This file contains all monitoring events with timestamps.