🎯 왜 로깅과 디버깅이 중요할까?

📚 Python 로깅의 기초: logging 모듈 완전 정복

🌟 로깅 레벨의 이해

🎨 기본 로깅 설정하기

import logging

# 기본 설정
logging.basicConfig(level=logging.DEBUG)

# 로그 메시지 출력
logging.debug("이건 디버그 메시지야")
logging.info("정보성 메시지")
logging.warning("경고! 뭔가 이상해")
logging.error("에러 발생!")
logging.critical("심각한 문제!")

🔧 실전 로깅 설정

import logging
import logging.handlers
from datetime import datetime
import os

def setup_logger(name, log_file, level=logging.INFO):
    """로거를 설정하는 함수"""
    
    # 로그 디렉토리가 없으면 생성
    log_dir = os.path.dirname(log_file)
    if log_dir and not os.path.exists(log_dir):
        os.makedirs(log_dir)
    
    # 포매터 설정 - 로그 메시지 형식
    formatter = logging.Formatter(
        '%(asctime)s | %(name)s | %(levelname)s | %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )
    
    # 파일 핸들러 - 로그를 파일에 저장
    file_handler = logging.handlers.RotatingFileHandler(
        log_file,
        maxBytes=10*1024*1024,  # 10MB
        backupCount=5,  # 최대 5개 백업 파일
        encoding='utf-8'
    )
    file_handler.setFormatter(formatter)
    
    # 콘솔 핸들러 - 터미널에도 출력
    console_handler = logging.StreamHandler()
    console_handler.setFormatter(formatter)
    
    # 로거 생성 및 설정
    logger = logging.getLogger(name)
    logger.setLevel(level)
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)
    
    return logger

# 사용 예제
app_logger = setup_logger('MyApp', 'logs/app.log')
app_logger.info("애플리케이션 시작!")

🎭 컨텍스트 정보 추가하기

import logging
from functools import wraps

