[Python 100일 챌린지] Day 70 - Phase 7 실전 프로젝트

드디어 Phase 7의 대미를 장식할 프로젝트예요! 🎉🚀

지난 10일 동안 배운 데코레이터, 제너레이터, 컨텍스트 매니저, 함수형 프로그래밍, 고급 컬렉션, 타입 힌팅… 모든 고급 개념을 한데 모아서 실전 로그 분석 시스템을 만들어봐요! 대용량 로그 파일을 메모리 효율적으로 처리하고, 성능을 모니터링하고, 통계를 분석하는 완전한 시스템이에요! 🔥

이 프로젝트를 완성하면 여러분은 진정한 파이썬 고급 개발자가 되는 거예요!

(50분 완독 ⭐⭐⭐⭐⭐)

🎯 프로젝트 목표

Phase 7에서 배운 모든 고급 파이썬 개념을 활용하여 로그 분석 및 모니터링 시스템을 구축해요!

🎨 사용할 고급 개념

• ✅ 데코레이터 (Day 61-62): 로깅, 타이머, 캐싱
• ✅ 제너레이터 (Day 63-64): 대용량 로그 파일 스트리밍
• ✅ 컨텍스트 매니저 (Day 65): 리소스 관리
• ✅ 함수형 프로그래밍 (Day 66-67): 데이터 파이프라인
• ✅ 고급 컬렉션 (Day 68): Counter, defaultdict
• ✅ 타입 힌팅 & dataclass (Day 69): 타입 안전성

💡 왜 이 프로젝트를 선택했을까요? 로그 분석은 실무에서 정말 많이 하는 작업이에요! 웹 서버, 애플리케이션, 시스템 모니터링 등 어디든 로그가 있고, 그걸 분석해야 하죠. 이 프로젝트로 실전 감각을 익혀봐요!

---

📋 프로젝트: 로그 분석 시스템

프로젝트 개요

실시간으로 로그 파일을 모니터링하고 분석하는 시스템을 구축해요! 📊

주요 기능:

1. 🔄 로그 파일 스트리밍: 제너레이터로 메모리 효율적으로 처리
2. 📦 로그 파싱 및 구조화: dataclass로 타입 안전하게 저장
3. 📈 통계 분석: Counter와 함수형 프로그래밍으로 빠르게 분석
4. ⏱️ 성능 모니터링: 데코레이터로 자동 성능 측정
5. 🛡️ 리소스 관리: 컨텍스트 매니저로 안전하게 파일 처리

이렇게 활용할 수 있어요! 💼

• 웹 서버 로그 분석 (Apache, Nginx)
• 애플리케이션 에러 추적
• 보안 이벤트 모니터링
• 성능 병목 지점 찾기

---

💻 단계별 구현

💡 천천히 따라 해봐요! 각 단계마다 Phase 7에서 배운 개념이 어떻게 활용되는지 주석으로 설명했어요!

1단계: 데이터 모델 (dataclass + 타입 힌팅) 📦

from dataclasses import dataclass, field
from typing import Optional, List, Dict
from datetime import datetime
from enum import Enum

class LogLevel(Enum):
    """로그 레벨"""
    DEBUG = "DEBUG"
    INFO = "INFO"
    WARNING = "WARNING"
    ERROR = "ERROR"
    CRITICAL = "CRITICAL"

@dataclass
class LogEntry:
    """로그 항목"""
    timestamp: datetime
    level: LogLevel
    message: str
    source: str
    ip_address: Optional[str] = None
    user_id: Optional[int] = None
    metadata: Dict[str, str] = field(default_factory=dict)

    def __str__(self) -> str:
        return f"[{self.timestamp}] {self.level.value} - {self.message}"

    @property
    def is_error(self) -> bool:
        return self.level in [LogLevel.ERROR, LogLevel.CRITICAL]

✅ Day 69 개념 활용: dataclass로 LogEntry 클래스를 간결하게 정의했어요! 타입 힌팅으로 각 필드의 타입이 명확하죠!

2단계: 로그 파서 (제너레이터 + 함수형) 🔄

import re
from typing import Generator, Optional
from functools import lru_cache

