def setup_logger() -> None:
"""Set up stderr logging format.
The logging format and colors can be overridden by setting up the
environment variables such as ``LOGURU_FORMAT``.
See `Loguru documentation`_ for details.
.. _Loguru documentation: https://loguru.readthedocs.io/en/stable/api/logger.html#env
"""
logger.remove() # Remove the default setting
# Set up the preferred logging colors and format unless overridden by its environment variable
logger.level("INFO", color=environ.get("LOGURU_INFO_COLOR") or "<white>")
logger.level("DEBUG",
color=environ.get("LOGURU_DEBUG_COLOR") or "<d><white>")
log_format = environ.get("LOGURU_FORMAT") or (
# "<green>{time:YYYY-MM-DD HH:mm:ss}</green> "
"<b><level>{level: <8}</level></b> "
"| <level>{message}</level>")
logger.add(sys.stderr, format=log_format)
# By default all the logging messages are disabled
logger.enable("charger")
def emit(self, record):
try:
level = logger.level(record.levelname).name
except AttributeError:
level = self.loglevel_mapping[record.levelno]
frame, depth = logging.currentframe(), 2
while frame.f_code.co_filename == logging.__file__:
frame = frame.f_back
depth += 1
log = logger.bind(request_id='app')
log.opt(depth=depth,
exception=record.exc_info).log(level, record.getMessage())
def emit(self, record):
# Get corresponding Loguru level if it exists
try:
level = logger.level(record.levelname).name
except ValueError:
level = record.levelno
# Find caller from where originated the logged message
frame, depth = logging.currentframe(), 2
while frame.f_code.co_filename == logging.__file__:
frame = frame.f_back
depth += 1
logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
def run(self):
# Make the rpyc logger a bit quieter when we aren't in debugging.
rpyc_logger = logging.getLogger('ipc.rpyc')
if logger.level(
self.manager.options.loglevel).no > logger.level('DEBUG').no:
rpyc_logger.setLevel(logging.WARNING)
DaemonService.manager = self.manager
self.server = ThreadedServer(
DaemonService,
hostname=self.host,
port=self.port,
authenticator=self.authenticator,
logger=rpyc_logger,
# Timeout can happen when piping to 'less' and delaying scrolling to bottom. Make it a long timeout.
protocol_config={'sync_request_timeout': 3600},
)
# If we just chose an open port, write save the chosen one
self.port = self.server.listener.getsockname()[1]
self.manager.write_lock(ipc_info={
'port': self.port,
'password': self.password
})
self.server.start()
def main() -> None:
logging.basicConfig(level=logging.DEBUG, datefmt='[%H:%M:%S]')
config_filename = 'config.yml' if ENV == 'debug' else f"config.yml.{ENV}"
logger.level("HEARTBEAT", no=38, color="<red><bold>", icon="🫀")
if not os.path.isfile(os.path.join(PROJ_ROOT, config_filename)):
raise RuntimeError("Config file doesn't exist")
conf = load_config(os.path.join(PROJ_ROOT, config_filename))
logger.info(f"Running on {ENV} environment")
msg_list = MsgList()
replication = Replication(conf, msg_list)
handler = MainHandler(replication)
app = web.Application(logger=logger)
app.router.add_get("/list-msg",
handler.list_messages,
name="list_messages")
app.router.add_post("/append-msg",
handler.append_message,
name="append_messages")
web.run_app(app, host=conf['host'], port=conf['port'])
def logger(self):
if not self._logger:
self._logger = logger
self._logger.remove()
self._logger.add(
sys.stderr,
colorize=True,
format="<green>{time}</green> <level>{message}</level>",
filter=lambda record: record["level"].no
>= logger.level(self.level.upper()).no,
level=self.level.upper(),
backtrace=True,
diagnose=True,
)
return self._logger
def emit(self, record: logging.LogRecord):
try:
level = logger.level(record.levelname).name
except ValueError:
level = record.levelno
frame, depth = logging.currentframe(), 2
while frame.f_code.co_filename == logging.__file__:
frame: Optional[FrameType] = frame.f_back
depth += 1
logger.opt(depth=depth, exception=record.exc_info).log(
level,
record.getMessage(),
)
def setup_cli():
logger.remove() # Remove the default setting
# Set up the preferred logging colors and format unless overridden by its environment variable
logger.level("INFO", color="<white>")
logger.level("DEBUG", color="<d><white>")
log_format = ("<green>{time:YYYY-MM-DD HH:mm:ss}</green> "
"<b><level>{level: <8}</level></b> "
"| <level>{message}</level>")
logger.add(sys.stderr, format=log_format, enqueue=True)
# Setup CLI parser
parser = argparse.ArgumentParser(
description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("json_folder", help="Path to XSD")
parser.add_argument("out_tsv", help="Path to the output TSV")
parser.add_argument("-j",
dest="num_processes",
type=int,
default=1,
help="Number of parallel workers")
return parser
def emit(self, record: logging.LogRecord) -> None: # pragma: no cover
try:
level = logger.level(record.levelname).name
except ValueError:
level = str(record.levelno)
frame, depth = logging.currentframe(), 2
while frame.f_code.co_filename == logging.__file__: # noqa: WPS609
frame = cast(FrameType, frame.f_back)
depth += 1
logger.opt(depth=depth, exception=record.exc_info).log(
level,
record.getMessage(),
)
def emit(self, record: logging.LogRecord) -> None: # pragma: no cover
# Get corresponding Loguru level if it exists
try:
level = logger.level(record.levelname).name
except ValueError:
level = str(record.levelno)
# Find caller from where originated the logged message
frame, depth = logging.currentframe(), 2
while frame.f_code.co_filename == logging.__file__: # noqa: WPS609
frame = cast(FrameType, frame.f_back)
depth += 1
logger.opt(depth=depth, exception=record.exc_info).log(
level, record.getMessage(),
)
def emit(self, record):
# Get corresponding Loguru level if it exists
try:
level = logger.level(record.levelname).name
except AttributeError:
level = self.loglevel_mapping[record.levelno]
# Find caller from where originated the logging call
frame, depth = logging.currentframe(), 2
while frame and frame.f_code.co_filename == logging.__file__:
frame = frame.f_back
depth += 1
log = logger.bind(request_id="app")
log.opt(depth=depth,
exception=record.exc_info).log(level, record.getMessage())
def emit(self, record: logging.LogRecord) -> None:
# Get corresponding Loguru level if it exists
try:
level = logger.level(record.levelname).name
except ValueError:
level = record.levelno
# Find caller from where originated the logged message
frame, depth = logging.currentframe(), 2
while frame.f_code.co_filename == logging.__file__:
frame = frame.f_back # type: ignore
depth += 1
if record.name == "uvicorn.access":
msg = InterceptHandler.accessFormat(record)
else:
msg = record.getMessage()
logger.opt(depth=depth, exception=record.exc_info).log(level, msg)
def emit(self, record: logging.LogRecord) -> None: # pragma: no cover
try:
level: str = logger.level(record.levelname).name
except ValueError:
level: str = self.loglevel_mapping[record.levelno]
frame: 'Frame' = logging.currentframe()
depth: int = 2
while frame.f_code.co_filename == logging.__file__: # noqa: WPS609
frame = frame.f_back
depth += 1
logger.opt(depth=depth, exception=record.exc_info).log(
level,
record.getMessage(),
)
def emit(self, record):
"""Intercept standard logging logs in loguru. Should test this for distributed pytorch lightning"""
# Get corresponding Loguru level if it exists
try:
level = logger.level(record.levelname).name
except ValueError:
level = record.levelno
# Find caller from where originated the logged message
frame, depth = logging.currentframe(), 2
while frame.f_code.co_filename == logging.__file__:
frame = frame.f_back
depth += 1
logger.opt(depth=depth,
exception=record.exc_info).log(level,
record.getMessage())
def test_edit_level(writer):
logger.level("info", no=0, color="<bold>", icon="[?]")
fmt = "<level>->{level.no}, {level.name}, {level.icon}, {message}<-</level>"
logger.add(writer, format=fmt, colorize=True)
logger.log("info", "nope")
logger.level("info", no=11)
logger.log("info", "a")
logger.level("info", icon="[!]")
logger.log("info", "b")
logger.level("info", color="<red>")
logger.log("info", "c")
assert writer.read() == parse("<bold>->11, info, [?], a<-</bold>\n"
"<bold>->11, info, [!], b<-</bold>\n"
"<red>->11, info, [!], c<-</red>\n")
def emit(self, record):
"""Get corresponding Loguru level if it exists."""
try:
level = logger.level(record.levelname).name
except (ValueError, AttributeError): # pragma: no cover
level = record.levelno
# Find caller from where originated the logged message
frame, depth = logging.currentframe(), 2
while frame.f_code.co_filename == logging.__file__:
frame = frame.f_back
depth += 1
logger.opt(
lazy=True,
depth=depth,
exception=record.exc_info,
).log(level, record.getMessage())
def emit(self, record: logging.LogRecord) -> None:
"""Propagates logs to loguru.
:param record: record to log.
"""
try:
level: Union[str, int] = logger.level(record.levelname).name
except ValueError:
level = record.levelno
# Find caller from where originated the logged message
frame, depth = logging.currentframe(), 2
while frame.f_code.co_filename == logging.__file__:
frame = frame.f_back # type: ignore
depth += 1
logger.opt(depth=depth, exception=record.exc_info).log(
level,
record.getMessage(),
)
def setup_logging(level, logger_name=None):
logger_name = logger_name or __name__.split(".")[0]
log_formats = {
"DEBUG": "{time}<level> {level} [{module}] {message}</level>",
"INFO": "<level>[{module}] {message}</level>",
}
# custom level for program output so it can be nicely colourised
logger.remove()
logger.debug(f"{logger_name} {level}")
logger.add(sys.stdout,
colorize=True,
format=log_formats[level],
level=level)
prog_level = logger.level("OUTPUT",
no=25,
color="<white><dim>",
icon="🤡")
logger.debug("====[debug mode enabled]====")
def init_logger():
# Remove all logger sinks.
logger.remove()
# Add custom levels.
logger.level("USER-SUCCESS", no=33, icon="s")
logger.level("USER-CRITICAL", no=34, icon="c")
logger.level("USER-ACTION", no=35, icon="a")
logger.level("USER-INFO", no=36, icon="i")
# Add filtered sys.stdout.
logger.add(sys.stdout,
filter=bittensor_log_filter,
colorize=True,
enqueue=True,
backtrace=True,
diagnose=True,
format=bittensor_formatter)
# Add filtered rollbar handler.
rollbar_token = os.environ.get("ROLLBAR_TOKEN", False)
rollbar_env = "production"
rollbar_handler = RollbarHandler()
if rollbar_token:
# Rollbar is enabled.
logger.info("Error reporting enabled using {}:{}", rollbar_token,
rollbar_env)
rollbar.init(rollbar_token, rollbar_env)
logger.add(
sink=rollbar_handler,
level='WARNING',
colorize=True,
enqueue=True,
backtrace=True,
diagnose=True,
)
# Return internal logger
return logger.bind(internal=True)
def emit(self, record: logging.LogRecord):
"""
Catch any stdlib log messages from our deps and propagate to loguru.
"""
if getattr(record, "_from_loguru", False):
# Skip records already propagated from logugu
return
# Get corresponding Loguru level if it exists
try:
level = logger.level(record.levelname).name
except ValueError:
level = record.levelno
# Find caller from where originated the logged message
frame, depth = logging.currentframe(), 2
while frame.f_code.co_filename == logging.__file__:
frame = frame.f_back
depth += 1
record._from_logging = True
logger.bind(name=record.name).opt(depth=depth, exception=record.exc_info).log(
level, record.getMessage()
)
import tempfile
from contextlib import suppress
# Doctest modules
import numpy as np
import pytest
from _pytest.logging import caplog as _caplog # noqa
from loguru import logger
from matplotlib import pyplot as plt
from panoptes.utils.config.server import config_server
from panoptes.utils.database import PanDB
_all_databases = ['file', 'memory']
logger.enable('panoptes')
logger.level("testing", no=15, icon="🤖", color="<YELLOW><black>")
log_fmt = "<lvl>{level:.1s}</lvl> " \
"<light-blue>{time:MM-DD HH:mm:ss.ss!UTC}</>" \
"<blue>({time:HH:mm:ss.ss})</> " \
"| <c>{name} {function}:{line}</c> | " \
"<lvl>{message}</lvl>"
# Put the log file in the tmp dir.
log_file_path = os.path.realpath(f'logs/panoptes-testing.log')
startup_message = f' STARTING NEW PYTEST RUN - LOGS: {log_file_path} '
logger.add(
log_file_path,
enqueue=True, # multiprocessing
format=log_fmt,
colorize=True,
# TODO decide on these options
def test_colors_with_level(writer, colorize):
logger.add(writer, format="{message}", colorize=colorize)
logger.level("DEBUG", color="<green>")
logger.opt(colors=True).debug("a <level>level</level> b")
assert writer.read() == parse("a <green>level</green> b\n",
strip=not colorize)
config = {
"handlers":[
{"sink":sys.stdout, "format":"{time} - {message}"},
{"sink": "file_2.log", "serialize": True}
]
}
logger.configure(**config)
if __name__ == "__main__":
# logger.add(sys.stderr, format="{time} {level} {message}", level="INFO")
logger.debug("That's it, beautiful and simple logging!")
logger.info("info")
print(my_function(0, 0, 0))
new_level = logger.level("SNAKY", no=38, color="<yellow>", icon="🐍")
logger.log("SNAKY", "Here we go!")
logger.info("=---",{"1":1})
# import notifiers
# params = {
# "username": "******",
# "password": "******",
# "to": "*****@*****.**"
# }
# # Send a single notification
import time
from loguru import logger
logger.level("PASS", no=38, color="<green>")
def log(prints, Boolean=True):
if Boolean == True:
try:
logger.log("PASS", str(prints))
except:
print(f"\033[0;32;40m{time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))}\033[0m",
"\033[0;32;40mPASS\033[0m", f"\033[0;32;40m{prints}\033[0m")
elif Boolean == False:
try:
logger.error(str(prints))
except:
print(f"\033[0;32;40m{time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))}\033[0m",
"\033[0;31;40mFALSE\033[0m", f"\033[0;31;40m{prints}\033[0m")
elif Boolean == "DEBUG":
try:
logger.debug(str(prints))
except:
print(f"\033[0;32;40m{time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))}\033[0m",
"\033[0;34;40mINFO\033[0m", f"\033[0;34;40m{prints}\033[0m")
else:
raise Exception("log函数没设置布尔值或DEBUG")
import sys
from functools import partial
import logging as legacy_logger
from loguru import logger as logging
legacy_logger.getLogger("charset_normalizer").setLevel(legacy_logger.ERROR)
logging.remove()
# Setup additional logging levels, from the less important to the more critical
# Each attempted mutated request will be logged as VERBOSE as it generates a lot of output
# Each attacked original request will be logged as INFO
# Others info like currently used attack module must be logged even in quiet mode so BLUE level must be used as least
# logging.debug is level 10, this is the value defined in Python's logging module and is reused by loguru
logging.level("VERBOSE", no=15)
# logging.info is 20
logging.level("BLUE", no=21, color="<blue>")
logging.level("GREEN", no=22, color="<green>")
# logging.success is 25
# logging.warning is 30
logging.level("ORANGE", no=35, color="<yellow>")
# logging.error is 40
logging.level("RED", no=45, color="<red>")
# logging.critical is 50
log_blue = partial(logging.log, "BLUE")
log_green = partial(logging.log, "GREEN")
log_red = partial(logging.log, "RED")
log_orange = partial(logging.log, "ORANGE")
log_verbose = partial(logging.log, "VERBOSE")
return True
def __call__(self, record):
return self.filter(record)
# you can modify this instance to change the messages that are never seen/only seen once
logfilter = LogFilter()
# remove the default logger so we can put in one with a custom filter
# this can be done elsewhere if more/different customization is needed
log.remove()
# Keep these here to see what is set at the enrivonment level
# again, this isn't needed by default but if you are setting these explicitly
# then it can be good to check
if "LOGURU_LEVEL" in os.environ:
level = os.environ["LOGURU_LEVEL"]
if "LOGURU_FORMAT" in os.environ:
format = os.environ["LOGURU_FORMAT"]
# use colorize=True to force colors
# otherwise the default selection turns them off e.g., for a Jupyter notebook
# since it isn't a tty
log.add(sys.stderr,
level=level,
filter=logfilter,
format=format,
colorize=True)
# change default DEBUG color
log.level("DEBUG", color=debug_color)
import os
from pathlib import Path
from loguru import logger
import re
import utils
import shutil
root = Path(".")
member_level = logger.level("MEMBER", no=38, color="<green>", icon="💦")
era_level = logger.level("ERA", no=38, color="<yellow>", icon="📀")
event_level = logger.level("EVENT", no=38, color="<blue>", icon="🎥")
sub_event_level = logger.level("SUB-EVENT", no=38, color="<magenta>")
setup_level = logger.level("SETUP", no=38, color="<white>", icon="🔨")
ACCEPTABLE_IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".tiff", ".bmp"]
ACCEPTABLE_VIDEO_EXTENSIONS = [".mov", ".mp4"]
# # all of the available eras
# eras = ["yes-or-yes",
# 'ooh-ahh',
# 'cheer-up',
# 'tt',
# 'knock-knock',
# 'signal',
# 'likey',
# 'heart-shaker',
# 'what-is-love',
# 'dance-the-night-away',
# 'bdz',
# 'yes-or-yes']
stdout_fmt = '<cyan>{time:HH:mm:ss,SSS}</cyan> ' \
'[<level>{level: <5}</level>] ' \
'<blue>{module}</blue>:<cyan>{line}</cyan> - ' \
'<level>{message}</level>'
# 日志文件记录格式
logfile_fmt = '<light-green>{time:YYYY-MM-DD HH:mm:ss,SSS}</light-green> ' \
'[<level>{level: <5}</level>] ' \
'<cyan>{process.name}({process.id})</cyan>:' \
'<cyan>{thread.name: <18}({thread.id: <5})</cyan> | ' \
'<blue>{module}</blue>.<blue>{function}</blue>:' \
'<blue>{line}</blue> - <level>{message}</level>'
log_path = result_save_path.joinpath('oneforall.log')
logger.remove()
logger.level(name='TRACE', no=5, color='<cyan><bold>', icon='✏️')
logger.level(name='DEBUG', no=10, color='<blue><bold>', icon='🐞 ')
logger.level(name='INFOR', no=20, color='<green><bold>', icon='ℹ️')
logger.level(name='ALERT', no=30, color='<yellow><bold>', icon='⚠️')
logger.level(name='ERROR', no=40, color='<red><bold>', icon='❌️')
logger.level(name='FATAL', no=50, color='<RED><bold>', icon='☠️')
if not os.environ.get('PYTHONIOENCODING'): # 设置编码
os.environ['PYTHONIOENCODING'] = 'utf-8'
logger.add(sys.stderr, level='INFOR', format=stdout_fmt, enqueue=True)
logger.add(log_path,
level='DEBUG',
format=logfile_fmt,
enqueue=True,
encoding='utf-8')
def cli(ctx, format_, from_, gcontributors, gcredentials, pages, to,
verbose): # noqa: D403
"""Retrieve APD's traffic fatality reports."""
ctx.obj = {**ctx.params}
ctx.auto_envvar_prefix = 'VZ'
# Load defaults from configuration file if any.
cfg_path = os.path.join(click.get_app_dir(APP_NAME), APP_NAME + '.conf')
cfg = cfg_path if os.path.exists(cfg_path) else None
ctx.default_map = config.load(cfg, with_defaults=True, validate=True)
# Configure logger.
INITIAL_LOG_LEVEL = logging.WARNING
LOG_FORMAT_COMPACT = "<level>{message}</level>"
LOG_FORMAT_VERBOSE = "<level>{time:YYYY-MM-DDTHH:mm:ssZZ} {name}:{line:<4} {message}</level>"
log_level = max(INITIAL_LOG_LEVEL - verbose * 10, 0)
log_format = LOG_FORMAT_VERBOSE if log_level < logging.INFO else LOG_FORMAT_COMPACT
# Remove any predefined logger.
logger.remove()
# Set the log colors.
logger.level('ERROR', color='<red><bold>')
logger.level('WARNING', color='<yellow>')
logger.level('SUCCESS', color='<green>')
logger.level('INFO', color='<cyan>')
logger.level('DEBUG', color='<blue>')
logger.level('TRACE', color='<magenta>')
# Add the logger.
logger.add(sys.stderr, format=log_format, level=log_level, colorize=True)
# Prepare the command.
command = Retrieve(ctx.params, ctx.obj)
command.execute()
def _stdout_filter(record):
return record["level"].no <= logger.level("WARNING").no