def log_function_call(logger):
    """함수 호출을 자동으로 로깅하는 데코레이터"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            logger.info(f"함수 호출: {func.__name__}")
            logger.debug(f"인자: args={args}, kwargs={kwargs}")
            
            try:
                result = func(*args, **kwargs)
                logger.info(f"함수 완료: {func.__name__}")
                return result
            except Exception as e:
                logger.error(f"함수 에러: {func.__name__} - {str(e)}")
                raise
        
        return wrapper
    return decorator

# 사용 예제
logger = logging.getLogger(__name__)

@log_function_call(logger)
def calculate_sum(a, b):
    return a + b

result = calculate_sum(5, 3)

🐛 디버깅 도구 완전 정복

🔬 pdb: Python 내장 디버거

import pdb

def buggy_function(x, y):
    result = x + y
    pdb.set_trace()  # 여기서 실행이 멈춤!
    result = result * 2
    return result

# 실행하면 대화형 디버깅 모드로 진입
buggy_function(5, 3)

def buggy_function(x, y):
    result = x + y
    breakpoint()  # 이게 더 편해!
    result = result * 2
    return result

🎨 ipdb: 더 예쁜 디버거

# 설치
pip install ipdb

# 사용
import ipdb

def my_function():
    x = 10
    ipdb.set_trace()  # 컬러풀한 디버깅 시작!
    y = x * 2
    return y

🚀 VS Code 디버거: 비주얼의 힘

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Current File",
            "type": "python",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal",
            "justMyCode": false,
            "env": {
                "PYTHONPATH": "${workspaceFolder}"
            }
        },
        {
            "name": "Python: Django",
            "type": "python",
            "request": "launch",
            "program": "${workspaceFolder}/manage.py",
            "args": [
                "runserver",
                "--noreload"
            ],
            "django": true
        },
        {
            "name": "Python: Flask",
            "type": "python",
            "request": "launch",
            "module": "flask",
            "env": {
                "FLASK_APP": "app.py",
                "FLASK_ENV": "development"
            },
            "args": [
                "run",
                "--no-debugger",
                "--no-reload"
            ]
        }
    ]
}

🔍 PyCharm 디버거: 프로페셔널의 선택

🎯 실전 로깅 전략

📊 구조화된 로깅 (Structured Logging)

import logging
import json
from datetime import datetime

class JsonFormatter(logging.Formatter):
    """JSON 형식으로 로그를 출력하는 포매터"""
    
    def format(self, record):
        log_data = {
            'timestamp': datetime.utcnow().isoformat(),
            'level': record.levelname,
            'logger': record.name,
            'message': record.getMessage(),
            'module': record.module,
            'function': record.funcName,
            'line': record.lineno
        }
        
        # 추가 컨텍스트 정보가 있으면 포함
        if hasattr(record, 'user_id'):
            log_data['user_id'] = record.user_id
        if hasattr(record, 'request_id'):
            log_data['request_id'] = record.request_id
        
        # 예외 정보가 있으면 포함
        if record.exc_info:
            log_data['exception'] = self.formatException(record.exc_info)
        
        return json.dumps(log_data, ensure_ascii=False)

# 사용 예제
logger = logging.getLogger(__name__)
handler = logging.StreamHandler()
handler.setFormatter(JsonFormatter())
logger.addHandler(handler)
logger.setLevel(logging.INFO)

# 컨텍스트 정보와 함께 로깅
logger.info("사용자 로그인", extra={'user_id': 12345, 'request_id': 'abc-123'})

🎭 컨텍스트 매니저를 활용한 로깅

import logging
import time
from contextlib import contextmanager

@contextmanager
def log_execution_time(logger, operation_name):
    """작업 실행 시간을 자동으로 로깅"""
    start_time = time.time()
    logger.info(f"{operation_name} 시작")
    
    try:
        yield
    except Exception as e:
        logger.error(f"{operation_name} 실패: {str(e)}")
        raise
    finally:
        elapsed_time = time.time() - start_time
        logger.info(f"{operation_name} 완료 (소요시간: {elapsed_time:.2f}초)")

# 사용 예제
logger = logging.getLogger(__name__)

with log_execution_time(logger, "데이터베이스 쿼리"):
    # 시간이 오래 걸리는 작업
    time.sleep(2)
    result = "데이터 조회 완료"

🔐 민감한 정보 필터링

import logging
import re

class SensitiveDataFilter(logging.Filter):
    """민감한 정보를 마스킹하는 필터"""
    
    PATTERNS = [
        (re.compile(r'password["\']?\s*[:=]\s*["\']?([^"\'}\s,]+)', re.I), 'password=***'),
        (re.compile(r'api[_-]?key["\']?\s*[:=]\s*["\']?([^"\'}\s,]+)', re.I), 'api_key=***'),
        (re.compile(r'\b\d{3}-\d{4}-\d{4}\b'), '***-****-****'),  # 전화번호
        (re.compile(r'\b\d{6}-\d{7}\b'), '******-*******'),  # 주민번호
    ]
    
    def filter(self, record):
        message = record.getMessage()
        
        for pattern, replacement in self.PATTERNS:
            message = pattern.sub(replacement, message)
        
        record.msg = message
        record.args = ()
        
        return True

# 사용 예제
logger = logging.getLogger(__name__)
logger.addFilter(SensitiveDataFilter())

# 이제 안전하게 로깅 가능
logger.info("사용자 정보: password=secret123, api_key=abc123xyz")
# 실제 로그: "사용자 정보: password=***, api_key=***"

🛠️ 고급 디버깅 테크닉

🎯 원격 디버깅 (Remote Debugging)

# 서버 측 코드
import debugpy

# 디버그 서버 시작
debugpy.listen(("0.0.0.0", 5678))
print("디버거 대기 중...")
debugpy.wait_for_client()  # 클라이언트 연결 대기

# 여기서부터 일반 코드
def main():
    print("애플리케이션 시작")
    # 작업 수행

if __name__ == "__main__":
    main()

{
    "name": "Python: Remote Attach",
    "type": "python",
    "request": "attach",
    "connect": {
        "host": "서버IP주소",
        "port": 5678
    },
    "pathMappings": [
        {
            "localRoot": "${workspaceFolder}",
            "remoteRoot": "/app"
        }
    ]
}

🔬 메모리 프로파일링

# 설치
pip install memory_profiler

# 사용
from memory_profiler import profile

@profile
def memory_intensive_function():
    # 메모리를 많이 사용하는 작업
    big_list = [i for i in range(1000000)]
    big_dict = {i: i**2 for i in range(100000)}
    return len(big_list) + len(big_dict)

# 실행
result = memory_intensive_function()

Line #    Mem usage    Increment   Line Contents
================================================
     3   38.816 MiB   38.816 MiB   @profile
     4                             def memory_intensive_function():
     5   45.289 MiB    6.473 MiB       big_list = [i for i in range(1000000)]
     6   53.125 MiB    7.836 MiB       big_dict = {i: i**2 for i in range(100000)}
     7   53.125 MiB    0.000 MiB       return len(big_list) + len(big_dict)

⚡ 성능 프로파일링

import cProfile
import pstats
from pstats import SortKey

def slow_function():
    total = 0
    for i in range(1000000):
        total += i
    return total

def fast_function():
    return sum(range(1000000))

# 프로파일링 실행
profiler = cProfile.Profile()
profiler.enable()

slow_function()
fast_function()

profiler.disable()

# 결과 분석
stats = pstats.Stats(profiler)
stats.sort_stats(SortKey.TIME)
stats.print_stats(10)  # 상위 10개 함수 출력

pip install snakeviz

# 프로파일 데이터 저장
python -m cProfile -o output.prof your_script.py

# 시각화
snakeviz output.prof

🏗️ 프로젝트별 로깅 전략

🌐 웹 애플리케이션 (Flask/Django)

from flask import Flask, request, g
import logging
import uuid

app = Flask(__name__)

# 로거 설정
logger = logging.getLogger(__name__)

@app.before_request
def before_request():
    """각 요청마다 고유 ID 생성"""
    g.request_id = str(uuid.uuid4())
    logger.info(f"[{g.request_id}] 요청 시작: {request.method} {request.path}")

@app.after_request
def after_request(response):
    """요청 완료 로깅"""
    logger.info(f"[{g.request_id}] 응답: {response.status_code}")
    return response

@app.errorhandler(Exception)
def handle_exception(e):
    """예외 처리 및 로깅"""
    logger.error(f"[{g.request_id}] 에러 발생: {str(e)}", exc_info=True)
    return {"error": "Internal Server Error"}, 500

@app.route('/api/users/<int:user_id>')
def get_user(user_id):
    logger.info(f"[{g.request_id}] 사용자 조회: {user_id}")
    # 실제 로직
    return {"user_id": user_id, "name": "홍길동"}

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '{levelname} {asctime} {module} {process:d} {thread:d} {message}',
            'style': '{',
        },
        'simple': {
            'format': '{levelname} {message}',
            'style': '{',
        },
    },
    'filters': {
        'require_debug_true': {
            '()': 'django.utils.log.RequireDebugTrue',
        },
    },
    'handlers': {
        'console': {
            'level': 'INFO',
            'filters': ['require_debug_true'],
            'class': 'logging.StreamHandler',
            'formatter': 'simple'
        },
        'file': {
            'level': 'INFO',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': 'logs/django.log',
            'maxBytes': 1024*1024*15,  # 15MB
            'backupCount': 10,
            'formatter': 'verbose',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['console', 'file'],
            'level': 'INFO',
            'propagate': False,
        },
        'myapp': {
            'handlers': ['console', 'file'],
            'level': 'DEBUG',
            'propagate': False,
        },
    },
}

🤖 데이터 파이프라인 / 배치 작업

import logging
from datetime import datetime
import time

class DataPipelineLogger:
    """데이터 파이프라인 전용 로거"""
    
    def __init__(self, name):
        self.logger = logging.getLogger(name)
        self.stats = {
            'processed': 0,
            'errors': 0,
            'start_time': None
        }
    
    def start_pipeline(self, total_items):
        """파이프라인 시작"""
        self.stats['start_time'] = time.time()
        self.stats['total'] = total_items
        self.logger.info(f"파이프라인 시작: 총 {total_items}개 항목")
    
    def log_progress(self, current):
        """진행 상황 로깅"""
        self.stats['processed'] = current
        progress = (current / self.stats['total']) * 100
        elapsed = time.time() - self.stats['start_time']
        rate = current / elapsed if elapsed > 0 else 0
        
        self.logger.info(
            f"진행: {current}/{self.stats['total']} ({progress:.1f}%) "
            f"| 속도: {rate:.1f}개/초 | 에러: {self.stats['errors']}개"
        )
    
    def log_error(self, item_id, error):
        """에러 로깅"""
        self.stats['errors'] += 1
        self.logger.error(f"항목 {item_id} 처리 실패: {str(error)}")
    
    def finish_pipeline(self):
        """파이프라인 완료"""
        elapsed = time.time() - self.stats['start_time']
        success_rate = ((self.stats['processed'] - self.stats['errors']) / 
                       self.stats['total'] * 100)
        
        self.logger.info(
            f"파이프라인 완료! "
            f"소요시간: {elapsed:.1f}초 | "
            f"성공률: {success_rate:.1f}% | "
            f"에러: {self.stats['errors']}개"
        )

# 사용 예제
pipeline_logger = DataPipelineLogger('data_pipeline')

items = range(1000)
pipeline_logger.start_pipeline(len(items))

for i, item in enumerate(items):
    try:
        # 데이터 처리
        time.sleep(0.001)  # 실제 작업 시뮬레이션
        
        if i % 100 == 0:
            pipeline_logger.log_progress(i)
    
    except Exception as e:
        pipeline_logger.log_error(item, e)

pipeline_logger.finish_pipeline()

🔌 API 클라이언트

import logging
import requests
from functools import wraps
import time

def log_api_call(logger):
    """API 호출을 자동으로 로깅하는 데코레이터"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            start_time = time.time()
            
            # 요청 정보 로깅
            logger.info(f"API 호출 시작: {func.__name__}")
            logger.debug(f"인자: args={args}, kwargs={kwargs}")
            
            try:
                response = func(*args, **kwargs)
                elapsed = time.time() - start_time
                
                # 성공 로깅
                logger.info(
                    f"API 호출 성공: {func.__name__} "
                    f"(소요시간: {elapsed:.2f}초, 상태코드: {response.status_code})"
                )
                logger.debug(f"응답: {response.text[:200]}")  # 처음 200자만
                
                return response
            
            except requests.exceptions.RequestException as e:
                elapsed = time.time() - start_time
                logger.error(
                    f"API 호출 실패: {func.__name__} "
                    f"(소요시간: {elapsed:.2f}초, 에러: {str(e)})"
                )
                raise
        
        return wrapper
    return decorator

