def set_console_logger(self, loglevel, enable_color): """ Method to create a ConsoleLogger object using the arguments and set the same as property 'console_logger' """ self.console_logger = ConsoleLogger(loglevel)
def main(): logger = ConsoleLogger() propertiespath = os.path.join( os.path.dirname(os.path.realpath(__file__)), 'properties') generalproperties = ConfigHelper.config(None, path=propertiespath, filename='properties.ini', section='general') dbproperties = ConfigHelper.config(None, path=propertiespath, filename='database.ini', section=generalproperties.get('db')) dirpath = generalproperties.get('dirpath') watch_file_extension = generalproperties.get('watch_file_extension') asc_files = [f for f in os.listdir(dirpath) if f.endswith(watch_file_extension)] asc_files_with_path = [] for file in asc_files: asc_files_with_path.append(os.path.join(dirpath, file)) logger.info('found hydrograph-files: {}'.format(asc_files_with_path)) filecount = len(asc_files) logger.info('Number of forecast files found: {}'.format(filecount)) shapenames = [] if filecount > 0: filenames = asc_files_with_path for filename in filenames: filename = ProcessingHelper.replacebackslashes(filename) logger.info("filename {}".format(filename)) dataframe_forecast = ProcessingHelper.getDataFrameForFile(None, filename) floodplain_name = ProcessingHelper.getfloodplainNameFromFilename(filename) # Determine Interpolation function for infile and calculate max Q from infile and Volume from interpol-func qvol, err = ProcessingHelper.getVolume(dataframe_forecast) qmax = dataframe_forecast['q'].max() logger.info("Floodplain: {0}; Input-Hydrograph: Q [m3]: {1:n}; Qmax [m3/s]: {2:n}".format(floodplain_name, int(round(qvol)), qmax)) # match hydrograph from infile to SDH's via Qmax and Volume # grab matching shapefile from postgis-database and display it shapenames.append(ProcessingHelper.getmatchingshapefromdb(None, qmax, qvol, floodplain_name, dbproperties, logger)) filteredShapeNames = list(filter(None.__ne__, shapenames)) if len(filteredShapeNames) > 0: mergeprocessor = MergeProcessor() logger.info('Merging and dissolving starts ...') spinner = Spinner() spinner.start() mergetablename = mergeprocessor.exec_merge_dissolve(dbproperties, generalproperties, filteredShapeNames, logger) spinner.stop() logger.info('Merging and dissolving finished. Resulting tablename is {}.'.format(mergetablename)) sys.stdout.write(mergetablename) sys.stdout.flush() sys.exit(0) else: logger.error('No resulting shapes available. Processing finished.') sys.exit(1)
class MultiLogger(BaseLoggerClass): """ class to facilitate logging at three places simultaneously: 1. System Logger (rsyslog) 2. Multi mails (Attaching debug logs) 3. System console +++ Logging in other areas if required (future additions) Init arguments: places: dictionary with string keys & boolean values to enable/disable logging in different places facility: used by system logger loglevel: Log Level for logs. Default: 'INFO' enable_color: used by console logger. Enables color output """ def __init__(self, places={'logger': True, 'email': True, 'console': False}, loglevel='INFO', facility=None, enable_color=True): """ Constructor to initialize MultiLogger object. """ if type(loglevel) == type(logging.INFO): self.loglevel = loglevel else: self.loglevel = LOGLEVELS[loglevel] self.log_in_logger = bool(places['logger']) self.log_in_email = bool(places['email']) self.log_in_console = bool(places['console']) if self.log_in_logger == True: self.set_system_logger(self.loglevel, facility) else: self.system_logger = None if self.log_in_email == True: self.set_email_logger(self.loglevel) else: self.email_logger = None if self.log_in_console == True: self.set_console_logger(self.loglevel, enable_color) else: self.console_logger = None self.highest_level_reported = None def set_system_logger(self, loglevel, facility=None): """ Method to create a System Logger object using the arguments and set the same as property 'system_logger' """ logger = logging.getLogger() logger.setLevel(loglevel) if facility: syslog = SysLogHandler(address='/dev/log', facility=facility) formatter = logging.Formatter('%(name)s: %(levelname)s %(message)r') syslog.setFormatter(formatter) logger.addHandler(syslog) self.system_logger = logger def set_email_logger(self, loglevel): """ Method to create a EmailLogger object using the arguments and set the same as property 'email_logger' """ self.email_logger = EmailLogger(loglevel) def set_console_logger(self, loglevel, enable_color): """ Method to create a ConsoleLogger object using the arguments and set the same as property 'console_logger' """ self.console_logger = ConsoleLogger(loglevel) def get_email_log(self): """ Return: The logs which can be appended in email """ if self.log_in_email == True: return self.email_logger.get_email_log() return '' def debug(self, error_message, *args, **kwargs): """ Logs a message with level DEBUG on this logger """ if logging.DEBUG >= self.loglevel: if self.log_in_logger: self.system_logger.debug(error_message, *args, **kwargs) if self.log_in_email: self.email_logger.debug(error_message, *args, **kwargs) if self.log_in_console: self.console_logger.debug(error_message, *args, **kwargs) if ((self.highest_level_reported == None) or (self.highest_level_reported < logging.DEBUG)): self.highest_level_reported = logging.DEBUG def info(self, error_message, *args, **kwargs): """ Logs a message with level INFO on this logger """ if logging.INFO >= self.loglevel: if self.log_in_logger: self.system_logger.info(error_message, *args, **kwargs) if self.log_in_email: self.email_logger.info(error_message, *args, **kwargs) if self.log_in_console: self.console_logger.info(error_message, *args, **kwargs) if ((self.highest_level_reported == None) or (self.highest_level_reported < logging.INFO)): self.highest_level_reported = logging.INFO def warning(self, error_message, *args, **kwargs): """ Logs a message with level WARNING on this logger """ if logging.WARNING >= self.loglevel: if self.log_in_logger: self.system_logger.warning(error_message, *args, **kwargs) if self.log_in_email: self.email_logger.warning(error_message, *args, **kwargs) if self.log_in_console: self.console_logger.warning(error_message, *args, **kwargs) if ((self.highest_level_reported == None) or (self.highest_level_reported < logging.WARNING)): self.highest_level_reported = logging.WARNING def warn(self, error_message, *args, **kwargs): """ Logs a message with level WARNING on this logger """ self.warning(error_message, *args, **kwargs) def error(self, error_message, *args, **kwargs): """ Logs a message with level ERROR on this logger """ if logging.ERROR >= self.loglevel: if self.log_in_logger: self.system_logger.error(error_message, *args, **kwargs) if self.log_in_email: self.email_logger.error(error_message, *args, **kwargs) if self.log_in_console: self.console_logger.error(error_message, *args, **kwargs) if ((self.highest_level_reported == None) or (self.highest_level_reported < logging.ERROR)): self.highest_level_reported = logging.ERROR def exception(self, error_message, *args): """ Logs a message with level ERROR on this logger. Exception info is added to the logging message. This method should only be called from an exception """ if logging.ERROR >= self.loglevel: if self.log_in_logger: self.system_logger.exception(error_message, *args) if self.log_in_email: self.email_logger.exception(error_message, *args) if self.log_in_console: self.console_logger.exception(error_message, *args) if ((self.highest_level_reported == None) or (self.highest_level_reported < logging.ERROR)): self.highest_level_reported = logging.ERROR def critical(self, error_message, *args, **kwargs): """ Logs a message with level CRITICAL on this logger """ if logging.CRITICAL >= self.loglevel: if self.log_in_logger: self.system_logger.critical(error_message, *args, **kwargs) if self.log_in_email: self.email_logger.critical(error_message, *args, **kwargs) if self.log_in_console: self.console_logger.critical(error_message, *args, **kwargs) if ((self.highest_level_reported == None) or (self.highest_level_reported < logging.CRITICAL)): self.highest_level_reported = logging.CRITICAL