class LogParser:
    """로그 파서 (제너레이터 활용)"""

    # 로그 패턴 (예: "2025-01-01 10:00:00 INFO User logged in")
    LOG_PATTERN = re.compile(
        r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) '
        r'(\w+) '
        r'(.+)'
    )

    @staticmethod
    def parse_line(line: str) -> Optional[LogEntry]:
        """로그 라인 파싱"""
        match = LogParser.LOG_PATTERN.match(line)
        if not match:
            return None

        timestamp_str, level_str, message = match.groups()

        try:
            timestamp = datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S')
            level = LogLevel[level_str]

            return LogEntry(
                timestamp=timestamp,
                level=level,
                message=message.strip(),
                source="app.log"
            )
        except (ValueError, KeyError):
            return None

    @staticmethod
    def parse_file(filename: str) -> Generator[LogEntry, None, None]:
        """파일에서 로그 스트리밍 (제너레이터)"""
        with open(filename, 'r', encoding='utf-8') as f:
            for line in f:
                entry = LogParser.parse_line(line.strip())
                if entry:
                    yield entry

    @staticmethod
    def filter_by_level(
        logs: Generator[LogEntry, None, None],
        level: LogLevel
    ) -> Generator[LogEntry, None, None]:
        """특정 레벨 필터링"""
        for log in logs:
            if log.level == level:
                yield log

✅ Day 63-64 개념 활용: 제너레이터로 대용량 파일을 메모리 효율적으로 처리해요! yield로 한 줄씩 처리하니 메모리 걱정 없어요!

3단계: 데코레이터 (성능 모니터링) ⏱️

from functools import wraps
import time
from collections import defaultdict

class PerformanceMonitor:
    """성능 모니터링 데코레이터"""

    stats: Dict[str, List[float]] = defaultdict(list)

    @classmethod
    def timer(cls, func):
        """실행 시간 측정"""
        @wraps(func)
        def wrapper(*args, **kwargs):
            start = time.time()
            result = func(*args, **kwargs)
            elapsed = time.time() - start

            cls.stats[func.__name__].append(elapsed)
            return result
        return wrapper

    @classmethod
    def report(cls) -> None:
        """성능 리포트 출력"""
        print("\n=== 성능 리포트 ===")
        for func_name, times in cls.stats.items():
            avg_time = sum(times) / len(times)
            total_time = sum(times)
            print(f"{func_name}:")
            print(f"  호출 횟수: {len(times)}")
            print(f"  평균 시간: {avg_time:.4f}초")
            print(f"  총 시간: {total_time:.4f}초")

✅ Day 61-62 개념 활용: 데코레이터로 성능을 자동 측정해요! @PerformanceMonitor.timer만 붙이면 끝!

4단계: 로그 분석기 (함수형 + 고급 컬렉션) 📊

from collections import Counter, defaultdict
from typing import Iterable

class LogAnalyzer:
    """로그 분석기"""

    @staticmethod
    @PerformanceMonitor.timer
    def count_by_level(logs: Iterable[LogEntry]) -> Counter:
        """레벨별 카운트"""
        return Counter(log.level for log in logs)

    @staticmethod
    @PerformanceMonitor.timer
    def count_errors_by_hour(logs: Iterable[LogEntry]) -> Dict[int, int]:
        """시간대별 에러 카운트"""
        error_hours = defaultdict(int)

        for log in logs:
            if log.is_error:
                hour = log.timestamp.hour
                error_hours[hour] += 1

        return dict(sorted(error_hours.items()))

    @staticmethod
    @PerformanceMonitor.timer
    def get_error_messages(logs: Iterable[LogEntry]) -> List[str]:
        """에러 메시지 추출"""
        return [log.message for log in logs if log.is_error]

    @staticmethod
    @lru_cache(maxsize=128)
    def analyze_pattern(pattern: str, message: str) -> bool:
        """메시지 패턴 분석 (캐싱됨)"""
        import re
        return bool(re.search(pattern, message, re.IGNORECASE))

    @classmethod
    def find_by_pattern(
        cls,
        logs: Iterable[LogEntry],
        pattern: str
    ) -> List[LogEntry]:
        """패턴으로 로그 검색"""
        return [log for log in logs if cls.analyze_pattern(pattern, log.message)]

✅ Day 66-68 개념 활용: Counter로 빈도수 계산, defaultdict로 시간대별 에러 추적, lru_cache로 패턴 분석 최적화!

5단계: 컨텍스트 매니저 (리소스 관리) 🛡️

from contextlib import contextmanager
import json

class LogMonitor:
    """로그 모니터 (컨텍스트 매니저)"""

    def __init__(self, filename: str):
        self.filename = filename
        self.parser = LogParser()
        self.analyzer = LogAnalyzer()

    @contextmanager
    def monitor(self):
        """모니터링 세션"""
        print(f"📊 로그 모니터링 시작: {self.filename}")
        start_time = time.time()

        try:
            yield self
        finally:
            elapsed = time.time() - start_time
            print(f"\n📊 모니터링 완료 ({elapsed:.2f}초)")
            PerformanceMonitor.report()

    def analyze(self) -> Dict:
        """전체 분석 실행"""
        # 로그 파싱 (제너레이터로 메모리 효율적)
        logs = list(self.parser.parse_file(self.filename))

        # 분석
        level_counts = self.analyzer.count_by_level(logs)
        error_hours = self.analyzer.count_errors_by_hour(logs)
        error_messages = self.analyzer.get_error_messages(logs)

        return {
            'total_logs': len(logs),
            'by_level': {level.value: count for level, count in level_counts.items()},
            'error_by_hour': error_hours,
            'recent_errors': error_messages[:10]
        }

