def set_up_loggers(config): """ Set up a pair of loggers so we can save our progress to text files """ output_folder = config['output_folder'] output_filename_stem = config['output_filename_stem'] now = datetime.now() current_time = now.strftime("%d_%m_%Y-%H_%M_%S") logger = logging.getLogger('tiling_progress') logger_R_code = logging.getLogger('R_code') logger.setLevel(logging.INFO) logger_R_code.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s: - %(message)s') logger.handlers = [] logger_R_code.handlers = [] # This if statement is to avoid us having multiple loggers if we run the code twice in the same session. if not logger.handlers: # Set up our console and file handlers console = logging.StreamHandler() console.setLevel(logging.INFO) file_handler = handlers.WatchedFileHandler( filename= f"{output_folder}/Logs/{output_filename_stem}_{current_time}.log") file_handler.setLevel(logging.INFO) console.setFormatter(formatter) file_handler.setFormatter(formatter) logger.addHandler(console) logger.addHandler(file_handler) # Now do the same for the R code log if not logger_R_code.handlers: file_handler_R_code = handlers.WatchedFileHandler( filename= f"{output_folder}/Logs/{output_filename_stem}_{current_time}_R_Output.log" ) file_handler_R_code.setLevel(logging.INFO) file_handler_R_code.setFormatter(formatter) logger_R_code.addHandler(file_handler_R_code) return logger, logger_R_code
def setup_logging(level="INFO", label="", log_file=""): if label: label = "(" + label + ")" filename = None stream = None if log_file: if log_file in ('-', '/dev/stderr'): stream = sys.stderr elif log_file == '/dev/stdout': stream = sys.stdout else: filename = log_file datefmt = "%Y-%m-%d %H:%M:%S" fmt = LOGFMT.format(label) logging.root = GLogger("root", level) logging.setLoggerClass(GLogger) logging.Formatter.converter = time.gmtime # Log in GMT/UTC time logging.getLogger().handlers = [] logging.getLogger().setLevel(level) if filename is not None: logging_handler = handlers.WatchedFileHandler(filename) formatter = logging.Formatter(fmt=fmt, datefmt=datefmt) logging_handler.setFormatter(formatter) logging.getLogger().addHandler(logging_handler) else: logging.basicConfig(stream=stream, format=fmt, datefmt=datefmt, level=level)
def init(self, *priv): if not priv: raise SnmpResponderError('Bad log file params, need filename') if sys.platform[:3] == 'win': # fix possibly corrupted absolute windows path if len(priv[0]) == 1 and priv[0].isalpha() and len(priv) > 1: priv = [priv[0] + ':' + priv[1]] + list(priv[2:]) maxsize = 0 maxage = None if len(priv) > 1 and priv[1]: try: if priv[1][-1] == 'k': maxsize = int(priv[1][:-1]) * 1024 elif priv[1][-1] == 'm': maxsize = int(priv[1][:-1]) * 1024 * 1024 elif priv[1][-1] == 'g': maxsize = int(priv[1][:-1]) * 1024 * 1024 * 1024 elif priv[1][-1] == 'S': maxage = ('S', int(priv[1][:-1])) elif priv[1][-1] == 'M': maxage = ('M', int(priv[1][:-1])) elif priv[1][-1] == 'H': maxage = ('H', int(priv[1][:-1])) elif priv[1][-1] == 'D': maxage = ('D', int(priv[1][:-1])) else: raise ValueError('Unknown log rotation criterion: %s' % priv[1][-1]) except ValueError: raise SnmpResponderError( 'Error in timed log rotation specification. Use <NNN>k,m,g ' 'for size or <NNN>S,M,H,D for time limits') try: if maxsize: handler = handlers.RotatingFileHandler(priv[0], backupCount=30, maxBytes=maxsize) elif maxage: handler = self.TimedRotatingFileHandler(priv[0], backupCount=30, when=maxage[0], interval=maxage[1]) else: handler = handlers.WatchedFileHandler(priv[0]) except Exception: raise SnmpResponderError('Failure configure logging: %s' % sys.exc_info()[1]) handler.setFormatter(logging.Formatter('%(message)s')) self._logger.addHandler(handler) self('Log file %s, rotation rules: %s' % (priv[0], maxsize and '> %sKB' % (maxsize / 1024) or maxage and '%s%s' % (maxage[1], maxage[0]) or '<none>'))
def setup(cls, **kw): lbl = kw.get('label', "") if lbl: lbl = '(' + lbl + ')' lprm = {'datefmt': "%Y-%m-%d %H:%M:%S", 'format': "[%(asctime)s.%(nsecs)d] %(lvlnam)s [%(module)s" + lbl + ":%(lineno)s:%(funcName)s] %(ctx)s: %(message)s"} lprm.update(kw) lvl = kw.get('level', logging.INFO) lprm['level'] = lvl logging.root = cls("root", lvl) logging.setLoggerClass(cls) logging.getLogger().handlers = [] logging.getLogger().setLevel(lprm['level']) if 'filename' in lprm: try: logging_handler = handlers.WatchedFileHandler(lprm['filename']) formatter = logging.Formatter(fmt=lprm['format'], datefmt=lprm['datefmt']) logging_handler.setFormatter(formatter) logging.getLogger().addHandler(logging_handler) except AttributeError: # Python version < 2.6 will not have WatchedFileHandler # so fallback to logging without any handler. # Note: logrotate will not work if Python version is < 2.6 logging.basicConfig(**lprm) else: # If filename not passed(not available in lprm) then it may be # streaming.(Ex: {"stream": "/dev/stdout"}) logging.basicConfig(**lprm)
def logRPCToFile(self, rpcPath): if not self.rpcFileHandler: fileHandler = handlers.WatchedFileHandler(rpcPath) fileHandler.setFormatter( self.formatterClass(self.rpcFormat, self.dateFormat)) self.rpcFileHandler = fileHandler self.xmlrpcLogger.addHandler(self.rpcFileHandler)
def INIT_LOG(name, bOpenDebug=False): if bOpenDebug: __gLoggerND.setLevel(logging.DEBUG) else: __gLoggerND.setLevel(logging.INFO) hl_nd = handlers.WatchedFileHandler('log/%s.log' % name) hl_nd.setFormatter( logging.Formatter(fmt='%(asctime)s %(levelname)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')) __gLoggerND.addHandler(hl_nd) __gLoggerWF.setLevel(logging.WARNING) hl_wf = handlers.WatchedFileHandler('log/%s.log.wf' % name) hl_wf.setFormatter( logging.Formatter(fmt='%(asctime)s %(levelname)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')) __gLoggerWF.addHandler(hl_wf) return
def __configure_handler(self, log_dir): _dir = '{}/{}'.format(Settings.PROJECT_ROOT, log_dir) if not os.path.exists(_dir): os.mkdir(_dir) _filename = "{}/{}.log".format(_dir, self.log_name) self.handler = handlers.WatchedFileHandler(_filename, mode="a", encoding="utf-8") self.handler.setFormatter(self.formatter)
def logMessagesToFile(self, logPath): if self.messageHandler: self.messageLogger.removeHandler(self.messageHandler) util.mkdirChain(os.path.dirname(logPath)) fileHandler = handlers.WatchedFileHandler(logPath) fileHandler.setFormatter( self.formatterClass(self.messageFormat, self.dateFormat)) self.messageHandler = fileHandler self.messageLogger.addHandler(self.messageHandler) self.messageLogger.setLevel(logging.INFO)
def __init__(self, filename, level='info', fmt="[%(asctime)s]-%(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s"): self.logger = logging.getLogger(filename) log_format = logging.Formatter(fmt) self.logger.setLevel(self.level_relations.get(level)) sh = logging.StreamHandler() sh.setFormatter(log_format) file = handlers.WatchedFileHandler(filename, encoding='UTF-8') file.setFormatter(log_format) self.logger.addHandler(sh) self.logger.addHandler(file)
def logToFile(self, logPath): if not self.fileHandler: util.mkdirChain(os.path.dirname(logPath)) kwargs = dict() fileHandler = handlers.WatchedFileHandler(logPath, delay=self.delay) fileHandler.setFormatter( self.formatterClass(self.fileFormat, self.dateFormat)) self.fileHandler = fileHandler self.logger.addHandler(self.fileHandler)
def setup_logging(): log_file = cfg.CONF.network_log.local_output_log_base if log_file: from logging import handlers as watch_handler log_file_handler = watch_handler.WatchedFileHandler(log_file) LOG.logger.addHandler(log_file_handler) elif cfg.CONF.use_journal: journal_handler = handlers.OSJournalHandler() LOG.logger.addHandler(journal_handler) else: syslog_handler = handlers.OSSysLogHandler() LOG.logger.addHandler(syslog_handler)
def initMainOut(self): s='outEDS_{0}.txt'.format(time.time()) logger = logging.getLogger(s) logger.setLevel("INFO") if not os.path.exists('out'): os.makedirs('out') log_file = handlers.WatchedFileHandler("out/{0}".format(s)) log_formater = logging.Formatter('%(message)s') log_file.setFormatter(log_formater) logger.addHandler(log_file) logger.debug('init') return logger
def init(self, *priv): if not priv: raise error.SnmpsimError('Bad log file params, need filename') if sys.platform[:3] == 'win': # fix possibly corrupted absolute windows path if len(priv[0]) == 1 and priv[0].isalpha() and len(priv) > 1: priv = [priv[0] + ':' + priv[1]] + priv[2:] maxsize = 0 maxage = None if len(priv) > 1 and priv[1]: localtime = time.localtime() if priv[1][-1] in ('k', 'K'): maxsize = int(priv[1][:-1]) * 1024 elif priv[1][-1] in ('m', 'M'): maxsize = int(priv[1][:-1]) * 1024 * 1024 elif priv[1][-1] in ('g', 'G'): maxsize = int(priv[1][:-1]) * 1024 * 1024 * 1024 elif priv[1][-1] in ('h', 'H'): maxage = ('H', int(priv[1][:-1])) elif priv[1][-1] in ('d', 'D'): maxage = ('D', int(priv[1][:-1])) else: raise error.SnmpsimError( 'Unknown log rotation criteria %s, use <NNN>K,M,G for size or <NNN>H,D for time limits' % priv[1]) try: if maxsize: handler = handlers.RotatingFileHandler(priv[0], backupCount=30, maxBytes=maxsize) elif maxage: handler = handlers.TimedRotatingFileHandler(priv[0], backupCount=30, when=maxage[0], interval=maxage[1]) else: handler = handlers.WatchedFileHandler(priv[0]) except AttributeError: raise error.SnmpsimError('Bad log rotation criteria: %s' % sys.exc_info()[1]) handler.setFormatter( logging.Formatter('%(asctime)s %(name)s: %(message)s')) self._logger.addHandler(handler) self('Log file %s, rotation rules: %s' % (priv[0], maxsize and '> %sKB' % (maxsize / 1024) or maxage and '%s%s' % (maxage[1], maxage[0]) or '<none>'))
def test_unwatch_log(self): stream_handler = logging.StreamHandler() logger = logging.Logger('fake') logger.addHandler(stream_handler) logger.addHandler(handlers.WatchedFileHandler(self.temp_file)) with mock.patch('logging.getLogger', return_value=logger): daemon.unwatch_log() self.assertEqual(2, len(logger.handlers)) logger.handlers.remove(stream_handler) observed = logger.handlers[0] self.assertEqual(logging.FileHandler, type(observed)) self.assertEqual(self.temp_file, observed.baseFilename)
def init(args): logdir = args['logdir'] or os.path.join(sys.path[0], 'logs') loglevel = args['loglevel'] or 'info' logfile_per_exec = args['logfile_per_exec'] or False formatter = logging.Formatter(args['logformat'] or LOGFORMAT) # Get log directory and file. commands = [ value for (arg, value) in sorted(args) if arg.startswith('command') ] if logfile_per_exec: logdir = os.path.join(args.logdir, *commands) logfile = os.path.join( logdir, '%s.log' % datetime.now().strftime('%Y%m%d%H%M')) else: if not commands: # if no subcommands.: filename = os.path.splitext(os.path.basename(sys.argv[0]))[0] logfile = os.path.join(logdir, '%s.log' % filename) else: logdir = os.path.join(logdir, *commands[:-1]) logfile = os.path.join(logdir, '%s.log' % commands[-1]) loglevel = args.loglevel or 'info' # If directory for storing logs does not exists, create it with group permissions. umask = os.umask(0) if not os.path.exists(logdir): try: os.makedirs(logdir, mode=0o770) except OSError as err: raise IOError('unable to create log directory: %s' % err) # Initialize logger; logger = logging.getLogger('-'.join(commands)) logger.setLevel('VERBOSE') # log level is overloaded by each handlers. # Add file handler. file_handler = handlers.WatchedFileHandler(logfile) file_handler.setFormatter(formatter) file_handler.setLevel('INFO') logger.addHandler(file_handler) os.chmod(logfile, 0o770) # Add cli handler. if loglevel != 'none': cli_handler = logging.StreamHandler() cli_handler.setFormatter(formatter) cli_handler.setLevel(loglevel.upper()) logger.addHandler(cli_handler) os.umask(umask) setattr(sys.modules[__name__], 'logger', logger)
def configure_logger(debug: bool = False, log_format: str = None): log_file = path.join(project_dir(), LOG_FILE) if log_format is None: log_format = LOG_FORMAT log_level = 20 # INFO if debug: log_level = 10 # DEBUG logging.basicConfig( format=log_format, level=log_level, handlers=[handlers.WatchedFileHandler(filename=log_file)], )
def initMainOut(self): #для упрощения вывода в текстовый файл в качестве выходного файла используется также файл лога но форматирование вида "сообщение" #имя файла будет вида out_[время_запуска_приложения] #ссылка на логгер является членом класса с именем out s='outEDS_{0}.txt'.format(time.time()) logger = logging.getLogger(s) logger.setLevel("INFO") #все выходные файлы пишутся в папку out if not os.path.exists('out'): os.makedirs('out') log_file = handlers.WatchedFileHandler("out/{0}".format(s)) log_formater = logging.Formatter('%(message)s') log_file.setFormatter(log_formater) logger.addHandler(log_file) logger.debug('init') return logger
def initOut(self,name): #Если в одном приложении требуется несколько выходных файлов, они инициализируются с именем name #остальное аналогично mainOut #все ссылки на логгеры помещяются в словарь outs s='outEDS_{1}_{0}.txt'.format(time.time(),name) logger = logging.getLogger(s) logger.setLevel("INFO") if not os.path.exists('out'): os.makedirs('out') log_file = handlers.WatchedFileHandler("out/{0}".format(s)) log_formater = logging.Formatter('%(message)s') log_file.setFormatter(log_formater) logger.addHandler(log_file) logger.debug('init') self.outs[name]=logger return logger
def set_logging(logger, loglevel, stdout=False, logfile=None, logformat=logformat): logger.setLevel(loglevel) formatter = logging.Formatter(logformat) if stdout: stream_handler = logging.StreamHandler() stream_handler.setLevel(loglevel) stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) if logfile: file_handler = handlers.WatchedFileHandler(logfile) file_handler.setLevel(loglevel) file_handler.setFormatter(formatter) logger.addHandler(file_handler) return logger
def setup_logging(): log_file = cfg.CONF.network_log.local_output_log_base if log_file: from logging import handlers as watch_handler log_file_handler = watch_handler.WatchedFileHandler(log_file) log_file_handler.setLevel( logging.DEBUG if cfg.CONF.debug else logging.INFO) LOG.logger.addHandler(log_file_handler) log_file_handler.setFormatter( formatters.ContextFormatter( fmt=cfg.CONF.logging_default_format_string, datefmt=cfg.CONF.log_date_format)) elif cfg.CONF.use_journal: journal_handler = handlers.OSJournalHandler() LOG.logger.addHandler(journal_handler) else: syslog_handler = handlers.OSSysLogHandler() LOG.logger.addHandler(syslog_handler)
def __init__( self, debug: bool, log_file: str, plugin_folder: str, level=None, logger_name: str = None, logger_enabled: bool = True, prefix: str = "VKBottle", prefix_color: str = "blue", ): self.__debug: bool = debug self.__coloring = Coloring(prefix, prefix_color) self.__level = level or logging.DEBUG self.__log_file = log_file self.__plugin_folder = plugin_folder self.__logger_name = logger_name self.__logger_enabled = logger_enabled self.colored = colored self.logger = logging.getLogger(logger_name or "VKBottle") path = "{path}/logs".format(path=plugin_folder) self.log_path = "{path}/{log_file}_{time}.log".format( path=path, log_file=log_file if log_file and re.match(LOG_FILE_PATTERN, log_file) else DEFAULT_LOG_NAME, time=time.strftime("%m-%d_%H:%M:%S", time.localtime()), ) if not os.path.isdir(path) and logger_enabled: os.makedirs("{path}/logs".format(path=plugin_folder)) if logger_enabled: open(self.log_path, "w+").close() self.logger.setLevel(self.__level) formatter = logging.Formatter(LOG_FORMAT) handler = handlers.WatchedFileHandler(self.log_path) handler.setLevel(self.__level) handler.setFormatter(formatter) self.logger.addHandler(handler) self.debug("My logging file path is {}".format(self.log_path))
def get_file_handler(name=None, logpath=None): """Get the file handler.""" if name is not None: logfile = name + '.log' else: logfile = 'master.log' if logpath is not None: fname = os.path.join(logpath, logfile) else: fname = logfile file_handler = handlers.WatchedFileHandler(fname, delay=True) # formatter for stdout logging; does not include name of log formatter = logging.Formatter('%(asctime)s:%(levelname)s - %(message)s', datefmt='%Y/%m/%d %H:%M:%S') formatter.converter = time.gmtime file_handler.setFormatter(formatter) file_handler.setLevel(logging.DEBUG) return file_handler
def init_logger(logger, lv, log_path=None, stdout_enabled=True): logger.setLevel(lv) formatter = logging.Formatter( '%(asctime)s - [%(name)s] - [%(levelname)s]: %(message)s') if log_path is not None: fh = logging_handlers.WatchedFileHandler(log_path) fh.setLevel(lv) fh.setFormatter(formatter) logger.addHandler(fh) if stdout_enabled: sh = logging.StreamHandler(sys.stdout) sh.setLevel(lv) sh.setFormatter(formatter) logger.addHandler(sh) return logger
def logger(logFile=None, setLevel="INFO", identity=""): """ Create a logger, by specifying a unique (or same) logFile, set the level of logging, and optional identity for what is sending logging message, to identify multiple workers """ logger = logging.getLogger('elife-bot') if (logFile): hdlr = handlers.WatchedFileHandler(os.getcwd() + os.sep + logFile) else: # No log file provided, use the stream handler hdlr = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s %(levelname)s ' + identity + ' %(message)s', '%Y-%m-%dT%H:%M:%SZ') hdlr.setFormatter(formatter) logger.addHandler(hdlr) logger.addHandler(NewRelicHandler()) logger.setLevel(eval("logging." + setLevel)) return logger
def InitLogger(): logger = logging.getLogger() # Use default logger (i.e. logging.info/logging.debug) logger.setLevel(logging.DEBUG) # create console handler and set level to INFO ch = logging.StreamHandler() ch.setLevel(logging.INFO) # Create log file handler and set level to DEBUG log_file_name = 'log.log' file_handler = handlers.WatchedFileHandler(log_file_name, 'w') formatter = logging.Formatter("%(asctime)s %(levelname)s:%(name)s:%(message)s") # Format for the file log lines file_handler.setFormatter(formatter) file_handler.setLevel(logging.DEBUG) # Add the handlers to the logger logger.addHandler(ch) logger.addHandler(file_handler) return logger
def __init__( self, debug: bool, log_file: str, plugin_folder: str, level=None, logger_name: str = None, logger_enabled: bool = True, prefix: str = "VKBottle", prefix_color: str = "blue", ): self.__debug: bool = debug self.__coloring = Coloring(prefix, prefix_color) self.__level = level or logging.DEBUG self.__log_file = log_file self.__plugin_folder = plugin_folder self.__logger_name = logger_name self.__logger_enabled = logger_enabled self.logger = logging.getLogger(logger_name or "VKBottle") self.log_path = "{path}/{log_file}".format( path=plugin_folder, log_file=log_file if log_file and re.match(LOG_FILE_PATTERN, log_file) else DEFAULT_LOG_NAME, ) if logger_enabled: open(self.log_path, "w+").close() self.logger.setLevel(self.__level) formatter = logging.Formatter(LOG_FORMAT) handler = handlers.WatchedFileHandler(self.log_path) handler.setLevel(self.__level) handler.setFormatter(formatter) self.logger.addHandler(handler) self.debug("My logging file path is {}".format(self.log_path))
action='store_true') parser.add_argument( "--hours", type=int, help= "Number of hours to return data for from the current time. Currently only works with the sources_file option" ) parser.add_argument("--debug", help="Print some basic debugging output", action='store_true') args = parser.parse_args() script_name, junk = argv[0].split('.') handler = handlers.WatchedFileHandler( environ.get("LOGFILE", "{}.log").format(script_name)) formatter = Formatter(BASIC_FORMAT) handler.setFormatter(formatter) root = getLogger() root.addHandler(handler) root.setLevel(INFO) ch = StreamHandler() ch.setLevel(ERROR) root.addHandler(handler) root.addHandler(ch) results = None try: if args.debug: sp = ScoutPrime(args.sp_config, debug=True)
from oslo_log import log from sahara.i18n import _LI CONF = cfg.CONF LOG = log.getLogger(__name__) def _get_log_file_path(logfile): logdir = CONF.log_dir if not logdir: logdir = os.path.curdir return os.path.join(logdir, logfile) fh = handlers.WatchedFileHandler(_get_log_file_path('timing.log')) fh.setLevel(logging.DEBUG) LOG.logger.addHandler(fh) def timed(f): @functools.wraps(f) def wrapper(*args, **kwds): indent_level = len(inspect.stack()) - 1 start = time.time() try: result = f(*args, **kwds) except Exception: LOG.info( _LI('Exception raised by invocation of %(name)s: %(info)s'), {
print("log_folder : %s" % log_folder) # Here we define our formatter if not (os.path.isdir(log_folder)): os.mkdir(log_folder) if not os.path.isfile(log_file_name): fp = open(log_file_name, "w") fp.write("Log file. \n") fp.close() #print("Logger define started !!!!!!!!!!!!!! ") formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') logHandler = handlers.WatchedFileHandler(log_file_name) logHandler.setLevel(LOGGING_LEVEL) # Here we set our logHandler's formatter logHandler.setFormatter(formatter) #logger.addHandler(logHandler) logger_lib = logging.getLogger('Test_Lib') logger_lib.setLevel(LOGGING_LEVEL) logger_lib.addHandler(logHandler) #print("Logger is defined !!!!!!!!!!!!!! ") dic = {} dic_val = {}
def create_logger( name: str, unit: str = None, experiment: str = None, source: str = "app", pub_client: Optional[Client] = None, to_mqtt: bool = True, ) -> Logger: """ Parameters ----------- name: string the name of the logger pub_client: paho.mqtt.Client use an existing Client, else one is created source: "app" for the core Pioreactor codebase, else the name of the plugin. to_mqtt: bool connect and log to MQTT """ logger = logging.getLogger(name) if len(logger.handlers) > 0: return logger logger.setLevel(logging.DEBUG) if unit is None: unit = get_unit_name() if experiment is None: # this fails if we aren't able to connect to leader, hence the to_mqtt check if to_mqtt: experiment = get_latest_experiment_name() else: experiment = UNIVERSAL_EXPERIMENT if (pub_client is None) and to_mqtt: import uuid pub_client = create_client(client_id=f"{unit}-logging-{uuid.uuid1()}") # file handler file_handler = handlers.WatchedFileHandler(config["logging"]["log_file"]) file_handler.setLevel(logging.DEBUG) file_handler.setFormatter( logging.Formatter( "%(asctime)s [%(name)s] %(levelname)-2s %(message)s", datefmt="%Y-%m-%dT%H:%M:%S%z", ) ) # define a Handler which writes to the sys.stderr console_handler = logging.StreamHandler() console_handler.setLevel(logging.DEBUG) console_handler.setFormatter( colorlog.ColoredFormatter( "%(log_color)s%(asctime)s %(levelname)-8s [%(name)s] %(message)s", datefmt="%Y-%m-%dT%H:%M:%S%z", log_colors={ "DEBUG": "cyan", "INFO": "green", "WARNING": "yellow", "ERROR": "red", "CRITICAL": "red,bg_white", }, ) ) # add local log handlers logger.addHandler(file_handler) logger.addHandler(console_handler) if to_mqtt: exp = experiment if am_I_active_worker() else UNIVERSAL_EXPERIMENT # create MQTT handlers for logs table topic = f"pioreactor/{unit}/{exp}/logs/{source}" mqtt_to_db_handler = MQTTHandler(topic, pub_client) mqtt_to_db_handler.setLevel(logging.DEBUG) mqtt_to_db_handler.setFormatter(CustomisedJSONFormatter()) # add MQTT/remote log handlers logger.addHandler(mqtt_to_db_handler) return logger