import tkinter as tk
from tkinter import ttk
import psutil
import threading
import time

class SystemMonitor:
    def __init__(self, root):
        self.root = root
        self.root.title("시스템 모니터링 툴 v1.0")
        self.root.geometry("600x400")
        self.root.resizable(False, False)
        
        # 모니터링 활성화 플래그
        self.monitoring = True
        
        # UI 구성
        self.setup_ui()
        
        # 모니터링 스레드 시작
        self.monitor_thread = threading.Thread(target=self.update_stats, daemon=True)
        self.monitor_thread.start()
    
    def setup_ui(self):
        """UI 구성 요소 설정"""
        
        # 타이틀 프레임
        title_frame = tk.Frame(self.root, bg="#667eea", height=80)
        title_frame.pack(fill=tk.X)
        
        title_label = tk.Label(
            title_frame, 
            text="💻 시스템 모니터", 
            font=("Arial", 24, "bold"),
            bg="#667eea",
            fg="white"
        )
        title_label.pack(pady=20)
        
        # 메인 컨텐츠 프레임
        content_frame = tk.Frame(self.root, bg="#f8f9fa")
        content_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=20)
        
        # CPU 섹션
        cpu_frame = tk.LabelFrame(
            content_frame, 
            text="🔥 CPU 사용률", 
            font=("Arial", 12, "bold"),
            bg="#f8f9fa",
            padx=10,
            pady=10
        )
        cpu_frame.pack(fill=tk.X, pady=(0, 10))
        
        self.cpu_label = tk.Label(
            cpu_frame,
            text="측정 중...",
            font=("Arial", 16),
            bg="#f8f9fa"
        )
        self.cpu_label.pack()
        
        self.cpu_progress = ttk.Progressbar(
            cpu_frame,
            length=500,
            mode='determinate'
        )
        self.cpu_progress.pack(pady=5)
        
        # 메모리 섹션
        memory_frame = tk.LabelFrame(
            content_frame,
            text="💾 메모리 사용률",
            font=("Arial", 12, "bold"),
            bg="#f8f9fa",
            padx=10,
            pady=10
        )
        memory_frame.pack(fill=tk.X, pady=(0, 10))
        
        self.memory_label = tk.Label(
            memory_frame,
            text="측정 중...",
            font=("Arial", 16),
            bg="#f8f9fa"
        )
        self.memory_label.pack()
        
        self.memory_progress = ttk.Progressbar(
            memory_frame,
            length=500,
            mode='determinate'
        )
        self.memory_progress.pack(pady=5)
        
        # 상세 정보 섹션
        detail_frame = tk.LabelFrame(
            content_frame,
            text="📊 상세 정보",
            font=("Arial", 12, "bold"),
            bg="#f8f9fa",
            padx=10,
            pady=10
        )
        detail_frame.pack(fill=tk.BOTH, expand=True)
        
        self.detail_text = tk.Text(
            detail_frame,
            height=6,
            font=("Courier", 10),
            bg="#ffffff",
            relief=tk.FLAT
        )
        self.detail_text.pack(fill=tk.BOTH, expand=True)
    
    def update_stats(self):
        """시스템 통계를 주기적으로 업데이트"""
        while self.monitoring:
            try:
                # CPU 정보 수집
                cpu_percent = psutil.cpu_percent(interval=1)
                cpu_count = psutil.cpu_count()
                
                # 메모리 정보 수집
                memory = psutil.virtual_memory()
                memory_percent = memory.percent
                memory_used = round(memory.used / (1024**3), 2)
                memory_total = round(memory.total / (1024**3), 2)
                
                # UI 업데이트
                self.root.after(0, self.update_ui, cpu_percent, memory_percent, 
                               cpu_count, memory_used, memory_total)
                
                time.sleep(1)
                
            except Exception as e:
                print(f"오류 발생: {e}")
                break
    
    def update_ui(self, cpu_percent, memory_percent, cpu_count, memory_used, memory_total):
        """UI 요소 업데이트"""
        
        # CPU 업데이트
        self.cpu_label.config(text=f"{cpu_percent}%")
        self.cpu_progress['value'] = cpu_percent
        
        # 색상 변경 (사용률에 따라)
        if cpu_percent > 80:
            self.cpu_label.config(fg="red")
        elif cpu_percent > 60:
            self.cpu_label.config(fg="orange")
        else:
            self.cpu_label.config(fg="green")
        
        # 메모리 업데이트
        self.memory_label.config(text=f"{memory_percent}%")
        self.memory_progress['value'] = memory_percent
        
        if memory_percent > 80:
            self.memory_label.config(fg="red")
        elif memory_percent > 60:
            self.memory_label.config(fg="orange")
        else:
            self.memory_label.config(fg="green")
        
        # 상세 정보 업데이트
        detail_info = f"""
CPU 코어 수: {cpu_count}개
CPU 사용률: {cpu_percent}%

메모리 사용: {memory_used} GB / {memory_total} GB
메모리 사용률: {memory_percent}%

업데이트 시간: {time.strftime("%H:%M:%S")}
        """
        
        self.detail_text.delete(1.0, tk.END)
        self.detail_text.insert(1.0, detail_info.strip())
    
    def on_closing(self):
        """프로그램 종료 시 처리"""
        self.monitoring = False
        self.root.destroy()

