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