# 사용 예제
logger = logging.getLogger(__name__)

@log_api_call(logger)
def fetch_user_data(user_id):
    """사용자 데이터 조회"""
    response = requests.get(f"https://api.example.com/users/{user_id}")
    response.raise_for_status()
    return response

# 호출
try:
    data = fetch_user_data(12345)
except Exception as e:
    logger.error(f"사용자 데이터 조회 실패: {e}")

🎨 로그 분석 및 모니터링

📈 ELK Stack (Elasticsearch, Logstash, Kibana)

from elasticsearch import Elasticsearch
import logging
from datetime import datetime

class ElasticsearchHandler(logging.Handler):
    """Elasticsearch로 로그를 전송하는 핸들러"""
    
    def __init__(self, es_host='localhost', es_port=9200, index_name='app-logs'):
        super().__init__()
        self.es = Elasticsearch([f'http://{es_host}:{es_port}'])
        self.index_name = index_name
    
    def emit(self, record):
        """로그 레코드를 Elasticsearch로 전송"""
        log_entry = {
            'timestamp': datetime.utcnow().isoformat(),
            'level': record.levelname,
            'logger': record.name,
            'message': record.getMessage(),
            'module': record.module,
            'function': record.funcName,
            'line': record.lineno
        }
        
        if record.exc_info:
            log_entry['exception'] = self.format(record)
        
        try:
            self.es.index(
                index=f"{self.index_name}-{datetime.utcnow().strftime('%Y.%m.%d')}",
                document=log_entry
            )
        except Exception as e:
            print(f"Elasticsearch 전송 실패: {e}")

