[ Python ] logging 만들어보기 (FileHandler 와 StreamHandler 위주로)

도움이 되셨다면, 광고 한번만 눌러주세요.  블로그 관리에 큰 힘이 됩니다 ^^

파이썬에서 logging 쌓기 (FileHandler 와 StreamHandler 위주로)

StreamHandler

Console에 log 남기기 

logging.StreamHandler()

FileHandler

log를 계속 쌓고 싶을 때

FileHandler('./log.txt' ,mode = "w")

RotatingFileHandler

파일 용량을 정해서 log를 쌓고 제거할 때

RotatingFileHandler(
	filename,  ## ~~.log / ~~.txt
    mode='a',  ## a : append / w : overwrite
    maxBytes=0,  ## 한 파일당 몇 몇가 byte까지 만들 수 있는지
    backupCount=0,  ## 몇개의 backup파일을 할지
    encoding=None, 
    delay=False)

TimedRotatingFileHandler

시간을 정해서 log를 쌓고 제거할 때

TimedRotatingFileHandler(
	filename,  ## ~~.log ~~.txt
    when='h',  ## 언제까지 log를 쌓을지
    interval=1,  ## 1 이면 1분 2면 2분
	backupCount=0,  ## back file을 몇개까지 만들지
    encoding=None, 
	delay=False,  
    utc=False, 
    atTime=None ## when w0~w6 일 때 시간 기록법
    )

TimedRotatingFileHandler

출처 : https://snowdeer.github.io/python/2017/11/17/python-logging-example/

 

import logging , datetime
import logging.handlers
from time import sleep

log = logging.getLogger('log_custom')
log.setLevel(logging.DEBUG)
log.propagate = True
formatter = logging.Formatter("%(asctime)s;[%(levelname)s];%(message)s",
                              "%Y-%m-%d %H:%M:%S")
## 그냥 처리
#fileHandler = logging.FileHandler('./log.txt' ,mode = "w")
streamHandler = logging.StreamHandler()
log_max_size = 10 * 512
log_file_count = 5
## 용량별 처리
### log.txt에는 용량만큼 쌓고
### backupCount 수만큼 쌓는 것을 저장함.
# fileHandler = logging.handlers.RotatingFileHandler(filename='./log.txt', 
#                                                    maxBytes=log_max_size,
#                                                    backupCount=log_file_count,
#                                                    mode = "w", 
#                                                   )
## 시간별 처리
### log.txt에는 when 시간 동안 쌓이고
### backupCount에서 그 형식의 이름으로 저장
fileHandler = logging.handlers.TimedRotatingFileHandler(
    filename='./log.txt', 
    when = "M" ,  # W0
    backupCount= 4 , 
    atTime=datetime.time(0, 0, 0)
    )
fileHandler.setLevel(logging.DEBUG)
streamHandler.setLevel(logging.INFO)

fileHandler.setFormatter(formatter)
streamHandler.setFormatter(formatter)
log.addHandler(fileHandler)
log.addHandler(streamHandler)

## Custom Log Class로 만들기

import logging
import datetime

class CustomLog :
    def __init__(self , name) :
        self.log = logging.getLogger(name)
        self.log.propagate = True
        self.formatter = logging.Formatter("%(asctime)s;[%(levelname)s];%(message)s",
                              "%Y-%m-%d %H:%M:%S")
        self.levels = {
            "DEBUG" : logging.DEBUG , 
            "INFO" : logging.INFO , 
            "WARNING" : logging.WARNING , 
            "ERROR" : logging.ERROR , 
            "CRITICAL" : logging.CRITICAL }
    
    def stream_handler(self, level) :
        """
        level :
        > "DEBUG" : logging.DEBUG , 
        > "INFO" : logging.INFO , 
        > "WARNING" : logging.WARNING , 
        > "ERROR" : logging.ERROR , 
        > "CRITICAL" : logging.CRITICAL , 
        """
        streamHandler = logging.StreamHandler()
        streamHandler.setLevel(self.levels[level])
        streamHandler.setFormatter(self.formatter)
        self.log.addHandler(streamHandler)
        return self.log
    
    def file_handler(self, file_name, mode , level) :
        """
        file_name : ~.txt / ~.log
        mode : "w" / "a"
        level :
        > "DEBUG" : logging.DEBUG , 
        > "INFO" : logging.INFO , 
        > "WARNING" : logging.WARNING , 
        > "ERROR" : logging.ERROR , 
        > "CRITICAL" : logging.CRITICAL , 
        """
        fileHandler = logging.FileHandler(file_name ,mode = mode)
        fileHandler.setLevel(logging.DEBUG)
        fileHandler.setFormatter(self.formatter)
        self.log.addHandler(fileHandler)
        return self.log
    def Rotating_filehandler(self, file_name , mode , level , backupCount , log_max_size ) :
        """
        file_name : ~.txt / ~.log
        mode : "w" / "a"
        backupCount : backup할 파일 개수
        log_max_size : 한 파일당 용량 최대
        level :
        > "DEBUG" : logging.DEBUG , 
        > "INFO" : logging.INFO , 
        > "WARNING" : logging.WARNING , 
        > "ERROR" : logging.ERROR , 
        > "CRITICAL" : logging.CRITICAL , 
        """
        
        fileHandler = logging.handlers.RotatingFileHandler(
            filename=file_name , 
            maxBytes=log_max_size,
            backupCount=backupCount,
            mode =  mode )
        fileHandler.setLevel(self.levels[level])
        fileHandler.setFormatter(self.formatter)
        self.log.addHandler(fileHandler)
        return self.log
    def timeRotate_handler(self , filename='./log.txt', 
                           when = "M" ,
                           level = "DEBUG" , 
                           backupCount= 4 , 
                           atTime = datetime.time(0, 0, 0),
                           interval = 1
                          ) :
        """
        file_name : 
        when : 저장 주기
        interval : 저장 주기에서 어떤 간격으로 저장할지 
        backupCount : 5
        atTime : datetime.time(0, 0, 0)
        """
        fileHandler = logging.handlers.TimedRotatingFileHandler(
            filename= filename, 
            when = when ,  # W0
            backupCount= backupCount , 
            interval = interval , 
            atTime=atTime )
        fileHandler.setLevel(self.levels[level])
        fileHandler.setFormatter(self.formatter)
        self.log.addHandler(fileHandler)
        return self.log

## 사용법

import logging , datetime
import logging.handlers
from time import sleep
from Custom_Log import CustomLog as CL

log = CL("custom_log")
log.stream_handler("INFO")
log = log.timeRotate_handler(filename="./time_log.txt",
                       when="M",
                       interval=2 ,
                       backupCount= 3 , 
                       level = "DEBUG"
                      )
                      
## run         
idx = 0
while True :
    log.debug('debug {}'.format(idx))
    log.info('info {}'.format(idx))
    log.warning('warning {}'.format(idx))
    log.error('error {}'.format(idx))
    log.critical('critical {}'.format(idx))
    idx += 1
    sleep(0.5)
    if idx ==1000 :
        break