def __init__(self, log_level, uuid): ''' # Initialize the log module, should only be called once at the begging of the program :param log_level: What logs to display :param uuid: The unique id for this MindsDB instance or training/prediction session ''' self.id = uuid self.internal_logger = logging.getLogger('mindsdb-logger-{}'.format( self.id)) self.internal_logger.handlers = [] self.internal_logger.propagate = False stream_handler = logging.StreamHandler() stream_handler.setFormatter( colorlog.ColoredFormatter( '%(log_color)s%(levelname)s:%(name)s:%(message)s')) self.internal_logger.addHandler(stream_handler) self.internal_logger.setLevel(log_level)
def getLogger(region): region = region.upper() if region in loggers.keys(): return loggers[region] logger = logging.getLogger(region) logger.propagate = False #configura handlers handler = logging.FileHandler('./logs/' + region + '.txt') handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s %(message)s')) chandler = colorlog.StreamHandler() chandler.setFormatter(colorlog.ColoredFormatter('%(log_color)s%(name)s\t| %(message)s')) logger.addHandler(handler) logger.addHandler(chandler) loggers[region] = logger return logger
def get_logger(command, verbose, daemon): """Return a Logger object with the right level, formatter and handler.""" if daemon: handler = SysLogHandler(address=get_domain_socket()) formatter = logging.Formatter(fmt=DAEMON_FORMAT.format(command)) logger = logging.getLogger(command) else: handler = colorlog.StreamHandler(stream=sys.stdout) formatter = colorlog.ColoredFormatter(INTERACTIVE_FORMAT, log_colors=LOG_COLORS) logger = colorlog.getLogger(command) if verbose: logger.setLevel(logging.DEBUG) else: logger.setLevel(logging.INFO) handler.setFormatter(formatter) logger.addHandler(handler) return logger
def __init__(self): handler_out = logging.StreamHandler(sys.stdout) handler_err = logging.StreamHandler(sys.stderr) handler_out.addFilter(SingleLevelFilter(logging.INFO, False)) handler_err.addFilter(SingleLevelFilter(logging.INFO, True)) formatter = colorlog.ColoredFormatter( '%(log_color)s%(asctime)s %(name)-12s %(levelname)-8s %(message)s') handler_out.setFormatter(formatter) handler_err.setFormatter(formatter) self.log = logging.getLogger("dogen") self.log.addHandler(handler_out) self.log.addHandler(handler_err) for package in ["requests.packages.urllib3", "pykwalify.rule"]: log = logging.getLogger(package) log.setLevel(logging.INFO) requests.packages.urllib3.disable_warnings()
def setup_logging(): handler_out = logging.StreamHandler(sys.stdout) handler_err = logging.StreamHandler(sys.stderr) handler_out.addFilter(SingleLevelFilter(logging.INFO, False)) handler_err.addFilter(SingleLevelFilter(logging.INFO, True)) formatter = colorlog.ColoredFormatter( '%(log_color)s%(asctime)s %(name)-12s %(levelname)-8s %(message)s') handler_out.setFormatter(formatter) handler_err.setFormatter(formatter) logger = logging.getLogger("cekit") # Reset all handlers logger.handlers = [] logger.addHandler(handler_out) logger.addHandler(handler_err) for package in ["pykwalify.rule"]: log = logging.getLogger(package) log.setLevel(logging.INFO)
def __init__(self, logger_name, colorise=False, level=logging.DEBUG): logging.addLevelName(Logger.DEBUG_RX_LVL, 'DEBUG_RX') logging.addLevelName(Logger.DEBUG_TX_LVL, 'DEBUG_TX') self.logger = colorlog.getLogger(logger_name) self.logger.setLevel(level) # log file formatter = logging.Formatter( '<%(asctime)s.%(msecs)03d {} [%(levelname)-8s]: %(message)s'. format(logger_name), datefmt='%H:%M:%S', style='%') file_handler = logging.FileHandler('log_{}.txt'.format(logger_name)) file_handler.setFormatter(formatter) self.logger.addHandler(file_handler) # console output if colorise: formatter = colorlog.ColoredFormatter( '<%(asctime)s.%(msecs)03d {} [%(levelname)-8s]:'.format(logger_name) + \ ' %(log_color)s%(message)s%(reset)s', datefmt='%H:%M:%S', reset=True, log_colors={ 'DEBUG': 'green', 'DEBUG_RX': 'white', 'DEBUG_TX': 'purple', 'INFO': 'cyan', 'WARNING': 'yellow', 'ERROR': 'red', 'CRITICAL': 'red,bg_white', }, secondary_log_colors={}, style='%' ) console_handler = colorlog.StreamHandler() console_handler.setFormatter(formatter) self.logger.addHandler(console_handler)
def init_logger(level='INFO', out=True): """ :param level: The logger threshold could be a positive int or string among: 'CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG' :param out: if the log message must be displayed :return: logger :rtype: :class:`logging.Logger` instance """ logger = colorlog.getLogger('macsyprofile') if isinstance(level, str): level = getattr(logging, level) if out: stdout_handler = colorlog.StreamHandler(sys.stderr) if level <= logging.DEBUG: msg_formatter = "%(log_color)s%(levelname)-8s : %(module)s: L %(lineno)d :%(reset)s %(message)s" else: msg_formatter = "%(log_color)s%(message)s" stdout_formatter = colorlog.ColoredFormatter(msg_formatter, datefmt=None, reset=True, log_colors={ 'DEBUG': 'cyan', 'INFO': 'green', 'WARNING': 'yellow', 'ERROR': 'red', 'CRITICAL': 'bold_red', }, secondary_log_colors={}, style='%') stdout_handler.setFormatter(stdout_formatter) logger.addHandler(stdout_handler) else: null_handler = logging.NullHandler() logger.addHandler(null_handler) logger.setLevel(level) return logger
def setup_logger(): """Setup a colored logger if available and possible""" logger = logging.getLogger('clikraken') logger.setLevel(logging.DEBUG) # log to stdout from DEBUG to INFO ch_out = logging.StreamHandler(sys.stdout) ch_out.setLevel(logging.DEBUG) ch_out.addFilter(LessThanFilter(logging.WARNING)) # WARNING and above goes to stderr ch_err = logging.StreamHandler(sys.stderr) ch_err.setLevel(logging.WARNING) format_str = '{levelname:8} - {message}' # basic formatter f = logging.Formatter(fmt=format_str, style='{') # colored formatted if have_colorlog: cf = colorlog.ColoredFormatter(fmt='{log_color}' + format_str, style='{') else: cf = f # only use the colored formatter when we are outputting to a terminal if os.isatty(2): ch_out.setFormatter(cf) ch_err.setFormatter(cf) else: ch_out.setFormatter(f) ch_err.setFormatter(f) logger.addHandler(ch_out) logger.addHandler(ch_err) return logger
def get_logger(logger_name, file_location): # create logger log = logging.getLogger(logger_name) log.setLevel(level=logging.DEBUG) # create formatter and add it to the handlers format_str = '%(asctime)s.%(msecs)d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s' date_format = '%Y-%m-%d %H:%M:%S' cformat = '%(log_color)s' + format_str colors = { 'DEBUG': 'green', 'INFO': 'cyan', 'WARNING': 'bold_yellow', 'ERROR': 'bold_red', 'CRITICAL': 'bold_purple' } formatter = colorlog.ColoredFormatter(cformat, date_format, log_colors=colors) # create file handler for logger. fh = logging.FileHandler( file_location + "/" + str(datetime.datetime.now().strftime('%Y-%m-%d_%H_%M_')) + "archive.log") fh.setLevel(level=logging.DEBUG) fh.setFormatter(formatter) # reate console handler for logger. ch = logging.StreamHandler() ch.setLevel(level=logging.DEBUG) ch.setFormatter(formatter) # add handlers to logger. log.addHandler(fh) log.addHandler(ch) return log
def setup_logging(extra_name=None, disable_tty=False): logger = logging.getLogger() logger.setLevel(logging.DEBUG) if extra_name: extra_name = '-' + extra_name else: extra_name = '' formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') if not os.path.exists('logs'): os.mkdir('logs') filename = os.path.basename(sys.argv[0]) basename = os.path.splitext(filename)[0] if sys.stdout.isatty() and not disable_tty: ch = colorlog.StreamHandler() ch.setLevel(logging.DEBUG) ch.setFormatter( colorlog.ColoredFormatter( '%(log_color)s%(levelname)s\t%(name)s\t%(message)s')) logger.addHandler(ch) fh = logging.handlers.TimedRotatingFileHandler( f'logs/{basename}{extra_name}.log', when='W0') fh.setLevel(logging.INFO) fh.setFormatter(formatter) logger.addHandler(fh) fh2 = logging.handlers.TimedRotatingFileHandler( f'logs/{basename}{extra_name}.debug.log', when='W0') fh2.setLevel(logging.DEBUG) fh2.setFormatter(formatter) logger.addHandler(fh2) return logger
def log_configuration(): logging.addLevelName(15, "VERBOSE") log_colors = colorlog.default_log_colors log_colors["VERBOSE"] = "cyan" fmt = "%(log_color)s%(asctime)s.%(msecs)03d | %(levelname)s | [%(funcName)s] %(message)s - %(filename)s:%(lineno)s" formatter = colorlog.ColoredFormatter(fmt, datefmt="%d/%m/%Y %H:%M:%S", log_colors=log_colors, secondary_log_colors={}, style='%') if LOG_LEVEL == "DEBUG": log_level = logging.DEBUG elif LOG_LEVEL == "VERBOSE": log_level = "VERBOSE" elif LOG_LEVEL == "INFO": log_level = logging.INFO elif LOG_LEVEL == "WARNING": log_level = logging.WARNING else: log_level = logging.ERROR stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter) if LOG_FILE is not None: # logging.basicConfig(filename=LOG_FILE, level=log_level, format=log_format, datefmt='%d/%m/%Y %H:%M:%S') file_handler = logging.FileHandler(LOG_FILE, mode='w') fmt = fmt.replace("%(log_color)", "") logging.basicConfig(level=log_level, format=fmt, datefmt='%d/%m/%Y %H:%M:%S', handlers=[file_handler]) else: logging.basicConfig(level=log_level, datefmt='%d/%m/%Y %H:%M:%S', handlers=[stream_handler]) logging.getLogger() logging.info("Logging just started!")
def init_logger(): # create logger logger = logging.getLogger("logger") logger.setLevel(logging.INFO) # create file handler and set level to INFO logfile = USER_DIR + "/.watcard_log" fh = logging.FileHandler(logfile) fh.setLevel(SUCCESS) # create stream handler and set level to INFO sh = logging.StreamHandler() sh.setLevel(logging.INFO) # create formatter colors = { "INFO": "black", "WARNING": "yellow", "ERROR": "red", "SUCCESS": "blue" } log_format_file = "%(asctime)s - %(levelname)s - %(message)s" log_format_console = "%(log_color)s" + PRINT_PREFIX + " %(message)s" date_format = "%Y-%m-%d %H:%M:%S" formatter_file = logging.Formatter(log_format_file, date_format) formatter_console = colorlog.ColoredFormatter(log_format_console, log_colors=colors) # add formatter to handler fh.setFormatter(formatter_file) sh.setFormatter(formatter_console) # add handler to logger logger.addHandler(fh) logger.addHandler(sh) return logfile
def __configure_logger(cls, name: str, level: int, path_output: str): log_format = '%(asctime)s - %(levelname)s - %(message)s' # logging.basicConfig(level=level) logging.setLoggerClass(MyLogger) cls.__instance = logging.getLogger(name) cls.__instance.setLevel(level) # create a file handler if not os.path.exists(path_output): os.makedirs(path_output) fh = logging.FileHandler( os.path.join(path_output, time.strftime('%Y-%m-%d-%H-%M-%S.log'))) fh.setLevel(level) ch = logging.StreamHandler() ch.setLevel(level) # create a logging format colored_formatter = colorlog.ColoredFormatter( "%(log_color)s" + log_format, log_colors={ 'DEBUG': 'cyan', 'INFO': 'green', 'WARNING': 'yellow', 'ERROR': 'red', 'CRITICAL': 'bold_purple' }) formatter = logging.Formatter(log_format) fh.setFormatter(formatter) ch.setFormatter(colored_formatter) # add the handlers to the logger cls.__instance.addHandler(fh) cls.__instance.addHandler(ch)
def setup_logging(): terminal_logger = logging.getLogger() terminal_logger.propagate = False stderr_format = '%(asctime)s - %(name)-10s - %(levelname)-8s - %(message)s' stdout_format = '%(asctime)s - %(levelname)-8s - %(message)s' date_format = '%Y-%m-%d %H:%M:%S' # ensuring that we are writing to a terminal and not a file # this avoids escape sequences being written to a file when the log output is redirected if 'colorlog' in sys.modules and os.isatty(2): cformat = '%(log_color)s' + stdout_format stdout_format = colorlog.ColoredFormatter(cformat, date_format, log_colors={ 'DEBUG': 'reset', 'INFO': 'reset', 'WARNING': 'bold_yellow', 'ERROR': 'bold_red', 'CRITICAL': 'bold_red' }) else: stdout_format = logging.Formatter(stdout_format, date_format) # to avoid duplicate logging output as pytorch lightning defines its own python logger `python_logging` if (terminal_logger.hasHandlers()): terminal_logger.handlers.clear() # create file handler which logs even debug messages fh = logging.StreamHandler(sys.stdout) fh.setLevel(logging.DEBUG) fh.setFormatter(stdout_format) terminal_logger.addHandler(fh) # create console handler with a higher log level ch = logging.StreamHandler() ch.setLevel(logging.ERROR) ch.setFormatter(logging.Formatter(stderr_format)) terminal_logger.addHandler(ch)
def init_logger(name, level, printout=True): """ Initialize app logger to configure its level/handler/formatter/etc.. Todo: * A way to raise click.Abort or sys.exit when CRITICAL is used; Arguments: name (str): Logger name used to instanciate and retrieve it. level (str): Level name (``debug``, ``info``, etc..). Keyword Arguments: printout (bool): If False, logs will never be outputed. Returns: logging.Logger: Application logger. """ root_logger = logging.getLogger(name) root_logger.setLevel(level) # Redirect outputs to the void space, mostly for usage within unittests if not printout: from io import StringIO dummystream = StringIO() handler = logging.StreamHandler(dummystream) # Standard output with colored messages else: handler = logging.StreamHandler() handler.setFormatter( colorlog.ColoredFormatter( '%(asctime)s - %(log_color)s%(message)s', datefmt="%H:%M:%S" ) ) root_logger.addHandler(handler) return root_logger
def main(config, verbose): processlist = [] logger = logging.getLogger() handler = logging.StreamHandler() handler.setFormatter(colorlog.ColoredFormatter( \ ' %(log_color)s%(name)s/%(levelname)-8s%(reset)s |' ' %(log_color)s%(message)s%(reset)s')) logger.addHandler(handler) logger.setLevel(logging.DEBUG if verbose else logging.ERROR) conf = json.load(config) for t in conf['tunnels']: tun = conf['tunnels'].get(t) for k in [ 'user', 'fhost', 'compression', 'rport' ]: if k not in tun.keys(): conf['tunnels'][t][k] = conf['settings']['default_' + k] p = multiprocessing.Process(target=ssh_tunnel, args=(tun, logger)) p.start() processlist.append(p) try: for p in processlist: p.join() except KeyboardInterrupt: for p in processlist: p.terminate() logger.info("C-c: Port forwarding stopped.") sys.exit(0)
def get_logger(name, log_file=None, log_level='DEBUG'): """ logger :param name: 模块名称 :param log_file: 日志文件,如无则输出到标准输出 :param log_level: 日志级别 :return: """ logger = logging.getLogger(name) logger.propagate = False logger.setLevel(log_level.upper()) formatter = colorlog.ColoredFormatter( '%(log_color)s[%(levelname)7s %(asctime)s %(module)s:%(lineno)4d] %(message)s', log_colors={key: conf['color'] for key, conf in log_config.items()}, datefmt='%Y%m%d %I:%M:%S') if log_file: f_handle = logging.FileHandler(log_file) f_handle.setFormatter(formatter) logger.addHandler(f_handle) handle = logging.StreamHandler() handle.setFormatter(formatter) logger.addHandler(handle) return logger
def __init__(self): self.logger = logging.getLogger("root") self.logger.propagate = False if not self.logger.handlers: self.logger.setLevel(logging.INFO) handler = TqdmLoggingHandler() formatter = colorlog.ColoredFormatter( '%(log_color)s%(asctime)s %(levelname).1s: %(message)s', datefmt='%Y-%d-%d %H:%M:%S', log_colors={ 'DEBUG': 'thin_cyan', 'INFO': 'thin_white', 'SUCCESS:': 'green', 'WARNING': 'yellow', 'ERROR': 'red', 'CRITICAL': 'red,bg_white' }, ) handler.setFormatter(formatter) self.logger.addHandler(handler)
def main(): args = parse_args() colorlog.root.setLevel("INFO") handler = colorlog.StreamHandler() handler.setFormatter( colorlog.ColoredFormatter( '%(log_color)s[%(name)s][%(levelname)s]: %(message)s')) logger = colorlog.getLogger('mangekyou:cli') logger.addHandler(handler) logger.info("Starting Mangekyou") try: config = Config(args.config, handler) target = str(Path.cwd() / args.target) man = Mangekyou(config, target) man.run() except Exception as e: logger.exception(e) logger.critical("exiting due to uncaught exception") sys.exit(2)
def __init__(self, host, port): # 初始化log logger = logging.getLogger('main') logger.setLevel(logging.DEBUG) console_handler = logging.StreamHandler() console_handler.setFormatter( colorlog.ColoredFormatter(constants.COLOR_LOG_FORMAT, log_colors={ 'DEBUG': 'cyan', 'INFO': 'green', 'WARNING': 'yellow', 'ERROR': 'red', 'CRITICAL': 'red', })) console_handler.setLevel(logging.DEBUG) logger.addHandler(console_handler) self.logger = logger self.net_msg_queue = Queue.Queue() self.logic_msg_queue = Queue.Queue() self.tcp_client = TcpClient(GameBox, host, port) self.tcp_client.tcp_nodelay = True
def create_logger(): """ Setup the logging environment """ log = logging.getLogger() # root logger log.setLevel(logging.INFO) format_str = '%(asctime)s - %(levelname)-8s - %(message)s' date_format = '%Y-%m-%d %H:%M:%S' if HAVE_COLORLOG and os.isatty(2): cformat = '%(log_color)s' + format_str colors = {'DEBUG': 'reset', 'INFO': 'reset', 'WARNING': 'bold_yellow', 'ERROR': 'bold_red', 'CRITICAL': 'bold_red'} formatter = colorlog.ColoredFormatter(cformat, date_format, log_colors=colors) else: formatter = logging.Formatter(format_str, date_format) stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter) log.addHandler(stream_handler) return logging.getLogger(__name__)
def setup_custom_logger(name): formatter = colorlog.ColoredFormatter( "%(log_color)s%(name)s | %(asctime)s | %(levelname)s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S", log_colors={ "DEBUG": "cyan", "INFO": "white", "SUCCESS:": "green", "WARNING": "yellow", "ERROR": "red", "CRITICAL": "red,bg_white", }, ) handler = TqdmHandler() handler.setFormatter(formatter) logger = logging.getLogger(name) logger.setLevel(logging.DEBUG) logger.addHandler(handler) dup_filter = DuplicateFilter() logger.addFilter(dup_filter) return logger
def configure_logging(args): '''Set format and configure logger to use colors, if output is a TTY.''' details = '' if args.verbose: level = logging.DEBUG details = '%(name)s:%(lineno)d: ' elif args.quiet: level = logging.ERROR else: level = logging.INFO if sys.stdout.isatty(): handler = colorlog.StreamHandler() handler.setFormatter( colorlog.ColoredFormatter('%(log_color)s' + details + '%(message)s%(reset)s', log_colors={ 'WARNING': 'yellow', 'CRITICAL': 'red', 'ERROR': 'red' })) logging.basicConfig(handlers=[handler], level=level) else: logging.basicConfig(format=details + '%(message)s', level=level)
def log_setup(): verbose_formatter = colorlog.ColoredFormatter( "%(log_color)s%(levelname)-2s%(reset)s %(name)-3s %(white)s%(message)s", # "%(log_color)s%(levelname)-2s%(reset)s %(white)s%(message)s", datefmt=None, reset=True, log_colors={ 'DEBUG': 'cyan', 'INFO': 'green', 'WARNING': 'yellow', 'ERROR': 'red', 'CRITICAL': 'red,bg_white', }, secondary_log_colors={}, style='%' ) logger = logging.getLogger('restconf') logger.setLevel(logging.DEBUG) handler = logging.StreamHandler(sys.stdout) handler.setFormatter(verbose_formatter) logger.addHandler(handler) return logger
def init_logging(): log = logging.getLogger('CL') term_handler = logging.StreamHandler() if PY35_COMPAT: exc = ImportError else: exc = ModuleNotFoundError try: import colorlog fmt = colorlog.ColoredFormatter( '%(asctime)s %(log_color)s[%(name)12s:%(lineno)3s' ' %(funcName)18s ]\t%(levelname)-.6s %(message)s') except exc: fmt = logging.Formatter( '%(asctime)s [%(name)12s:%(lineno)3s ' '%(funcName)18s ]\t%(levelname)-.6s %(message)s') term_handler.setFormatter(fmt) log.addHandler(term_handler) log.setLevel(logging.DEBUG) return log
def log(loglevel, log_name): handler = colorlog.StreamHandler() handler.setFormatter( colorlog.ColoredFormatter( fmt='%(log_color)s[%(levelname)s] [%(threadName)s] [%(asctime)s] [%(filename)s:%(lineno)d] %(message)s', datefmt="%H:%M:%S", log_colors={ 'DEBUG': 'cyan', 'INFO': 'green', 'WARNING': 'yellow', 'ERROR': 'red', 'CRITICAL': 'red,bg_white', }, ) ) f = open(log_name, 'a+') handler2 = logging.StreamHandler(f) formatter = logging.Formatter( "[%(levelname)s] [%(threadName)s] [%(asctime)s] [%(filename)s:%(lineno)d] %(message)s") handler2.setFormatter(formatter) logger.addHandler(handler2) logger.addHandler(handler) logger.setLevel(loglevel)
def logger_config(name=None): if not name: log = logging.getLogger() # root logger else: log = logging.getLogger(name) log.setLevel(logging.INFO) format_str = "%(asctime)s - [%(filename)12s:%(lineno)3s - %(funcName)12s() ]- %(levelname)s - %(message)s" date_format = '%d-%b-%y %H-:%M:%S' cformat = '%(log_color)s' + format_str colors = { 'DEBUG': 'green', 'INFO': 'cyan', 'WARNING': 'bold_yellow', 'ERROR': 'bold_red', 'CRITICAL': 'bold_purple' } formatter = colorlog.ColoredFormatter(cformat, date_format, log_colors=colors) stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter) log.addHandler(stream_handler) return log
def Logger(): logger = logging.getLogger() logger.setLevel(logging.INFO) cformat = "[%(asctime)s] %(log_color)s%(message)s" colors = { 'DEBUG': 'cyan', 'INFO': 'green', 'WARNING': 'yellow', 'ERROR': 'red', 'CRITICAL': 'red,bg_white' } formatter = colorlog.ColoredFormatter(cformat, log_colors=colors) stream_handler = logging.StreamHandler() stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) formatter = logging.Formatter('%(asctime)s : %(message)s') log = logging.FileHandler('JK.log') log.setLevel(logging.DEBUG) log.setFormatter(formatter) logger.addHandler(log) return logging.getLogger(__name__)
def __init__(self): root = logging.getLogger() root.setLevel(logging.DEBUG) date_format = '%d-%m-%Y %I:%M:%S %p' format = '%(asctime)s - %(levelname)-8s - %(message)s' if 'colorlog' in sys.modules and os.isatty(2): cformat = '%(log_color)s' + format f = colorlog.ColoredFormatter(cformat, date_format, log_colors={ 'DEBUG': 'cyan', 'INFO': 'white', 'WARNING': 'bold_yellow', 'ERROR': 'bold_red', 'CRITICAL': 'bold_red' }) else: f = logging.Formatter(format, date_format) ch = logging.StreamHandler() ch.setFormatter(f) root.addHandler(ch) self.log = logging.getLogger(__name__)
def __init__(self, name): self.fh = logging.FileHandler(filename=log_name, mode='a', encoding='utf-8') self.sh = logging.StreamHandler() self.logger = logging.getLogger(name=name) if __DEBUG__: self._SET_LEVEL = logging.DEBUG else: self._SET_LEVEL = logging.INFO self.formatters = colorlog.ColoredFormatter( '%(log_color)s%(asctime)s - %(levelname)s - %(filename)s:[line:%(lineno)d] | %(message)s', "%Y-%m-%d %H:%M:%S", log_colors=log_colors_config) self.formatter = logging.Formatter( '%(asctime)s - %(levelname)s - %(filename)s:[line:%(lineno)d] | %(message)s', "%Y-%m-%d %H:%M:%S") self.sh.setFormatter(self.formatters) self.fh.setFormatter(self.formatter) self.logger.setLevel(self._SET_LEVEL) self.logger.addHandler(self.sh) self.logger.addHandler(self.fh) self.logger.propagate = False