# 사용 예제
logger = logging.getLogger(__name__)
es_handler = ElasticsearchHandler()
logger.addHandler(es_handler)
logger.setLevel(logging.INFO)

logger.info("이 로그는 Elasticsearch에 저장됩니다!")

🔔 실시간 알림 설정

import logging
import requests

class SlackHandler(logging.Handler):
    """Slack으로 로그를 전송하는 핸들러"""
    
    def __init__(self, webhook_url, username='LogBot', emoji=':robot_face:'):
        super().__init__()
        self.webhook_url = webhook_url
        self.username = username
        self.emoji = emoji
    
    def emit(self, record):
        """로그 레코드를 Slack으로 전송"""
        if record.levelno < logging.ERROR:
            return  # ERROR 이상만 전송
        
        # 색상 설정
        color_map = {
            logging.ERROR: '#ff9800',
            logging.CRITICAL: '#f44336'
        }
        
        message = {
            'username': self.username,
            'icon_emoji': self.emoji,
            'attachments': [{
                'color': color_map.get(record.levelno, '#2196f3'),
                'title': f'{record.levelname}: {record.name}',
                'text': record.getMessage(),
                'fields': [
                    {
                        'title': '파일',
                        'value': f'{record.filename}:{record.lineno}',
                        'short': True
                    },
                    {
                        'title': '함수',
                        'value': record.funcName,
                        'short': True
                    }
                ],
                'footer': 'Python Logger',
                'ts': int(record.created)
            }]
        }
        
        if record.exc_info:
            message['attachments'][0]['text'] += f"\n```{self.format(record)}```"
        
        try:
            requests.post(self.webhook_url, json=message)
        except Exception as e:
            print(f"Slack 전송 실패: {e}")