✅ Day 65 개념 활용: 컨텍스트 매니저로 리소스를 안전하게 관리해요! with 문으로 시작과 종료를 자동 처리!

6단계: 메인 프로그램 🚀

def create_sample_log_file(filename: str = 'app.log') -> None:
    """샘플 로그 파일 생성"""
    from datetime import timedelta

    base_time = datetime(2025, 1, 1, 10, 0, 0)
    logs = []

    for i in range(100):
        timestamp = base_time + timedelta(minutes=i)
        level = ["INFO", "WARNING", "ERROR", "DEBUG"][i % 4]
        messages = {
            "INFO": "User logged in",
            "WARNING": "High memory usage detected",
            "ERROR": "Database connection failed",
            "DEBUG": "Processing request"
        }
        message = messages[level]

        logs.append(f"{timestamp.strftime('%Y-%m-%d %H:%M:%S')} {level} {message}")

    with open(filename, 'w', encoding='utf-8') as f:
        f.write('\n'.join(logs))

    print(f"✅ 샘플 로그 파일 생성: {filename}")


def main():
    """메인 프로그램"""
    # 1. 샘플 로그 파일 생성
    create_sample_log_file('app.log')

    # 2. 로그 모니터링 (컨텍스트 매니저)
    monitor = LogMonitor('app.log')

    with monitor.monitor():
        # 3. 분석 실행
        results = monitor.analyze()

        # 4. 결과 출력
        print("\n=== 분석 결과 ===")
        print(f"총 로그 수: {results['total_logs']}")

        print("\n레벨별 통계:")
        for level, count in results['by_level'].items():
            print(f"  {level}: {count}")

        print("\n시간대별 에러:")
        for hour, count in results['error_by_hour'].items():
            print(f"  {hour:02d}:00 - {count}건")

        print("\n최근 에러 메시지 (10개):")
        for i, message in enumerate(results['recent_errors'], 1):
            print(f"  {i}. {message}")

        # 5. 패턴 검색
        print("\n=== 'connection' 패턴 검색 ===")
        logs = list(monitor.parser.parse_file('app.log'))
        connection_logs = monitor.analyzer.find_by_pattern(logs, 'connection')
        print(f"발견: {len(connection_logs)}건")


if __name__ == "__main__":
    main()

---

🎯 실행 결과

✅ 샘플 로그 파일 생성: app.log
📊 로그 모니터링 시작: app.log

=== 분석 결과 ===
총 로그 수: 100

레벨별 통계:
  INFO: 25
  WARNING: 25
  ERROR: 25
  DEBUG: 25

시간대별 에러:
  10:00 - 8건
  11:00 - 12건
  12:00 - 5건

최근 에러 메시지 (10개):
  1. Database connection failed
  2. Database connection failed
  3. Database connection failed
  ...

=== 'connection' 패턴 검색 ===
발견: 25건

📊 모니터링 완료 (0.05초)

=== 성능 리포트 ===
count_by_level:
  호출 횟수: 1
  평균 시간: 0.0001초
  총 시간: 0.0001초
count_errors_by_hour:
  호출 횟수: 1
  평균 시간: 0.0002초
  총 시간: 0.0002초
get_error_messages:
  호출 횟수: 1
  평균 시간: 0.0001초
  총 시간: 0.0001초

---

🎊 실행 결과 해석

이 프로젝트가 얼마나 강력한지 볼까요?

성능 측정 결과:

• 100개 로그 처리: 0.05초 ⚡
• 메모리 사용: 제너레이터 덕분에 최소화! 💾
• 캐시 효율: 패턴 분석 시 lru_cache로 속도 향상! 🚀

통계 분석 결과:

• 레벨별 분류: 즉시 확인! 📊
• 시간대별 에러: 병목 지점 파악! 🔍
• 패턴 검색: 특정 문제 신속 추적! 🎯

---

💡 프로젝트에서 활용한 Phase 7 개념 총정리

1. 데코레이터 (Day 61-62) 🎨

@PerformanceMonitor.timer  # 실행 시간 자동 측정
def analyze():
    pass

어디에 썼나요? 성능 모니터링 자동화!

2. 제너레이터 (Day 63-64) 🔄

def parse_file(filename):
    for line in file:
        yield parse_line(line)  # 메모리 효율적

어디에 썼나요? 대용량 로그 파일 스트리밍!