def main():
    root = tk.Tk()
    app = SystemMonitor(root)
    root.protocol("WM_DELETE_WINDOW", app.on_closing)
    root.mainloop()

if __name__ == "__main__":
    main()

import matplotlib.pyplot as plt
import matplotlib.animation as animation
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import psutil
import tkinter as tk
from collections import deque

class RealtimeMonitor:
    def __init__(self, root):
        self.root = root
        self.root.title("실시간 시스템 모니터")
        self.root.geometry("900x600")
        
        # 데이터 저장용 deque (최대 60개 데이터 포인트)
        self.cpu_data = deque([0] * 60, maxlen=60)
        self.memory_data = deque([0] * 60, maxlen=60)
        self.time_data = deque(range(60), maxlen=60)
        
        # 그래프 설정
        self.setup_plot()
        
        # 애니메이션 시작
        self.ani = animation.FuncAnimation(
            self.fig,
            self.update_plot,
            interval=1000,  # 1초마다 업데이트
            blit=False
        )
    
    def setup_plot(self):
        """그래프 초기 설정"""
        
        # Figure 생성
        self.fig, (self.ax1, self.ax2) = plt.subplots(2, 1, figsize=(9, 6))
        self.fig.patch.set_facecolor('#f8f9fa')
        
        # CPU 그래프 설정
        self.ax1.set_title('CPU 사용률 (%)', fontsize=14, fontweight='bold')
        self.ax1.set_ylim(0, 100)
        self.ax1.set_xlim(0, 60)
        self.ax1.grid(True, alpha=0.3)
        self.ax1.set_facecolor('#ffffff')
        self.line1, = self.ax1.plot([], [], 'b-', linewidth=2, label='CPU')
        self.ax1.legend(loc='upper right')
        self.ax1.set_ylabel('사용률 (%)')
        
        # 메모리 그래프 설정
        self.ax2.set_title('메모리 사용률 (%)', fontsize=14, fontweight='bold')
        self.ax2.set_ylim(0, 100)
        self.ax2.set_xlim(0, 60)
        self.ax2.grid(True, alpha=0.3)
        self.ax2.set_facecolor('#ffffff')
        self.line2, = self.ax2.plot([], [], 'r-', linewidth=2, label='Memory')
        self.ax2.legend(loc='upper right')
        self.ax2.set_xlabel('시간 (초)')
        self.ax2.set_ylabel('사용률 (%)')
        
        # 레이아웃 조정
        plt.tight_layout()
        
        # tkinter에 그래프 삽입
        self.canvas = FigureCanvasTkAgg(self.fig, master=self.root)
        self.canvas.draw()
        self.canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
    
    def update_plot(self, frame):
        """그래프 데이터 업데이트"""
        
        # 시스템 정보 수집
        cpu_percent = psutil.cpu_percent(interval=0.1)
        memory_percent = psutil.virtual_memory().percent
        
        # 데이터 추가
        self.cpu_data.append(cpu_percent)
        self.memory_data.append(memory_percent)
        
        # 그래프 업데이트
        self.line1.set_data(range(60), list(self.cpu_data))
        self.line2.set_data(range(60), list(self.memory_data))
        
        # 현재 값 표시
        self.ax1.set_title(
            f'CPU 사용률: {cpu_percent:.1f}%',
            fontsize=14,
            fontweight='bold'
        )
        self.ax2.set_title(
            f'메모리 사용률: {memory_percent:.1f}%',
            fontsize=14,
            fontweight='bold'
        )
        
        return self.line1, self.line2

def main():
    root = tk.Tk()
    app = RealtimeMonitor(root)
    root.mainloop()

if __name__ == "__main__":
    main()

import psutil
import time
import winsound  # Windows 전용 (다른 OS는 다른 라이브러리 사용)
from datetime import datetime
import json

