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