def test_logger_rotating_rollover(tmp_path):
log_file = tmp_path / "logs" / "test_log.log"
logger1 = get_logger(str(uuid.uuid4()))
logger1.start_file_logger(log_file)
assert len(list((tmp_path / "logs").glob("*"))) == 1
logger2 = get_logger(str(uuid.uuid4()))
logger2.start_file_logger(log_file, rollover=True)
assert len(list((tmp_path / "logs").glob("*"))) == 2
def logger_no_fh():
_logger = get_logger(str(uuid.uuid4()))
yield _logger
handlers = _logger.warnings_logger.handlers
for handler in handlers:
_logger.warnings_logger.removeHandler(handler)
def setup_logger(
self,
log: Any,
log_dir: Optional[Union[pathlib.Path, str]],
verbose: Union[bool, int] = False,
):
"""Starts the file logger."""
if not log:
log = get_logger("clu:" + self.name)
else:
assert isinstance(log, SDSSLogger), "Logger must be sdsstools.SDSSLogger"
self.log = log
return log
log.setLevel(REPLY)
if log is not False and log_dir:
log_dir = pathlib.Path(log_dir).expanduser()
log.start_file_logger(
str(log_dir / f"{self.name}.log"),
rotating=True,
rollover=True,
)
if log.fh: # In case starting the file logger fails.
log.fh.formatter.converter = time.gmtime
log.fh.setLevel(REPLY)
log.sh.setLevel(logging.WARNING)
if verbose is True:
log.sh.setLevel(logging.DEBUG)
elif verbose is not False and isinstance(verbose, int):
log.sh.setLevel(verbose)
self.log = log
self.log.debug(f"{self.name}: logging system initiated.")
# Set the loop exception handler to be handled by the logger.
self.loop.set_exception_handler(self.log.asyncio_exception_handler)
return log
# encoding: utf-8
from sdsstools import get_config, get_logger, get_package_version
# pip package name
NAME = 'sdss-valis'
# Loads config. config name is the package name.
config = get_config('valis')
# Inits the logging system as NAME. Only shell logging, and exception and warning catching.
# File logging can be started by calling log.start_file_logger(path). Filename can be different
# than NAME.
log = get_logger(NAME)
# package name should be pip package name
__version__ = get_package_version(path=__file__, package_name=NAME)
from typing import TYPE_CHECKING
import warnings
from sdsstools import get_config, get_logger, get_package_version
from sdsstools.configuration import __ENVVARS__
from .exceptions import JaegerUserWarning
if TYPE_CHECKING:
from .actor import JaegerActor
NAME = "jaeger"
__version__ = get_package_version(path=__file__, package_name=NAME)
log = get_logger("jaeger", log_level=logging.WARNING)
can_log = get_logger("jaeger_can",
log_level=logging.ERROR,
capture_warnings=False)
# Start by loading the internal configuration file.
__ENVVARS__["OBSERVATORY"] = "?"
config = get_config(NAME)
# If we are not in debug mode, remove some possible warnings.
if config["debug"] is False:
warnings.filterwarnings(
"ignore",
message=".+was never awaited.+",
category=RuntimeWarning,
)
# encoding: utf-8 # isort: skip_file import logging from sdsstools import get_config, get_logger, get_package_version NAME = "fvc" __version__ = get_package_version(path=__file__, package_name=NAME) config = get_config(NAME) log = get_logger(NAME, log_level=logging.WARNING)
def __init__(
self,
camera_class: Optional[Type[_T_BaseCamera]] = None,
camera_config: Optional[Union[AnyPath, Dict[str, Any]]] = None,
include: Optional[List[Any]] = None,
exclude: Optional[List[Any]] = None,
logger: Optional[SDSSLogger] = None,
log_header: Optional[str] = None,
log_file: Optional[AnyPath] = None,
verbose: Optional[Union[bool, int]] = False,
):
self.camera_class = camera_class or self.camera_class
if not self.camera_class or not issubclass(self.camera_class,
BaseCamera):
raise ValueError("camera_class must be a subclass of BaseCamera.")
self.include = self.include or include
self.exclude = self.exclude or exclude
logger_name = self.__class__.__name__.upper()
self.log_header = log_header or f"[{logger_name.upper()}]: "
self.logger = logger or cast(SDSSLogger, get_logger(logger_name))
if verbose:
self.logger.sh.setLevel(int(verbose))
else:
self.logger.sh.setLevel(logging.WARNING)
if log_file:
self.logger.start_file_logger(str(log_file))
if self.logger.fh:
assert self.logger.fh.formatter
self.logger.fh.formatter.converter = time.gmtime
self.log(f"logging to {log_file}")
self.loop = asyncio.get_event_loop()
self.loop.set_exception_handler(self.logger.asyncio_exception_handler)
#: list: The list of cameras being handled.
self.cameras: List[_T_BaseCamera] = []
self._camera_poller = None
#: .EventNotifier: Notifies of `.CameraSystemEvent` and `.CameraEvent` events.
self.notifier = EventNotifier()
self._config: Optional[Dict[str, Any]] = None
if camera_config:
if isinstance(camera_config, dict):
self._config = camera_config.copy()
else:
self._config = cast(Dict[str, Any],
read_yaml_file(str(camera_config)))
self.log(f"read configuration file from {camera_config}")
# If the config has a section named "cameras", prefer that.
if self._config is not None:
if isinstance(self._config.get("cameras", None), dict):
self._config = self._config["cameras"]
assert self._config is not None
uids = [self._config[camera]["uid"] for camera in self._config]
if len(uids) != len(set(uids)):
raise ValueError("repeated UIDs in the configuration data.")
self.running: bool = False
def test_get_logger_twice(logger):
logger2 = get_logger(logger.name)
assert logger == logger2