# 사용 예제
logger = logging.getLogger(__name__)
slack_handler = SlackHandler('https://hooks.slack.com/services/YOUR/WEBHOOK/URL')
logger.addHandler(slack_handler)

# 이제 ERROR 이상의 로그는 Slack으로 전송됨
logger.error("긴급! 데이터베이스 연결 실패!")

🧪 테스트 환경에서의 로깅

🎯 pytest와 로깅

# conftest.py
import logging
import pytest

@pytest.fixture(autouse=True)
def setup_logging(caplog):
    """모든 테스트에 로깅 설정 적용"""
    caplog.set_level(logging.DEBUG)

# test_example.py
import logging

logger = logging.getLogger(__name__)

def test_with_logging():
    """로깅을 포함한 테스트"""
    logger.info("테스트 시작")
    
    result = 2 + 2
    logger.debug(f"계산 결과: {result}")
    
    assert result == 4
    logger.info("테스트 성공")

def test_log_capture(caplog):
    """로그 캡처 테스트"""
    logger.warning("경고 메시지")
    
    # 로그가 제대로 기록됐는지 확인
    assert "경고 메시지" in caplog.text
    assert any(record.levelname == "WARNING" for record in caplog.records)

# 모든 로그 출력
pytest -v --log-cli-level=DEBUG

# 실패한 테스트의 로그만 출력
pytest -v --log-cli-level=INFO

# 로그를 파일로 저장
pytest --log-file=test.log --log-file-level=DEBUG

🔍 Mock과 로깅

import logging
from unittest.mock import Mock, patch
import pytest

logger = logging.getLogger(__name__)

def fetch_data_from_api(api_client, user_id):
    """API에서 데이터를 가져오는 함수"""
    logger.info(f"사용자 {user_id} 데이터 조회 시작")
    
    try:
        data = api_client.get_user(user_id)
        logger.info(f"데이터 조회 성공: {len(data)} 항목")
        return data
    except Exception as e:
        logger.error(f"데이터 조회 실패: {e}")
        raise

def test_fetch_data_success(caplog):
    """성공 케이스 테스트"""
    # Mock API 클라이언트
    mock_client = Mock()
    mock_client.get_user.return_value = {'id': 123, 'name': '홍길동'}
    
    # 함수 실행
    result = fetch_data_from_api(mock_client, 123)
    
    # 결과 확인
    assert result['id'] == 123
    
    # 로그 확인
    assert "데이터 조회 시작" in caplog.text
    assert "데이터 조회 성공" in caplog.text

def test_fetch_data_failure(caplog):
    """실패 케이스 테스트"""
    # Mock API 클라이언트 (에러 발생)
    mock_client = Mock()
    mock_client.get_user.side_effect = Exception("API 에러")
    
    # 예외 발생 확인
    with pytest.raises(Exception):
        fetch_data_from_api(mock_client, 123)
    
    # 에러 로그 확인
    assert "데이터 조회 실패" in caplog.text
    assert "API 에러" in caplog.text

🚀 프로덕션 환경 최적화

⚡ 비동기 로깅

import logging
from logging.handlers import QueueHandler, QueueListener
import queue
import atexit

def setup_async_logging():
    """비동기 로깅 설정"""
    # 로그 큐 생성
    log_queue = queue.Queue(-1)  # 무제한 크기
    
    # 실제 로그를 처리할 핸들러들
    file_handler = logging.handlers.RotatingFileHandler(
        'logs/app.log',
        maxBytes=10*1024*1024,
        backupCount=5
    )
    console_handler = logging.StreamHandler()
    
    # 포매터 설정
    formatter = logging.Formatter(
        '%(asctime)s | %(levelname)s | %(name)s | %(message)s'
    )
    file_handler.setFormatter(formatter)
    console_handler.setFormatter(formatter)
    
    # QueueListener: 백그라운드에서 큐의 로그를 처리
    listener = QueueListener(
        log_queue,
        file_handler,
        console_handler,
        respect_handler_level=True
    )
    listener.start()
    
    # 프로그램 종료 시 리스너도 종료
    atexit.register(listener.stop)
    
    # 루트 로거에 QueueHandler 추가
    queue_handler = QueueHandler(log_queue)
    root_logger = logging.getLogger()
    root_logger.addHandler(queue_handler)
    root_logger.setLevel(logging.INFO)
    
    return listener

# 사용
listener = setup_async_logging()
logger = logging.getLogger(__name__)

# 이제 로깅이 비동기로 처리됨!
for i in range(10000):
    logger.info(f"메시지 {i}")  # 메인 스레드를 블로킹하지 않음

