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
