import logging

# 기본 로깅 설정
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    filename='app.log'
)

# 로거 생성
logger = logging.getLogger(__name__)

# 로그 레벨 사용
logger.debug('디버그 메시지')
logger.info('정보 메시지')
logger.warning('경고 메시지')
logger.error('에러 메시지')
logger.critical('치명적 에러 메시지')

# 계층적 로거 예시
logger = logging.getLogger('app.module.submodule')

import logging
from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler

# 파일 핸들러 설정
file_handler = RotatingFileHandler(
    'app.log',
    maxBytes=1024*1024,  # 1MB
    backupCount=5
)
file_handler.setLevel(logging.DEBUG)

# 콘솔 핸들러
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.WARNING)

# 포매터 설정
formatter = logging.Formatter(
    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 로거에 핸들러 추가
logger = logging.getLogger(__name__)
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# 크기 기반 로테이션 (더 상세한 예시)
size_handler = RotatingFileHandler(
    'app.log',
    maxBytes=10*1024*1024,  # 10MB
    backupCount=10
)

# 시간 기반 로테이션
time_handler = TimedRotatingFileHandler(
    'app.log',
    when='midnight',  # 매일 자정
    interval=1,       # 1일마다
    backupCount=30    # 30일치 보관
)

# 사용자 정의 로테이션 (S3 백업 예시)
import boto3
from logging.handlers import RotatingFileHandler

class S3RotatingFileHandler(RotatingFileHandler):
    def __init__(self, filename, mode='a', maxBytes=0, backupCount=0,
                 encoding=None, delay=False, bucket_name=None):
        self.bucket_name = bucket_name
        super().__init__(filename, mode, maxBytes, backupCount, encoding, delay)
    
    def doRollover(self):
        # 기본 로테이션 수행
        super().doRollover()
        
        # S3에 백업
        if self.bucket_name:
            s3 = boto3.client('s3')
            backup_file = f"{self.baseFilename}.1"
            s3.upload_file(
                backup_file, 
                self.bucket_name, 
                f"logs/{os.path.basename(backup_file)}"
            )

# 레벨별 다중 핸들러 설정 예시
logger = logging.getLogger('app')
logger.setLevel(logging.DEBUG)  # 로거 자체는 모든 메시지 처리

# 모든 로그는 파일에 기록
file_handler = logging.FileHandler('full.log')
file_handler.setLevel(logging.DEBUG)
logger.addHandler(file_handler)

# 경고 이상은 콘솔에 출력
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.WARNING)
logger.addHandler(console_handler)

# 에러 이상은 이메일로 전송
email_handler = logging.handlers.SMTPHandler(
    mailhost=('smtp.example.com', 587),
    fromaddr='[email protected]',
    toaddrs=['[email protected]'],
    subject='Application Error',
    credentials=('username', 'password'),
    secure=()
)
email_handler.setLevel(logging.ERROR)
logger.addHandler(email_handler)

# logging.conf
[loggers]
keys=root,myapp

[handlers]
keys=consoleHandler,fileHandler

[formatters]
keys=simpleFormatter

[logger_root]
level=DEBUG
handlers=consoleHandler

[logger_myapp]
level=DEBUG
handlers=fileHandler
qualname=myapp
propagate=0