🎚️ 동적 로그 레벨 조정

import logging
import signal
import sys

class DynamicLogLevel:
    """동적으로 로그 레벨을 조정하는 클래스"""
    
    def __init__(self):
        self.logger = logging.getLogger()
        self.current_level = logging.INFO
        self.logger.setLevel(self.current_level)
        
        # 시그널 핸들러 등록
        signal.signal(signal.SIGUSR1, self.increase_verbosity)
        signal.signal(signal.SIGUSR2, self.decrease_verbosity)
    
    def increase_verbosity(self, signum, frame):
        """로그 레벨을 더 상세하게 (SIGUSR1)"""
        levels = [logging.CRITICAL, logging.ERROR, logging.WARNING, 
                 logging.INFO, logging.DEBUG]
        
        current_index = levels.index(self.current_level)
        if current_index < len(levels) - 1:
            self.current_level = levels[current_index + 1]
            self.logger.setLevel(self.current_level)
            print(f"로그 레벨 변경: {logging.getLevelName(self.current_level)}")
    
    def decrease_verbosity(self, signum, frame):
        """로그 레벨을 덜 상세하게 (SIGUSR2)"""
        levels = [logging.CRITICAL, logging.ERROR, logging.WARNING, 
                 logging.INFO, logging.DEBUG]
        
        current_index = levels.index(self.current_level)
        if current_index > 0:
            self.current_level = levels[current_index - 1]
            self.logger.setLevel(self.current_level)
            print(f"로그 레벨 변경: {logging.getLevelName(self.current_level)}")

# 사용
dynamic_log = DynamicLogLevel()

# 이제 실행 중인 프로세스에 시그널을 보내서 로그 레벨 조정 가능
# kill -USR1 <pid>  # 더 상세하게
# kill -USR2 <pid>  # 덜 상세하게

📊 로그 샘플링

import logging
import random

class SamplingFilter(logging.Filter):
    """로그를 샘플링하는 필터"""
    
    def __init__(self, sample_rate=0.1):
        """
        sample_rate: 0.0 ~ 1.0 사이의 값
        0.1 = 10%만 로깅
        """
        super().__init__()
        self.sample_rate = sample_rate
    
    def filter(self, record):
        # ERROR 이상은 항상 로깅
        if record.levelno >= logging.ERROR:
            return True
        
        # 나머지는 샘플링
        return random.random() < self.sample_rate

# 사용 예제
logger = logging.getLogger(__name__)
handler = logging.StreamHandler()

# INFO 로그는 10%만 기록
sampling_filter = SamplingFilter(sample_rate=0.1)
handler.addFilter(sampling_filter)

logger.addHandler(handler)
logger.setLevel(logging.INFO)

# 1000개 중 약 100개만 로깅됨
for i in range(1000):
    logger.info(f"요청 처리: {i}")

# 하지만 에러는 모두 로깅됨
logger.error("이건 반드시 기록됨!")

🛡️ 보안 고려사항

🔐 안전한 로깅 체크리스트

import logging
import hashlib
import re

class SecureLogger:
    """보안을 고려한 로거 래퍼"""
    
    def __init__(self, name):
        self.logger = logging.getLogger(name)
        self.sensitive_patterns = {
            'password': re.compile(r'password["\']?\s*[:=]\s*["\']?([^"\'}\s,]+)', re.I),
            'token': re.compile(r'token["\']?\s*[:=]\s*["\']?([^"\'}\s,]+)', re.I),
            'api_key': re.compile(r'api[_-]?key["\']?\s*[:=]\s*["\']?([^"\'}\s,]+)', re.I),
            'card': re.compile(r'\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b'),
            'ssn': re.compile(r'\b\d{6}-\d{7}\b'),
        }
    
    def _sanitize(self, message):
        """민감한 정보를 마스킹"""
        for name, pattern in self.sensitive_patterns.items():
            message = pattern.sub(f'{name}=***REDACTED***', message)
        return message
    
    def _hash_identifier(self, identifier):
        """식별자를 해시로 변환 (추적은 가능하되 원본은 숨김)"""
        return hashlib.sha256(str(identifier).encode()).hexdigest()[:16]
    
    def info(self, message, **kwargs):
        """안전한 INFO 로깅"""
        safe_message = self._sanitize(message)
        self.logger.info(safe_message, **kwargs)
    
    def error(self, message, **kwargs):
        """안전한 ERROR 로깅"""
        safe_message = self._sanitize(message)
        self.logger.error(safe_message, **kwargs)
    
    def log_user_action(self, user_id, action):
        """사용자 행동 로깅 (ID는 해시로)"""
        hashed_id = self._hash_identifier(user_id)
        self.logger.info(f"사용자 행동: {hashed_id} - {action}")

