def get_log(self, log_name):
if log_name in self.registered_logs:
return self.registered_logs[log_name]
logger = logging.getLogger(log_name)
logger.handlers.clear()
logger.setLevel(logging.INFO)
# Init File Handler
file_name = os.path.join(Config.LOG_DIR, '%s.log' % log_name)
file_handler = WatchedFileHandler(file_name)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s ')
)
logger.addHandler(file_handler)
file_name = os.path.join(Config.LOG_DIR, '%s.err' % log_name)
file_handler = WatchedFileHandler(file_name)
file_handler.setLevel(logging.ERROR)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s ')
)
logger.addHandler(file_handler)
if Config.DEBUG:
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
console_format = logging.Formatter('%(asctime)s %(levelname)s: %(message)s')
console_handler.setFormatter(console_format)
logger.addHandler(console_handler)
self.registered_logs[log_name] = logger
return logger
def init(cls, config):
formatter = logging.Formatter(config.FORMAT)
root = logging.getLogger('')
root.setLevel(config.ROOT_LEVEL)
if config.LOG_TO_CONSOLE:
console_handler = logging.StreamHandler()
console_handler.setLevel(config.CONSOLE_LEVEL)
console_handler.setFormatter(formatter)
root.addHandler(console_handler)
if config.LOG_TO_FILE:
file_name = cls.generate_log_file_name()
file_handler = WatchedFileHandler(os.path.join(
config.FILE_BASE, file_name),
encoding='utf-8')
file_handler.setLevel(config.FILE_LEVEL)
file_handler.setFormatter(formatter)
root.addHandler(file_handler)
if config.TEMP_LOG:
file_name = cls.generate_log_file_name()
file_handler = WatchedFileHandler(os.path.join('', file_name),
encoding='utf-8')
file_handler.setLevel(config.FILE_LEVEL)
file_handler.setFormatter(formatter)
root.addHandler(file_handler)
def setup_logging(options, settings):
logger = logging.getLogger("pdud")
"""
Setup the log handler and the log level
"""
if options.journal:
from systemd.journal import JournalHandler
handler = JournalHandler(SYSLOG_IDENTIFIER="pdudaemon")
handler.setFormatter(logging.Formatter(logging_FORMAT_JOURNAL))
elif options.logfile == "-" or not options.logfile:
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(logging.Formatter(logging_FORMAT))
else:
handler = WatchedFileHandler(options.logfile)
handler.setFormatter(logging.Formatter(logging_FORMAT))
logger.addHandler(handler)
settings_level = settings.get('daemon', {}).get('logging_level', None)
if settings_level:
options.loglevel = settings_level.upper()
else:
options.loglevel = options.loglevel.upper()
if options.loglevel == "DEBUG":
logger.setLevel(logging.DEBUG)
elif options.loglevel == "INFO":
logger.setLevel(logging.INFO)
elif options.loglevel == "WARNING":
logger.setLevel(logging.WARNING)
else:
logger.setLevel(logging.ERROR)
def setup_logger(configs):
"""Setup logging
Args:
configs (dict): logging configuration
Returns:
logging.logger: the configured logger
"""
# TO-DO: use logging.config.dictConfig instead
logger = logging.getLogger(LOGGER)
level = getattr(logging, configs['level'])
log_formatter = (
'%(threadName)s::%(levelname)s::%(asctime)s'
'::%(lineno)d::(%(funcName)s) %(message)s'
)
fmt = logging.Formatter(log_formatter)
logger.setLevel(level)
if configs.get('file', False):
file_h = WatchedFileHandler(configs.get('file'))
file_h.setLevel(level)
file_h.setFormatter(fmt)
logger.addHandler(file_h)
else:
std_h = logging.StreamHandler(sys.stdout)
std_h.setLevel(level)
std_h.setFormatter(fmt)
logger.addHandler(std_h)
return logger
def set_logger(debug=False, logfile=None):
logFormatter = \
logging.Formatter("%(asctime)s %(levelname)s %(process)d %(filename)s:%(funcName)s:%(lineno)d %(message)s")
rootLogger = logging.getLogger()
if debug:
logging.level = logging.DEBUG
rootLogger.setLevel(logging.DEBUG)
else:
logging.level = logging.INFO
rootLogger.setLevel(logging.INFO)
if logfile:
try:
logdir = os.path.dirname(logfile)
if logdir and not os.path.isdir(logdir):
os.makedirs(logdir)
fileHandler = WatchedFileHandler(logfile)
fileHandler.setFormatter(logFormatter)
rootLogger.addHandler(fileHandler)
except Exception:
pass
consoleHandler = logging.StreamHandler()
consoleHandler.setFormatter(logFormatter)
rootLogger.addHandler(consoleHandler)
def __init__(self, application):
self.application = application
log_file = WatchedFileHandler(settings.API_LOG)
log_format = logging.Formatter(LOGFORMAT, DATEFORMAT)
log_file.setFormatter(log_format)
api_logger.setLevel(logging.DEBUG)
api_logger.addHandler(log_file)
def __init__(self, config, foreground=False):
self.cfg = config
self.logger = logging.getLogger('MQTToRRD')
self.logger.setLevel(self.cfg.log_level)
formatter = logging.Formatter(self.cfg.log_format)
self.client = None
if foreground:
self.handler = logging.StreamHandler()
self.cfg.log_handler = "stderr"
elif self.cfg.log_handler == "file":
if sys.platform == 'windows':
self.handler = logging.FileHandler(self.cfg.log_file,
encoding="utf-8")
else:
self.handler = WatchedFileHandler(self.cfg.log_file,
encoding="utf-8")
else:
self.handler = SysLogHandler(self.cfg.log_syslog,
SysLogHandler.LOG_DAEMON)
for hdlr in logger.root.handlers: # reset root logger handlers
logger.root.removeHandler(hdlr)
logger.root.addHandler(self.handler)
self.handler.setFormatter(formatter)
def init_logging(name: str,
log_level: int,
*,
log_file: Optional[str] = None,
foreground: Optional[bool] = False):
rootlogger = logging.getLogger()
rootlogger.setLevel(log_level)
if foreground:
console = logging.StreamHandler()
console.setFormatter(
logging.Formatter(
'%(asctime)s {}: %(levelname)s: (%(name)s) %(message)s'.format(
name)))
rootlogger.addHandler(console)
elif log_file:
logfile = WatchedFileHandler(log_file)
logfile.setFormatter(
logging.Formatter(
'%(asctime)s {}: %(levelname)s: (%(name)s) %(message)s'.format(
name)))
rootlogger.addHandler(logfile)
else:
syslog = SysLogHandler('/dev/log')
syslog.setFormatter(
logging.Formatter(
'{}: %(levelname)s: (%(name)s) %(message)s'.format(name)))
rootlogger.addHandler(syslog)
# Duplicate syslog's file descriptor to stout/stderr.
syslog_fd = syslog.socket.fileno()
os.dup2(syslog_fd, 1)
os.dup2(syslog_fd, 2)
def log_setup():
log_handler = WatchedFileHandler(LOG_FILE)
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
log_handler.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(log_handler)
logger.setLevel(logging.INFO)
def add_file_handler(self, log_file):
ch = WatchedFileHandler(log_file)
ch.setLevel(self.logger.level)
formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - %(message)s', "%Y-%m-%d %H:%M:%S")
ch.setFormatter(formatter)
self.logger.addHandler(ch)
def setup_logfile_logger(log_path,
log_level=None,
log_format=None,
date_format=None):
"""
Set up logging to a file.
"""
# Create the handler
handler = WatchedFileHandler(log_path, mode='a', encoding='utf-8', delay=0)
if log_level:
# Grab and set the level
level = LOG_LEVELS.get(log_level.lower(), logging.ERROR)
handler.setLevel(level)
# Set the default console formatter config
if not log_format:
log_format = '%(asctime)s [%(name)s][%(levelname)s] %(message)s'
if not date_format:
date_format = '%Y-%m-%d %H:%M:%S'
formatter = logging.Formatter(log_format, datefmt=date_format)
handler.setFormatter(formatter)
root_logger.addHandler(handler)
return handler
def __prepare_logger(self):
self.logger = logging.getLogger('app')
self.logger.propagate = False
log_level = self.config.log.get("LOG_LEVEL") or self.DEFAULT_LOG_LEVEL
log_level = log_level.upper()
log_level = getattr(logging, log_level)
if "LOG_FILE" in self.config.log:
from logging.handlers import WatchedFileHandler
handler = WatchedFileHandler(self.config.log["LOG_FILE"])
self.logger.addHandler(handler)
if self.config.log.get("DEBUG"):
handler = logging.StreamHandler(stream=sys.stdout)
log_level = logging.DEBUG
self.logger.addHandler(handler)
log_format = self.config.log.get(
"LOG_FORMAT") or self.DEFAULT_LOG_FORMAT
log_format = logging.Formatter(log_format)
self.logger.setLevel(log_level)
for handler in self.logger.handlers:
handler.setLevel(log_level)
handler.setFormatter(log_format)
self.logger.info("Logger created. Environment type set to %s" %
self.envtype)
def __init__(self, filename, tz=timezone.utc):
self.loghandler = WatchedFileHandler(filename,
encoding='utf-8',
delay=True)
self.loghandler.setLevel(logging.INFO)
self.loghandler.setFormatter(logging.Formatter('%(message)s'))
self.tz = tz
def setup_logger(logger):
"""Setup the Flask app's logger
:param logger: Flask app's logger
"""
cfy_config = config.instance
# setting up the app logger with a watched file handler, in addition to
# the built-in flask logger which can be helpful in debug mode.
# log rotation is handled by logrotate.
additional_log_handlers = [
WatchedFileHandler(
filename=cfy_config.rest_service_log_path
)
]
_setup_python_logger(
logger=logger,
logger_level=cfy_config.rest_service_log_level,
handlers=additional_log_handlers,
remove_existing_handlers=False
)
# log all warnings passed to function
for w in cfy_config.warnings:
logger.warning(w)
def __init__(self, config_file, logger=None):
self.config_file = config_file
self.config = self._load_config(config_file)
logging.basicConfig(format=self.config['log_format'])
if logger:
self.log = logger
else:
self.log = logging.getLogger()
if self.config['log_file']:
fh = WatchedFileHandler(self.config['log_file'])
formatter = logging.Formatter(self.config['log_format'])
fh.setFormatter(formatter)
self.log.addHandler(fh)
self.log.setLevel(getattr(logging, self.config['log_level']))
self.log.info('Loaded config')
self.log.debug('Config: %s', self.config)
self.end_event = threading.Event()
self.reload_event = threading.Event()
self.__setup_signal_handlers()
self.pin_state = False
self._setup_pins()
self.log.info('FanDriverDaemon inited')
async def init_app():
# Setup logger
if DEBUG_MODE:
print("debug mode")
logging.basicConfig(level=logging.DEBUG)
else:
root = logging.getLogger('aiohttp.server')
logging.basicConfig(level=logging.WARN)
handler = WatchedFileHandler(LOG_FILE)
formatter = logging.Formatter("%(asctime)s;%(levelname)s;%(message)s", "%Y-%m-%d %H:%M:%S %z")
handler.setFormatter(formatter)
root.addHandler(handler)
root.addHandler(TimedRotatingFileHandler(LOG_FILE, when="d", interval=1, backupCount=100))
app = web.Application()
# Global vars
app['clients'] = {} # Keep track of connected clients
app['limit'] = {} # Limit messages based on IP
app['active_messages'] = set() # Avoid duplicate messages from being processes simultaneously
app['subscriptions'] = {} # Store subscription UUIDs, this is used for targeting callback accounts
app.add_routes([web.get('/', websocket_handler)]) # All WS requests
app.add_routes([web.post(f'/callback/{CALLBACK_TOKEN}', callback_handler)]) # http/https callback from node
return app
def _initLogging(self):
logging.basicConfig()
logger = logging.getLogger()
if self.interactive:
logger.setLevel(logging.DEBUG)
else:
logger.removeHandler(
logger.handlers[0]) # get rid of the default one
if self.error_log:
handler = WatchedFileHandler(
filename=self.error_log
) # something that can handle logrotate
handler.setFormatter(
logging.Formatter(
fmt=
'\n\n%(asctime)s pid:%(process)d thread: %(thread)d\n%(module)s - %(lineno)d\n%(message)s'
))
handler.setLevel(logging.ERROR)
logger.addHandler(handler)
handler = SysLogHandler(address='/dev/log',
facility=SysLogHandler.LOG_DAEMON)
handler.setFormatter(
logging.Formatter(fmt=self.proc_name +
'[%(process)d]: %(message)s'))
logger.addHandler(handler)
logger.setLevel(logging.INFO)
def setupLogging(stream=None, path=None, level=None, format=None):
"""Setup logging.
Either a stream or a path can be provided. When a path is provided a log
handler that works correctly with C{logrotate} is used. Generally
speaking, C{stream} should only be used for non-file streams that don't
need log rotation.
@param name: The name of the logger to setup.
@param stream: The stream to write output to.
@param path: The path to write output to.
@param level: Optionally, the log level to set on the logger. Default is
C{logging.INFO}.
@param format: A format string for the logger.
@raise RuntimeError: Raised if neither C{stream} nor C{path} are provided,
or if both are provided.
@return: The configured logger, ready to use.
"""
if (not stream and not path) or (stream and path):
raise RuntimeError('A stream or path must be provided.')
if stream:
handler = StreamHandler(stream)
else:
handler = WatchedFileHandler(path)
if format is None:
format = '%(asctime)s %(levelname)8s %(message)s'
formatter = Formatter(format)
handler.setFormatter(formatter)
log = getLogger()
log.addHandler(handler)
log.propagate = False
log.setLevel(level or INFO)
return log
def set_logger():
if logger.hasHandlers():
return
logger.setLevel(logging.DEBUG)
formatter = CustomFormatter(
'[%(levelname)s %(asctime)s] %(message)s',
datefmt='%Y-%m-%d %H:%M:%S.%f'
)
file_handler = WatchedFileHandler('logs/output.log', encoding='utf8')
file_handler.setFormatter(formatter)
file_handler.setLevel(logging.DEBUG)
logger.addHandler(file_handler)
logger.info('Added logging handler: ' + str(file_handler))
console_handler = StreamHandler()
console_handler.setFormatter(formatter)
console_handler.setLevel(logging.DEBUG)
logger.addHandler(console_handler)
logger.info('Added logging handler: ' + str(console_handler))
logger.info('Set new logger up.')
return
def create_app(config_file='settings.py'):
app = Flask(__name__)
jwt = JWT(app, authenticate, identity) # Auto Creates /auth endpoint
app.config.from_pyfile(config_file)
api = Api(app)
db.init_app(app)
app.cli.add_command(create_tables) # To interact with app from CLI
api.add_resource(UserRegister, '/users/register')
api.add_resource(UserList, '/users')
api.add_resource(User, '/users/<int:user_id>')
api.add_resource(CreatePost, '/posts/create')
# Logging
log_level = logging.INFO if app.config['DEBUG'] else logging.ERROR
handler = WatchedFileHandler('server.log')
formatter = logging.Formatter('%(asctime)s | %(levelname)s: %(message)s',
'%d-%m-%Y %H:%M:%S')
handler.setFormatter(formatter)
root = logging.getLogger()
root.setLevel(log_level)
root.addHandler(handler)
logging.info('\n------------------- Starting Server -------------------')
return app
def get_handler(debug=False,
syslog=False,
logfile=None,
rotation_parameters=None):
"""get an apropriate handler according to given parameters"""
if os.environ.get('APYCOT_ROOT'):
handler = logging.StreamHandler(sys.stdout)
if debug:
handler = logging.StreamHandler()
elif logfile is None:
if syslog:
from logging import handlers
handler = handlers.SysLogHandler()
else:
handler = logging.StreamHandler()
else:
try:
if rotation_parameters is None:
if os.name == 'posix' and sys.version_info >= (2, 6):
from logging.handlers import WatchedFileHandler
handler = WatchedFileHandler(logfile)
else:
handler = logging.FileHandler(logfile)
else:
from logging.handlers import TimedRotatingFileHandler
handler = TimedRotatingFileHandler(logfile,
**rotation_parameters)
except IOError:
handler = logging.StreamHandler()
return handler
def setup_logging(console_level, log_file=None):
'''
Log to stderr with given console level (0: warnings, 1: info, 2+: debug).
Log to log file if path given.
'''
from logging import DEBUG, INFO, WARNING, Formatter
from logging.handlers import WatchedFileHandler
logging.getLogger().setLevel(DEBUG)
if console_level < 3:
# TODO: filter in a handler instead in logger
logging.getLogger('botocore').setLevel(INFO)
h = logging.StreamHandler()
h.setFormatter(Formatter(log_format))
if console_level == 0:
h.setLevel(WARNING)
elif console_level == 1:
h.setLevel(INFO)
else:
h.setLevel(DEBUG)
logging.getLogger().addHandler(h)
if log_file:
h = WatchedFileHandler(str(log_file))
h.setFormatter(Formatter(log_format))
h.setLevel(DEBUG)
logging.getLogger().addHandler(h)
def setup_log_file(log_file_path):
from logging import DEBUG, getLogger, Formatter
from logging.handlers import WatchedFileHandler
h = WatchedFileHandler(str(log_file_path))
h.setFormatter(Formatter(log_format))
h.setLevel(DEBUG)
getLogger('').addHandler(h)
def main(args):
logger = logging.getLogger("localftp")
logger.setLevel(args.log_level)
formatter = logging.Formatter(
"%(asctime)s %(levelname)-7s %(name)s|%(message)s")
ch = logging.StreamHandler()
if args.log_path is None:
ch.setLevel(args.log_level)
else:
fh = WatchedFileHandler(args.log_path)
fh.setLevel(args.log_level)
fh.setFormatter(formatter)
logger.addHandler(fh)
ch.setLevel(logging.WARNING)
ch.setFormatter(formatter)
logger.addHandler(ch)
logger.setLevel(args.log_level)
logger.addHandler(ch)
work_dir = args.work if args.work and os.path.isdir(
args.work) else tempfile.mkdtemp()
return serve(work_dir, "testuser", "password", "127.0.0.1", args.port)
def init_app(app):
"""Initialize application logger"""
# Use default config in DEBUG mode, configure logger otherwise
if not app.debug and app.config['LOGGER_ENABLED']:
log_level = app.config['LOGGER_LEVEL']
log_dir = Path(app.config['LOGGER_DIR'])
log_format = app.config['LOGGER_FORMAT']
# Remove Flask default handler
app.logger.removeHandler(default_handler)
# Use WatchedFileHandler to reopen if logrotate rotates the log file
file_handler = WatchedFileHandler(log_dir / 'pyodhean.log')
# Create record formatter
formatter = RequestFormatter(log_format)
formatter.converter = time.gmtime
file_handler.setFormatter(formatter)
# Add our custom handler
app.logger.addHandler(file_handler)
# Set logging level
app.logger.setLevel(log_level)
def __init__(self, filename=None, directory=None,
file_suffix=".log", formatter=DEFAULT_FORMAT,
level=None):
programe_name = get_program_name()
file_path = get_log_file_path(filename, directory, programe_name, file_suffix)
handler = WatchedFileHandler(file_path)
super(File, self).__init__(handler, level, formatter)
def init_server(level, sentry_dsn, release, logfile, with_gr_name=True):
patch_gevent_hub_print_exception()
root = logging.getLogger()
root.setLevel(level)
fmter = ServerLogFormatter(with_gr_name=with_gr_name)
std = logging.StreamHandler(stream=sys.stdout)
std.setFormatter(fmter)
root.addHandler(std)
hdlr = SentryHandler(
raven.Client(sentry_dsn,
transport=GeventedHTTPTransport,
release=release))
hdlr.setLevel(logging.ERROR)
root.addHandler(hdlr)
logging.getLogger('sentry.errors').setLevel(1000)
if logfile:
from logging.handlers import WatchedFileHandler
filehdlr = WatchedFileHandler(logfile)
filehdlr.setFormatter(fmter)
root.addHandler(filehdlr)
def _file_handler(logger_name: str, formatter: logging.Formatter,
log_path: str):
os.makedirs(log_path, exist_ok=True)
path = f"{log_path}{snakecase(logger_name.replace('.', 'x'))}.log"
file_handler = WatchedFileHandler(path)
file_handler.setFormatter(formatter)
return file_handler
def _detect_handler(self, logfile=None):
"""Create log handler with either a filename, an open stream
or :const:`None` (stderr)."""
logfile = sys.__stderr__ if logfile is None else logfile
if hasattr(logfile, 'write'):
return logging.StreamHandler(logfile)
return WatchedFileHandler(logfile)
def _setup_logger(self, level, log_file):
"""Setup log level and log file if set"""
if not level:
return
if logger.handlers:
return
if hasattr(logging, 'NullHandler'):
logger.addHandler(logging.NullHandler())
formatter = logging.Formatter(
'[%(levelname)s] %(asctime)s - %(module)s.%(funcName)s() '
'- %(message)s')
level = getattr(logging, level.upper())
logger.setLevel(level)
handler = logging.StreamHandler()
logger.addHandler(handler)
handler.setFormatter(formatter)
if not log_file:
return
try:
_handler = WatchedFileHandler(log_file)
except IOError:
logger.error("Could not write to %s, falling back to stdout",
log_file)
else:
logger.addHandler(_handler)
_handler.setFormatter(formatter)