class AlertSystem:
    def __init__(self, cpu_threshold=80, memory_threshold=85):
        """
        알림 시스템 초기화
        
        Args:
            cpu_threshold: CPU 사용률 임계값 (%)
            memory_threshold: 메모리 사용률 임계값 (%)
        """
        self.cpu_threshold = cpu_threshold
        self.memory_threshold = memory_threshold
        
        # 알림 기록
        self.alert_history = []
        
        # 연속 알림 방지를 위한 쿨다운 (초)
        self.cooldown = 60
        self.last_cpu_alert = 0
        self.last_memory_alert = 0
    
    def check_cpu(self):
        """CPU 사용률 체크"""
        cpu_percent = psutil.cpu_percent(interval=1)
        current_time = time.time()
        
        if cpu_percent > self.cpu_threshold:
            # 쿨다운 체크
            if current_time - self.last_cpu_alert > self.cooldown:
                self.trigger_alert(
                    "CPU",
                    cpu_percent,
                    self.cpu_threshold
                )
                self.last_cpu_alert = current_time
                return True
        
        return False
    
    def check_memory(self):
        """메모리 사용률 체크"""
        memory = psutil.virtual_memory()
        memory_percent = memory.percent
        current_time = time.time()
        
        if memory_percent > self.memory_threshold:
            if current_time - self.last_memory_alert > self.cooldown:
                self.trigger_alert(
                    "Memory",
                    memory_percent,
                    self.memory_threshold
                )
                self.last_memory_alert = current_time
                return True
        
        return False
    
    def trigger_alert(self, resource_type, current_value, threshold):
        """알림 발생"""
        
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        
        alert_info = {
            "timestamp": timestamp,
            "type": resource_type,
            "value": current_value,
            "threshold": threshold
        }
        
        # 알림 기록 저장
        self.alert_history.append(alert_info)
        
        # 콘솔 출력
        print("\n" + "="*50)
        print(f"⚠️  경고 알림!")
        print(f"시간: {timestamp}")
        print(f"유형: {resource_type}")
        print(f"현재 값: {current_value:.1f}%")
        print(f"임계값: {threshold}%")
        print("="*50 + "\n")
        
        # 소리 알림 (Windows)
        try:
            winsound.Beep(1000, 500)  # 1000Hz, 500ms
        except:
            pass  # 다른 OS에서는 무시
        
        # 로그 파일에 기록
        self.save_to_log(alert_info)
    
    def save_to_log(self, alert_info):
        """알림을 로그 파일에 저장"""
        try:
            with open("system_alerts.log", "a", encoding="utf-8") as f:
                log_entry = json.dumps(alert_info, ensure_ascii=False)
                f.write(log_entry + "\n")
        except Exception as e:
            print(f"로그 저장 실패: {e}")
    
    def get_alert_summary(self):
        """알림 요약 정보 반환"""
        if not self.alert_history:
            return "알림 기록이 없습니다."
        
        cpu_alerts = sum(1 for a in self.alert_history if a['type'] == 'CPU')
        memory_alerts = sum(1 for a in self.alert_history if a['type'] == 'Memory')
        
        summary = f"""
📊 알림 요약
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
총 알림 수: {len(self.alert_history)}개
CPU 알림: {cpu_alerts}개
메모리 알림: {memory_alerts}개

최근 알림:
"""
        # 최근 5개 알림 표시
        for alert in self.alert_history[-5:]:
            summary += f"\n[{alert['timestamp']}] {alert['type']}: {alert['value']:.1f}%"
        
        return summary
    
    def monitor(self, duration=None):
        """
        지속적인 모니터링 시작
        
        Args:
            duration: 모니터링 시간(초), None이면 무한 실행
        """
        print("🔍 시스템 모니터링을 시작합니다...")
        print(f"CPU 임계값: {self.cpu_threshold}%")
        print(f"메모리 임계값: {self.memory_threshold}%")
        print("\n종료하려면 Ctrl+C를 누르세요.\n")
        
        start_time = time.time()
        
        try:
            while True:
                # 시간 제한 체크
                if duration and (time.time() - start_time) > duration:
                    break
                
                # CPU 체크
                self.check_cpu()
                
                # 메모리 체크
                self.check_memory()
                
                # 현재 상태 출력
                cpu = psutil.cpu_percent(interval=0.1)
                memory = psutil.virtual_memory().percent
                
                print(f"[{datetime.now().strftime('%H:%M:%S')}] "
                      f"CPU: {cpu:.1f}% | Memory: {memory:.1f}%", end='\r')
                
                time.sleep(5)  # 5초마다 체크
                
        except KeyboardInterrupt:
            print("\n\n모니터링을 종료합니다.")
            print(self.get_alert_summary())

# 사용 예제
if __name__ == "__main__":
    # 알림 시스템 생성 (CPU 80%, 메모리 85% 임계값)
    alert_system = AlertSystem(cpu_threshold=80, memory_threshold=85)
    
    # 모니터링 시작
    alert_system.monitor()

import psutil
import csv
import time
from datetime import datetime
import os

