def __init__(self, *, instrument, level):
# If you define a level with the same numeric value, it overwrites the
# predefined value; the predefined name is lost.
logging.addLevelName(10, '<D>') # DEBUG
logging.addLevelName(20, '<I>') # INFO
logging.addLevelName(30, '<W>') # WARNING
logging.addLevelName(40, '<E>') # ERROR
logging.addLevelName(50, '<C>') # CRITICAL
root = logging.getLogger()
root.setLevel(level)
root.handlers = []
# syslog handler relies on syslog server to add timestamp
syslog_handler = SysLogHandler('/dev/log')
syslog_handler.setLevel(level)
syslog_formatter = logging.Formatter(
instrument + '-%(module)s[%(process)d]: %(levelname)s %(message)s')
syslog_handler.setFormatter(syslog_formatter)
root.addHandler(syslog_handler)
# console handler applies local timestamp
console_handler = logging.StreamHandler(None)
console_handler.setLevel(level)
console_formatter = logging.Formatter(
'%(asctime)s ' + instrument +
'-%(module)s[%(process)d]: %(levelname)s %(message)s')
console_handler.setFormatter(console_formatter)
root.addHandler(console_handler)
self.syslog_handler = syslog_handler
self.console_handler = console_handler
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 create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
if not app.config['DEBUG'] and not app.config['TESTING']:
# configure logging for production
# send standard logs to syslog
import logging
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler()
syslog_handler.setLevel(logging.WARNING)
app.logger.addHandler(syslog_handler)
bootstrap.init_app(app)
db.init_app(app)
login_manager.init_app(app)
from .users import users_bp as users_blueprint
app.register_blueprint(users_blueprint, url_prefix='/users')
from .api_v1 import api_bp as api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/api/v1')
@app.route('/')
def index():
redirect(url_for('users.index'))
return app
def setup():
global esm_events
if not esm_events:
esm_events = EsmEvents()
try:
logging.info("***About to setup SysLogHandler for ESM...")
# SysLog support at Sample level -Perhaps is better at global level.
# SysLogHandler configured to local syslog and it requires that the
# user configures rsyslog.conf to point to remote ESM because:
# 1. TLS can be configured from local sys log to remote ESM (In order to avoid Man in the Middle Attack)
# 2. More performant as rsyslog can be configured to send batches
# Anyways, if the SDK client developer decides to not point lolcally simply pass url to SysLogHandler:
# handler = SysLogHandler(address=('ESM_REMOTE_SERVER_IP', UDP_OR_TLS_PORT))
logger = logging.getLogger()
handler = SysLogHandler(address='/dev/log')
# Logging level must be info for SysLogHandler in order to send proper information:
handler.setLevel(logging.INFO)
logger.addHandler(handler)
logging.info("***SysLogHandler setup successfull!")
# Default log location in case needed at sudo level for investigating payloads.
# Normally commented as it needs to be run as sudo but it can be used for troubleshoot purposes:
#logger.addHandler(logging.FileHandler("/var/log/mvedr_activity_feed_esm.log"))
except Exception as e:
logging.error(
"***Error while setting up SysLogHandler or FileHandler for ESM"
)
def create_app(config_name):
# import here or else manage.py cant update os.environ inside config
from config import config
app = Flask(__name__)
app.config.from_object(config[config_name])
if not app.config['DEBUG'] and not app.config['TESTING']:
# configure logging for production
import logging
from logging.handlers import SysLogHandler
handler = SysLogHandler()
handler.setLevel(logging.INFO)
app.logger.addHandler(handler)
else:
import logging
from logging.handlers import RotatingFileHandler
import os
handler = RotatingFileHandler(os.path.join(app.config['LOG_ROOT'],
'app.log'),
maxBytes=10000,
backupCount=1)
handler.setLevel(logging.INFO)
app.logger.addHandler(handler)
# module.init_app(app)
# db.init_app(app)
# migrate.init_app(app, db)
# @app.route('/')
# def index():
# return redirect(url_for('mybp.index'))
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
if not app.config['DEBUG'] and not app.config['TESTING']:
# send standard logs to syslog
import logging
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler()
syslog_handler.setLevel(logging.WARNING)
app.logger.addHandler(syslog_handler)
db.init_app(app)
login_manager.init_app(app)
from .api_1_0 import api_blueprint
from .api_1_0.restplus import api as api_app
from .api_1_0.routes import ns_user as user_namespace
api_app.init_app(api_blueprint)
api_app.add_namespace(user_namespace)
app.register_blueprint(api_blueprint, url_prefix='/api')
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/')
return app
def init_app(self, app):
Config.init_app(app)
# email errors to the administrators
import logging
from logging.handlers import SMTPHandler
credentials = None
secure = None
if getattr(self, 'MAIL_USERNAME', None) is not None:
credentials = (self.MAIL_USERNAME, self.MAIL_PASSWORD)
if getattr(self, 'MAIL_USE_TLS', None):
secure = ()
mail_handler = SMTPHandler(
mailhost=(self.MAIL_SERVER, self.MAIL_PORT),
fromaddr=self.MAIL_DEFAULT_SENDER,
toaddrs=[self.ADMINS],
subject=self.FLASKLLERY_MAIL_SUBJECT_PREFIX + ' Application Error',
credentials=credentials,
secure=secure)
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler()
syslog_handler.setLevel(logging.WARNING)
app.logger.addHandler(syslog_handler)
def basic_logger():
"""Configure a basic logger for KairosDB interface
:return: Logger object
"""
if not LOG:
logger = logging.getLogger('kairosdb')
logger.setLevel(logging.DEBUG)
fmt_syslog = logging.Formatter(
'%(module)s %(processName)s %(levelname)s: %(message)s')
fmt_stream = logging.Formatter(
'%(processName)s %(levelname)s: %(message)s')
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(fmt_stream)
logger.addHandler(stream_handler)
syslog_handler = SysLogHandler(address='/dev/log')
syslog_handler.setFormatter(fmt_syslog)
syslog_handler.setLevel(logging.INFO)
logger.addHandler(syslog_handler)
global LOG
LOG = logger
return LOG
def create_base_app(config):
"""Init configuration and extensions"""
app = Flask(__name__)
app.config.from_object(config)
config.init_app(app)
file_handler = SysLogHandler()
file_handler.setLevel(logging.WARNING)
app.logger.addHandler(file_handler)
db.init_app(app)
bcrypt.init_app(app)
if app.config['DEBUG']:
admin_extension.init_app(app)
debug_toolbar.init_app(app)
login_manager.init_app(app)
login_manager.anonymous_user = Anonymous
# Change these views to fit your app
login_manager.login_view = "auth.login"
login_manager.refresh_view = "auth.login"
login_manager.login_message = "You do not have access to that page."
login_manager.user_loader(load_user)
app.json_encoder = CustomJSONEncoder
return app
def open_syslog(self):
from logging.handlers import SysLogHandler
try:
# setup logger level
self.logger.setLevel (logging.DEBUG)
# setup formatter
fmt = logging.Formatter ("%(name)s: %(levelname)s: %(message)s")
system = platform.system()
if system == "Linux":
fh = SysLogHandler (address="/dev/log",facility=self.facility)
else:
# In Solaris, /dev/log is a stream device, but python expects it to be
# a unix domain socket. So we use the default UDP port address.
fh = SysLogHandler(facility=self.facility)
# set log level to INFO
fh.setLevel (logging.DEBUG)
#add formatter to fh
fh.setFormatter (fmt)
#add fh to logger
self.logger.addHandler(fh)
except:
print "Unable to Open syslog!"
raise
def create_app(config_name, with_blueprint=True):
app = Flask(__name__)
app.config.from_object(config[config_name])
if not app.config['DEBUG'] and not app.config['TESTING']:
# configure logging for production
# send standard logs to syslog
import logging
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler()
syslog_handler.setLevel(logging.WARNING)
app.logger.addHandler(syslog_handler)
bootstrap.init_app(app)
db.init_app(app)
moment.init_app(app)
login_manager.init_app(app)
if with_blueprint:
from .auth.routes import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
from .display.routes import display as display_blueprint
app.register_blueprint(display_blueprint)
from .hardware.routes import hardware as hardware_blueprint
app.register_blueprint(hardware_blueprint)
from .manage.routes import manage as manage_blueprint
app.register_blueprint(manage_blueprint)
return app
def create_app(config_name):
app = Flask(__name__)
Bootstrap(app)
if config_name is not None:
app.config.from_object(config_name)
if not app.debug:
import logging
from logging.handlers import SysLogHandler
file_handler = SysLogHandler()
file_handler.setLevel(logging.WARNING)
app.logger.addHandler(file_handler)
with app.app_context():
# the app context is needed to switch the storage
# backend based on the config parameter.
# (which is bound to the app object)
from eudat_http_api.http_storage.init import http_storage
app.register_blueprint(http_storage)
from eudat_http_api.registration.init import registration
app.register_blueprint(registration)
from eudat_http_api.registration.models import db
#jj: f****d up blueprints, after blowing up tests now they blow up the ORM
db.app = app
db.init_app(app)
return app
def __daemon(self):
"""
Daemonizes the process; returns a non-zero exit code in case of failure.
"""
# Daemonize
try:
# Create and check PID file
oPidLockFile = make_pidlockfile(self.__oArguments.pid, 0)
if is_pidfile_stale(oPidLockFile):
oPidLockFile.break_lock()
if oPidLockFile.is_locked():
iPid = oPidLockFile.read_pid()
logger.error(f"daemon: Process already running; PID={iPid}")
return errno.EEXIST
# Create daemon context
oDaemonContext = DaemonContext(pidfile=oPidLockFile)
oDaemonContext.signal_map = {signal.SIGTERM: self.__signal}
oDaemonContext.open()
emit_message(f"daemon: Forked to background; PID={os.getpid()}")
# Redirect standard error to syslog
oHandler = SysLogHandler(address="/dev/log")
oHandler.setLevel(logger.level)
oHandler.setFormatter(
logging.Formatter(
"%(name)s[%(process)d]: %(levelname)s: %(message)s"))
logger.addHandler(oHandler)
# Execute
return self.__updater()
except Exception as e:
logger.error(f"daemon: Failed to fork to background; {str(e)}")
return errno.ESRCH
def getlogger():
logger = getattr(_LOCAL, 'logger', None)
if logger is not None:
return logger
logger = logging.getLogger()
formatter = logging.Formatter('[%(asctime)s] %(levelname)-8s"%(message)s"',
'%Y-%m-%d %a %H:%M:%S')
if settings.LOG_FILENAME:
log_handler = logging.FileHandler(settings.LOG_FILENAME)
log_handler.setFormatter(formatter)
log_handler.setLevel(settings.LOG_FILE_LEVEL)
logger.addHandler(log_handler)
if settings.LOG_SYSLOG:
syslog_handler = SysLogHandler(address='/dev/log')
formatter = logging.Formatter('authentic %(levelname)-8s"%(message)s"',
'%Y-%m-%d %a %H:%M:%S')
syslog_handler.setFormatter(formatter)
syslog_handler.setLevel(settings.LOG_SYS_LEVEL)
logger.addHandler(syslog_handler)
setattr(_LOCAL, 'logger', logger)
return logger
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 __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 _configLogger(self,
logToSysLog=None,
logToStdout=None,
logToStderr=None,
logLevel=None,
propagate=None,
formatString=None,
sysLogAddress=None):
if propagate is not None:
self._mainLogger.propagate = propagate
if logLevel is not None:
self._mainLogger.setLevel(logLevel)
_logging_formatter = logging.Formatter(
formatString) if formatString else None
if logToSysLog:
_syslogHandler = SysLogHandler(address=sysLogAddress)
_syslogHandler.setFormatter(_logging_formatter)
_syslogHandler.setLevel(logLevel)
self._mainLogger.addHandler(_syslogHandler)
if logToStdout:
_stdoutHandler = logging.StreamHandler(sys.stdout)
_stdoutHandler.setFormatter(_logging_formatter)
_stdoutHandler.setLevel(logLevel)
self._mainLogger.addHandler(_stdoutHandler)
if logToStderr:
_stderrHandler = logging.StreamHandler(sys.stderr)
_stderrHandler.setFormatter(_logging_formatter)
_stderrHandler.setLevel(logLevel)
self._mainLogger.addHandler(_stderrHandler)
def get_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
"""
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 add_destination(self, dest):
"""Add a logging destination to self.loggers"""
if not isinstance(dest.tag, str):
return
if dest.tag == "syslog":
logger = logging.Logger(dest.attrib["id"])
srv = (dest.attrib["id"], 514)
hdlr = SysLogHandler(srv, SysLogHandler.LOG_LOCAL5)
hdlr.setLevel(logging.DEBUG)
fmt = logging.Formatter("%(asctime)s " + self.fmtstring,
"%b %d %H:%M:%S")
hdlr.setFormatter(fmt)
logger.addHandler(hdlr)
self.loggers.append([logger, int(dest.attrib["loglevel"])])
elif dest.tag == "file":
logger = logging.Logger(dest.attrib["id"])
filepath = os.path.join(self.log_dir,
dest.attrib["id"])
hdlr = logging.FileHandler(filepath)
fmt = logging.Formatter(self.fmtstring)
hdlr.setFormatter(fmt)
logger.addHandler(hdlr)
self.loggers.append([logger, int(dest.attrib["loglevel"])])
elif dest.tag == "trfile":
when = dest.get('when', 'd')
interval = int(dest.get('interval', 1))
backupCount = int(dest.get('backupCount', 5))
logger = logging.Logger(dest.attrib["id"])
filepath = os.path.join(self.log_dir,
dest.attrib["id"])
hdlr = logging.handlers.TimedRotatingFileHandler(
filepath,
when = when,
interval = interval,
backupCount = backupCount
)
fmt = logging.Formatter(self.fmtstring)
hdlr.setFormatter(fmt)
logger.addHandler(hdlr)
self.loggers.append([logger, int(dest.attrib["loglevel"])])
elif dest.tag == 'stream':
logger = logging.Logger(dest.attrib['id'])
hdlr = logging.StreamHandler(getattr(sys,
dest.get('id',
'stderr')))
fmt = logging.Formatter(self.fmtstring)
hdlr.setFormatter(fmt)
logger.addHandler(hdlr)
self.loggers.append([logger,
int(dest.get("loglevel",
self.default_loglevel))
])
else:
# Unhandled value
raise IOError("1", "Unknown log method " + repr(dest.tag))
def __init__(self, logger_name, log_file):
# Create a custom logger
self.logger = logging.getLogger(logger_name) # name of the module
self.logger.setLevel(logging.DEBUG)
# Create handlers
c_handler = logging.StreamHandler()
f_handler = logging.FileHandler(log_file)
sysl_handler = SysLogHandler(address='/dev/log')
sysl_handler.setLevel(logging.CRITICAL)
# c_handler.setLevel(logging.NOTSET)
f_handler.setLevel(logging.ERROR)
# Create formatters and add it to handlers
c_format = MyFormatter('%(name)s - %(levelname)s - %(message)s')
f_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
sysl_format = logging.Formatter('sentinel-logger: %(message)s')
c_handler.setFormatter(c_format)
f_handler.setFormatter(f_format)
sysl_handler.setFormatter(sysl_format)
# Add handlers to the logger
self.logger.addHandler(c_handler)
self.logger.addHandler(f_handler)
self.logger.addHandler(sysl_handler)
def __init__(self, name, level, directory=None, server=None, port=None):
if not isinstance(name, str) or len(name) == 0:
raise OSError(
'Parameter "name" must be a non-empty Python string!')
if not isinstance(level, str) or len(level) == 0:
raise OSError(
'Parameter "level" must be a non-empty Python string!')
self.log = getLogger(name.lower())
self.log.setLevel(level.upper())
if isinstance(directory, str):
if not isdir(directory):
raise OSError(
'Parameter "directory" ("%s") must be an existant directory!'
% directory)
else:
file = FileHandler(join(directory, '%s.log' % name.lower()))
file.setFormatter(LOG_FORMAT)
file.setLevel(level.upper())
self.log.addHandler(file)
del file
if isinstance(server, str) and isinstance(port, int):
syslog = SysLogHandler(address=(server, port))
syslog.setFormatter(LOG_FORMAT)
syslog.setLevel(level.upper())
self.log.addHandler(syslog)
del syslog
stream = StreamHandler()
stream.setFormatter(LOG_FORMAT)
self.log.addHandler(stream)
del stream
self.log.info('[%s: %s] Log "%s" started!' %
(Name, Version, name.lower()))
def __init__(self, config, name, *args, **kwargs):
Logger.__init__(self, name, *args, **kwargs)
log_format = "temboard[%(process)d]: [%(name)s] %(levelname)s: %(message)s"
if config.logging['level'] == 'DEBUG':
# Add extra informations when we are in DEBUG mode.
log_format = "temboard[%(process)d]: [%(name)s] [%(funcName)s@"
log_format += "%(pathname)s#L%(lineno)d] %(levelname)s: %(message)s"
if config.logging['method'] == 'syslog':
try:
# Instanciate a new syslog handler.
lh = SysLogHandler(
address=str(config.logging['destination']),
facility=LOG_FACILITIES[config.logging['facility']])
except socket.error as e:
raise ConfigurationError(e)
elif config.logging['method'] == 'file':
try:
# Instanciate a new file handler.
lh = FileHandler(filename=config.logging['destination'],
mode='a')
# Add timestamp when using a FileHandler.
log_format = "%(asctime)s " + log_format
except IOError as e:
raise ConfigurationError(e)
# Set log level according to the level defined in configuration files.
lh.setLevel(LOG_LEVELS[config.logging['level']])
lh.setFormatter(Formatter(log_format))
self.addHandler(lh)
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
def init_app(cls, app):
Development.init_app(app)
import logging
from logging.handlers import SMTPHandler, SysLogHandler
credentials, secure = None, None
if getattr(cls, 'MAIL_USERNAME', None) is not None:
credentials = (cls.MAIL_USERNAME, cls.MAIL_PASSWORD)
if getattr(cls, 'MAIL_USE_TLS', None):
secure = ()
mail_handler = SMTPHandler(
mailhost=(cls.MAIL_SERVER, cls.MAIL_PORT),
fromaddr=cls.MAIL_SENDER,
toaddrs=[cls.XYCH_ADMIN],
subject=cls.MAIL_SUBJECT_PREFIX + ' App Error',
credentials=credentials,
secure=secure
)
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(logging.Formatter("""
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message: %(message)s"""))
app.logger.addHandler(mail_handler)
sys_log = SysLogHandler(address='/dev/log')
sys_log.setLevel(logging.WARNING)
app.logger.addHandler(sys_log)
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 init_app(cls, app):
Config.init_app(app)
import logging
from logging.handlers import SMTPHandler
credentials = None
secure = None
if getattr(cls, 'MAIL_USERNAME', None) is not None:
credentials = (cls.MAIL_USERNAME, cls.MAIL_PASSWORD)
if getattr(cls, 'MAIL_USE_TLS', None):
secure = ()
mail_handler = SMTPHandler(mailhost=(cls.MAIL_SERVER, cls.MAIL_PORT),
fromaddr=cls.FLASKY_MAIL_SENDER,
toaddr=cls.FLASKY_ADMIN,
subject=cls.FLASKY_MAIL_SUBJECT_PREFIX +
'Application Error',
credentials=credentials,
secure=secure)
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler()
syslog_handler.setLevel(logging.WARNING)
app.logger.addHandler(syslog_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 open_syslog(self):
from logging.handlers import SysLogHandler
try:
# setup logger level
self.logger.setLevel(logging.DEBUG)
# setup formatter
fmt = logging.Formatter("%(name)s: %(levelname)s: %(message)s")
system = platform.system()
if system == "Linux":
fh = SysLogHandler(address="/dev/log", facility=self.facility)
else:
# In Solaris, /dev/log is a stream device, but python expects it to be
# a unix domain socket. So we use the default UDP port address.
fh = SysLogHandler(facility=self.facility)
# set log level to INFO
fh.setLevel(logging.DEBUG)
#add formatter to fh
fh.setFormatter(fmt)
#add fh to logger
self.logger.addHandler(fh)
except:
print "Unable to Open syslog!"
raise
def setupLogging():
"""Sets up the logging for RQD.
Logs to /var/log/messages"""
# TODO(bcipriano) These should be config based. (Issue #72)
consoleFormat = '%(asctime)s %(levelname)-9s rqd3-%(module)-10s %(message)s'
consoleLevel = log.DEBUG
fileFormat = '%(asctime)s %(levelname)-9s rqd3-%(module)-10s %(message)s'
fileLevel = log.WARNING # Equal to or greater than the consoleLevel
log.basicConfig(level=consoleLevel, format=consoleFormat)
try:
import platform
if platform.system().upper() != 'WINDOWS':
logfile = SysLogHandler(address='/dev/log')
else:
logfile = StreamHandler()
except socket.error:
import platform
if platform.system().upper() == 'WINDOWS':
logfile = StreamHandler()
else:
logfile = SysLogHandler()
logfile.setLevel(fileLevel)
logfile.setFormatter(log.Formatter(fileFormat))
log.getLogger('').addHandler(logfile)
def init_app(cls, app):
ProductionConfig.init_app(app)
import logging
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler()
syslog_handler.setLevel(logging.WARNING)
app.logger.addHandler(syslog_handler)
def init_app(cls, app):
ProductionConfig.init_app(app)
import logging
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler()
syslog_handler.setLevel(logging.WARNING)
app.logger.addHandler(syslog_handler)
def init_app(cls, app):
# log to syslog
import logging
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler()
syslog_handler.setLevel(logging.INFO)
app.logger.addHandler(syslog_handler)
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 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 __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(self):
''' Initialize log object '''
self._log = logging.getLogger("mining_control")
self._log.setLevel(logging.DEBUG)
sysloghandler = SysLogHandler()
sysloghandler.setLevel(logging.DEBUG)
self._log.addHandler(sysloghandler)
streamhandler = logging.StreamHandler(sys.stdout)
streamhandler.setLevel(logging.getLevelName(self.debug_level))
self._log.addHandler(streamhandler)
if self.log_file is not None:
log_file = self.log_file
else:
home_folder = os.environ.get('HOME',
os.environ.get('USERPROFILE', ''))
log_folder = os.path.join(home_folder, "log")
log_file = os.path.join(log_folder, "mining_control.log")
if not os.path.exists(os.path.dirname(log_file)):
os.mkdir(os.path.dirname(log_file))
filehandler = logging.handlers.RotatingFileHandler(log_file,
maxBytes=102400000)
# create formatter
formatter = logging.Formatter(
'%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
filehandler.setFormatter(formatter)
filehandler.setLevel(logging.DEBUG)
self._log.addHandler(filehandler)
return True
def configurar_log(salida='console', verbosidad=0):
"""Configura el log"""
log = logging.getLogger(__name__)
verbosidad = 4 if verbosidad > 4 else verbosidad
nivel = ['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG'][verbosidad]
formato = logging.Formatter(
'elastica[%(process)s] %(module)s.%(funcName)s: %(message)s')
handler = None
if salida == 'syslog':
handler = SysLogHandler(address='/dev/log')
else:
handler = logging.StreamHandler(stdout)
nivel_verbosidad = getattr(logging, nivel)
handler.setLevel(nivel_verbosidad)
handler.setFormatter(formato)
log = logging.getLogger('elastica')
log.setLevel(nivel_verbosidad)
if not log.handlers:
log.addHandler(handler)
else:
manejador = log.handlers[0]
log.removeHandler(manejador)
log.addHandler(handler)
return log
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 getLoggerWithHandler(loggername, logToSysLog=True, logToStdout=False, logToStderr=False, logLevel=logging.DEBUG, propagate=True,
formatString='%(name)s[{}]: %(levelname)s: %(message)s'.format(os.getpid())):
logger = logging.getLogger(loggername)
logger.propagate = propagate
logger.setLevel(logLevel)
loggingFormatter = logging.Formatter(formatString)
logger.handlers = []
if logToSysLog:
sysLogHandler = SysLogHandler(address=Consts.SYSLOG_PATH)
sysLogHandler.setFormatter(loggingFormatter)
sysLogHandler.setLevel(logLevel)
logger.addHandler(sysLogHandler)
if logToStdout:
stdoutHandler = logging.StreamHandler(sys.stdout)
stdoutHandler.setFormatter(loggingFormatter)
stdoutHandler.setLevel(logLevel)
logger.addHandler(stdoutHandler)
if logToStderr:
stderrHandler = logging.StreamHandler(sys.stderr)
stderrHandler.setFormatter(loggingFormatter)
stderrHandler.setLevel(logging.ERROR)
logger.addHandler(stderrHandler)
return logger
def configure_logger(app, config):
if not app.debug:
if app.config.get('SENTRY_DSN', None) is not None:
sentry_sdk.init(app.config.get('SENTRY_DSN'),
integrations=[FlaskIntegration()])
if app.config.get('PAPERTRAIL_HOST', None):
syslog = SysLogHandler(
address=(app.config.get('PAPERTRAIL_HOST'),
int(app.config.get('PAPERTRAIL_PORT'))))
formatter = logging.Formatter(
'%(asctime)s %(hostname)s: %(levelname)s %(message)s',
datefmt='%b %d %H:%M:%S')
syslog.setFormatter(formatter)
syslog.setLevel(logging.WARNING)
syslog.addFilter(_ContextFilter())
app.logger.addHandler(syslog)
# Create a file logger since we got a logdir
stream_handler = logging.StreamHandler()
formatter = logging.Formatter(
"%(asctime)s %(levelname)s\t: %(message)s")
stream_handler.setFormatter(formatter)
app.logger.addHandler(stream_handler)
app.logger.setLevel(config.LOG_LEVEL)
app.logger.info("Logger started")
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 init_app(cls, app):
# Log messages to syslogd.
import logging
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler(address=cls.SYSLOG_ADDRESS)
syslog_handler.setLevel(logging.WARNING)
syslog_handler.setFormatter(logging.Formatter(
'%(name)s %(asctime)s %(levelname)s: %(message)s'))
app.logger.addHandler(syslog_handler)
def init_app(cls, app):
DevelopmentConfig.init_app(app)
# log to syslog
import logging
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler()
syslog_handler.setLevel(logging.WARNING)
app.logger.addHandler(syslog_handler)
def setup_log():
log.setLevel(logging.DEBUG)
handler = SysLogHandler(address="/dev/log")
log.addHandler(handler)
handler = logging.StreamHandler()
handler.setLevel(logging.INFO)
formatter = logging.Formatter("DD: %(message)s")
handler.setFormatter(formatter)
log.addHandler(handler)
def init_app(app):
if app.config['LOGGING_HANDLER'] == 'syslog':
# Log messages to syslogd.
import logging
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler(app.config['LOGGING_ADDRESS'])
syslog_handler.setLevel(app.config['LOGGING_LEVEL'])
syslog_handler.setFormatter(logging.Formatter(app.config['LOGGING_FORMAT']))
app.logger.addHandler(syslog_handler)
def setupSyslogLogger(facility, level, programName=None):
"""configure logging to syslog based on the specified facility. If
programName specified, each line is prefixed with the name"""
handler = SysLogHandler(address="/dev/log", facility=facility)
# add a formatter that includes the program name as the syslog ident
if progName is not None:
handler.setFormatter(logging.Formatter(fmt=progName+" %(message)s"))
handler.setLevel(level)
setupLogger(handler)
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
if not app.config['DEBUG'] and not app.config['TESTING']:
# configure logging for production
# email errors to the administrators
if app.config.get('MAIL_ERROR_RECIPIENT') is not None:
import logging
from logging.handlers import SMTPHandler
credentials = None
secure = None
if app.config.get('MAIL_USERNAME') is not None:
credentials = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'])
if app.config['MAIL_USE_TLS'] is not None:
secure = ()
mail_handler = SMTPHandler(
mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
fromaddr=app.config['MAIL_DEFAULT_SENDER'],
toaddrs=[app.config['MAIL_ERROR_RECIPIENT']],
subject='[Talks] Application Error',
credentials=credentials,
secure=secure)
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
# send standard logs to syslog
import logging
from logging.handlers import SysLogHandler
syslog_handler = SysLogHandler()
syslog_handler.setLevel(logging.WARNING)
app.logger.addHandler(syslog_handler)
bootstrap.init_app(app)
db.init_app(app)
moment.init_app(app)
pagedown.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
from .talks import talks as talks_blueprint
app.register_blueprint(talks_blueprint)
from .auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint, url_prefix='/auth')
from .api_1_0 import api as api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/api/1.0')
from app.emails import start_email_thread
@app.before_first_request
def before_first_request():
start_email_thread()
return app
def __init__(self, settings):
super(Syslog, self).__init__(settings)
option = settings.logger_settings["Syslog"]
if option["socket"]:
handler = SysLogHandler(address=option["socket"])
else:
handler = SysLogHandler(address=(option["host"], option["port"]))
handler.setLevel(logging.DEBUG)
handler.setFormatter(self.formatter)
self.logger.addHandler(handler)
def setup_syslog():
slogger = SysLogHandler()
slogger.setLevel(logging.INFO)
formatter = logging.Formatter(FORMAT)
slogger.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(slogger)
def add_syslog_handler(level=logging.DEBUG):
"""Add a syslog (local5) handler to the root logger"""
handler = SysLogHandler(facility=SysLogHandler.LOG_LOCAL5,
address="/dev/log")
handler.setLevel(level)
handler.setFormatter(utils.OptionalKeysFormatter(_format_string))
logger = logging.getLogger()
logger.setLevel(min(level, logger.level))
logger.addHandler(handler)
def get_logger(configuration):
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
file_handler = SysLogHandler(address='/dev/log',facility=configuration['syslog_facility'])
file_handler.setLevel(logging.DEBUG)
frmt = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(frmt)
logger.addHandler(file_handler)
return logger
def setup_logging(enable_debug):
level = logging.INFO
if enable_debug:
level = logging.DEBUG
logging.basicConfig(level=level, date_fmt='%m-%d %H:%M')
syslog = SysLogHandler(address='/dev/log')
syslog.setLevel(level)
syslog_formatter = logging.Formatter('%(name)s: %(levelname)s %(message)s')
syslog.setFormatter(syslog_formatter)
LOG.addHandler(syslog)
def create_sys_log_handler(revision):
""" Create a logger handler which logs to sys log and uses the given revision within the format """
format = DEFAULT_SYS_LOG_FORMAT.format(revision)
formatter = Formatter(format)
sys_log_handler = SysLogHandler(address=DEFAULT_SYS_LOG_ADDRESS)
sys_log_handler.setFormatter(formatter)
sys_log_handler.setLevel(DEFAULT_SYS_LOG_LEVEL)
return sys_log_handler
def create_sys_log_handler(revision):
""" creates a logger handler which logs to syslog and uses the given revision within the log format """
syslog_format = SYS_LOG_FORMAT.format(revision)
formatter = Formatter(syslog_format)
sys_log_handler = SysLogHandler(address=SYS_LOG_ADDRESS, facility=SYS_LOG_FACILITY)
sys_log_handler.setFormatter(formatter)
sys_log_handler.setLevel(SYS_LOG_LEVEL)
return sys_log_handler
def set_logger(log_level):
log_level = getattr(logging, log_level)
logger = logging.getLogger('DynHost')
base_format = '%(levelname)s - %(message)s'
handler = SysLogHandler(address='/dev/log')
formatter = logging.Formatter('%(name)s: ' + base_format)
handler.setFormatter(formatter)
handler.setLevel(log_level)
logger.addHandler(handler)
logger.setLevel(log_level)
return logger
