monitor_system.py

#!/usr/bin/env python3
import time
import argparse
import subprocess
import logging
from datetime import datetime, timedelta
import os
import re
import sys
import yaml

def load_config(config_path):
    if not os.path.exists(config_path):
        print(f"Config file not found: {config_path}", file=sys.stderr)
        sys.exit(1)
    with open(config_path, 'r', encoding='utf-8') as f:
        return yaml.safe_load(f)

def setup_logger(log_file):
    logging.basicConfig(
        level=logging.INFO,
        format="%(asctime)s - %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S",
        handlers=[
            logging.FileHandler(log_file),
        ]
    )
    return logging.getLogger(__name__)

def run(cmd):
    try:
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=10)
        return result.stdout.strip()
    except Exception:
        return ""

def get_memory_info():
    free_out = run("free -b")
    lines = free_out.splitlines()
    if len(lines) < 3:
        return "MEM: N/A | SWAP: N/A | CPU_LOAD: N/A"

    mem = lines[1].split()
    swap = lines[2].split()
    load = run("cat /proc/loadavg").split()[0] if run("cat /proc/loadavg") else "?"

    total_mem = int(mem[1])
    used_mem = int(mem[2])
    total_swap = int(swap[1])
    used_swap = int(swap[2]) if len(swap) > 2 else 0

    mem_pct = (used_mem / total_mem * 100) if total_mem > 0 else 0
    swap_pct = (used_swap / total_swap * 100) if total_swap > 0 else 0

    return (
        f"MEM: {used_mem//1024//1024}M/{total_mem//1024//1024}M ({mem_pct:.1f}%) | "
        f"SWAP: {used_swap//1024//1024}M/{total_swap//1024//1024}M ({swap_pct:.1f}%) | "
        f"CPU_LOAD: {load}"
    )

def get_kernel_events_since(prio, since_seconds):
    cmd = f"journalctl -k -p {prio} -S -{since_seconds}s --no-pager --output=short-iso"
    raw = run(cmd)
    if not raw or "-- No entries --" in raw:
        return ""
    return raw

def get_system_journal_since(prio, since_seconds):
    cmd = f"journalctl -p {prio} -S -{since_seconds}s --no-pager --output=short-iso"
    raw = run(cmd)
    if not raw or "-- No entries --" in raw:
        return ""
    lines = [line for line in raw.splitlines() if "kernel:" not in line]
    return "\n".join(lines)

def check_critical_conditions(config, mem_info_str, kernel_events, journal_events):
    critical = False
    reasons = []

    if config['resources']['enable_resource_check']:
        mem_match = re.search(r"MEM:.*\((\d+\.\d+)%\)", mem_info_str)
        swap_match = re.search(r"SWAP:.*\((\d+\.\d+)%\)", mem_info_str)

        if mem_match:
            mem_pct = float(mem_match.group(1))
            if mem_pct >= config['resources']['mem_usage_percent_threshold']:
                critical = True
                reasons.append(f"Память: {mem_pct:.1f}%")

        if swap_match:
            swap_pct = float(swap_match.group(1))
            if swap_pct >= config['resources']['swap_usage_percent_threshold']:
                critical = True
                reasons.append(f"Swap: {swap_pct:.1f}%")

    if config['events']['enable_kernel_check'] and kernel_events.strip():
        critical = True
        reasons.append("Kernel event")

    if config['events']['enable_journal_check'] and journal_events.strip():
        critical = True
        reasons.append("System event")

    return critical, reasons

def generate_report(config, logger, mem_info, kernel_events, journal_events):
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    report_path = config['report']['output_file'].replace(".txt", f"_{timestamp}.txt")

    report = []
    report.append(f"time: {datetime.now().isoformat()}")
    report.append("")

    report.append("Resource:")
    report.append(mem_info)
    report.append("")

    prio = config['journalctl']['max_priority']
    report.append(f"Kernel event (journalctl -k -p {prio}, last {config['monitoring']['interval_seconds']} sec.):")
    if kernel_events:
        report.extend([f"  • {line}" for line in kernel_events.splitlines()])
    else:
        report.append("  — No event.")
    report.append("")

    report.append(f"System event (journalctl -p {prio}, last {config['monitoring']['interval_seconds']} sec.):")
    if journal_events:
        report.extend([f"  • {line}" for line in journal_events.splitlines()])
    else:
        report.append("  — No event.")
    report.append("")

    full_text = "\n".join(report)

    with open(report_path, "w") as f:
        f.write(full_text)

    logger.info(f"Report saved at: {report_path}")

def main():
    parser = argparse.ArgumentParser(description="Monitoring resourses and logs")
    parser.add_argument("-c", "--config", default="monitor_config.yaml", help="Path to yaml-config")
    args = parser.parse_args()

    config = load_config(args.config)

    logger = setup_logger(config['report']['log_file'])

    interval_sec = config['monitoring']['interval_seconds']
    duration_min = config['monitoring']['duration_minutes']
    end_time = (datetime.now() + timedelta(minutes=duration_min)) if duration_min > 0 else None
    prio = config['journalctl']['max_priority']

    try:
        while True:
            if end_time and datetime.now() >= end_time:
                print("Monitoring was finished.")
                break

            mem_info = get_memory_info()
            kernel_events = get_kernel_events_since(prio, interval_sec)
            journal_events = get_system_journal_since(prio, interval_sec)

            ts = datetime.now().strftime("%H:%M:%S")
            print(f"[{ts}] {mem_info}")
            if kernel_events:
                for line in kernel_events.splitlines():
                    print(f"[{ts}] KERNEL: {line}")
            if journal_events:
                for line in journal_events.splitlines():
                    print(f"[{ts}] JOURNAL: {line}")

            is_critical, reasons = check_critical_conditions(
                config, mem_info, kernel_events, journal_events
            )

            if is_critical:
                logger.info(f"Critical conditions was found: {', '.join(reasons)}")
                generate_report(config, logger, mem_info, kernel_events, journal_events)

            time.sleep(interval_sec)

    except KeyboardInterrupt:
        print("\nMonitoring was stopped.")

if __name__ == "__main__":
    main()