class DataLogger:
    def __init__(self, log_file="system_log.csv"):
        """
        데이터 로거 초기화
        
        Args:
            log_file: 로그 파일 경로
        """
        self.log_file = log_file
        self.initialize_log_file()
    
    def initialize_log_file(self):
        """로그 파일 초기화 (헤더 작성)"""
        
        # 파일이 이미 존재하면 건너뛰기
        if os.path.exists(self.log_file):
            print(f"기존 로그 파일을 사용합니다: {self.log_file}")
            return
        
        # 새 파일 생성 및 헤더 작성
        headers = [
            "timestamp",
            "cpu_percent",
            "cpu_count",
            "memory_total_gb",
            "memory_used_gb",
            "memory_percent",
            "disk_usage_percent",
            "network_sent_mb",
            "network_recv_mb"
        ]
        
        with open(self.log_file, 'w', newline='', encoding='utf-8') as f:
            writer = csv.writer(f)
            writer.writerow(headers)
        
        print(f"새 로그 파일을 생성했습니다: {self.log_file}")
    
    def collect_system_info(self):
        """현재 시스템 정보 수집"""
        
        # CPU 정보
        cpu_percent = psutil.cpu_percent(interval=1)
        cpu_count = psutil.cpu_count()
        
        # 메모리 정보
        memory = psutil.virtual_memory()
        memory_total = round(memory.total / (1024**3), 2)
        memory_used = round(memory.used / (1024**3), 2)
        memory_percent = memory.percent
        
        # 디스크 정보
        disk = psutil.disk_usage('/')
        disk_percent = disk.percent
        
        # 네트워크 정보
        network = psutil.net_io_counters()
        network_sent = round(network.bytes_sent / (1024**2), 2)
        network_recv = round(network.bytes_recv / (1024**2), 2)
        
        # 타임스탬프
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        
        return {
            "timestamp": timestamp,
            "cpu_percent": cpu_percent,
            "cpu_count": cpu_count,
            "memory_total_gb": memory_total,
            "memory_used_gb": memory_used,
            "memory_percent": memory_percent,
            "disk_usage_percent": disk_percent,
            "network_sent_mb": network_sent,
            "network_recv_mb": network_recv
        }
    
    def log_data(self):
        """데이터를 로그 파일에 기록"""
        
        info = self.collect_system_info()
        
        with open(self.log_file, 'a', newline='', encoding='utf-8') as f:
            writer = csv.writer(f)
            writer.writerow([
                info["timestamp"],
                info["cpu_percent"],
                info["cpu_count"],
                info["memory_total_gb"],
                info["memory_used_gb"],
                info["memory_percent"],
                info["disk_usage_percent"],
                info["network_sent_mb"],
                info["network_recv_mb"]
            ])
        
        return info
    
    def start_logging(self, interval=60, duration=None):
        """
        주기적인 로깅 시작
        
        Args:
            interval: 로깅 간격 (초)
            duration: 총 로깅 시간 (초), None이면 무한
        """
        print(f"📝 데이터 로깅을 시작합니다.")
        print(f"로그 파일: {self.log_file}")
        print(f"로깅 간격: {interval}초")
        print("\n종료하려면 Ctrl+C를 누르세요.\n")
        
        start_time = time.time()
        log_count = 0
        
        try:
            while True:
                # 시간 제한 체크
                if duration and (time.time() - start_time) > duration:
                    break
                
                # 데이터 로깅
                info = self.log_data()
                log_count += 1
                
                # 진행 상황 출력
                print(f"[{info['timestamp']}] "
                      f"로그 #{log_count} | "
                      f"CPU: {info['cpu_percent']:.1f}% | "
                      f"Memory: {info['memory_percent']:.1f}%")
                
                time.sleep(interval)
                
        except KeyboardInterrupt:
            print(f"\n\n로깅을 종료합니다.")
            print(f"총 {log_count}개의 로그가 기록되었습니다.")

# 사용 예제
if __name__ == "__main__":
    logger = DataLogger("system_log.csv")
    
    # 60초마다 로깅 (무한 실행)
    logger.start_logging(interval=60)

import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime

