def _config_handler(self,
handler: logging.Handler,
level: Union[str, int] = None,
formatter: Union[str, dict] = None,
set_from_master: bool = False):
"""
Configure the handler's level and formatter
:param handler: logging.Handler type object
:param level: the level of the handler
:param formatter: the formatter of the handler
:param set_from_master: Set *level* or *formatter* from obj.master_level and obj.master_formatter
"""
# Set level
if level:
log_level = self._get_level(level)
handler.setLevel(log_level)
elif set_from_master:
handler.setLevel(self.master_level)
# Set formatter
if type(handler) == logging.StreamHandler:
formatter_class = partial(ColorFormatter,
color_config=self.color_config)
else:
formatter_class = logging.Formatter
if formatter:
self._set_formatter(handler, formatter_class, formatter)
elif set_from_master:
self._set_formatter(handler, formatter_class,
self.master_formatter)
def update_logger(self
, new_logging_level: int
, new_logging_handler: lg.Handler = None
, new_logging_formatter: lg.Formatter = None
) -> LoggableObject:
current_logger = self.logger(extend_logger_name = False)
if new_logging_level is not None:
current_logger.setLevel(new_logging_level)
if new_logging_handler is not None:
if new_logging_level is not None:
new_logging_handler.setLevel(new_logging_level)
if new_logging_formatter is not None:
new_logging_handler.setFormatter(new_logging_formatter)
for h in current_logger.handlers:
if str(h) == str(new_logging_handler):
current_logger.removeHandler(h)
current_logger.addHandler(new_logging_handler)
break
else:
current_logger.addHandler(new_logging_handler)
return self
def configure_logging(
stderr_handler: logging.Handler,
quiet: bool,
debug: bool,
enable_color: bool,
timestamps: bool,
base_logger: logging.Logger = _logger,
) -> None:
"""Configure logging."""
rdflib_logger = logging.getLogger("rdflib.term")
rdflib_logger.addHandler(stderr_handler)
rdflib_logger.setLevel(logging.ERROR)
if quiet:
# Silence STDERR, not an eventual provenance log file
stderr_handler.setLevel(logging.WARN)
if debug:
# Increase to debug for both stderr and provenance log file
base_logger.setLevel(logging.DEBUG)
stderr_handler.setLevel(logging.DEBUG)
rdflib_logger.setLevel(logging.DEBUG)
fmtclass = coloredlogs.ColoredFormatter if enable_color else logging.Formatter
formatter = fmtclass("%(levelname)s %(message)s")
if timestamps:
formatter = fmtclass(
"[%(asctime)s] %(levelname)s %(message)s", "%Y-%m-%d %H:%M:%S"
)
stderr_handler.setFormatter(formatter)
def _set_level_register_and_store(handler: logging.Handler, log_level: int):
""" Set handler log level, register it if needed, save setting to config file if specified. """
oml_level, py_level = _convert_log_levels(log_level)
handler.setLevel(py_level)
if openml_logger.level > py_level or openml_logger.level == logging.NOTSET:
openml_logger.setLevel(py_level)
if handler not in openml_logger.handlers:
openml_logger.addHandler(handler)
def configure_handler(
handler: logging.Handler,
level: int,
formatter: logging.Formatter,
filter_: logging.Filter = None,
):
handler.setLevel(level)
handler.setFormatter(formatter)
if filter_:
handler.addFilter(filter_)
return handler
def register_handler(handler: logging.Handler, logger: logging.Logger, level: int, format_string: str, record_filter: logging.Filter, verbose: bool = True) -> None:
handler.setLevel(level)
formatter = logging.Formatter(format_string)
handler.setFormatter(formatter)
if record_filter:
handler.addFilter(record_filter)
logger.addHandler(handler)
if verbose:
print("------------- New Logging Handler ---------------")
print("Added handler: {}".format(str(handler)))
print("To Logger: {}".format(str(logger)))
if record_filter:
print("With Filter: {}".format(str(record_filter)))
def addHandler(self,
handler: logging.Handler,
include_descendants: bool = True,
set_log_level: bool = True):
if set_log_level:
handler.setLevel(self.log_level)
self._logger.addHandler(handler)
self._handlers.append(handler)
if include_descendants:
self._descendant_handlers.append(handler)
for child in self.children:
if isinstance(child, EthenoLogger):
child.addHandler(handler,
include_descendants=include_descendants,
set_log_level=set_log_level)
else:
child.addHandler(handler)
def _add_handler(handler: logging.Handler,
logger: logging.Logger = logging.getLogger(),
name: str = 'log_handler',
level: int = logging.INFO,
fmt: str = default_fmt,
datefmt: str = default_date_fmt) -> logging.Handler:
"""
>>> result = set_stream_handler()
>>> result2 = set_stream_handler()
"""
handler.addFilter(HostnameFilter())
fmt = format_fmt(fmt)
formatter = logging.Formatter(fmt, datefmt)
handler.setFormatter(formatter)
handler.setLevel(level)
handler.name = name
logger.addHandler(handler)
return handler
def add_handler(handler: logging.Handler,
logger_name: Optional[str] = None,
level: int = logging.DEBUG,
log_format: Optional[str] = None):
"""
Adds a new handler to an existing logger, with the specified formatter
in ```init_logging```. If a new format is specified (is not None) then
it will be used for this handler.
:param handler: the new handler to be added.
:param logger_name: the logger name to which add the handler.
:param level: the logging level for that formatter.
:param log_format: the log format used if not formatter was created.
"""
logger = logging.getLogger(logger_name)
fmt = logging.Formatter(log_format) if log_format else logging.Formatter(
LOG_DEFAULT_FORMAT)
handler.setFormatter(fmt)
handler.setLevel(level)
logger.addHandler(handler)
def _configureHandler(logger: logging.Logger, handler: logging.Handler,
formatter: logging.Formatter,
level: typing.Optional[Level]) -> None:
"""Configures the handler
#. Sets the level to the given one or, if None, to the logger's level
#. Sets the formatter to the given one
#. Adds this handler to the logger
It is called by internally by this package's handler
"""
if level is None:
handler.setLevel(logger.level)
else:
if isinstance(level, Level):
level = level.value
elif isinstance(level, (int, str)):
handler.setLevel(level)
else:
raise TypeError("Wrong level type: %s" % type(level))
handler.setFormatter(formatter)
logger.addHandler(handler)
def configure_logging(
args: argparse.Namespace,
stderr_handler: logging.Handler,
runtimeContext: RuntimeContext,
) -> None:
rdflib_logger = logging.getLogger("rdflib.term")
rdflib_logger.addHandler(stderr_handler)
rdflib_logger.setLevel(logging.ERROR)
if args.quiet:
# Silence STDERR, not an eventual provenance log file
stderr_handler.setLevel(logging.WARN)
if runtimeContext.debug:
# Increase to debug for both stderr and provenance log file
_logger.setLevel(logging.DEBUG)
stderr_handler.setLevel(logging.DEBUG)
rdflib_logger.setLevel(logging.DEBUG)
fmtclass = coloredlogs.ColoredFormatter if args.enable_color else logging.Formatter
formatter = fmtclass("%(levelname)s %(message)s")
if args.timestamps:
formatter = fmtclass("[%(asctime)s] %(levelname)s %(message)s",
"%Y-%m-%d %H:%M:%S")
stderr_handler.setFormatter(formatter)
def __init__(self,
name: str,
strFormat: str,
handler: logging.Handler = logging.StreamHandler()):
"""
Parameters
----------
name: str
The name to give this logger.
strFormat: str
The formatting string to use.
handler: logging.StreamHandler, optional
The handler to use.
"""
self.log: logging.Logger = logging.getLogger(name)
self.log.setLevel(logging.INFO)
handler: logging.Handler = handler
handler.setLevel(logging.INFO)
handler.setFormatter(logging.Formatter(strFormat))
self.log.addHandler(handler)
def get_logger(name: str = None,
handler: logging.Handler = None,
level=logging.INFO,
formatting: str = DEFAULT_FORMAT_STR,
propagate: bool = False,
print_trace_id: bool = True):
logger = logging.getLogger(name)
logger.setLevel(level)
logger.propagate = propagate
if not handler:
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(level)
# If APP_ENV is `test` or unset we use a colorful formatter 🌈.
# Else we use a plain formatter to avoid passing ANSI color characters
# into staging/prod env logs
app_env = os.getenv('APP_ENV', TEST_ENV)
if app_env == TEST_ENV:
formatter = ColorfulFormatter(formatting)
else:
formatter = logging.Formatter(formatting)
handler.setFormatter(formatter)
if logger.hasHandlers():
# To prevent the same stream handler from being added multiple times to the
# same logger. If the same handler (stdout in this case) is added multiple
# times to the same logger then each log will show up more and more times in
# that stream.
logger.handlers.clear()
logger.addHandler(handler)
if print_trace_id:
logger = KubricLogAdapter(logger, {})
return logger
def _add_handler(self, handler: logging.Handler) -> None:
handler.setLevel(self._level.value)
handler.setFormatter(self._format)
self._logger.addHandler(handler)
def __add_handler(self, handler: logging.Handler,
add_colors: bool) -> NoReturn:
handler.setLevel(self.log_level)
handler.setFormatter(self.__get_formatter(add_colors=add_colors))
self.__logger.addHandler(handler)
def addHandler(self, handler: logging.Handler, handlerLevel: int):
handler.setLevel(handlerLevel)
handler.setFormatter(logging.Formatter(self.formatStr))
self.logger.addHandler(handler)
def _setHandlerDefaults(self, handler: logging.Handler) -> None:
handler.setLevel(self.level)
handler.setFormatter(self.formatter)
def _setup_handler(handler: logging.Handler, formatter: logging.Formatter,
level: int) -> None:
handler.setLevel(level)
handler.setFormatter(formatter)
logging.getLogger().addHandler(handler)
def add_handler(handler: logging.Handler, level: int) -> None:
handler.setLevel(level)
handler.setFormatter(formatter)
logger.addHandler(handler)