[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=simpleFormatter
args=(sys.stdout,)

[handler_fileHandler]
class=FileHandler
level=DEBUG
formatter=simpleFormatter
args=('app.log', 'a')

[formatter_simpleFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt=%Y-%m-%d %H:%M:%S

import logging
import logging.config

# .conf 파일 사용
logging.config.fileConfig('logging.conf')

# 설정 파일에 정의된 로거 사용
logger = logging.getLogger('myapp')
logger.info('설정 파일에서 로드된 로거로 메시지 기록')

# logging.json 예시
{
    "version": 1,
    "disable_existing_loggers": false,
    "formatters": {
        "standard": {
            "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
        },
        "detailed": {
            "format": "%(asctime)s - %(name)s - %(levelname)s - %(pathname)s:%(lineno)d - %(message)s"
        }
    },
    "handlers": {
        "console": {
            "class": "logging.StreamHandler",
            "level": "INFO",
            "formatter": "standard",
            "stream": "ext://sys.stdout"
        },
        "file": {
            "class": "logging.handlers.RotatingFileHandler",
            "level": "DEBUG",
            "formatter": "detailed",
            "filename": "app.log",
            "maxBytes": 10485760,
            "backupCount": 5,
            "encoding": "utf8"
        }
    },
    "loggers": {
        "": {
            "handlers": ["console"],
            "level": "INFO"
        },
        "myapp": {
            "handlers": ["file"],
            "level": "DEBUG",
            "propagate": false
        }
    }
}

# JSON 설정 로드
import json
import logging.config

with open('logging.json', 'r') as f:
    config = json.load(f)
    
logging.config.dictConfig(config)
logger = logging.getLogger('myapp')

import os
import logging.config
import yaml

# 환경 변수에 따른 설정 파일 선택
env = os.environ.get('ENVIRONMENT', 'development')
config_path = f'config/logging_{env}.yaml'

# YAML 설정 로드
with open(config_path, 'r') as f:
    config = yaml.safe_load(f)
    
logging.config.dictConfig(config)

# 실행 중 로그 레벨 변경
def set_log_level(logger_name, level):
    """로거의 레벨을 동적으로 변경"""
    logger = logging.getLogger(logger_name)
    logger.setLevel(getattr(logging, level))
    
    # 핸들러 레벨도 변경
    for handler in logger.handlers:
        handler.setLevel(getattr(logging, level))
    
    return f"로거 '{logger_name}'의 레벨이 {level}로 변경되었습니다."

# 사용 예: 디버그 모드 전환
set_log_level('myapp', 'DEBUG')  # 더 상세한 로깅으로 전환

import logging
import re
from datetime import datetime

class SecurityFilter(logging.Filter):
    def __init__(self, param=None):
        self.param = param
        
    def filter(self, record):
        if hasattr(record, 'msg'):
            record.msg = self.mask_sensitive_data(record.msg)
        return True
    
    def mask_sensitive_data(self, msg):
        if isinstance(msg, str):
            msg = re.sub(r'\d{4}-\d{4}-\d{4}-\d{4}', 'XXXX-XXXX-XXXX-XXXX', msg)
            msg = re.sub(r'password=.*?[,\s]', 'password=****', msg)
        return msg

class CustomLogger(logging.Logger):
    def __init__(self, name):
        super().__init__(name)
        self.addFilter(SecurityFilter())

import logging
import re

class SensitiveDataFilter(logging.Filter):
    """민감한 개인정보를 마스킹하는 필터"""
    
    def __init__(self):
        super().__init__()
        # 정규식 패턴 컴파일
        self.patterns = {
            'credit_card': re.compile(r'\b(?:\d{4}[- ]?){3}\d{4}\b'),
            'email': re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'),
            'phone': re.compile(r'\b01[016789][- ]?\d{3,4}[- ]?\d{4}\b'),
            'ssn': re.compile(r'\b\d{6}[- ]?\d{7}\b')
        }
        self.replacements = {
            'credit_card': 'XXXX-XXXX-XXXX-XXXX',
            'email': '[이메일 삭제됨]',
            'phone': '[전화번호 삭제됨]',
            'ssn': '[주민번호 삭제됨]'
        }
    
    def filter(self, record):
        if isinstance(record.msg, str):
            for key, pattern in self.patterns.items():
                record.msg = pattern.sub(self.replacements[key], record.msg)
        return True

# 필터 적용
logger = logging.getLogger('secure')
logger.addFilter(SensitiveDataFilter())

# 사용 예시
logger.info("사용자 이메일: [email protected], 카드번호: 1234-5678-9012-3456")
# 출력: "사용자 이메일: [이메일 삭제됨], 카드번호: XXXX-XXXX-XXXX-XXXX"

import logging
import time

class PerformanceLogger(logging.Logger):
    """실행 시간을 자동으로 측정하는 로거"""
    
    def __init__(self, name, level=logging.NOTSET):
        super().__init__(name, level)
        self.start_times = {}
    
    def start_timer(self, task_name):
        """작업 타이머 시작"""
        self.start_times[task_name] = time.time()
        self.info(f"작업 시작: {task_name}")
    
    def end_timer(self, task_name):
        """작업 타이머 종료 및 경과 시간 로깅"""
        if task_name in self.start_times:
            elapsed = time.time() - self.start_times[task_name]
            self.info(f"작업 완료: {task_name} (소요 시간: {elapsed:.3f}초)")
            del self.start_times[task_name]
        else:
            self.warning(f"알 수 없는 작업: {task_name}")

# 커스텀 로거 클래스 등록
logging.setLoggerClass(PerformanceLogger)

# 사용 예시
logger = logging.getLogger('performance')
logger.start_timer('데이터 처리')
# ... 시간이 걸리는 작업 수행 ...
logger.end_timer('데이터 처리')

import logging
import requests

class SlackHandler(logging.Handler):
    """Slack으로 로그 메시지를 전송하는 핸들러"""
    
    def __init__(self, webhook_url, channel="#alerts", username="Logger"):
        super().__init__()
        self.webhook_url = webhook_url
        self.channel = channel
        self.username = username
    
    def emit(self, record):
        try:
            # 로그 메시지 포맷팅
            log_message = self.format(record)
            
            # Slack 메시지 페이로드
            payload = {
                "channel": self.channel,
                "username": self.username,
                "text": log_message,
                "icon_emoji": ":warning:" if record.levelno >= logging.WARNING else ":information_source:"
            }
            
            # Slack webhook 호출
            requests.post(self.webhook_url, json=payload)
        except Exception:
            self.handleError(record)

# 사용 예시
slack_handler = SlackHandler('https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK')
slack_handler.setLevel(logging.ERROR)  # 오류만 Slack으로 전송
formatter = logging.Formatter('%(levelname)s - %(message)s')
slack_handler.setFormatter(formatter)

logger = logging.getLogger('app')
logger.addHandler(slack_handler)

from contextvars import ContextVar
from threading import Lock

request_id = ContextVar('request_id', default=None)

class ContextualLogger:
    def __init__(self, logger):
        self.logger = logger
        self._lock = Lock()
    
    def _format_message(self, message):
        rid = request_id.get()
        return f"[RequestID: {rid}] {message}" if rid else message
    
    def info(self, message, *args, **kwargs):
        with self._lock:
            self.logger.info(self._format_message(message), *args, **kwargs)

import logging
from contextvars import ContextVar
import uuid

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

class ContextFilter(logging.Filter):
    """로그 레코드에 컨텍스트 정보 추가"""
    
    def filter(self, record):
        # 컨텍스트 변수에서 값 가져오기
        record.request_id = request_id.get()
        record.user_id = user_id.get()
        return True

# 웹 요청 처리 예시
def process_request(request_data, user=None):
    # 컨텍스트 설정
    req_id = str(uuid.uuid4())
    request_id.set(req_id)
    
    if user:
        user_id.set(user['id'])
    
    logger = logging.getLogger('app')
    logger.info(f"요청 처리 시작: {request_data}")
    
    # 처리 로직...
    
    logger.info("요청 처리 완료")
    return {"status": "success", "request_id": req_id}

import logging
import threading
import uuid

# 스레드 로컬 스토리지
context = threading.local()

class ThreadContextFilter(logging.Filter):
    """스레드 로컬 컨텍스트를 로그에 추가"""
    
    def filter(self, record):
        if hasattr(context, 'request_id'):
            record.request_id = context.request_id
        else:
            record.request_id = 'no-request-id'
            
        if hasattr(context, 'user_id'):
            record.user_id = context.user_id
        else:
            record.user_id = 'anonymous'
            
        return True

# 스레드 컨텍스트 초기화
def init_request_context():
    context.request_id = str(uuid.uuid4())
    context.start_time = time.time()

# 컨텍스트 클리어
def clear_request_context():
    if hasattr(context, 'request_id'):
        delattr(context, 'request_id')
    if hasattr(context, 'start_time'):
        delattr(context, 'start_time')

import logging
from contextlib import contextmanager
import time

logger = logging.getLogger('app')

@contextmanager
def log_context(**kwargs):
    """로깅 컨텍스트를 설정하는 컨텍스트 매니저"""
    # 이전 MDC 저장
    old_mdc = logging.MDC.get_map() if hasattr(logging, 'MDC') else {}
    
    # 새 컨텍스트 설정
    for k, v in kwargs.items():
        logging.MDC.put(k, v) if hasattr(logging, 'MDC') else None
    
    try:
        yield
    finally:
        # 이전 MDC 복원
        logging.MDC.clear() if hasattr(logging, 'MDC') else None
        for k, v in old_mdc.items():
            logging.MDC.put(k, v) if hasattr(logging, 'MDC') else None

# 사용 예시
with log_context(operation='data_export', user_id='12345'):
    logger.info("데이터 내보내기 시작")
    # ... 작업 수행 ...
    logger.info("데이터 내보내기 완료")

import logging
import json
from datetime import datetime

class JsonFormatter(logging.Formatter):
    """로그 메시지를 JSON 형식으로 포맷팅"""
    
    def format(self, record):
        log_object = {
            "timestamp": datetime.fromtimestamp(record.created).isoformat(),
            "level": record.levelname,
            "message": record.getMessage(),
            "logger": record.name,
            "path": record.pathname,
            "line": record.lineno,
            "function": record.funcName
        }
        
        # 예외 정보 추가
        if record.exc_info:
            log_object["exception"] = self.formatException(record.exc_info)
            
        # 추가 속성 포함
        for key, value in record.__dict__.items():
            if key not in log_object and not key.startswith('_') and isinstance(value, (str, int, float, bool, type(None))):
                log_object[key] = value
                
        return json.dumps(log_object)

# 사용 예시
handler = logging.StreamHandler()
handler.setFormatter(JsonFormatter())

logger = logging.getLogger('app')
logger.addHandler(handler)
logger.setLevel(logging.INFO)

# 구조화된 로그 출력
logger.info("사용자 로그인", extra={
    "user_id": "user123",
    "ip_address": "192.168.1.1",
    "browser": "Chrome 90.0",
    "status": "success"
})

# python-json-logger 사용 예시
import logging
from pythonjsonlogger import jsonlogger

logger = logging.getLogger()

handler = logging.StreamHandler()
formatter = jsonlogger.JsonFormatter('%(timestamp)s %(level)s %(name)s %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)

# structlog 사용 예시
import structlog

structlog.configure(
    processors=[
        structlog.processors.TimeStamper(fmt="iso"),
        structlog.processors.JSONRenderer()
    ],
    context_class=dict,
    logger_factory=structlog.stdlib.LoggerFactory(),
)

logger = structlog.get_logger()
logger.info("이벤트 발생", user_id=123, action="login")

import logging
import json
import socket
import os
import platform

class EnhancedJsonFormatter(logging.Formatter):
    """시스템 정보가 포함된 향상된 JSON 포맷터"""
    
    def __init__(self):
        super().__init__()
        # 정적 메타데이터 미리 계산
        self.static_metadata = {
            "hostname": socket.gethostname(),
            "pid": os.getpid(),
            "python_version": platform.python_version(),
            "platform": platform.platform(),
            "application": os.environ.get("APP_NAME", "unknown")
        }
    
    def format(self, record):
        log_data = {
            "timestamp": self.formatTime(record, self.datefmt),
            "level": record.levelname,
            "logger": record.name,
            "message": record.getMessage(),
            "location": f"{record.pathname}:{record.lineno}",
            **self.static_metadata
        }
        
        # 동적 메타데이터 추가
        for key, value in record.__dict__.items():
            if key not in log_data and not key.startswith('_'):
                if isinstance(value, (str, int, float, bool, type(None))):
                    log_data[key] = value
        
        # 스택 트레이스 처리
        if record.exc_info:
            log_data["exception"] = self.formatException(record.exc_info)
            
        return json.dumps(log_data)

# Sentry 연동 예시
import logging
import sentry_sdk
from sentry_sdk.integrations.logging import LoggingIntegration

# Sentry 설정
sentry_logging = LoggingIntegration(
    level=logging.INFO,        # 캡처할 최소 로그 레벨
    event_level=logging.ERROR  # 이벤트로 전송할 최소 레벨
)

sentry_sdk.init(
    dsn="https://[email protected]/0",
    integrations=[sentry_logging]
)

# ELK 스택용 로깅 설정
import logging
from logstash_async.handler import AsynchronousLogstashHandler

# Logstash 핸들러 설정
logstash_handler = AsynchronousLogstashHandler(
    host='logstash.example.com',
    port=5959,
    database_path='logstash.db'
)

# 로거 설정
logger = logging.getLogger('app')
logger.addHandler(logstash_handler)
logger.setLevel(logging.INFO)

# OpenTelemetry와 트레이싱 통합 예시
import logging
from opentelemetry import trace
from opentelemetry.trace.status import Status, StatusCode

# 현재 스팬에서 트레이스 ID 가져오기
class TraceContextFilter(logging.Filter):
    def filter(self, record):
        current_span = trace.get_current_span()
        if current_span:
            ctx = current_span.get_span_context()
            record.trace_id = format(ctx.trace_id, '032x')
            record.span_id = format(ctx.span_id, '016x')
        else:
            record.trace_id = '0' * 32
            record.span_id = '0' * 16
        return True

# 로거 설정
logger = logging.getLogger('app')
logger.addFilter(TraceContextFilter())

import logging
import random

class SamplingFilter(logging.Filter):
    """특정 비율로 로그를 샘플링하는 필터"""
    
    def __init__(self, rate=0.1):
        self.rate = rate  # 로그 샘플링 비율 (0.0 ~ 1.0)
    
    def filter(self, record):
        # DEBUG 로그는 샘플링
        if record.levelno == logging.DEBUG:
            return random.random() < self.rate
        # 그 외 레벨은 모두 로깅
        return True

# 사용 예시
debug_handler = logging.FileHandler('debug.log')
debug_handler.setLevel(logging.DEBUG)
debug_handler.addFilter(SamplingFilter(rate=0.01))  # 디버그 로그의 1%만 기록

logger = logging.getLogger('app')
logger.addHandler(debug_handler)

import logging
import logging.handlers
import queue
import threading

# 로그 메시지를 담을 큐
log_queue = queue.Queue(-1)  # 무제한 큐 크기

# 큐 핸들러
queue_handler = logging.handlers.QueueHandler(log_queue)

# 실제 핸들러
file_handler = logging.FileHandler('app.log')
console_handler = logging.StreamHandler()

# 리스너 설정
listener = logging.handlers.QueueListener(
    log_queue, file_handler, console_handler, respect_handler_level=True
)

# 로거 설정
logger = logging.getLogger()
logger.addHandler(queue_handler)
logger.setLevel(logging.INFO)

# 리스너 시작
listener.start()

# 애플리케이션 종료 시 리스너 정지
# atexit.register(listener.stop)

import logging
import re

class GDPRCompliantFilter(logging.Filter):
    """GDPR을 준수하는 로깅 필터"""
    
    def __init__(self):
        super().__init__()
        # 마스킹할 패턴 정의
        self.patterns = {
            'email': (r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '[이메일]'),
            'phone': (r'\b\+?[0-9]{1,3}[-\s]?[0-9]{3,4}[-\s]?[0-9]{3,4}[-\s]?[0-9]{3,4}\b', '[전화번호]'),
            'credit_card': (r'\b(?:\d{4}[- ]?){3}\d{4}\b', '[카드번호]'),
            'ip': (r'\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b', '[IP주소]'),
            'password': (r'password["\']?\s*[:=]\s*["\']?[^"\',\s]+', 'password=*****'),
            'ssn': (r'\d{3}-\d{2}-\d{4}', '[주민번호]'),
        }
        
    def filter(self, record):
        if isinstance(record.msg, str):
            for _, (pattern, replacement) in self.patterns.items():
                record.msg = re.sub(pattern, replacement, record.msg)
        return True

# 암호화된 로그 핸들러
import logging
from cryptography.fernet import Fernet

class EncryptedFileHandler(logging.FileHandler):
    """로그를 암호화하여 저장하는 핸들러"""
    
    def __init__(self, filename, mode='a', encoding=None, delay=False, key=None):
        super().__init__(filename, mode, encoding, delay)
        if key:
            self.fernet = Fernet(key)
        else:
            # 키 생성 및 저장 (실제로는 안전하게 관리해야 함)
            key = Fernet.generate_key()
            with open('log_key.key', 'wb') as key_file:
                key_file.write(key)
            self.fernet = Fernet(key)
    
    def emit(self, record):
        try:
            msg = self.format(record)
            # 로그 메시지 암호화
            encrypted_msg = self.fernet.encrypt(msg.encode())
            # 바이너리 모드로 변경
            if self.stream is None:
                self.stream = self._open()
            self.stream.write(encrypted_msg + b'\n')
            self.flush()
        except Exception:
            self.handleError(record)

import logging
import functools
import inspect
import json
from datetime import datetime

# 감사 로거 설정
audit_logger = logging.getLogger('audit')
audit_handler = logging.FileHandler('audit.log')
audit_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
audit_handler.setFormatter(audit_formatter)
audit_logger.addHandler(audit_handler)
audit_logger.setLevel(logging.INFO)

def audit_log(action=None):
    """함수 호출을 감사 로그에 기록하는 데코레이터"""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            # 호출 정보 수집
            func_args = inspect.getcallargs(func, *args, **kwargs)
            # 민감한 인자 마스킹
            for arg_name in func_args:
                if arg_name.lower() in ('password', 'secret', 'token'):
                    func_args[arg_name] = '*****'
            
            # 감사 이벤트 기록
            event = {
                'timestamp': datetime.now().isoformat(),
                'action': action or func.__name__,
                'function': f"{func.__module__}.{func.__name__}",
                'args': json.dumps(func_args, default=str)
            }
            
            audit_logger.info(f"AUDIT: {json.dumps(event)}")
            
            # 함수 실행 및 결과 반환
            return func(*args, **kwargs)
        return wrapper
    return decorator

# 사용 예시
@audit_log(action='user_update')
def update_user(user_id, name=None, email=None, password=None):
    # 사용자 정보 업데이트 로직
    pass

import logging

logger = logging.getLogger('app')

# 비효율적인 로깅 - 항상 문자열 연산 수행
def inefficient(data):
    logger.debug("복잡한 데이터 처리 결과: " + str(process_data(data)))

# 효율적인 로깅 - 필요할 때만 문자열 연산 수행
def efficient(data):
    if logger.isEnabledFor(logging.DEBUG):
        logger.debug("복잡한 데이터 처리 결과: %s", process_data(data))
        
# 더 효율적인 로깅 - f-string 사용 방지
def more_efficient(data):
    # logger.debug(f"복잡한 데이터 처리 결과: {process_data(data)}")  # 비효율적
    logger.debug("복잡한 데이터 처리 결과: %s", process_data(data))   # 효율적

# 앞서 설명한 QueueHandler와 QueueListener 활용

import logging
import threading
import time
import queue

class BatchingHandler(logging.Handler):
    """로그 메시지를 배치로 처리하는 핸들러"""
    
    def __init__(self, capacity=100, flush_interval=5.0, target_handler=None):
        super().__init__()
        self.capacity = capacity  # 최대 배치 크기
        self.flush_interval = flush_interval  # 강제 플러시 간격(초)
        self.target_handler = target_handler  # 실제 처리할 핸들러
        self.buffer = []  # 로그 메시지 버퍼
        self.lock = threading.Lock()
        self.timer = None
        self._start_timer()
    
    def emit(self, record):
        with self.lock:
            self.buffer.append(record)
            
            # 버퍼가 용량을 초과하면 플러시
            if len(self.buffer) >= self.capacity:
                self.flush()
    
    def flush(self):
        with self.lock:
            if not self.buffer:
                return
                
            # 타겟 핸들러로 모든 로그 레코드 전달
            if self.target_handler:
                for record in self.buffer:
                    self.target_handler.handle(record)
            
            self.buffer.clear()
        
        # 타이머 재시작
        self._start_timer()
    
    def _start_timer(self):
        if self.timer:
            self.timer.cancel()
        
        self.timer = threading.Timer(self.flush_interval, self.flush)
        self.timer.daemon = True
        self.timer.start()
    
    def close(self):
        self.flush()
        if self.timer:
            self.timer.cancel()
        super().close()

# 앞서 설명한 SamplingFilter 활용