class LogAnalyzer:
    def __init__(self, log_file="system_log.csv"):
        """로그 분석기 초기화"""
        self.log_file = log_file
        self.df = None
        self.load_data()
    
    def load_data(self):
        """CSV 파일에서 데이터 로드"""
        try:
            self.df = pd.read_csv(self.log_file)
            self.df['timestamp'] = pd.to_datetime(self.df['timestamp'])
            print(f"✅ {len(self.df)}개의 로그를 불러왔습니다.")
        except FileNotFoundError:
            print(f"❌ 로그 파일을 찾을 수 없습니다: {self.log_file}")
        except Exception as e:
            print(f"❌ 데이터 로드 실패: {e}")
    
    def get_statistics(self):
        """기본 통계 정보 출력"""
        if self.df is None or self.df.empty:
            print("데이터가 없습니다.")
            return
        
        print("\n" + "="*60)
        print("📊 시스템 사용 통계")
        print("="*60)
        
        # CPU 통계
        print("\n🔥 CPU 사용률")
        print(f"  평균: {self.df['cpu_percent'].mean():.2f}%")
        print(f"  최대: {self.df['cpu_percent'].max():.2f}%")
        print(f"  최소: {self.df['cpu_percent'].min():.2f}%")
        
        # 메모리 통계
        print("\n💾 메모리 사용률")
        print(f"  평균: {self.df['memory_percent'].mean():.2f}%")
        print(f"  최대: {self.df['memory_percent'].max():.2f}%")
        print(f"  최소: {self.df['memory_percent'].min():.2f}%")
        
        # 디스크 통계
        print("\n💿 디스크 사용률")
        print(f"  평균: {self.df['disk_usage_percent'].mean():.2f}%")
        
        # 네트워크 통계
        print("\n🌐 네트워크 사용량")
        total_sent = self.df['network_sent_mb'].iloc[-1] - self.df['network_sent_mb'].iloc[0]
        total_recv = self.df['network_recv_mb'].iloc[-1] - self.df['network_recv_mb'].iloc[0]
        print(f"  전송: {total_sent:.2f} MB")
        print(f"  수신: {total_recv:.2f} MB")
        
        print("\n" + "="*60 + "\n")
    
    def plot_trends(self):
        """시간에 따른 트렌드 그래프 생성"""
        if self.df is None or self.df.empty:
            print("데이터가 없습니다.")
            return
        
        fig, axes = plt.subplots(2, 2, figsize=(14, 10))
        fig.suptitle('시스템 모니터링 트렌드 분석', fontsize=16, fontweight='bold')
        
        # CPU 사용률
        axes[0, 0].plot(self.df['timestamp'], self.df['cpu_percent'], 
                        color='#667eea', linewidth=2)
        axes[0, 0].set_title('CPU 사용률', fontweight='bold')
        axes[0, 0].set_ylabel('사용률 (%)')
        axes[0, 0].grid(True, alpha=0.3)
        axes[0, 0].axhline(y=80, color='r', linestyle='--', alpha=0.5, label='위험 수준')
        axes[0, 0].legend()
        
        # 메모리 사용률
        axes[0, 1].plot(self.df['timestamp'], self.df['memory_percent'], 
                        color='#f5576c', linewidth=2)
        axes[0, 1].set_title('메모리 사용률', fontweight='bold')
        axes[0, 1].set_ylabel('사용률 (%)')
        axes[0, 1].grid(True, alpha=0.3)
        axes[0, 1].axhline(y=85, color='r', linestyle='--', alpha=0.5, label='위험 수준')
        axes[0, 1].legend()
        
        # 메모리 사용량 (GB)
        axes[1, 0].plot(self.df['timestamp'], self.df['memory_used_gb'], 
                        color='#4facfe', linewidth=2)
        axes[1, 0].set_title('메모리 사용량', fontweight='bold')
        axes[1, 0].set_ylabel('사용량 (GB)')
        axes[1, 0].grid(True, alpha=0.3)
        
        # 디스크 사용률
        axes[1, 1].plot(self.df['timestamp'], self.df['disk_usage_percent'], 
                        color='#43e97b', linewidth=2)
        axes[1, 1].set_title('디스크 사용률', fontweight='bold')
        axes[1, 1].set_ylabel('사용률 (%)')
        axes[1, 1].grid(True, alpha=0.3)
        
        # 레이아웃 조정
        plt.tight_layout()
        plt.show()
    
    def find_peak_usage(self, top_n=5):
        """최고 사용률 시점 찾기"""
        if self.df is None or self.df.empty:
            print("데이터가 없습니다.")
            return
        
        print("\n" + "="*60)
        print(f"🔝 CPU 사용률 상위 {top_n}개 시점")
        print("="*60)
        
        top_cpu = self.df.nlargest(top_n, 'cpu_percent')[['timestamp', 'cpu_percent']]
        for idx, row in top_cpu.iterrows():
            print(f"{row['timestamp']} - {row['cpu_percent']:.2f}%")
        
        print("\n" + "="*60)
        print(f"🔝 메모리 사용률 상위 {top_n}개 시점")
        print("="*60)
        
        top_memory = self.df.nlargest(top_n, 'memory_percent')[['timestamp', 'memory_percent']]
        for idx, row in top_memory.iterrows():
            print(f"{row['timestamp']} - {row['memory_percent']:.2f}%")
        
        print("\n")

# 사용 예제
if __name__ == "__main__":
    analyzer = LogAnalyzer("system_log.csv")
    
    # 통계 정보 출력
    analyzer.get_statistics()
    
    # 최고 사용률 시점 찾기
    analyzer.find_peak_usage(top_n=5)
    
    # 트렌드 그래프 생성
    analyzer.plot_trends()

from flask import Flask, render_template, jsonify
import psutil
import json
from datetime import datetime

app = Flask(__name__)

@app.route('/')
def index():
    """메인 대시보드 페이지"""
    return render_template('dashboard.html')

