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