def __init__(self):
"""
Constructor for Utilities class
"""
# Initiate Config Parser instance
self.parser = config_parser()
# Read config file inside
self.parser.read(CONFIG_FILE)
# Set Config object by config parser sections
CONFIG.update(self.parser._sections)
# Set global NOW value to be used in any where in application
self.now = strftime(self.config_get("locale", "datetime_format"))
# Set log destination
# Convert Json string into DotDict/OrderedDict object
log_destination = json.loads(unicode(self.config_get("logging", "destination")))
# Initiate Syslog handler with log destination regarding to the system architecture
syslog = SysLogHandler(address=log_destination[sys.platform])
# Set syslog format
syslog.setFormatter(
logging.Formatter(self.config_get("logging", "format"))
)
self.logger.addHandler(syslog)
def setLog(debug=False, use_syslog=False, use_file=None):
"""Setup logger"""
log = logging.getLogger(__package__)
if use_syslog:
try:
handler = SysLogHandler(address="/dev/log", facility='local0')
except IOError:
# fallback to UDP
handler = SysLogHandler(facility='local0')
handler.setFormatter(logging.Formatter('%(name)s[%(process)d]: %(levelname)s: %(message)s'))
else:
if use_file:
handler = logging.FileHandler(use_file)
else:
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter('%(asctime)s: %(name)s: %(levelname)s: %(message)s'))
log.addHandler(handler)
if debug:
log.setLevel(logging.DEBUG)
log.debug("Verbose log enabled")
else:
log.setLevel(logging.INFO)
return log
def init_logger(name=None,
address='/dev/log', facility=SysLogHandler.LOG_LOCAL5,
format=FORMAT_VERBOSE, level=logging.DEBUG):
"""Initialize the static logger instance
Will reinitialize static logger instance if it is already set.
:param name: the logger name passed on to logging.getLogger(..).
:type name: string
:param address: the address used when initializing the logger. This is
the same as address in SysLogHandler.__init__.
:type address: string
:param facility: the facility to use when logging. This is the same as
facility in SysLogHandler.__init__.
:type facility: integer
:param format: the format
:returns: logging.SysLogHandler object
"""
global _logger
logger = logging.getLogger(name)
logger.setLevel(level)
handler = SysLogHandler(address=address, facility=facility)
handler.setFormatter(logging.Formatter(format))
logger.addHandler(handler)
_logger = logger
return _logger
def main(configuration):
"""
Main iteration loop operating on incoming events
"""
handler = SysLogHandler('/dev/log', facility=SysLogHandler.LOG_DAEMON)
logformat = 'dockdetect[%(process)d]: %(message)s'
handler.setFormatter(logging.Formatter(logformat))
logger = logging.getLogger()
logger.addHandler(handler)
try:
device = configuration['device']
except KeyError:
device = finddevice(configuration['devicename'])
listener = eventlistener(device)
logger.warn("started")
for event in listener:
if event.type == int(configuration['eventtype']) and \
event.code == int(configuration['eventcode']):
logger.warn("event detected. Value {}".format(event.value))
executetargets(configuration['scriptdir'], event)
def add_syslog_handler(address):
"""Send events to a remote syslog."""
from logging.handlers import SysLogHandler
handler = SysLogHandler(address)
handler.setFormatter(logging.Formatter(Logger.SYSLOG_FORMAT))
Logger.logger.addHandler(handler)
def get_logger(name,
level=logging.INFO,
verbose=False,
debug=False,
syslog=False):
global syslogh
log = logging.getLogger(name)
if verbose or debug:
log.setLevel(level if not debug else logging.DEBUG)
channel = logging.StreamHandler(sys.stdout if debug else sys.stderr)
channel.setFormatter(logging.Formatter('%(asctime)s - '
'%(levelname)s - %(message)s'))
channel.setLevel(level if not debug else logging.DEBUG)
log.addHandler(channel)
if syslog:
log.setLevel(level)
syslogh = SysLogHandler(address='/dev/log')
syslogh.setFormatter(logging.Formatter('%(message)s'))
syslogh.setLevel(logging.INFO)
log.addHandler(syslogh)
return log
def get_logger(name):
"""
Set up loggers for this class. There are two loggers in use. StreamLogger prints information on the screen with
the default level ERROR (INFO if the verbose flag is set). FileLogger logs INFO entries to the report.log file.
report.log is never purged, but information from new runs is appended to the end of the file.
:return:
"""
def _exception_hook(excType, excValue, traceback, logger):
logger.error("", exc_info=(excType, excValue, traceback))
logger = logging.getLogger(name)
sys.excepthook = _exception_hook
formatter = logging.Formatter('%(asctime)s - %(message)s')
if is_console:
stream_logger = logging.StreamHandler(sys.stdout)
stream_logger.setLevel(logging_level)
logger.addHandler(stream_logger)
else:
syslog_logger = SysLogHandler()
syslog_logger.setLevel(logging_level)
syslog_logger.setFormatter(formatter)
logger.addHandler(syslog_logger)
if is_filelog:
file_logger = logging.FileHandler("log.txt") # os.path.join(get_config_dir(),
file_logger.setLevel(logging_level)
file_logger.setFormatter(formatter)
logger.addHandler(file_logger)
logger.level = logging_level
return logger
class Logger():
'''Creates a logger class.'''
def __init__(self,logfile='', scrlog=True, syslog='1', loglevel=logging.INFO):
self.logfile=logfile
self.scrlog=scrlog
self.syslog=syslog
self.loglevel=loglevel
self.format=logging.Formatter(fmt='%(asctime)s %(levelname)s: %(message)s',datefmt=None)
self.syslog_format=logging.Formatter(fmt='NSCAweb: %(message)s',datefmt=None)
self.log = logging.getLogger(__name__)
self.log.setLevel(self.loglevel)
if logfile != '':
self.file_handler = logging.FileHandler( logfile )
self.file_handler.setFormatter(self.format)
self.log.addHandler(self.file_handler)
if scrlog == True:
self.scr_handler = logging.StreamHandler()
self.scr_handler.setFormatter(self.format)
self.log.addHandler(self.scr_handler)
if syslog == '1':
from logging.handlers import SysLogHandler
if os.path.exists('/var/run/syslog'):
self.sys_handler = SysLogHandler(address='/var/run/syslog')
else:
self.sys_handler = SysLogHandler(address='/dev/log')
self.sys_handler.setFormatter(self.syslog_format)
self.log.addHandler(self.sys_handler)
def create_instance():
"""
Load from django settings the necessary information to start the log.
"""
logger = logging.getLogger(settings.INSTANCE_NAME)
logger.setLevel(logging._levelNames[settings.LOG_LEVEL])
if len(logger.handlers) == 0:
type_log_handler = settings.APP_CONFIG.get_config_value("logger", "log_handler", default_value="syslog")
if type_log_handler == "syslog":
log_address = settings.APP_CONFIG.get_config_value("logger", "address", default_value="/dev/log")
log_facility = settings.APP_CONFIG.get_config_value("logger", "facility", default_value="local0")
handler = SysLogHandler(address=log_address, facility=log_facility)
__instance_type = type_log_handler
else:
filename = settings.APP_CONFIG.get_config_value("logger", "filename", default_value=join(gettempdir(), settings.INSTANCE_NAME + ".log"))
mode = settings.APP_CONFIG.get_config_value("logger", "mode", default_value="a")
maxBytes = settings.APP_CONFIG.get_config_value("logger", "maxBytes", default_value=10485760)
backupCount = settings.APP_CONFIG.get_config_value("logger", "backupCount", default_value=100)
log_encoding = settings.APP_CONFIG.get_config_value("logger", "encoding", default_value=None)
delay = settings.APP_CONFIG.get_config_value("logger", "delay", default_value=0)
handler = RotatingFileHandler(filename, mode, maxBytes, backupCount, log_encoding, delay)
handler_file.append(handler.stream.fileno())
formatter = logging.Formatter(settings.LOG_FORMAT)
handler.setFormatter(formatter)
logger.addHandler(handler)
return logger
def start_logger(logger_name, log_level, container_id):
"""
Initialize logging of this process and set logger format
:param logger_name: The name to report with
:param log_level: The verbosity level. This should be selected
:param container_id: container id
"""
logging.raiseExceptions = False
log_level = log_level.upper()
# NOTE(takashi): currently logging.WARNING is defined as the same value
# as logging.WARN, so we can properly handle WARNING here
try:
level = getattr(logging, log_level)
except AttributeError:
level = logging.ERROR
logger = logging.getLogger("CONT #" + container_id + ": " + logger_name)
if log_level == 'OFF':
logging.disable(logging.CRITICAL)
else:
logger.setLevel(level)
log_handler = SysLogHandler('/dev/log')
str_format = '%(name)-12s: %(levelname)-8s %(funcName)s' + \
' %(lineno)s [%(process)d, %(threadName)s]' + \
' %(message)s'
formatter = logging.Formatter(str_format)
log_handler.setFormatter(formatter)
log_handler.setLevel(level)
logger.addHandler(log_handler)
return logger
def set_logger(self):
self.logger = logging.getLogger("meaner4")
hdlr = SysLogHandler(address='/dev/log', facility=SysLogHandler.LOG_DAEMON)
formatter = logging.Formatter('%(filename)s: meaner4: %(message)s')
hdlr.setFormatter(formatter)
self.logger.addHandler(hdlr)
self.logger.setLevel(logging.INFO)
def __setupSysLogOutput(self):
"""Sets up the handler for to the local syslog daemon."""
syslogHandler = SysLogHandler("/dev/log", SysLogHandler.LOG_DAEMON)
syslogHandler.setLevel(logging.INFO)
formatter = logging.Formatter('vNode: %(levelname)s %(funcName)s: %(message)s')
syslogHandler.setFormatter(formatter)
logging.getLogger('').addHandler(syslogHandler)
def addSysLogHandler (self, logger, host, port=SYSLOG_UDP_PORT,
minLevel=DEFAULT_LEVEL):
fmt = logging.Formatter("%(levelname)-8s %(message)s")
syslogHandler = SysLogHandler((host, port))
syslogHandler.setLevel(minLevel)
syslogHandler.setFormatter(fmt)
logger.addHandler(syslogHandler)
def setupLogging(agentConfig):
"""Configure logging to use syslog whenever possible.
Also controls debug_mode."""
if agentConfig['debug_mode']:
logFile = "/tmp/dd-agent.log"
logging.basicConfig(filename=logFile, filemode='w', level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logging.info("Logging to %s" % logFile)
else:
try:
from logging.handlers import SysLogHandler
rootLog = logging.getLogger()
rootLog.setLevel(logging.INFO)
sys_log_addr = "/dev/log"
# Special-case macs
if sys.platform == 'darwin':
sys_log_addr = "/var/run/syslog"
handler = SysLogHandler(address=sys_log_addr, facility=SysLogHandler.LOG_DAEMON)
formatter = logging.Formatter("dd-agent - %(name)s - %(levelname)s - %(message)s")
handler.setFormatter(formatter)
rootLog.addHandler(handler)
logging.info('Logging to syslog is set up')
except Exception,e:
sys.stderr.write("Error while setting up syslog logging (%s). No logging available" % str(e))
logging.disable(logging.ERROR)
def setup_logging():
global log
progname = basename(argv[0])
log = getLogger()
log.setLevel(DEBUG)
handlers = []
buildlog_handler = FileHandler(getenv("HOME") + "/build.log")
buildlog_handler.setFormatter(
Log8601Formatter("%(asctime)s " + progname + " %(levelname)s " +
"%(filename)s:%(lineno)s: %(message)s"))
handlers.append(buildlog_handler)
stderr_handler = StreamHandler(stderr)
stderr_handler.setFormatter(
Log8601Formatter("%(asctime)s %(name)s %(levelname)s " +
"%(filename)s:%(lineno)s: %(message)s"))
handlers.append(stderr_handler)
if exists("/dev/log"):
syslog_handler = SysLogHandler(
address="/dev/log", facility=LOG_LOCAL1)
syslog_handler.setFormatter(
Log8601Formatter(progname +
" %(asctime)s %(levelname)s: %(message)s"))
handlers.append(syslog_handler)
log.addHandler(MultiHandler(handlers))
getLogger("boto").setLevel(INFO)
getLogger("boto3").setLevel(INFO)
getLogger("botocore").setLevel(INFO)
return
def run(self):
""" Configures logging and runs the command. Overridden from the super-class.
"""
log_file_config = self.config_mod.log_file_config
if log_file_config:
logging.config.fileConfig(log_file_config)
else:
syslog_facility = self.config_mod.syslog_facility
log_level = self.config_mod.log_level
syslog_address = self.config_mod.syslog_address
log_level = logging.getLevelName(log_level)
handler = SysLogHandler(syslog_address, syslog_facility)
handler.setFormatter(LoggingFormatter())
logger = logging.getLogger('')
logger.addHandler(handler)
logger.setLevel(log_level)
object_name = 'https_proxy_class' if self.is_https else 'http_proxy_class'
proxy_class = self.app_ctx.get_object(object_name)
proxy_class(self.config_mod, self.app_ctx).serve_forever()
def main():
"""Prepares the ephemeral devices"""
logging.basicConfig(format="%(asctime)s - %(message)s", level=logging.INFO)
log.setLevel(logging.INFO)
syslog = SysLogHandler(address='/dev/log')
formatter = logging.Formatter(
'manage_instance_storage.py: %(name)s: %(levelname)s %(message)s')
syslog.setFormatter(formatter)
log.addHandler(syslog)
devices = get_ephemeral_devices()
if not devices:
# no ephemeral devices, nothing to do, quit
log.info('no ephemeral devices found')
return
lvm_devices = [d for d in devices if not needs_pvcreate(d)]
if lvm_devices:
maybe_fix_lvm_devices(lvm_devices)
devices = [d for d in devices if needs_pvcreate(d)]
if not devices:
log.info('Ephemeral devices already in LVM')
return
root_vg = query_vg_name()
root_lv = query_lv_path()
for dev in devices:
pvcreate(dev)
run_cmd(["vgextend", root_vg, dev])
run_cmd(["lvextend", "-l", "100%VG", root_lv])
run_cmd(["resize2fs", root_lv])
def __init__(self, name, debug=False):
"""
args:
name -- name passed to logging.Logger
kwargs:
debug -- bool to enable debug logging
"""
logging.Logger.__init__(self, name)
# Set the name, much like logging.getLogger(name) would
formatter = logging.Formatter('%(name)s [%(levelname)s] %(message)s')
# Emit to sys.stderr, ERROR and above
stream_handler = logging.StreamHandler(sys.stderr)
stream_handler.setLevel(logging.ERROR)
stream_handler.setFormatter(formatter)
self.addHandler(stream_handler)
# Emit to syslog, INFO and above, or DEBUG if debug
syslog_handler = SysLogHandler('/dev/log')
if debug:
syslog_handler.setLevel(logging.DEBUG)
else:
syslog_handler.setLevel(logging.INFO)
syslog_handler.setFormatter(formatter)
self.addHandler(syslog_handler)
def init(LOG_FILE=False, LOG_CONSOLE=False, LOG_SYSLOG=False):
# remove all root handlers
for handler in logging.root.handlers:
logging.root.removeHandler(handler)
# Log to file
if LOG_FILE:
logging.basicConfig(
filename=LOG_FILE,
level=logging.INFO,
format="%(asctime)-15s %(levelname)s:%(filename)s:%(lineno)d -- %(message)s",
)
# Log to console
if LOG_CONSOLE:
console = logging.StreamHandler()
console.setLevel(logging.DEBUG)
console.setFormatter(logging.Formatter("%(levelname)s:%(filename)s:%(lineno)d -- %(message)s"))
logging.getLogger().addHandler(console)
# Log to syslog
if LOG_SYSLOG:
from logging.handlers import SysLogHandler
syslog = SysLogHandler(address="/dev/log")
syslog.setFormatter(logging.Formatter("%(asctime)-15s %(levelname)s:%(filename)s:%(lineno)d -- %(message)s"))
logging.getLogger().addHandler(syslog)
def Logging(console, syslog):
import logging, os
# set up logging to file with logging format
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(name)s: %(levelname)-12s %(message)s',
datefmt='%d-%m-%Y %H:%M:%S',
filename=logf,
filemode='a'
)
procname = ' * ' + os.path.basename(sys.argv[0])
logger = logging.getLogger(procname)
if console:
console = logging.StreamHandler()
console.setLevel(logging.INFO)
formatter = logging.Formatter('%(name)s: [%(levelname)s] %(message)s')
console.setFormatter(formatter)
logger.addHandler(console)
if syslog:
from logging.handlers import SysLogHandler
syslog = SysLogHandler(address='/dev/log')
syslog.setLevel(logging.INFO)
formatter = logging.Formatter('%(name)s: %(levelname)-12s %(message)s')
syslog.setFormatter(formatter)
logger.addHandler(syslog)
return logger
def _createLogger(self):
self.watchedfiles = []
logger = logging.getLogger(self.name)
logger.setLevel(logging.NOTSET)
logger.propagate = False
# Create log formatter.
format_dict = {'version': '1',
'timestamp': '%(asctime)s',
'hostname': config['hostname'],
'appname': self.files['tag'],
'procid': '-',
'msgid': '-',
'structured_data': '-',
'msg': '%(message)s'
}
log_format = rfc5424_format.format(**format_dict)
formatter = logging.Formatter(log_format, date_format)
# Add log handler for each server.
for server in self.servers:
port = 'port' in server and server['port'] or 514
syslog = SysLogHandler((server["host"], port))
syslog.setFormatter(formatter)
logger.addHandler(syslog)
self.logger = logger
# Create WatchedFile objects from list of files.
for name in self.files['files']:
self.watchedfiles.append(WatchedFile(name))
def getLogger(name, level=logging.INFO, handlers=[]):
logger = logging.getLogger(name)
if len(handlers) != 0:
logger.setLevel(level)
if "console" in handlers:
strm = StreamHandler()
fmt = logging.Formatter('%(message)s')
strm.setLevel(level)
strm.setFormatter(fmt)
logger.addHandler(strm)
if "file" in handlers:
conf = handlers['file']
fl = WatchedFileHandler(conf['logfile'])
fl.setLevel(level)
fmt = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fl.setFormatter(fmt)
logger.addHandler(fl)
if "syslog" in handlers:
sysl = SysLogHandler(address='/dev/log', facility=SysLogHandler.LOG_SYSLOG)
sysl.setLevel(level)
formatter = logging.Formatter('%(name)s[' + str(os.getpid()) + '] %(levelname)-8s: %(message)s')
sysl.setFormatter(formatter)
logger.addHandler(sysl)
return logger
def main():
"""
Main application loop.
"""
env = os.environ
try:
host = env['SYSLOG_SERVER']
port = int(env['SYSLOG_PORT'])
socktype = socket.SOCK_DGRAM if env['SYSLOG_PROTO'] == 'udp' \
else socket.SOCK_STREAM
except KeyError:
sys.exit("SYSLOG_SERVER, SYSLOG_PORT and SYSLOG_PROTO are required.")
handler = SysLogHandler(
address=(host, port),
socktype=socktype,
)
handler.setFormatter(PalletFormatter())
for event_headers, event_data in supervisor_events(sys.stdin, sys.stdout):
event = logging.LogRecord(
name=event_headers['processname'],
level=logging.INFO,
pathname=None,
lineno=0,
msg=event_data,
args=(),
exc_info=None,
)
event.process = int(event_headers['pid'])
handler.handle(event)
def setup_log(self):
"""Setup server logging facility."""
self.log = paramiko.util.get_logger("paramiko")
if self.options.log_file:
paramiko.util.log_to_file(self.options.log_file)
if self.options.syslog is True:
try:
handler = SysLogHandler(address="/dev/log", facility=SysLogHandler.LOG_DAEMON)
except IOError:
# fall back to UDP
handler = SysLogHandler(facility=SysLogHandler.LOG_DAEMON)
finally:
handler.setFormatter(logging.Formatter("%(name)s[%(_threadid)s]: %(levelname)s: %(message)s"))
self.log.addHandler(handler)
if self.options.foreground:
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter("%(asctime)s: %(name)s[%(_threadid)s]: %(levelname)s: %(message)s"))
self.log.addHandler(handler)
if self.options.verbose:
# enable debug for the root logger (used by ObjectStorageFS)
logging.getLogger().setLevel(logging.DEBUG)
self.log.setLevel(logging.DEBUG)
self.log.debug(self.options)
else:
self.log.setLevel(logging.INFO)
def create_log(tofile=False, file_level=1, file_name=None, toconsole=False, console_level=1, tosyslog=False, syslog_level=1, syslog_address='/dev/log'):
levels = [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG]
logger = logging.getLogger(prg_name())
logger.setLevel(logging.DEBUG)
fmt_general = logging.Formatter('%(asctime)s - %(name)s - %(thread)d - %(threadName)s - %(levelname)s - %(message)s')
fmt_syslog = logging.Formatter('%(name)s: %(threadName)s; %(levelname)s; %(message)s')
# logs to a file
if tofile:
if os.path.isdir(os.path.dirname(file_name)):
fh = logging.FileHandler(file_name)
fh.setLevel(levels[file_level])
fh.setFormatter(fmt_general)
logger.addHandler(fh)
else:
sys.stderr.write("\nLog file directory '%s' not found.\nCan't continue. Quitting...\n\n" % (os.path.dirname(file_name)))
quit()
# logs to the console
if toconsole:
ch = logging.StreamHandler()
ch.setLevel(levels[console_level])
ch.setFormatter(fmt_general)
logger.addHandler(ch)
# logs to syslog
if tosyslog:
sh = SysLogHandler(address=syslog_address)
sh.setLevel(levels[syslog_level])
sh.setFormatter(fmt_syslog)
logger.addHandler(sh)
return logger
def bootstrap_logger(name):
l = logging.getLogger(name)
l.setLevel(logging.DEBUG)
#Catchall for all uncaught Exceptions
def handleUncaughtException(excType, excValue, traceback):
l.error("Uncaught exception", exc_info=(excType, excValue, traceback))
sys.excepthook = handleUncaughtException
prefix = "{0}[{1}] ".format(name, str(getpid()))
#Console handler
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(logging.Formatter(prefix + LOG_FORMAT))
l.addHandler(ch)
#Syslog handler
sh = SysLogHandler(address='/dev/log')
sh.setLevel(logging.DEBUG)
sh.setFormatter(logging.Formatter(prefix + LOG_FORMAT))
l.addHandler(sh)
l.debug("Starting {0} script.".format(name))
return l
def configure_syslog(request=None, logger=None, exceptions=False):
"""
Configure syslog logging channel.
It is turned on by setting `syslog_host` in the config file.
The port default to 514 can be overridden by setting `syslog_port`.
:param request: tornado.httputil.HTTPServerRequest instance
:param exceptions: boolean - This indicates if we should raise
exceptions encountered in the logging system.
"""
syslog_host = getattr(options, 'syslog_host', None)
if not syslog_host:
return
sys.modules["logging"].raiseExceptions = exceptions
handler = SysLogHandler(address=(syslog_host, options.syslog_port))
formatter = log_formatter(request)
handler.setFormatter(formatter)
if request:
handler.addFilter(RequestFilter(request))
if logger:
logger.addHandler(handler)
else:
logging.getLogger().addHandler(handler)
def patch_settings():
"""
Patches default project settings.
Don't know if it's the best way to do it... but it works...
I do that because I don't want to force users to manually edit lots of settings, except 'skissh' in INSTALLED_APPS.
"""
settings.LOGIN_URL = "/skwissh/login"
settings.LANGUAGES = (
('fr', _(u'Français')),
('en', _(u'Anglais')),
)
settings.CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
'LOCATION': 'skwissh-cache'
}
}
settings.MIDDLEWARE_CLASSES += (
'django.middleware.locale.LocaleMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'django.middleware.gzip.GZipMiddleware',
'django.middleware.http.ConditionalGetMiddleware',
)
logger = logging.getLogger('skwissh')
logger.setLevel(logging.DEBUG)
syslog = SysLogHandler(address='/dev/log')
formatter = logging.Formatter('%(name)s: %(levelname)s %(message)s')
syslog.setFormatter(formatter)
logger.addHandler(syslog)
def __custom(hostname='localhost', udp_port=514, name=hex(hash(random.random())), level=logging.INFO,
formatter=None):
"""
Create a custom syslog.
Private, called by Logger.__init__
:param hostname: IP or DNS name for syslog host
:type hostname: str
:param udp_port: syslog listening port - UDP only, no TCP
:type udp_port: int
:param name: Unique name for logger
:type name: str
:param formatter: Format logging better, default is no bueno
:type formatter: logging.Formatter
:param level: minimum event level to log
:type level: logging.level (logging.DEBUG for verbose, import logging)
:return: custom
:rtype: logging.getLogger
"""
if formatter is None:
formatter = logging.Formatter(
'%(asctime)s.%(msecs)03d PID%(process)d:%(levelname)-8s:%(filename)s:%(funcName)-15s:%(message)s',
'%Y-%m-%dT%H:%M:%S')
# Create remote sylog destination - incl. for system logging
custom_handler = SysLogHandler(address=(hostname, udp_port))
custom_handler.setFormatter(formatter)
# Create a new instance named custom - separate from root and customize
custom = logging.getLogger(name)
# Modify STDOUT to use both syslog and console_handler logging
custom.addHandler(custom_handler)
# Explicitly set minimum logging level INFO
custom.setLevel(level)
return custom
def syslogs_sender():
# Initalize SysLogHandler
logger = logging.getLogger()
logger.setLevel(logging.INFO)
syslog = SysLogHandler(address=(args.host, args.port))
logger.addHandler(syslog)
for message in range(1, args.count+1):
# Randomize some fields
time_output = time.strftime("%b %d %H:%M:%S")
random_host = random.choice(range(1,11))
random_tag = random.choice(tag)
random_level = random.choice(syslog_level)
fqdn = "{0}{1}{2}".format(hostname, random_host, domain_name)
random_pid = random.choice(range(500,9999))
message = open_sample_log(args.file)
fields = {'host_field': fqdn, 'date_field': time_output,\
'tag_field': random_tag}
format = logging.Formatter\
('%(date_field)s %(host_field)s {0}[{1}]: %(message)s'\
.format(random_tag, random_pid))
syslog.setFormatter(format)
print("[+] Sent: {0}: {1}".format(time_output, message), end='')
getattr(logger, random_level)(message, extra=fields)
logger.removeHandler(syslog)
syslog.close()
def __init__(self, url, port):
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
self.logger = logging.getLogger()
self.logger.setLevel(logging.INFO)
f = ContextFilter()
self.logger.addFilter(f)
syslog = SysLogHandler(address=(url, port))
formatter = logging.Formatter('%(levelname)s - %(name)s - %(message)s')
syslog.setFormatter(formatter)
self.logger.addHandler(syslog)
def setup_logging(debug):
'''
:params args - logging information arguments in cli
various utilties to support logging
'''
level = logging.DEBUG if debug else logging.INFO
logging.basicConfig(level=level, format=LOG_FORMAT, date_fmt=LOG_DATE)
handler = SysLogHandler(address='/dev/log')
syslog_formatter = logging.Formatter('%(name)s: %(levelname)s %(message)s')
handler.setFormatter(syslog_formatter)
LOG.addHandler(handler)
def get_logger(conf, name=None, verbose=False, fmt="%(message)s"):
if not conf:
conf = {}
if name is None:
name = 'oio'
logger = logging.getLogger(name)
logger.propagate = False
syslog_prefix = conf.get('syslog_prefix', '')
formatter = logging.Formatter(fmt=fmt)
if syslog_prefix:
fmt = '%s: %s' % (syslog_prefix, fmt)
syslog_formatter = logging.Formatter(fmt=fmt)
if not hasattr(get_logger, 'handler4logger'):
get_logger.handler4logger = {}
if logger in get_logger.handler4logger:
logger.removeHandler(get_logger.handler4logger[logger])
facility = getattr(SysLogHandler, conf.get('log_facility', 'LOG_LOCAL0'),
SysLogHandler.LOG_LOCAL0)
log_address = conf.get('log_address', '/dev/log')
try:
handler = SysLogHandler(address=log_address, facility=facility)
except socket.error as e:
if e.errno not in [errno.ENOTSOCK, errno.ENOENT]:
raise e
handler = SysLogHandler(facility=facility)
handler.setFormatter(syslog_formatter)
logger.addHandler(handler)
get_logger.handler4logger[logger] = handler
if verbose or hasattr(get_logger, 'console_handler4logger'):
if not hasattr(get_logger, 'console_handler4logger'):
get_logger.console_handler4logger = {}
if logger in get_logger.console_handler4logger:
logger.removeHandler(get_logger.console_handler4logger[logger])
console_handler = logging.StreamHandler(sys.__stderr__)
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)
get_logger.console_handler4logger[logger] = console_handler
logging_level = getattr(logging,
conf.get('log_level', 'INFO').upper(),
logging.INFO)
logger.setLevel(logging_level)
return logger
def log_handler(self):
if self.log_type == 'syslog':
handler = SysLogHandler('/dev/log', self.log_facility)
handler.setFormatter(
logging.Formatter(SYSLOG_FORMAT, SYSLOG_DATE_FORMAT))
else: # self.log_type == 'file'
handler = logging.FileHandler(self.log_file, delay=True)
handler.setFormatter(
logging.Formatter(FILE_LOG_FORMAT_DEBUG if self.log_level ==
logging.DEBUG else FILE_LOG_FORMAT))
return handler
def setup_logging(cls, name: str, level: str):
if cls.logger is not None:
return
formatter = logging.Formatter('[%(asctime)s] %(levelname)-3.3s: %(name)s: %(message)s')
handler = SysLogHandler(address=('localhost', SYSLOG_UDP_PORT), facility=SysLogHandler.LOG_LOCAL0)
handler.setLevel(level=level)
handler.setFormatter(fmt=formatter)
cls.logger = logging.getLogger(name=name)
cls.logger.setLevel(level=level)
cls.logger.addHandler(hdlr=handler)
def setup_logging(app: Flask):
formatter = Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
default_level = 'debug' if app.config['DEBUG'] else 'info'
address = app.config.get('LOG_ADDRESS', '/dev/log')
facility = app.config.get('LOG_FACILITY', 'LOG_SYSLOG')
level = app.config.get('LOG_LEVEL', default_level)
handler = SysLogHandler(
address=address,
facility=SysLogHandler.__dict__[facility],
)
handler.setFormatter(formatter)
app.logger.addHandler(handler)
def setup_logging(use_syslog=False):
"""Sets up logging and associated handlers."""
LOG.setLevel(logging.INFO)
if use_syslog:
ch = SysLogHandler()
else:
ch = logging.StreamHandler(sys.stdout)
ch.setFormatter(
logging.Formatter('%(asctime)s %(name)s[%(process)d] '
'%(levelname)s: %(message)s'))
LOG.addHandler(ch)
def add_syslog_handler(logger, syslog_facility):
try:
mds_syslog_handler = SysLogHandler(address="/dev/log",
facility=syslog_facility)
mds_syslog_handler.setLevel(MIN_LOG_LEVEL)
mds_syslog_handler.setFormatter(SYSLOG_FORMATTER)
logger.addHandler(mds_syslog_handler)
return True
except Exception:
logger.error('Exception occurred when adding syslog handler: ' +
traceback.format_exc())
return False
def add_syslog_handler(logger):
syslog_enabled = config.has_option("logging","syslog_enabled") and (int(config.get("logging","syslog_enabled")) == 1)
#add syslog handler if we are on linux and syslog is enabled in ambari config
if syslog_enabled and IS_LINUX:
logger.info("Adding syslog handler to ambari agent logger")
syslog_handler = SysLogHandler(address="/dev/log",
facility=SysLogHandler.LOG_LOCAL1)
syslog_handler.setFormatter(SYSLOG_FORMATTER)
logger.addHandler(syslog_handler)
def set_up_logging(save_to_file=True,
print_to_console=True,
logger_name="bot"):
"""
Logger for tenhou communication and AI output
"""
logger = logging.getLogger(logger_name)
logger.setLevel(logging.DEBUG)
if print_to_console:
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
formatter = ColoredFormatter(LOG_FORMAT, datefmt=DATE_FORMAT)
ch.setFormatter(formatter)
logger.addHandler(ch)
log_prefix = settings.LOG_PREFIX
if not log_prefix:
log_prefix = hashlib.sha1(
settings.USER_ID.encode("utf-8")).hexdigest()[:5]
if save_to_file:
logs_directory = os.path.join(
os.path.dirname(os.path.realpath(__file__)), "..", "logs")
if not os.path.exists(logs_directory):
os.mkdir(logs_directory)
formatter = logging.Formatter(LOG_FORMAT, datefmt=DATE_FORMAT)
# we need it to distinguish different bots logs (if they were run in the same time)
file_name = "{}_{}.log".format(
log_prefix,
datetime.datetime.now().strftime("%Y-%m-%d_%H_%M_%S"))
fh = logging.FileHandler(os.path.join(logs_directory, file_name),
encoding="utf-8")
fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
logger.addHandler(fh)
if settings.PAPERTRAIL_HOST_AND_PORT:
syslog = SysLogHandler(address=settings.PAPERTRAIL_HOST_AND_PORT)
game_id = f"BOT_{log_prefix}"
formatter = ColoredFormatter(f"%(asctime)s {game_id}: %(message)s",
datefmt=DATE_FORMAT)
syslog.setFormatter(formatter)
logger.addHandler(syslog)
return logger
def get_logger(name='tools', component='unknown'):
"""
:return: Logger
"""
logger = logging.getLogger(name)
logger.setLevel(logging.INFO)
if not logger.handlers:
syslog_handler = SysLogHandler(address=('syslog', 601))
syslog_handler.setFormatter(JsonFormatter(component=component))
logger.addHandler(syslog_handler)
return logger
def setup_logging(syslog_socket, log_format):
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(log_format)
consoleHandler = logging.StreamHandler()
consoleHandler.setFormatter(formatter)
logger.addHandler(consoleHandler)
if args.syslog_socket != '/dev/null':
syslogHandler = SysLogHandler(args.syslog_socket)
syslogHandler.setFormatter(formatter)
logger.addHandler(syslogHandler)
def __init__(self, hostname, username, password, timeout=60, api='JSONv2'):
self.timeout = timeout
self.api = api
self.instance = 'https://%s.service-now.com/' % hostname
self.session = SnowSession()
self.session.auth = (username, password)
# Enables sending logging messages to the local syslog server.
self.log = logging.getLogger('ServiceNowRac')
sysh = SysLogHandler()
formatter = logging.Formatter('%(levelname)s: %(message)s')
sysh.setFormatter(formatter)
self.log.addHandler(sysh)
def get_syslog_handler():
logger_host = Config.LOGGER_HOST
logger_port = Config.LOGGER_PORT
if not logger_port:
logging.basicConfig()
return None
syslog = SysLogHandler(address=(logger_host, int(logger_port)))
formatter = logging.Formatter(
'%(asctime)s %(name)s %(hostname)s: %(message)s',
datefmt='%b %d %H:%M:%S')
syslog.setLevel(logging.INFO)
syslog.setFormatter(formatter)
return syslog
def setup_log(**args):
# redirect stdout and stderr to logger
redirect_stdouts_to_logger(args['logger'])
# logs to local syslog
hl = SysLogHandler('/dev/log',
facility=SysLogHandler.facility_names['syslog'])
# setting log level
hl.setLevel(args['loglevel'])
# setting log format
formatter = Formatter(probe_config.log.prefix + BASIC_FORMAT)
hl.setFormatter(formatter)
# add new handler to logger
args['logger'].addHandler(hl)
def __init__(self):
syslog = SysLogHandler(address=(os.getenv("PAPERTRAIL_HOST"),
int(os.getenv("PAPERTRAIL_PORT"))))
syslog.addFilter(ContextFilter())
syslog.setFormatter(
logging.Formatter('%(asctime)s %(hostname)s ' +
os.getenv("APP_NAME") +
' [%(levelname)s]: %(message)s',
datefmt='%b %d %H:%M:%S'))
self.Logger = logging.getLogger()
self.Logger.addHandler(syslog)
self.Logger.setLevel(logging.INFO)
def initLoggingSystem():
screenformatter = logging.Formatter(
'[%(asctime)s] %(levelname)s - %(message)s')
syslogformatter = logging.Formatter(
'ELS-Purge-Old-Idx[%(process)d]: %(levelname)s - %(message)s')
sysloghandler = SysLogHandler(address='/dev/log',
facility=SysLogHandler.LOG_CRON)
sysloghandler.setFormatter(syslogformatter)
logger.addHandler(sysloghandler)
steamhandler = logging.StreamHandler()
steamhandler.setLevel(logging.INFO)
steamhandler.setFormatter(screenformatter)
logger.addHandler(steamhandler)
def rsyslog(args, msg):
logger = logging.getLogger(args.nodeip + '_sysflow')
logger.setLevel(logging.INFO)
logger.propagate = False
socketType = socket.SOCK_STREAM
if args.syslogprotocol == 'UDP':
socketType = socket.SOCK_DGRAM
syslog_handler = SysLogHandler(address=(args.sysloghost, args.syslogport), socktype=socketType)
fmt = logging.Formatter('%(asctime)s %(name)s %(message)s', datefmt="%b %d %H:%M:%S")
syslog_handler.setFormatter(fmt)
logger.addHandler(syslog_handler)
logger.info(msg)
sleep(float(args.syslogexpint))
def _Log(name, path=None, logformat=''):
log = logging.getLogger(name)
if path is not None:
hdlr = logging.FileHandler(path)
else:
hdlr = SysLogHandler()
if not logformat:
logformat = '%(name)s - %(levelname)s: %(message)s'
frmt = logging.Formatter(logformat)
hdlr.setFormatter(frmt)
log.addHandler(hdlr)
log.setLevel(logging.DEBUG)
return log
def create_logger(logger_name, filename=None, max_file_size=None, max_backups=None):
"""Creates and returns the named logger
If the logger already exists, it will be destroyed and recreated
with the current config in env.yaml
"""
# If the logger already exists, destroy it
if logger_name in logging.root.manager.loggerDict:
del(logging.root.manager.loggerDict[logger_name])
# Grab the logging conf
conf = _load_conf(logger_name)
log_path.ensure(dir=True)
if filename:
log_file = filename
else:
log_file = str(log_path.join('{}.log'.format(logger_name)))
# log_file is dynamic, so we can't used logging.config.dictConfig here without creating
# a custom RotatingFileHandler class. At some point, we should do that, and move the
# entire logging config into env.yaml
file_formatter = logging.Formatter(conf['file_format'])
file_handler = RotatingFileHandler(log_file, maxBytes=max_file_size or conf['max_file_size'],
backupCount=max_backups or conf['max_file_backups'], encoding='utf8')
file_handler.setFormatter(file_formatter)
logger = logging.getLogger(logger_name)
logger.addHandler(file_handler)
syslog_settings = _get_syslog_settings()
if syslog_settings:
lid = fauxfactory.gen_alphanumeric(8)
fmt = '%(asctime)s [' + lid + '] %(message)s'
syslog_formatter = SyslogMsecFormatter(fmt=fmt)
syslog_handler = SysLogHandler(address=syslog_settings)
syslog_handler.setFormatter(syslog_formatter)
logger.addHandler(syslog_handler)
logger.setLevel(conf['level'])
if conf['errors_to_console']:
stream_formatter = logging.Formatter(conf['stream_format'])
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.ERROR)
stream_handler.setFormatter(stream_formatter)
logger.addHandler(stream_handler)
logger.addFilter(_RelpathFilter())
return logger
def bootstrap_core_logging():
"""This is a replacement for standard Tornado logging configuration."""
handlers = []
level = getattr(logging, options.loglevel.upper())
context_filter = ContextFilter()
ROOT_LOGGER.setLevel(logging.NOTSET)
if options.logfile:
file_handler = logging.handlers.WatchedFileHandler(options.logfile)
file_handler.setFormatter(logging.Formatter(options.logformat))
handlers.append(file_handler)
if options.stderr_log:
stderr_handler = logging.StreamHandler()
stderr_handler.setFormatter(
LogFormatter(fmt=options.stderr_format,
datefmt=options.stderr_dateformat))
handlers.append(stderr_handler)
if options.syslog:
if options.syslog_port is not None:
syslog_address = (options.syslog_address, options.syslog_port)
else:
syslog_address = options.syslog_address
try:
syslog_formatter = logging.Formatter('{}: {}'.format(
options.app, options.logformat))
syslog_handler = SysLogHandler(
facility=SysLogHandler.facility_names[options.syslog_facility],
address=syslog_address)
syslog_handler.setFormatter(syslog_formatter)
handlers.append(syslog_handler)
except socket.error:
logging.getLogger('frontik.logging').exception(
'cannot initialize syslog')
for logger_name in options.suppressed_loggers:
logging.getLogger(logger_name).setLevel(logging.WARN)
for handler in handlers:
handler.setLevel(level)
handler.addFilter(context_filter)
ROOT_LOGGER.addHandler(handler)
ROOT_LOGGER.addHandler(GlobalLogHandler())
if not ROOT_LOGGER.handlers:
ROOT_LOGGER.addHandler(logging.NullHandler())
class StartLog:
def __init__(self, verbose=False, quiet=False, syslog=None, logpath=None, loglevel=None):
'''
start logging facilities
pass an optional logpath to log to disk (using WatchedFileHandler)
'''
levels = {'DEBUG':DEBUG, 'INFO':INFO, 'WARNING':WARNING, 'ERROR':ERROR, 'CRITICAL':CRITICAL}
assert loglevel in levels.keys() or loglevel == None, 'log level must be one of ' + str(levels)
# set loglevel based on verbosity/quiet args
if loglevel is not None:
loglevel = levels[loglevel]
elif verbose is True and quiet is False:
loglevel = DEBUG
elif quiet is True and verbose is False:
loglevel = CRITICAL
else:
loglevel = INFO
# logger
formatter = Formatter('%(name)s - %(message)s')
self.log = getLogger('blacklistparser')
self.log.setLevel(loglevel)
# setup console logger
self.console_log = StreamHandler()
self.console_log.setFormatter(formatter)
self.console_log.setLevel(loglevel)
self.log.addHandler(self.console_log)
self.log.debug('Added StreamHandler() console logging')
# alternative logging types below
if logpath is None:
self.log.debug('log path not specified')
elif types.base_path_type(logpath) is not None:
# setup disk log
self.disk_log = WatchedFileHandler(logpath)
self.disk_log.setFormatter(formatter)
self.disk_log.setLevel(loglevel)
self.log.addHandler(self.disk_log)
self.log.debug('Added WatchedFileHandler() logging')
if syslog:
# setup syslog
# this is using /dev/log socket that is very (linux/openbsd)
# platform dependant, should add some os detection logic here
# and an argument to log to remote syslog server/port
self.sys_log_handler = SysLogHandler(address='/dev/log')
self.sys_log_handler.setFormatter(formatter)
self.sys_log_handler.setLevel(loglevel)
self.log.addHandler(self.sys_log_handler)
self.log.debug('Added SysLogHandler() logging')
# log setup success/fail msg at DEBUG level
debugmsg = ('setting log level to ' + str(loglevel))
self.log.debug(debugmsg)
def copytool_log_setup():
handler = SysLogHandler(facility=SysLogHandler.LOG_DAEMON,
address="/dev/log")
# FIXME: define a custom formatter that will handle unicode strings
handler.setFormatter(
SafeSyslogFormatter(
'[%(asctime)s] copytool %(levelname)s: %(message)s',
'%d/%b/%Y:%H:%M:%S'))
copytool_log.addHandler(handler)
# Hijack these so that we can reuse code without stomping on other
# processes' logging.
console_log.addHandler(handler)
daemon_log.addHandler(handler)
def setup_logging(config: Dict[str, Any]) -> None:
"""
Process -v/--verbose, --logfile options
"""
# Log level
verbosity = config['verbosity']
# Log to stderr
log_handlers: List[logging.Handler] = [logging.StreamHandler(sys.stderr)]
logfile = config.get('logfile')
if logfile:
s = logfile.split(':')
if s[0] == 'syslog':
# Address can be either a string (socket filename) for Unix domain socket or
# a tuple (hostname, port) for UDP socket.
# Address can be omitted (i.e. simple 'syslog' used as the value of
# config['logfilename']), which defaults to '/dev/log', applicable for most
# of the systems.
address = (s[1], int(s[2])) if len(s) > 2 else s[1] if len(s) > 1 else '/dev/log'
handler = SysLogHandler(address=address)
# No datetime field for logging into syslog, to allow syslog
# to perform reduction of repeating messages if this is set in the
# syslog config. The messages should be equal for this.
handler.setFormatter(Formatter('%(name)s - %(levelname)s - %(message)s'))
log_handlers.append(handler)
elif s[0] == 'journald':
try:
from systemd.journal import JournaldLogHandler
except ImportError:
raise OperationalException("You need the systemd python package be installed in "
"order to use logging to journald.")
handler = JournaldLogHandler()
# No datetime field for logging into journald, to allow syslog
# to perform reduction of repeating messages if this is set in the
# syslog config. The messages should be equal for this.
handler.setFormatter(Formatter('%(name)s - %(levelname)s - %(message)s'))
log_handlers.append(handler)
else:
log_handlers.append(RotatingFileHandler(logfile,
maxBytes=1024 * 1024, # 1Mb
backupCount=10))
logging.basicConfig(
level=logging.INFO if verbosity < 1 else logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=log_handlers
)
_set_loggers(verbosity)
logger.info('Verbosity set to %s', verbosity)
def setup_log(**args):
# redirect stdout and stderr to logger
redirect_stdouts_to_logger(args['logger'])
# logs to local syslog
#syslog = SysLogHandler(address=settings.SYSLOG_FILE, facility=logging.handlers.SysLogHandler.LOG_LOCAL3)
syslog = SysLogHandler(address=settings.SYSLOG_FILE,
facility=logging.handlers.SysLogHandler.LOG_LOCAL3)
# setting log level
syslog.setLevel(args['loglevel'])
# setting log format
formatter = logging.Formatter('dbaas: #celery %(name)s %(message)s')
syslog.setFormatter(formatter)
# add new handler to logger
args['logger'].addHandler(syslog)
def get_logger():
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
formatter = Formatter("%(asctime)s [%(module)s] %(message)s")
stream_handler = StreamHandler()
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
syslog_handler = SysLogHandler(address='/dev/log',
facility=SysLogHandler.LOG_DAEMON)
syslog_handler.setFormatter(formatter)
logger.addHandler(syslog_handler)
return logger
def setup_logging(loglevel, use_syslog=False) -> None:
root = logging.getLogger()
root.setLevel(loglevel)
if use_syslog:
from logging.handlers import SysLogHandler
hdlr = SysLogHandler(address='/dev/log') # type: logging.Handler
else:
hdlr = logging.StreamHandler()
fmt = logging.Formatter(logging.BASIC_FORMAT)
hdlr.setFormatter(fmt)
root.addHandler(hdlr)
def setup_logger(cfg, component):
logging.basicConfig(
format=
"%%(asctime)s [%%(levelname)s] netl2api.%s[%%(process)d/%%(threadName)s]: %%(message)s"
% component)
logger = logging.getLogger(component)
logger.setLevel(_LOG_CFG.get(cfg.get("logger", "level"), logging.WARN))
syslog_socket = syslog_sockets.get(sys.platform)
if syslog_socket is not None:
syslog = SysLogHandler(address=syslog_socket, facility="daemon")
syslog.setFormatter(logging.Formatter("%%(asctime)s [%%(levelname)s] netl2api.%s[%%(process)d/%%(threadName)-10s]: %%(message)s" \
% component, "%b %d %H:%m:%S"))
logger.addHandler(syslog)
return logger
def set_logger():
if args.foreground:
logging.basicConfig(format='%(asctime)s %(levelname)-8s %(message)s',
level=logging.DEBUG)
else:
logfac = config.get('doorbot', 'logfacility')
logfac = SysLogHandler.facility_names[logfac]
logger = logging.root
logger.setLevel(logging.DEBUG)
syslog = SysLogHandler(address='/dev/log', facility=logfac)
formatter = logging.Formatter(
'Doorbot[%(process)d]: %(levelname)-8s %(message)s')
syslog.setFormatter(formatter)
logger.addHandler(syslog)
def setup_logging(args):
level = logging.INFO
if args.quiet:
level = logging.WARN
if args.debug:
level = logging.DEBUG
logging.basicConfig(level=level, format=LOG_FORMAT, date_fmt=LOG_DATE)
handler = SysLogHandler(address='/dev/log')
syslog_formatter = logging.Formatter('%(name)s: %(levelname)s %(message)s')
handler.setFormatter(syslog_formatter)
LOG.addHandler(handler)
# Create a local rotating logging object
load_local_logging()