@app.route('/api/system-info')
def get_system_info():
    """시스템 정보 API 엔드포인트"""
    
    # CPU 정보
    cpu_percent = psutil.cpu_percent(interval=1)
    cpu_count = psutil.cpu_count()
    cpu_freq = psutil.cpu_freq()
    
    # 메모리 정보
    memory = psutil.virtual_memory()
    swap = psutil.swap_memory()
    
    # 디스크 정보
    disk = psutil.disk_usage('/')
    
    # 네트워크 정보
    network = psutil.net_io_counters()
    
    # 프로세스 정보 (상위 5개)
    processes = []
    for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
        try:
            processes.append(proc.info)
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            pass
    
    # CPU 사용률 기준으로 정렬
    processes.sort(key=lambda x: x['cpu_percent'] or 0, reverse=True)
    top_processes = processes[:5]
    
    # JSON 응답 생성
    response = {
        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        'cpu': {
            'percent': cpu_percent,
            'count': cpu_count,
            'frequency': {
                'current': cpu_freq.current if cpu_freq else 0,
                'min': cpu_freq.min if cpu_freq else 0,
                'max': cpu_freq.max if cpu_freq else 0
            }
        },
        'memory': {
            'total': round(memory.total / (1024**3), 2),
            'available': round(memory.available / (1024**3), 2),
            'used': round(memory.used / (1024**3), 2),
            'percent': memory.percent
        },
        'swap': {
            'total': round(swap.total / (1024**3), 2),
            'used': round(swap.used / (1024**3), 2),
            'percent': swap.percent
        },
        'disk': {
            'total': round(disk.total / (1024**3), 2),
            'used': round(disk.used / (1024**3), 2),
            'free': round(disk.free / (1024**3), 2),
            'percent': disk.percent
        },
        'network': {
            'bytes_sent': round(network.bytes_sent / (1024**2), 2),
            'bytes_recv': round(network.bytes_recv / (1024**2), 2)
        },
        'top_processes': top_processes
    }
    
    return jsonify(response)

@app.route('/api/cpu-history')
def get_cpu_history():
    """CPU 사용률 히스토리 (간단한 예제)"""
    # 실제로는 데이터베이스나 캐시에서 가져와야 함
    history = []
    for i in range(60):
        history.append({
            'time': i,
            'value': psutil.cpu_percent(interval=0.1)
        })
    return jsonify(history)

if __name__ == '__main__':
    print("🌐 모니터링 서버를 시작합니다...")
    print("브라우저에서 http://localhost:5000 으로 접속하세요!")
    app.run(debug=True, host='0.0.0.0', port=5000)

