rework of logging class for toargridding

now any handler and its formatter can be added
added possibility to pass all uncaught exceptions to the logging

tests/conversionOfTimestamps.py

 import logging
-from logging.handlers import SysLogHandler
 
 from datetime import datetime as dt
 from collections import namedtuple
@@ -10,14 +9,15 @@ from toargridding.grids import RegularGrid
 from toargridding.gridding import get_gridded_toar_data
 from toargridding.metadata import TimeSample
 
-##setting up logger
+##setting up logging
 from toargridding.defaultLogging import toargridding_defaultLogging
 logger = toargridding_defaultLogging()
 logger.addShellLogger(logging.DEBUG)
+logger.logExceptions()
+#logger.addSysLogger(logging.DEBUG)
 
+#raise RuntimeError("For testing purposes")
 
-
-## add logger to syslog
 #creation of request.
 
 Config = namedtuple("Config", ["grid", "time", "variables", "stats","moreOptions"])

toargridding/defaultLogging.py

+import sys
 import logging
+from collections import namedtuple
 from logging.handlers import SysLogHandler
 
+
+registeredLogger = namedtuple("registeredLogger", ["handler","formatter"])
+
 class toargridding_defaultLogging:
     """! class to setup default loggers for toargridding
+
+    The added handler and their formatters are stored by this class for further configuration.
+    Parameters:
+    ----------
+    loggername:
+        name of the logger to be used. default: toargridding
     
     Methods:
     -------
+    registerHandler:
+        register a handler. Adds it to the logger and stores references in this class
     addShellLogger:
         adds a formatting logging to the shell. Default level is DEBUG
     addSysLogger:
         adds a formatted logging to the system log (on a linux system). Default level is WARNING
+    logExceptions:
+        enable passing of any uncaught exception to the logger
+    getHandler:
+        get a registered handler
+    getFormatter:
+        get a registered formatter
     """
-    def __init__(self):
-        self.logger = logging.getLogger("toargridding")
+    def __init__(self, loggername : str = "toargridding" ):
+        self.logger = logging.getLogger(loggername)
         self.logger.setLevel(logging.DEBUG)
+        self.registeredLoggers = {}# name : registeredLogger
+    def registerHandler(self, name : str, handler, formatter = None):
+        """register a handler. Adds it to the logger and stores references in this class.
+        The given formatter (if not None) is added to the handler.
+        The handler is added to the logger.
+        Handler and logger are stored for a possible later access.
+        
+        Throws an exception if the name of the handler is already known.
+        """
+        if name in self.registeredLoggers:
+            raise ValueError(f"There is already a registered handler with the name {name}.")
+        if formatter is not None:
+            handler.setFormatter(formatter)
+        self.logger.addHandler(handler)
+        self.registeredLoggers[name] = registeredLogger(handler, formatter)
+    def getHandler(self, name : str):
+        """get a handler for logging by its name used for the registration
+        """
+        if name in self.registeredLoggers:
+            return self.registeredLoggers[name].handler
+        return None
+    def getFormatter(self, name : str):
+        """get a formatter by its name used for the registration
+        """
+        if name in self.registeredLoggers:
+            return self.registeredLoggers[name].formatter
+        return None
     def addShellLogger(self, level=logging.INFO):
         """!adds a formatted logging to the shell to the "toargridding" logger.
-        The output handler can afterwards be accessed as shell_handler and its formatter as shell_formatter 
+        The handler is registered as "shell".
 
         Parameters:
         ----------
         level:
             set the verbosity level of the logger (default: info)
         """
-        self.shell_handler = logging.StreamHandler()
-        self.shell_handler.setLevel(level)
-        self.shell_formatter = logging.Formatter(fmt="%(asctime)s [%(levelname)s] - %(filename)s:%(lineno)d: '%(message)s'", datefmt="%Y-%m-%d %H:%M:%S")
-        self.shell_handler.setFormatter(self.shell_formatter)
-        self.logger.addHandler(self.shell_handler)
+        shell_handler = logging.StreamHandler()
+        shell_handler.setLevel(level)
+        shell_formatter = logging.Formatter(fmt="%(asctime)s [%(levelname)s] - %(filename)s:%(lineno)d: '%(message)s'", datefmt="%Y-%m-%d %H:%M:%S")
+        self.registerHandler("shell", shell_handler, shell_formatter)
     def addSysLogger(self, level=logging.WARNING):
         """!adds a formatted logging to the system log of a linux system to the "toargridding" logger.
-        The output handler can afterwards be accessed as syslog_handler and its formatter as syslog_formatter 
+        This logging is registered as "syslog".
         
         Parameters:
         ----------
         level:
             set the verbosity level of the logger (default: warning)
         """
-        self.syslog_handler = SysLogHandler(facility=SysLogHandler.LOG_DAEMON, address='/dev/log')
-        self.syslog_formatter = logging.Formatter(fmt="TOARGRIDDING [%(levelname)s] - %(filename)s:%(lineno)d: '%(message)s'")
-        self.syslog_handler.setFormatter(self.syslog_formatter)
-        self.syslog_handler.setLevel(level)
-        self.logger.addHandler(self.syslog_handler)
+        syslog_handler = SysLogHandler(facility=SysLogHandler.LOG_DAEMON, address='/dev/log')
+        syslog_formatter = logging.Formatter(fmt="TOARGRIDDING [%(levelname)s] - %(filename)s:%(lineno)d: '%(message)s'")
+        syslog_handler.setLevel(level)
+        self.registerHandler("syslog",syslog_handler, syslog_formatter)
+    def logExceptions(self):
+        """calling this function will redirect all uncaught exceptions to the logger
+        This is especially useful to write the exceptions to the system log 
+        """
+        sys.excepthook = self.handle_exception
+    def handle_exception(self, exc_type, exc_value, exc_traceback):
+        """function for passing uncaught exceptions to the logger
+
+        """
+        if issubclass(exc_type, KeyboardInterrupt):
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+
+        self.logger.error("Program terminated by the following exception:", exc_info=(exc_type, exc_value, exc_traceback))
+