# 사용 예제
secure_logger = SecureLogger(__name__)

# 위험한 정보가 자동으로 마스킹됨
secure_logger.info("로그인 시도: password=secret123, token=abc123xyz")
# 실제 로그: "로그인 시도: password=***REDACTED***, token=***REDACTED***"

# 사용자 ID는 해시로 변환
secure_logger.log_user_action(12345, "상품 구매")
# 실제 로그: "사용자 행동: 8d969eef6ecad3c2 - 상품 구매"

🔒 로그 파일 보안

import os
import logging
from logging.handlers import RotatingFileHandler

def create_secure_log_handler(log_file):
    """보안이 강화된 로그 핸들러 생성"""
    
    # 로그 디렉토리 생성 (권한 제한)
    log_dir = os.path.dirname(log_file)
    if not os.path.exists(log_dir):
        os.makedirs(log_dir, mode=0o750)  # rwxr-x---
    
    # 핸들러 생성
    handler = RotatingFileHandler(
        log_file,
        maxBytes=10*1024*1024,
        backupCount=5
    )
    
    # 로그 파일 권한 설정 (소유자만 읽기/쓰기)
    if os.path.exists(log_file):
        os.chmod(log_file, 0o600)  # rw-------
    
    return handler

# 사용
handler = create_secure_log_handler('/var/log/myapp/app.log')
logger = logging.getLogger(__name__)
logger.addHandler(handler)

🎓 실전 프로젝트 예제

🏗️ 완전한 로깅 시스템 구축

# logging_config.py
import logging
import logging.handlers
import os
import json
from datetime import datetime
from pathlib import Path

class ProductionLoggingSystem:
    """프로덕션 환경을 위한 완전한 로깅 시스템"""
    
    def __init__(self, app_name, log_dir='logs', environment='production'):
        self.app_name = app_name
        self.log_dir = Path(log_dir)
        self.environment = environment
        
        # 로그 디렉토리 생성
        self.log_dir.mkdir(parents=True, exist_ok=True)
        
        # 로거 딕셔너리
        self.loggers = {}
        
        # 기본 로거들 설정
        self._setup_loggers()
    
    def _setup_loggers(self):
        """다양한 목적의 로거들을 설정"""
        
        # 1. 애플리케이션 로거
        self.loggers['app'] = self._create_logger(
            'app',
            self.log_dir / 'app.log',
            level=logging.INFO
        )
        
        # 2. 에러 로거 (ERROR 이상만)
        self.loggers['error'] = self._create_logger(
            'error',
            self.log_dir / 'error.log',
            level=logging.ERROR
        )
        
        # 3. 액세스 로거 (API 요청 등)
        self.loggers['access'] = self._create_logger(
            'access',
            self.log_dir / 'access.log',
            level=logging.INFO,
            format_type='access'
        )
        
        # 4. 성능 로거
        self.loggers['performance'] = self._create_logger(
            'performance',
            self.log_dir / 'performance.log',
            level=logging.INFO,
            format_type='json'
        )
        
        # 5. 보안 로거
        self.loggers['security'] = self._create_logger(
            'security',
            self.log_dir / 'security.log',
            level=logging.WARNING
        )
    
    def _create_logger(self, name, log_file, level=logging.INFO, format_type='standard'):
        """개별 로거 생성"""
        logger = logging.getLogger(f'{self.app_name}.{name}')
        logger.setLevel(level)
        logger.propagate = False
        
        # 파일 핸들러
        file_handler = logging.handlers.RotatingFileHandler(
            log_file,
            maxBytes=50*1024*1024,  # 50MB
            backupCount=10,
            encoding='utf-8'
        )
        
        # 포매터 선택
        if format_type == 'json':
            formatter = self._get_json_formatter()
        elif format_type == 'access':
            formatter = self._get_access_formatter()
        else:
            formatter = self._get_standard_formatter()
        
        file_handler.setFormatter(formatter)
        logger.addHandler(file_handler)
        
        # 개발 환경에서는 콘솔에도 출력
        if self.environment == 'development':
            console_handler = logging.StreamHandler()
            console_handler.setFormatter(formatter)
            logger.addHandler(console_handler)
        
        return logger
    
    def _get_standard_formatter(self):
        """표준 포매터"""
        return logging.Formatter(
            '%(asctime)s | %(levelname)-8s | %(name)s | %(funcName)s:%(lineno)d | %(message)s',
            datefmt='%Y-%m-%d %H:%M:%S'
        )
    
    def _get_access_formatter(self):
        """액세스 로그 포매터"""
        return logging.Formatter(
            '%(asctime)s | %(message)s',
            datefmt='%Y-%m-%d %H:%M:%S'
        )
    
    def _get_json_formatter(self):
        """JSON 포매터"""
        class JsonFormatter(logging.Formatter):
            def format(self, record):
                log_data = {
                    'timestamp': datetime.utcnow().isoformat(),
                    'level': record.levelname,
                    'logger': record.name,
                    'message': record.getMessage(),
                    'module': record.module,
                    'function': record.funcName,
                    'line': record.lineno
                }
                
                if record.exc_info:
                    log_data['exception'] = self.formatException(record.exc_info)
                
                return json.dumps(log_data, ensure_ascii=False)
        
        return JsonFormatter()
    
    def get_logger(self, logger_type='app'):
        """특정 타입의 로거 반환"""
        return self.loggers.get(logger_type, self.loggers['app'])

