def postOptions(self):
from baca.application import app
if self.opts['config'] == "~/.ilog":
self.opt_config(self.opts['config'])
if not isfile(join(app.config.dir, app.config.file)):
app.config_initial_populate()
app.config_save()
app.config_load()
# Setup logging
from baca.utils.logger import Logging
if logging.getLoggerClass() is not Logging:
logging.config.fileConfig(
usefull_path(str(app.config.logging_config_file))
)
logging.setLoggerClass(Logging)
twisted_logging = PythonLoggingObserver('twisted')
twisted_logging.start()
# self._setup_database()
app.setup_log()
if not self.subCommand:
self.opt_help()
def bootstrap():
logging.setLoggerClass(CustomLogger)
logging.addLevelName(CONSOLE, 'CONSOLE')
root_logger = logging.getLogger('engineer')
root_logger.setLevel(logging.DEBUG)
root_logger.addHandler(get_console_handler(logging.WARNING))
def _patch_logger_class():
"""Make sure process name is recorded when loggers are used."""
try:
from multiprocessing.process import current_process
except ImportError:
current_process = None # noqa
logging._acquireLock()
try:
OldLoggerClass = logging.getLoggerClass()
if not getattr(OldLoggerClass, '_process_aware', False):
class ProcessAwareLogger(OldLoggerClass):
_process_aware = True
def makeRecord(self, *args, **kwds):
record = OldLoggerClass.makeRecord(self, *args, **kwds)
if current_process:
record.processName = current_process()._name
else:
record.processName = ""
return record
logging.setLoggerClass(ProcessAwareLogger)
finally:
logging._releaseLock()
def tearDown(self):
self.eng = None
TestInstallEngine._instance = None
InstallLogger.DEFAULTFILEHANDLER = None
logging.Logger.manager.loggerDict = {}
logging.setLoggerClass(logging.Logger)
self.test_logger.name = None
self.test_logger.destination = None
self.test_logger.level = None
self.test_logger.parent = None
self.test_logger.propagate = 1
self.test_logger.handlers = []
self.test_logger.disabled = 0
self.callfunction = None
self.list = []
logging._defaultFormatter = logging.Formatter()
try:
os.remove(solaris_install.logger.DEFAULTLOG)
except OSError:
# File doesn't exist
pass
try:
os.remove("simplelog")
except OSError:
# File doesn't exist
pass
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 init(name, level, colors=True):
global logger, critical, fatal, warn, warning, info, skip, debug, error
logging.setLoggerClass(SkipHandler)
logger = logging.getLogger(name)
handler = TerminalHandler()
if colors:
handler.setFormatter(ANSIFormatter('%(message)s'))
logger.addHandler(handler)
logger.setLevel(level)
error = logger.error
fatal = logger.fatal
critical = logger.critical
warn = logger.warn
warning = logger.warning
info = logger.info
skip = logger.skip
debug = logger.debug
warnings.resetwarnings()
warnings.showwarning = showwarning if level == DEBUG else lambda *x: None
def ensure_process_aware_logger(force=False):
"""Make sure process name is recorded when loggers are used."""
global _process_aware
if force or not _process_aware:
logging._acquireLock()
try:
_process_aware = True
Logger = logging.getLoggerClass()
if getattr(Logger, '_process_aware', False): # pragma: no cover
return
class ProcessAwareLogger(Logger):
_signal_safe = True
_process_aware = True
def makeRecord(self, *args, **kwds):
record = Logger.makeRecord(self, *args, **kwds)
record.processName = current_process()._name
return record
def log(self, *args, **kwargs):
if _in_sighandler:
return
return Logger.log(self, *args, **kwargs)
logging.setLoggerClass(ProcessAwareLogger)
finally:
logging._releaseLock()
def _initialize():
"""Initializes loggers and handlers."""
global _absl_logger, _absl_handler
if _absl_logger:
return
original_logger_class = logging.getLoggerClass()
logging.setLoggerClass(ABSLLogger)
_absl_logger = logging.getLogger('absl')
logging.setLoggerClass(original_logger_class)
python_logging_formatter = PythonFormatter()
_absl_handler = ABSLHandler(python_logging_formatter)
# The absl handler logs to stderr by default. To prevent double logging to
# stderr, the following code tries its best to remove other handlers that emit
# to stderr. Those handlers are most commonly added when logging.info/debug is
# called before importing this module.
handlers = [
h for h in logging.root.handlers
if isinstance(h, logging.StreamHandler) and h.stream == sys.stderr]
for h in handlers:
logging.root.removeHandler(h)
# The absl handler will always be attached to root, not the absl logger.
if not logging.root.handlers:
# Attach the absl handler at import time when there are no other handlers.
# Otherwise it means users have explicitly configured logging, and the absl
# handler will only be attached later in app.run(). For App Engine apps,
# the absl handler is not used.
logging.root.addHandler(_absl_handler)
def config_logger():
"""Configures netlogger"""
nllog.PROJECT_NAMESPACE = NETLOGGER_NAMESPACE
#logging.setLoggerClass(nllog.PrettyBPLogger)
logging.setLoggerClass(nllog.BPLogger)
log = logging.getLogger(nllog.PROJECT_NAMESPACE)
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter("%(message)s"))
log.addHandler(handler)
if GN_ADDR:
# setup socket to global node, GN
socketHandler = logging.handlers.SocketHandler(GN_ADDR,
logging.handlers.DEFAULT_TCP_LOGGING_PORT)
log.addHandler(socketHandler)
# set level
if TRACE:
log_level = (logging.WARN, logging.INFO, logging.DEBUG,
nllog.TRACE)[3]
elif DEBUG:
log_level = (logging.WARN, logging.INFO, logging.DEBUG,
nllog.TRACE)[2]
elif CONSOLE:
log_level = (logging.WARN, logging.INFO, logging.DEBUG,
25)[3]
else:
log_level = (logging.WARN, logging.INFO, logging.DEBUG,
nllog.TRACE)[1]
log.setLevel(log_level)
def getLogger(name):
"""
Return the correct logger class.
"""
logging.setLoggerClass(Logger)
log = logging.getLogger(name=name)
return log
def setupLogging(config_options=[]):
"""Set up overall logging for the program given the config options.
Arguments:
config_options (List of XML objects):
Empty if the user did not elect to use logging.
Otherwise could contain either or both of the
<Logging>...</Logging> and <Metadata>...</Metadata>
elements.
"""
# There must be a metadata logger regardless of its level,
# so that its internal functions may be called from any other
# module without error.
OldClass = logging.getLoggerClass()
logging.setLoggerClass(MetaDataLogger)
logging.getLogger('metadata')
logging.setLoggerClass(OldClass)
# this will be reset below if the loggers are configured.
logging.getLogger().setLevel(level=logging.CRITICAL)
logging.getLogger("metadata").setLevel(level=logging.CRITICAL)
if not config_options:
logging.disable(level=logging.CRITICAL)
else:
for child in config_options:
if child.tag == "Logging":
_setupLogging(child)
elif child.tag == "Metadata":
_setupLogging(child, "metadata")
else:
logging.getLogger('').critical("Logging configuration attempted for an object that is not a logger: %s" % str(child.tag))
sys.exit()
def TrLogger(logger_name, options):
"""
Factory for the actual logging-derived logger
"""
try:
trEmbraceAndExtendErrno()
old = logging.getLoggerClass() # save old setting
logging.setLoggerClass(TrLoggerClass)
#
# Provide a logging configuration backdoor for sites that want
# to do something sophisticated.
#
if options.logconfig:
if os.path.exists(options.logconfig):
logging.config.fileConfig(options.logconfig)
else:
options.logconfig = None
logger = logging.getLogger(logger_name)
logging.setLoggerClass(old) # restore
if not options.logconfig:
# In the typical case that there is no logging config file,
# apply our usual handlers.
logger.trBasicConfig(options)
except Exception:
logger = TrDesperationLogger(logger_name)
logger.exception("logging configuration failed")
return logger
def __init__(self, args):
self.args = args
# -- Hijack the Yum logging ------------------------------------------
logging.setLoggerClass(NBYumLogger)
logging.addLevelName(PROGRESS_LEVEL, "progress")
logging.addLevelName(RECAP_LEVEL, "recap")
self.base = NBYumBase()
# -- Deal with the preconfig stuff -----------------------------------
if not args.debug:
self.base.preconf.debuglevel = 0
else:
self.base.preconf.debuglevel = 6
if args.config:
self.base.preconf.fn = args.config
self.base.prerepoconf.progressbar = NBYumTextMeter()
# This sets up a bunch of stuff
self.base.conf
if self.args.func == "last_updated":
args.force_cache = True
if args.force_cache:
if self.args.func == "rebuild_cache":
self.base.logger.warning("Ignoring --force-cache argument, as"
" we are rebuilding the cache")
else:
self.base.conf.cache = 1
def configure_logging(stream=sys.stdout, formatter=JsonLogFormatter, format_=log_format, level=logging.DEBUG):
logging.setLoggerClass(BalrogLogger)
handler = logging.StreamHandler(stream)
formatter = formatter(fmt=format_)
handler.setFormatter(formatter)
logging.root.addHandler(handler)
logging.root.setLevel(level)
def getLogger(name):
og_class = logging.getLoggerClass()
try:
logging.setLoggerClass(Logger)
return logging.getLogger(name)
finally:
logging.setLoggerClass(og_class)
def patch_logging():
"""
This hack is used to log the context inside standard and thirdparty libraries which
uses usually python logging. The context inherits from caller using contextlog.
"""
if logging.getLoggerClass() != _SlaveContextLogger:
logging.setLoggerClass(_SlaveContextLogger)
def _enable_dev_mode(self):
logging.setLoggerClass(JSLogger)
self._logger.setLevel(logging.DEBUG)
self._logger.propagate = False
logging.lastResort = None
for h in self.handlers.values():
self._logger.addHandler(h)
def __init__(self, download_to_disk=True):
"""
Initialises the DataLoader class
Parameters
----------
download_to_disk : boolean, default True
Whether to download all source data to local
"""
self.load_web_source = False # for debug; always download website
self.source_url = "http://web.mta.info/developers/turnstile.html"
self.data_url_base = "http://web.mta.info/developers/"
self.data_folder = "data/"
logging.setLoggerClass(GoodLogger)
self.logger = logging.getLogger("2S_Turnstile")
self.download_to_disk = download_to_disk
self.data = None # main data
self.available_dates = [] # List of dates available for request
# The start/end datetime of the data request
self.request_start_dt = None
self.request_end_dt = None
# The start/end datetime of data pull from source
self.data_start_dt = None
self.data_end_dt = None
self.N = 7 # For each request [Time A] to [Time B], the data for [Time A - N days] to [Time B - N days] will be prepared, so that there are sufficient sample observations to imputation, default N = 40
# Parse links
self.data_urls = self.parse_source_url()
# Download the hash table for stations
self.station_table = self.get_station_table()
def setup_system():
logger=logging.getLogger()#logging.getLogger('quicknxs')
logger.setLevel(min(FILE_LEVEL, CONSOLE_LEVEL, GUI_LEVEL))
if not sys.platform.startswith('win'):
# no console logger for windows (py2exe)
console=logging.StreamHandler(sys.__stdout__)
formatter=logging.Formatter('%(levelname) 7s: %(message)s')
console.setFormatter(formatter)
console.setLevel(CONSOLE_LEVEL)
logger.addHandler(console)
logfile=logging.FileHandler(paths.LOG_FILE, 'w')
formatter=logging.Formatter('[%(levelname)s] - %(asctime)s - %(filename)s:%(lineno)i:%(funcName)s %(message)s', '')
logfile.setFormatter(formatter)
logfile.setLevel(FILE_LEVEL)
logger.addHandler(logfile)
logging.info('*** QuickNXS %s Logging started ***'%str_version)
# define numpy warning behavior
global nplogger
old_class=logging.getLoggerClass()
logging.setLoggerClass(NumpyLogger)
nplogger=logging.getLogger('numpy')
nplogger.setLevel(logging.DEBUG)
null_handler=logging.StreamHandler(StringIO())
null_handler.setLevel(logging.CRITICAL)
nplogger.addHandler(null_handler)
logging.setLoggerClass(old_class)
seterr(divide='call', over='call', under='ignore', invalid='call')
seterrcall(numpy_logger)
# write information on program exit
sys.excepthook=excepthook_overwrite
atexit.register(goodby)
def getLogger(name, handler=None):
"""
Returns the logger with the specified name.
If the logger doesn't exist, it is created.
If handler is specified, adds it to the logger. Otherwise a default handler
that logs to standard output will be used.
:param name: The name of the logger to retrieve
:param handler: A handler to add to the logger. If the logger already exists,
and a handler is specified, an exception will be raised. To
add a handler to an existing logger, call that logger's
addHandler method.
"""
setLoggerClass(MozLogger)
if name in Logger.manager.loggerDict:
if handler:
raise ValueError('The handler parameter requires ' + \
'that a logger by this name does ' + \
'not already exist')
return Logger.manager.loggerDict[name]
logger = getSysLogger(name)
logger.setLevel(_default_level)
if handler is None:
handler = StreamHandler()
handler.setFormatter(MozFormatter())
logger.addHandler(handler)
logger.propagate = False
return logger
def getLogger(name, logfile=None):
"""
Returns the logger with the specified name.
If the logger doesn't exist, it is created.
name - The name of the logger to retrieve
[filePath] - If specified, the logger will log to the specified filePath
Otherwise, the logger logs to stdout
This parameter only has an effect if the logger doesn't exist
"""
setLoggerClass(_MozLogger)
if name in Logger.manager.loggerDict:
return getSysLogger(name)
logger = getSysLogger(name)
logger.setLevel(_default_level)
if logfile:
handler = FileHandler(logfile)
else:
handler = StreamHandler()
handler.setFormatter(_MozFormatter())
logger.addHandler(handler)
return logger
def _init_logger(self):
"""Init logger to be able to intercept message from each command."""
class HandlerWrapper(logging.Handler):
def emit(self, record):
# FIXME Configure logging on executor threads
w = self.bgutil_workers.get(record.threadName, None)
if not w:
return
w["output"].append(
"{:<7} {:<25} :: {}".format(
record.levelname,
record.filename + ":" + str(record.lineno),
record.getMessage(),
)
)
class LoggerWrapper(logging.Logger):
def __init__(self, name):
super(LoggerWrapper, self).__init__(name)
self.addHandler(HandlerWrapper())
self.propagate = True
logging.setLoggerClass(LoggerWrapper)
logging.getLogger().propagate = True
logging.getLogger().addHandler(HandlerWrapper())
def setup_logging(increase_padding=False):
"""
Setup overall logging engine and add 2 more levels of logging lower than
DEBUG, TRACE and GARBAGE.
"""
import logging
if increase_padding and logging.getLoggerClass() is not Logging:
logging.setLoggerClass(Logging)
if not hasattr(LoggingLoggerClass, 'trace'):
def trace(cls, msg, *args, **kwargs):
return cls.log(5, msg, *args, **kwargs)
logging.addLevelName(5, 'TRACE')
LoggingLoggerClass.trace = new.instancemethod(
trace, None, LoggingLoggerClass
)
if not hasattr(LoggingLoggerClass, 'garbage'):
def garbage(cls, msg, *args, **kwargs):
return cls.log(1, msg, *args, **kwargs)
logging.addLevelName(1, 'GARBAGE')
LoggingLoggerClass.garbage = new.instancemethod(
garbage, None, LoggingLoggerClass
)
# Set the root logger at the lowest level possible
logging.getLogger().setLevel(1)
def setup_logging():
""" Method to setup the logging options. """
global debug, info, warning, critical, error, root_logger, set_level,\
setLevel, filename, level
level = log_dict.get(config.get_parameter('brisa', 'logging'),
logging.DEBUG)
filename = config.get_parameter('brisa', 'logging_output')
if filename == 'file':
filename = os.path.join(config.brisa_home, 'brisa.log')
logging.basicConfig(level=level, filename=filename,
format='%(created)f %(levelname)s %(module)s:'\
'%(lineno)d:%(funcName)s() %(message)s')
root_logger = logging.getLogger('RootLogger')
else:
logging.setLoggerClass(ColoredLogger)
root_logger = getLogger('RootLogger')
root_logger.setLevel(level)
def set_level(level):
""" Real implementation of the set level function. """
root_logger.setLevel(log_dict.get(level))
def setLevel(level):
""" Method to set the log level. """
set_level(level)
def robottelo_logger(request, worker_id):
"""Set up a separate logger for each pytest-xdist worker
if worker_id != 'master' then xdist is running in multi-threading so
a logfile named 'robottelo_gw{worker_id}.log' will be created.
"""
logger = logging.getLogger('robottelo')
if (hasattr(request.session.config, '_reportportal_configured') and
request.session.config._reportportal_configured):
logging.setLoggerClass(RPLogger)
if '{0}'.format(worker_id) not in [h.get_name() for h in logger.handlers]:
if worker_id != 'master':
formatter = logging.Formatter(
fmt='%(asctime)s - {0} - %(name)s - %(levelname)s -'
' %(message)s'.format(worker_id),
datefmt='%Y-%m-%d %H:%M:%S'
)
handler = logging.FileHandler(
'robottelo_{0}.log'.format(worker_id)
)
handler.set_name('{0}'.format(worker_id))
handler.setFormatter(formatter)
logger.addHandler(handler)
# Nailgun HTTP logs should also be included in gw* logs
logging.getLogger('nailgun').addHandler(handler)
if (hasattr(request.session.config, '_reportportal_configured') and
request.session.config._reportportal_configured):
rp_handler = RPLogHandler(request.node.config.py_test_service)
rp_handler.set_name('{0}'.format(worker_id))
rp_handler.setFormatter(formatter)
logger.addHandler(rp_handler)
logging.getLogger('nailgun').addHandler(rp_handler)
return logger
def init_temp_log_service(self, msg_level, extra_log_id):
""" Initialize the temporary logging service to record logs until know where to log to
This is done by using a Memory handler temporarily
"""
# Create and register the logger
logging.setLoggerClass(TealLogger)
logger = logging.getLogger('tealLogger')
hdlr = logging.handlers.MemoryHandler(100, logging.NOTSET, target=None)
# Set the logging format for this logger
use_eli = extra_log_id
if len(use_eli) != 0:
use_eli = extra_log_id[:4]
use_eli = use_eli.strip()
use_eli = use_eli + ':'
log_format = "%(asctime)-15s [%(process)d:%(thread)d] {0}%(module)s - %(levelname)s: %(message)s".format(use_eli)
formatter = logging.Formatter(log_format)
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
# Define the string levels and set them in the logger
levels = {'debug': logging.DEBUG,
'info': logging.INFO,
'warning': logging.WARNING,
'error': logging.ERROR,
'critical': logging.CRITICAL}
# Set the lowest level of message to log
level = levels.get(msg_level, logging.NOTSET)
logger.setLevel(level)
registry.register_service(SERVICE_LOGGER, logger)
registry.register_service(SERVICE_MSG_LEVEL, msg_level)
def _check_logger_class():
"""
Make sure process name is recorded when loggers are used
"""
# XXX This function is unnecessary once logging is patched
import logging
if hasattr(logging, "multiprocessing"):
return
logging._acquireLock()
try:
OldLoggerClass = logging.getLoggerClass()
if not getattr(OldLoggerClass, "_process_aware", False):
class ProcessAwareLogger(OldLoggerClass):
_process_aware = True
def makeRecord(self, *args, **kwds):
record = OldLoggerClass.makeRecord(self, *args, **kwds)
record.processName = current_process()._name
return record
logging.setLoggerClass(ProcessAwareLogger)
finally:
logging._releaseLock()
def getLogger(name, logfile=None):
"""
Returns the logger with the specified name.
If the logger doesn't exist, it is created.
:param name: The name of the logger to retrieve
:param logfile: If specified, the logger will log to the specified file.
Otherwise, the logger logs to stdout.
This parameter only has an effect if the logger doesn't already exist.
"""
setLoggerClass(MozLogger)
if name in Logger.manager.loggerDict:
return getSysLogger(name)
logger = getSysLogger(name)
logger.setLevel(_default_level)
if logfile:
handler = FileHandler(logfile)
else:
handler = StreamHandler()
handler.setFormatter(_MozFormatter())
logger.addHandler(handler)
logger.propagate = False
return logger
def createLogger(name, console=True):
# Start Logging Module
logging.setLoggerClass(ColoredLogger)
mylogger = logging.getLogger(name)
mylogger.to_console = console
mylogger.setLevel(LOGLEVEL)
return mylogger
def setup(self):
"""Configure the :class:`LoggingMixin`.
This method adds the :option:`-l`, :option:`q`,
:option:`-s` and :option:`-v` parameters to the
application and instantiates the :attr:`log` attribute.
"""
# Add logging-related options.
self.add_param("-l", "--logfile", default=self.logfile,
help="log to file (default: log to stdout)")
self.add_param("-q", "--quiet", default=0, help="decrease the verbosity",
action="count")
self.add_param("-s", "--silent", default=False, help="only log warnings",
action="store_true")
self.add_param("-v", "--verbose", default=0, help="raise the verbosity",
action="count")
# Create logger.
logging.setLoggerClass(CommandLineLogger)
self.log = logging.getLogger(self.name)
self.formatter = Formatter(fmt=self.message_format, datefmt=self.date_format)
self.log.level = self.log.default_level
# If requested, make our logger the root.
if self.root:
logging.root = self.log
logging.Logger.root = self.log
logging.Logger.manager = logging.Manager(self.log)
(
'en',
'English',
),
(
'th',
'Thai',
),
)
LANGUAGES = CMS_LANGUAGES
#logger
logging.getLogger('django.db.backends').setLevel(logging.ERROR)
logging.getLogger('PYREADLINE').setLevel(logging.ERROR)
logging.getLogger('south').setLevel(logging.ERROR)
logging.setLoggerClass(
LoggerClass(
file_suffix='.log',
default_level=logging.INFO,
files_path=path.abspath(path.join(PROJECT_ROOT, 'logs')),
))
# Use this for settings that you need in all environments but that shouldn't be
# kept in public version control, like Twitter API keys, etc.
#
# This does not catch an ImportError because it *should* be a fatal error in
# production if it's missing (database credentials, etc.). It will be put in
# place by Chef in production.
from secrets import *
def _setup_logging(color: bool = bool(ColoredFormatter)):
logging.getLogger("urllib3.connectionpool").setLevel(logging.ERROR)
logging.setLoggerClass(LoggerWithSuccess)
# Silence any noisy loggers here.
logging.getLogger("watchdog.observers").setLevel(logging.INFO)
# -*- coding: utf-8 -*-
# Author: Ztj
import logging
import logging.config
import os
from configfile import ConfigFile
from registry import Registry
from libs.logger import JsonLogger
"""全局设置"""
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s - %(levelname)s - %(message)s')
"""全局变量"""
service_root_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
"""初始化配置"""
GlobalConfigFile = ConfigFile(os.path.join(service_root_path, 'configs'))
"""加载配置文件"""
app_options = Registry(GlobalConfigFile.load_app('app'))
"""配置日志"""
log_options = GlobalConfigFile.load_app('log')
if log_options is not None:
logging.setLoggerClass(JsonLogger)
logging.config.dictConfig(log_options)
json_logger = logging.getLogger('json')
CMDLINE_LOG_LEVELS = ['info', 'debug', 'debug_analyzer']
DEBUG_ANALYZER = logging.DEBUG_ANALYZER = 15
logging.addLevelName(DEBUG_ANALYZER, 'DEBUG_ANALYZER')
class CCLogger(logging.Logger):
def __init__(self, name, level=NOTSET):
super(CCLogger, self).__init__(name, level)
def debug_analyzer(self, msg, *args, **kwargs):
if self.isEnabledFor(logging.DEBUG_ANALYZER):
self._log(logging.DEBUG_ANALYZER, msg, args, **kwargs)
logging.setLoggerClass(CCLogger)
package_root = os.environ.get('CC_PACKAGE_ROOT', '')
DEFAULT_LOG_CFG_FILE = os.path.join(package_root, 'config', 'logger.conf')
# Default config which can be used if reading log config from a
# file fails.
DEFAULT_LOG_CONFIG = '''{
"version": 1,
"disable_existing_loggers": false,
"formatters": {
"brief": {
"format": "[%(asctime)s][%(levelname)s] - %(message)s",
"datefmt": "%Y-%m-%d %H:%M"
},
"precise": {
if EXEC_PARAMS.command_mode:
cmd_file_hndlr = logging.FileHandler(FILE_LOG_FILEPATH,
mode='a',
delay=True)
logformat = LOG_REC_FORMAT_FILE_C.format(EXEC_PARAMS.command_name)
formatter = logging.Formatter(logformat)
cmd_file_hndlr.setFormatter(formatter)
return cmd_file_hndlr
else:
return file_hndlr
# setting up public logger. this will be imported in with other modules -------
if not EXEC_PARAMS.doc_mode:
logging.setLoggerClass(LoggerWrapper)
loggers = {}
def get_logger(logger_name):
"""Register and return a logger with given name.
Caches all registered loggers and returns the same logger object on
second call with the same logger name.
Args:
logger_name (str): logger name
val (type): desc
Returns:
messagesLogFilename = os.path.join(_logDir, 'messages.log')
_handler = BetterFileHandler(messagesLogFilename)
except EnvironmentError, e:
raise SystemExit, \
'Error opening messages logfile (%s). ' \
'Generally, this is because you are running Supybot in a directory ' \
'you don\'t have permissions to add files in, or you\'re running ' \
'Supybot as a different user than you normal do. The original ' \
'error was: %s' % (messagesLogFilename, utils.gen.exnToString(e))
# These are public.
formatter = Formatter('NEVER SEEN; IF YOU SEE THIS, FILE A BUG!')
pluginFormatter = PluginFormatter('NEVER SEEN; IF YOU SEE THIS, FILE A BUG!')
# These are not.
logging.setLoggerClass(Logger)
_logger = logging.getLogger('supybot')
_stdoutHandler = StdoutStreamHandler(sys.stdout)
class ValidLogLevel(registry.String):
"""Invalid log level."""
handler = None
minimumLevel = -1
def set(self, s):
s = s.upper()
try:
level = logging._levelNames[s]
except KeyError:
try:
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#
###############################################################################
import signal
from common.logging_setup import VerboseLogger
from logging import setLoggerClass
# set custom logger class for VERBOSE log level
setLoggerClass(VerboseLogger)
import argparse
import sys
import multiprocessing
from __version import __version__
def parseArgs(argv=sys.argv[1:]):
'''
Parses command line arguments
Returns parsed argument names and values in form {name: value}
@return Returns parsed argument names and values [dict]
'''
import logging
try:
from customlog import CustomLog
logging.setLoggerClass(CustomLog)
except OSError:
print "Could not instantiate logger class!"
#! /usr/bin/env python3
"""Handles the logging."""
import logging
class MyFilter(logging.Filter):
def filter(self, record):
return record.name in ['detsbot', 'jstris', 'database', 'main_model']
class MyLogger(logging.Logger):
def __init__(self, name):
logging.Logger.__init__(self, name)
self.addFilter(MyFilter())
logging.setLoggerClass(MyLogger)
logging.basicConfig(level=logging.DEBUG)
def __init__(self, name, isStderr=False):
RunLogger.__init__(self, name)
if isStderr:
self.handlers = [logging.StreamHandler(sys.stderr)]
else:
self.handlers = [logging.StreamHandler(sys.stdout)]
def addHandler(self, *args, **kwargs):
"""ensure this STAYS a null logger"""
pass
# Setting the default logging class to be ours
logging.RunLogger = RunLogger
logging.setLoggerClass(RunLogger)
# ============ begin logging support ============
def createLogDir(logDir: str = None) -> None:
"""A helper method to create the log directory"""
# the usual case is the user does not pass in a log dir path, so we use the global one
if logDir is None:
logDir = LOG_DIR
# create the directory
if not os.path.exists(logDir):
try:
os.makedirs(logDir)
def monkey_patched_getLogger(*args, **kwargs):
orig_class = logging.getLoggerClass()
result = orig_getLogger(*args, **kwargs)
logging.setLoggerClass(orig_class)
return result
file_handler = FileHandler(
filename=f"logs/{self.room_name}/{chosen_level[1]}.log")
file_handler.setLevel(level)
file_handler.setFormatter(file_formatter)
# secondary log file that contains only messages.
if self.level == self.CHAT:
self.add_chat_handler()
stream_handler.addFilter(ChatFilter())
stream_handler.setFormatter(terminal_formatter)
else:
stream_handler.addFilter(DebugFilter())
stream_handler.setFormatter(terminal_formatter)
if self.chat_handler_enabled:
self.add_chat_handler()
self.addHandler(file_handler)
# log to the terminal.
self.addHandler(stream_handler)
return True
# level was not set
return False
setLoggerClass(QuantumLogger)
result = self.manager.getLogger(suffix)
self._children.add(result)
return result
def setLevel(self, level):
"""
Sets the level of the current logger and all of its children loggers.
"""
self.level = level
for child in self._children:
child.setLevel(level)
logging.setLoggerClass(FafLogger)
logging.basicConfig()
# Invalid name "log" for type constant
# pylint: disable-msg=C0103
log = logging.getLogger(name="faf")
# pylint: enable-msg=C0103
def import_dir(module, dirname, prefix=None):
"""
Imports python files from `dirname` into `module`.
Ignores files whose name starts with underscore.
"""
for filename in os.listdir(dirname):
logging.addLevelName(OUTPUT, "OUTPUT")
def success(self, msg: str, *args: Any, **kwargs: Any) -> None:
if self.isEnabledFor(SUCCESS):
self._log(SUCCESS, msg, args, **kwargs)
else: # pragma: no cover
pass
def output(self, msg: str, *args: Any, **kwargs: Any) -> None:
if self.isEnabledFor(OUTPUT):
self._log(OUTPUT, msg, args, **kwargs)
else: # pragma: no cover
pass
logging.setLoggerClass(LoggerWithSuccessAndOutput)
logger = cast(LoggerWithSuccessAndOutput, logging.getLogger("nox"))
def _get_formatter(color: bool, add_timestamp: bool) -> logging.Formatter:
if color is True:
return NoxColoredFormatter(
reset=True,
log_colors={
"DEBUG": "cyan",
"INFO": "blue",
"WARNING": "yellow",
"ERROR": "red",
"CRITICAL": "red,bg_white",
"SUCCESS": "green",
},
def __init__(self, logger):
"""
Object constructor.
:param logger: The logger object instance
"""
self.logger = logger
def write(self, msg):
"""
Write a message in the logger with severity 'ERROR'
:param msg: The message to write
"""
self.logger.error('STDERR %r' % msg)
logging.setLoggerClass(OutputHandler)
def getInstance(logfile='b3.log',
loglevel=21,
logsize=10485760,
log2console=False):
"""
Return a Logger instance.
:param logfile: The logfile name.
:param loglevel: The logging level.
:param logsize: The size of the log file (in bytes)
:param log2console: Whether or not to extend logging to the console.
"""
global __output
'handlers': ['console'],
'propagate': False,
},
}
}
class LoggerAutoInit(logging.getLoggerClass()):
def handle(self, record):
if len(logging.root.handlers) == 0:
if init_logger():
self.disabled = 0
return super(LoggerAutoInit, self).handle(record)
logging.setLoggerClass(LoggerAutoInit)
def gen_logger(name=None, options=None):
logger = logging.getLogger(name)
return logger
def init_logger(options=None):
global logging_conf
conf_fname = os.path.join('etc', 'embers', 'logging.conf')
if not logging_conf:
if os.path.exists(conf_fname):
logging_conf = yaml.load(open(conf_fname))
else:
logging_conf = default_conf
except Exception, e:
jobID = hst._options.jobID
completionReason = ClientJobsDAO.CMPL_REASON_ERROR
completionMsg = "ERROR: %s" % (e, )
raise
finally:
if jobID is not None:
cjDAO = ClientJobsDAO.get()
cjDAO.jobSetCompleted(jobID=jobID,
completionReason=completionReason,
completionMsg=completionMsg)
return jobID
#############################################################################
if __name__ == "__main__":
logging.setLoggerClass(ExtendedLogger)
buildID = Configuration.get('nupic.software.buildNumber', 'N/A')
logPrefix = '<BUILDID=%s, WORKER=HS, WRKID=N/A, JOBID=N/A> ' % buildID
ExtendedLogger.setLogPrefix(logPrefix)
try:
main(sys.argv)
except:
logging.exception(
"HypersearchWorker is exiting with unhandled exception; "
"argv=%r", sys.argv)
raise
logging.root.removeHandler(handler)
logging.root = NovaRootLogger("nova")
NovaLogger.root = logging.root
NovaLogger.manager.root = logging.root
for logger in NovaLogger.manager.loggerDict.itervalues():
logger.root = logging.root
if isinstance(logger, logging.Logger):
NovaLogger.manager._fixupParents(logger)
NovaLogger.manager.loggerDict["nova"] = logging.root
logging._releaseLock()
sys.excepthook = handle_exception
reset()
root = logging.root
logging.setLoggerClass(NovaLogger)
def audit(msg, *args, **kwargs):
"""Shortcut for logging to root log with sevrity 'AUDIT'."""
logging.root.log(AUDIT, msg, *args, **kwargs)
class WritableLogger(object):
"""A thin wrapper that responds to `write` and logs."""
def __init__(self, logger, level=logging.INFO):
self.logger = logger
self.level = level
def write(self, msg):
import requests
import requests.packages.urllib3.util.connection as urllib3_connection
from requests.packages.urllib3.util.connection import allowed_gai_family
from streamlink import __version__, plugins
from streamlink.compat import is_win32, lru_cache
from streamlink.exceptions import NoPluginError, PluginError
from streamlink.logger import Logger, StreamlinkLogger
from streamlink.options import Options
from streamlink.plugin import api
from streamlink.utils import update_scheme
from streamlink.utils.l10n import Localization
# Ensure that the Logger class returned is Streamslink's for using the API (for backwards compatibility)
logging.setLoggerClass(StreamlinkLogger)
log = logging.getLogger(__name__)
def print_small_exception(start_after):
type, value, traceback_ = sys.exc_info()
tb = traceback.extract_tb(traceback_)
index = 0
for i, trace in enumerate(tb):
if trace[2] == start_after:
index = i + 1
break
lines = traceback.format_list(tb[index:])
def setLoggerClass():
logging.setLoggerClass(hxtool_logger)
try:
self.checkPos(len(msg))
self.stream.write(msg)
except (UnicodeDecodeError, UnicodeEncodeError):
msg = msg.encode("UTF-8")
self.checkPos(len(msg))
self.stream.write(msg)
StreamHandler.lastwrite = StatusHandler
self.flush()
except:
self.handleError(record)
setLoggerClass(Logger)
root = Logger()
_loggers = {None: root}
def getLogger(name=None):
"""
Return a logger with the specified name, creating it if necessary.
If no name is specified, return the root logger.
"""
if name:
logger = Logger.manager.getLogger(name)
_loggers[name] = logger
print = functools.partial(print, flush=True)
class TrackableLogger(logging.Logger):
guid = str(uuid4())
def _log(self, msg, *args, **kwargs):
x = {'guid': self.guid}
if 'extra' in kwargs:
kwargs['extra'].update(x)
else:
kwargs['extra'] = x
super()._log(msg, *args, **kwargs)
logging.setLoggerClass(TrackableLogger)
logger = logging.getLogger('prebuild')
def headSha():
if shutil.which('git') is None:
logger.warning(
"Unable to find git executable, can't caclulate commit ID")
return '0xDEADBEEF'
repo_dir = os.path.dirname(os.path.abspath(__file__))
git = subprocess.Popen(
'git rev-parse --short HEAD',
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True,
cwd=repo_dir,
COLOR_FORMAT = formatter_message(FORMAT, use_color)
def __init__(self, name):
logging.Logger.__init__(self, name, logging.DEBUG)
color_formatter = ColoredFormatter(self.COLOR_FORMAT,
use_color=self.use_color)
console = logging.StreamHandler()
console.setFormatter(color_formatter)
# Use the custom handler instead of streaming one.
if hasattr(sys, '_kivy_logging_handler'):
self.addHandler(getattr(sys, '_kivy_logging_handler'))
else:
self.addHandler(console)
self.addHandler(HistoryHandler())
self.addHandler(FileHandler())
return
if 'nosetests' not in sys.argv:
logging.setLoggerClass(ColoredLogger)
#: Kivy default logger instance
Logger = logging.getLogger('Kivy')
Logger.logfile_activated = False
Logger.trace = partial(Logger.log, logging.TRACE)
#: Kivy history handler
LoggerHistory = HistoryHandler
def remove_all_handlers(self):
for handler in self.handlers:
self.removeHandler(handler)
@classmethod
def _setup_console_handler(cls):
if cls._console_handler is not None:
return
cls._console_handler = logging.StreamHandler()
cls._console_handler.setFormatter(cls._formatter)
@classmethod
def _setup_file_handler(cls, filename):
if cls._file_handler is not None:
return
log_directory = os.path.dirname(filename)
if not os.path.exists(log_directory):
os.makedirs(log_directory)
cls._file_handler = logging.handlers.RotatingFileHandler(
filename,
maxBytes=consts.LOG_FILE_MAXBYTES,
backupCount=consts.LOG_FILE_COUNT)
cls._file_handler.setFormatter(cls._formatter)
logging.setLoggerClass(TunedLogger)
atexit.register(logging.shutdown)
new_msg = msg if isinstance(msg, str) else msg()
except:
locale_info = 'Unknown'
try:
locale_info = 'Terminal encoding=%s, LANG=%s, LANGUAGE=%s' % (
sys.stdout.encoding, os.getenv('LANG'), os.getenv('LANGUAGE'))
logging.getLogger("variety").exception('Errors while logging. Locale info: %s' % locale_info)
# TODO gather and log more info here
except:
pass
new_msg = 'Errors while logging. Locale info: %s' % locale_info
return super().makeRecord(name, level, fn, lno, new_msg, *args, **kwargs)
logging.setLoggerClass(SafeLogger)
# # Change default encoding from ascii to UTF8 - works OK on Linux and prevents various UnicodeEncodeErrors/UnicodeDecodeErrors
# Still, generally considerd bad practice, may cause some deep hidden errors, as various Python stuff depends on it
# reload(sys)
# sys.setdefaultencoding('UTF8')
import signal
import dbus, dbus.service, dbus.glib
import logging
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gdk, GObject # pylint: disable=E0611
import os
import logging
from covid.core.logger import CovidLogger
logging.setLoggerClass(CovidLogger)
working_directory = 'data'
os.makedirs(working_directory, exist_ok=True)
DATABASE_USER = os.environ.get('PGUSER')
DATABASE_PASS = os.environ.get('PGPASSWORD')
DATABASE_HOST = os.environ.get('PGHOST')
DATABASE_PORT = os.environ.get('PGPORT', '5432')
DATABASE_NAME = os.environ.get('PGDATABASE')
DATABASE_CONNECTION_STRING = os.environ.get(
'TimeseriesDatabase__ConnectionString_ETL',
f'postgresql+pg8000://{DATABASE_USER}:{DATABASE_PASS}@{DATABASE_HOST}:{DATABASE_PORT}/{DATABASE_NAME}'
)
COUNTRY_CONNECTION_STRING = os.environ.get('CountryDatabase__ConnectionString')
COUNTRY_DATBASENAME = os.environ.get('CountryDatabase__DatabaseName', 'covid')
COUNTRY_COLLECTIONNAME = os.environ.get('CountryDatabase__Collection',
'countries')
FIELDS_CONNECTION_STRING = os.environ.get('FieldsDatabase__ConnectionString')
FIELDS_DATABASENAME = os.environ.get('FieldsDatabase__DatabaseName', 'covid')
FIELDS_COLLECTIONNAME = os.environ.get('FieldsDatabase__Collection', 'fields')