<!-- templates/dashboard.html -->
<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>시스템 모니터링 대시보드</title>
    <style>
        * { margin: 0; padding: 0; box-sizing: border-box; }
        body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background: #f5f7fa; }
        .header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; text-align: center; }
        .container { max-width: 1400px; margin: 30px auto; padding: 0 20px; }
        .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; margin-bottom: 30px; }
        .card { background: white; border-radius: 12px; padding: 25px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
        .card-title { font-size: 18px; font-weight: bold; margin-bottom: 15px; color: #333; }
        .metric { font-size: 36px; font-weight: bold; color: #667eea; margin: 10px 0; }
        .progress-bar { width: 100%; height: 20px; background: #e9ecef; border-radius: 10px; overflow: hidden; margin: 10px 0; }
        .progress-fill { height: 100%; background: linear-gradient(90deg, #667eea, #764ba2); transition: width 0.3s ease; }
        .process-list { list-style: none; }
        .process-item { padding: 10px; border-bottom: 1px solid #e9ecef; display: flex; justify-content: space-between; }
        .status-good { color: #28a745; }
        .status-warning { color: #ffc107; }
        .status-danger { color: #dc3545; }
    </style>
</head>
<body>
    <div class="header">
        <h1>💻 시스템 모니터링 대시보드</h1>
        <p>실시간 시스템 리소스 모니터링</p>
    </div>

    <div class="container">
        <div class="grid">
            <div class="card">
                <div class="card-title">🔥 CPU 사용률</div>
                <div class="metric" id="cpu-percent">--%</div>
                <div class="progress-bar">
                    <div class="progress-fill" id="cpu-progress" style="width: 0%"></div>
                </div>
                <p>코어 수: <span id="cpu-count">--</span>개</p>
            </div>

            <div class="card">
                <div class="card-title">💾 메모리 사용률</div>
                <div class="metric" id="memory-percent">--%</div>
                <div class="progress-bar">
                    <div class="progress-fill" id="memory-progress" style="width: 0%"></div>
                </div>
                <p><span id="memory-used">--</span> GB / <span id="memory-total">--</span> GB</p>
            </div>

            <div class="card">
                <div class="card-title">💿 디스크 사용률</div>
                <div class="metric" id="disk-percent">--%</div>
                <div class="progress-bar">
                    <div class="progress-fill" id="disk-progress" style="width: 0%"></div>
                </div>
                <p><span id="disk-used">--</span> GB / <span id="disk-total">--</span> GB</p>
            </div>
        </div>

        <div class="card">
            <div class="card-title">📊 상위 프로세스 (CPU 사용률 기준)</div>
            <ul class="process-list" id="process-list">
                <li class="process-item">로딩 중...</li>
            </ul>
        </div>
    </div>

    <script>
        function updateDashboard() {
            fetch('/api/system-info')
                .then(response => response.json())
                .then(data => {
                    // CPU 업데이트
                    document.getElementById('cpu-percent').textContent = data.cpu.percent.toFixed(1) + '%';
                    document.getElementById('cpu-progress').style.width = data.cpu.percent + '%';
                    document.getElementById('cpu-count').textContent = data.cpu.count;
                    
                    // 메모리 업데이트
                    document.getElementById('memory-percent').textContent = data.memory.percent.toFixed(1) + '%';
                    document.getElementById('memory-progress').style.width = data.memory.percent + '%';
                    document.getElementById('memory-used').textContent = data.memory.used;
                    document.getElementById('memory-total').textContent = data.memory.total;
                    
                    // 디스크 업데이트
                    document.getElementById('disk-percent').textContent = data.disk.percent.toFixed(1) + '%';
                    document.getElementById('disk-progress').style.width = data.disk.percent + '%';
                    document.getElementById('disk-used').textContent = data.disk.used;
                    document.getElementById('disk-total').textContent = data.disk.total;
                    
                    // 프로세스 목록 업데이트
                    const processList = document.getElementById('process-list');
                    processList.innerHTML = '';
                    
                    data.top_processes.forEach(proc => {
                        const li = document.createElement('li');
                        li.className = 'process-item';
                        li.innerHTML = `
                            <span>${proc.name} (PID: ${proc.pid})</span>
                            <span>CPU: ${(proc.cpu_percent || 0).toFixed(1)}%</span>
                        `;
                        processList.appendChild(li);
                    });
                })
                .catch(error => console.error('Error:', error));
        }

        // 초기 로드
        updateDashboard();
        
        // 2초마다 업데이트
        setInterval(updateDashboard, 2000);
    </script>
</body>
</html>

import psutil
from datetime import datetime
import time

class ProcessMonitor:
    def __init__(self):
        """프로세스 모니터 초기화"""
        self.process_history = {}
    
    def get_process_info(self, pid):
        """특정 프로세스의 상세 정보 가져오기"""
        try:
            process = psutil.Process(pid)
            
            # 프로세스 기본 정보
            info = {
                'pid': pid,
                'name': process.name(),
                'status': process.status(),
                'create_time': datetime.fromtimestamp(process.create_time()).strftime('%Y-%m-%d %H:%M:%S'),
                'username': process.username(),
                'cpu_percent': process.cpu_percent(interval=0.1),
                'memory_info': {
                    'rss': round(process.memory_info().rss / (1024**2), 2),  # MB
                    'vms': round(process.memory_info().vms / (1024**2), 2),  # MB
                    'percent': process.memory_percent()
                },
                'num_threads': process.num_threads(),
                'num_fds': process.num_fds() if hasattr(process, 'num_fds') else 'N/A',
                'io_counters': None
            }
            
            # I/O 카운터 (지원되는 경우)
            try:
                io = process.io_counters()
                info['io_counters'] = {
                    'read_bytes': round(io.read_bytes / (1024**2), 2),  # MB
                    'write_bytes': round(io.write_bytes / (1024**2), 2)  # MB
                }
            except (psutil.AccessDenied, AttributeError):
                pass
            
            # 연결 정보
            try:
                connections = process.connections()
                info['connections'] = len(connections)
            except (psutil.AccessDenied, psutil.NoSuchProcess):
                info['connections'] = 'N/A'
            
            return info
            
        except (psutil.NoSuchProcess, psutil.AccessDenied) as e:
            return {'error': str(e)}
    
    def get_all_processes(self, sort_by='cpu'):
        """모든 프로세스 목록 가져오기"""
        processes = []
        
        for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent', 'status']):
            try:
                info = proc.info
                info['cpu_percent'] = proc.cpu_percent(interval=0.1)
                processes.append(info)
            except (psutil.NoSuchProcess, psutil.AccessDenied):
                pass
        
        # 정렬
        if sort_by == 'cpu':
            processes.sort(key=lambda x: x['cpu_percent'] or 0, reverse=True)
        elif sort_by == 'memory':
            processes.sort(key=lambda x: x['memory_percent'] or 0, reverse=True)
        
        return processes
    
    def monitor_process(self, pid, duration=60, interval=1):
        """특정 프로세스를 일정 시간 동안 모니터링"""
        print(f"🔍 프로세스 {pid} 모니터링 시작")
        print(f"기간: {duration}초, 간격: {interval}초\n")
        
        start_time = time.time()
        samples = []
        
        try:
            while (time.time() - start_time) < duration:
                info = self.get_process_info(pid)
                
                if 'error' in info:
                    print(f"❌ 오류: {info['error']}")
                    break
                
                samples.append({
                    'timestamp': datetime.now().strftime('%H:%M:%S'),
                    'cpu': info['cpu_percent'],
                    'memory': info['memory_info']['percent']
                })
                
                print(f"[{samples[-1]['timestamp']}] "
                      f"CPU: {info['cpu_percent']:.1f}% | "
                      f"Memory: {info['memory_info']['percent']:.1f}% | "
                      f"Threads: {info['num_threads']}")
                
                time.sleep(interval)
                
        except KeyboardInterrupt:
            print("\n모니터링을 중단합니다.")
        
        # 통계 출력
        if samples:
            print("\n" + "="*60)
            print("📊 모니터링 결과 요약")
            print("="*60)
            
            cpu_values = [s['cpu'] for s in samples]
            memory_values = [s['memory'] for s in samples]
            
            print(f"CPU 사용률:")
            print(f"  평균: {sum(cpu_values)/len(cpu_values):.2f}%")
            print(f"  최대: {max(cpu_values):.2f}%")
            print(f"  최소: {min(cpu_values):.2f}%")
            
            print(f"\n메모리 사용률:")
            print(f"  평균: {sum(memory_values)/len(memory_values):.2f}%")
            print(f"  최대: {max(memory_values):.2f}%")
            print(f"  최소: {min(memory_values):.2f}%")
    
    def find_memory_hogs(self, top_n=10):
        """메모리를 많이 사용하는 프로세스 찾기"""
        processes = self.get_all_processes(sort_by='memory')
        
        print("\n" + "="*60)
        print(f"💾 메모리 사용량 상위 {top_n}개 프로세스")
        print("="*60)
        
        for i, proc in enumerate(processes[:top_n], 1):
            print(f"{i}. {proc['name']} (PID: {proc['pid']})")
            print(f"   메모리: {proc['memory_percent']:.2f}%")
            print()
    
    def find_cpu_hogs(self, top_n=10):
        """CPU를 많이 사용하는 프로세스 찾기"""
        processes = self.get_all_processes(sort_by='cpu')
        
        print("\n" + "="*60)
        print(f"🔥 CPU 사용량 상위 {top_n}개 프로세스")
        print("="*60)
        
        for i, proc in enumerate(processes[:top_n], 1):
            print(f"{i}. {proc['name']} (PID: {proc['pid']})")
            print(f"   CPU: {proc['cpu_percent']:.2f}%")
            print()

# 사용 예제
if __name__ == "__main__":
    monitor = ProcessMonitor()
    
    # CPU 사용량 상위 프로세스
    monitor.find_cpu_hogs(top_n=5)
    
    # 메모리 사용량 상위 프로세스
    monitor.find_memory_hogs(top_n=5)
    
    # 특정 프로세스 모니터링 (예: PID 1234)
    # monitor.monitor_process(1234, duration=30, interval=2)

import psutil

def monitor_temperatures():
    """시스템 온도 모니터링"""
    
    # 온도 센서가 지원되는지 확인
    if not hasattr(psutil, "sensors_temperatures"):
        print("❌ 이 시스템은 온도 센서를 지원하지 않습니다.")
        return
    
    temps = psutil.sensors_temperatures()
    
    if not temps:
        print("❌ 온도 센서를 찾을 수 없습니다.")
        return
    
    print("\n" + "="*60)
    print("🌡️  시스템 온도 정보")
    print("="*60 + "\n")
    
    for name, entries in temps.items():
        print(f"📍 {name}:")
        for entry in entries:
            status = ""
            if entry.current > 80:
                status = " ⚠️ 경고: 높은 온도!"
            elif entry.current > 70:
                status = " ⚡ 주의"
            
            print(f"  {entry.label or 'N/A'}: {entry.current}°C{status}")
            if entry.high:
                print(f"    최대 안전 온도: {entry.high}°C")
            if entry.critical:
                print(f"    임계 온도: {entry.critical}°C")
        print()

def monitor_fans():
    """팬 속도 모니터링"""
    
    if not hasattr(psutil, "sensors_fans"):
        print("❌ 이 시스템은 팬 센서를 지원하지 않습니다.")
        return
    
    fans = psutil.sensors_fans()
    
    if not fans:
        print("❌ 팬 센서를 찾을 수 없습니다.")
        return
    
    print("\n" + "="*60)
    print("🌀 팬 속도 정보")
    print("="*60 + "\n")
    
    for name, entries in fans.items():
        print(f"📍 {name}:")
        for entry in entries:
            print(f"  {entry.label or 'N/A'}: {entry.current} RPM")
        print()

def monitor_battery():
    """배터리 상태 모니터링 (노트북)"""
    
    if not hasattr(psutil, "sensors_battery"):
        print("❌ 배터리 정보를 사용할 수 없습니다.")
        return
    
    battery = psutil.sensors_battery()
    
    if battery is None:
        print("❌ 배터리가 감지되지 않았습니다. (데스크톱?)")
        return
    
    print("\n" + "="*60)
    print("🔋 배터리 정보")
    print("="*60 + "\n")
    
    print(f"배터리 잔량: {battery.percent}%")
    print(f"전원 연결: {'예' if battery.power_plugged else '아니오'}")
    
    if battery.secsleft != psutil.POWER_TIME_UNLIMITED:
        hours = battery.secsleft // 3600
        minutes = (battery.secsleft % 3600) // 60
        print(f"남은 시간: {hours}시간 {minutes}분")
    else:
        print("남은 시간: 충전 중")
    
    print()

# 사용 예제
if __name__ == "__main__":
    monitor_temperatures()
    monitor_fans()
    monitor_battery()