# 사용 예제
logging_system = ProductionLoggingSystem('MyApp', environment='production')

# 다양한 로거 사용
app_logger = logging_system.get_logger('app')
error_logger = logging_system.get_logger('error')
access_logger = logging_system.get_logger('access')
perf_logger = logging_system.get_logger('performance')
security_logger = logging_system.get_logger('security')

# 로깅
app_logger.info("애플리케이션 시작")
access_logger.info("GET /api/users - 200 - 45ms")
perf_logger.info("데이터베이스 쿼리 완료", extra={'duration': 0.045})
security_logger.warning("의심스러운 로그인 시도")
error_logger.error("데이터베이스 연결 실패", exc_info=True)

🎯 컨텍스트 기반 로깅

# context_logging.py
import logging
import contextvars
import uuid
from functools import wraps

# 컨텍스트 변수 정의
request_id_var = contextvars.ContextVar('request_id', default=None)
user_id_var = contextvars.ContextVar('user_id', default=None)

class ContextFilter(logging.Filter):
    """컨텍스트 정보를 로그에 추가하는 필터"""
    
    def filter(self, record):
        record.request_id = request_id_var.get() or 'N/A'
        record.user_id = user_id_var.get() or 'anonymous'
        return True

def setup_context_logging():
    """컨텍스트 로깅 설정"""
    logger = logging.getLogger()
    
    # 컨텍스트 필터 추가
    context_filter = ContextFilter()
    
    handler = logging.StreamHandler()
    handler.addFilter(context_filter)
    
    # 포매터에 컨텍스트 정보 포함
    formatter = logging.Formatter(
        '%(asctime)s | [%(request_id)s] [%(user_id)s] | %(levelname)s | %(message)s'
    )
    handler.setFormatter(formatter)
    
    logger.addHandler(handler)
    logger.setLevel(logging.INFO)

def with_request_context(func):
    """요청 컨텍스트를 자동으로 설정하는 데코레이터"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 새로운 요청 ID 생성
        request_id = str(uuid.uuid4())
        request_id_var.set(request_id)
        
        logger = logging.getLogger(__name__)
        logger.info(f"요청 시작: {func.__name__}")
        
        try:
            result = func(*args, **kwargs)
            logger.info(f"요청 완료: {func.__name__}")
            return result
        except Exception as e:
            logger.error(f"요청 실패: {func.__name__} - {str(e)}")
            raise
        finally:
            # 컨텍스트 정리
            request_id_var.set(None)
    
    return wrapper

# 사용 예제
setup_context_logging()
logger = logging.getLogger(__name__)

@with_request_context
def process_user_request(user_id, action):
    """사용자 요청 처리"""
    # 사용자 ID 설정
    user_id_var.set(user_id)
    
    logger.info(f"작업 수행: {action}")
    
    # 실제 작업
    if action == "delete":
        logger.warning("삭제 작업 수행")
    
    return "완료"

# 호출
process_user_request(12345, "update")
process_user_request(67890, "delete")

# 출력 예시:
# 2024-01-15 10:30:45 | [a1b2c3d4-...] [12345] | INFO | 요청 시작: process_user_request
# 2024-01-15 10:30:45 | [a1b2c3d4-...] [12345] | INFO | 작업 수행: update
# 2024-01-15 10:30:45 | [a1b2c3d4-...] [12345] | INFO | 요청 완료: process_user_request

🎨 디버깅 워크플로우

📋 디버깅 체크리스트

🔬 디버깅 도구 조합

🌟 재능넷에서 배우고 나누기

🎯 마무리하며