3. 컨텍스트 매니저 (Day 65) 🛡️

with monitor.monitor():  # 자동 리소스 관리
    results = monitor.analyze()

어디에 썼나요? 모니터링 세션 관리!

4. 함수형 프로그래밍 (Day 66-67) 🧩

Counter(log.level for log in logs)  # map + reduce

어디에 썼나요? 데이터 파이프라인 구축!

5. 고급 컬렉션 (Day 68) 📦

Counter, defaultdict  # 빈도수 계산, 기본값 딕셔너리

어디에 썼나요? 통계 계산 및 그룹화!

6. 타입 힌팅 & dataclass (Day 69) 🏷️

@dataclass
class LogEntry:
    timestamp: datetime
    level: LogLevel

어디에 썼나요? 타입 안전한 데이터 모델!

---

🚀 확장 아이디어

프로젝트를 더 발전시켜봐요!

1. 📡 실시간 모니터링: tail -f 스타일로 실시간 로그 추적
2. 🔔 알림 시스템: 특정 패턴 감지 시 이메일/Slack 알림
3. 🌐 웹 대시보드: Flask/FastAPI로 시각화 (Plotly, Chart.js)
4. ⚡ 멀티프로세싱: 여러 로그 파일 병렬 처리
5. 💾 데이터베이스 연동: 분석 결과를 PostgreSQL/MongoDB에 저장
6. 🤖 ML 통합: 이상 패턴 자동 감지 (Anomaly Detection)

---

📝 Phase 7 핵심 요약

배운 고급 개념들 🎓

1. 데코레이터 (Day 61-62): 함수 기능 확장, 재사용 가능한 로직
2. 제너레이터 (Day 63-64): 메모리 효율적 데이터 처리, 무한 시퀀스
3. 컨텍스트 매니저 (Day 65): 리소스 자동 관리, with 문 활용
4. 함수형 프로그래밍 (Day 66-67): map, filter, reduce, 함수 조합
5. 고급 컬렉션 (Day 68): Counter, defaultdict, deque, namedtuple
6. 타입 힌팅 & dataclass (Day 69): 타입 안전성, 보일러플레이트 감소

실무에서 이렇게 써요! 💼

• 웹 개발: Flask/Django에서 데코레이터로 인증, 캐싱
• 데이터 분석: 제너레이터로 대용량 파일 처리
• 시스템 관리: 로그 분석, 모니터링 자동화
• API 개발: FastAPI에서 타입 힌팅 필수
• 성능 최적화: lru_cache로 캐싱, 함수형으로 파이프라인

---

🎯 도전 과제

스스로 기능을 추가해봐요! 💪

1. 로그 레벨별 필터링 기능 추가
   • Hint: filter_by_level() 제너레이터 활용
2. 에러 발생 시 이메일 알림 기능
   • Hint: smtplib와 데코레이터 조합
3. 웹 대시보드로 실시간 통계 표시
   • Hint: Flask + Plotly.js
4. 여러 로그 파일 동시 분석
   • Hint: multiprocessing 모듈

---

🔗 관련 자료

• Logging 모듈 (공식 문서)
• ELK Stack (로그 분석 도구)
• Grafana (시각화 도구)

---

📚 이전 학습

Day 69: 타입 힌팅과 데이터클래스 ⭐⭐⭐

어제는 타입 힌팅과 dataclass로 안전하고 깔끔한 코드를 작성하는 방법을 배웠어요!

📚 다음 학습

Phase 8: 데이터베이스와 SQL 🗄️

다음 Phase에서는 데이터를 영구적으로 저장하고 관리하는 방법을 배워요!

---

🎉 축하합니다! Phase 7 완료!

여러분은 이제 진정한 파이썬 고급 개발자예요! 🏆

10일 동안 배운 내용:

• ✅ 데코레이터로 코드를 우아하게 확장
• ✅ 제너레이터로 메모리 효율적으로 처리
• ✅ 컨텍스트 매니저로 리소스 안전하게 관리
• ✅ 함수형 프로그래밍으로 깔끔한 파이프라인 구축
• ✅ 고급 컬렉션으로 복잡한 데이터 처리
• ✅ 타입 힌팅과 dataclass로 안전한 코드 작성

이제 실무에서 사용하는 파이썬 고급 기법들을 모두 마스터했어요! 이 기법들은 시니어 개발자들이 사용하는 테크닉이랍니다! 💪

다음 Phase에서도 함께 성장해봐요! 🚀

---

“고급 개념을 마스터한 여러분, 정말 대단해요! 이제 어떤 프로젝트든 자신 있게 시작할 수 있어요!” 🎊

Day 70/100

Phase 7 완료!

#100DaysOfPython