def _configure_syslog(
logger_name: str,
use_json_formatter: bool = True,
formatter: 'Optional[Formatter]' = None) -> 'List[Handler]':
try:
syslog_handler = SysLogHandler(
address=(options.syslog_host, options.syslog_port),
facility=SysLogHandler.facility_names[options.syslog_facility],
socktype=socket.SOCK_DGRAM)
log_extension = '.slog' if use_json_formatter else '.log'
syslog_handler.ident = f'{logger_name}{log_extension}: '
if formatter is not None:
syslog_handler.setFormatter(formatter)
elif use_json_formatter:
syslog_handler.setFormatter(_JSON_FORMATTER)
else:
syslog_handler.setFormatter(get_text_formatter())
syslog_handler.addFilter(_CONTEXT_FILTER)
return [syslog_handler]
except socket.error:
logging.getLogger('frontik.logging').exception(
'cannot initialize syslog')
return []
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 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 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 remote(secondary=False):
settings = configs["cirta"]["settings"]
facilityCode = getattr(SysLogHandler, "LOG_%s" % settings["SYSLOG_FACILITY"].upper())
if settings["SYSLOG_PROTOCOL"].lower() == "tcp":
sock = socket.SOCK_STREAM
elif settings["SYSLOG_PROTOCOL"].lower() == "udp":
sock = socket.SOCK_DGRAM
else:
log.error("Unsupported syslog protocol configuration: %s" % settings["SYSLOG_PROTOCOL"])
log.debug('msg="Usupported syslog protocol configuration" protocol="%s"' % settings["SYSLOG_PROTOCOL"])
exit()
try:
if secondary:
sysHandler = SysLogHandler(
address=(settings["SYSLOG_SECONDARY_SERVER"], int(settings["SYSLOG_PORT"])),
facility=facilityCode,
socktype=socket.SOCK_STREAM,
)
else:
sysHandler = SysLogHandler(
address=(settings["SYSLOG_SERVER"], int(settings["SYSLOG_PORT"])),
facility=facilityCode,
socktype=socket.SOCK_STREAM,
)
sysHandler.addFilter(MultilineFilter())
return sysHandler
except:
return None
def bootstrap_logger(logger_info, logger_level, use_json_formatter=True, formatter=None):
if isinstance(logger_info, tuple):
logger, logger_name = logger_info
else:
logger, logger_name = logging.getLogger(logger_info), logger_info
handlers = []
if options.log_dir:
file_handler = logging.handlers.WatchedFileHandler(os.path.join(options.log_dir, f'{logger_name}.log'))
if use_json_formatter:
file_handler.setFormatter(_JSON_FORMATTER)
elif formatter is not None:
file_handler.setFormatter(formatter)
else:
file_handler.setFormatter(get_text_formatter())
file_handler.addFilter(_CONTEXT_FILTER)
handlers.append(file_handler)
if options.stderr_log:
stderr_handler = logging.StreamHandler()
if formatter is not None:
stderr_handler.setFormatter(formatter)
else:
stderr_handler.setFormatter(get_stderr_formatter())
stderr_handler.addFilter(_CONTEXT_FILTER)
handlers.append(stderr_handler)
if options.syslog:
try:
syslog_handler = SysLogHandler(
address=(options.syslog_host, options.syslog_port),
facility=SysLogHandler.facility_names[options.syslog_facility],
socktype=socket.SOCK_DGRAM
)
syslog_handler.ident = f'{logger_name}: '
if use_json_formatter:
syslog_handler.setFormatter(_JSON_FORMATTER)
elif formatter is not None:
syslog_handler.setFormatter(formatter)
else:
syslog_handler.setFormatter(get_text_formatter())
syslog_handler.addFilter(_CONTEXT_FILTER)
handlers.append(syslog_handler)
except socket.error:
logging.getLogger('frontik.logging').exception('cannot initialize syslog')
for handler in handlers:
handler.setLevel(logger_level)
logger.addHandler(handler)
logger.addHandler(GlobalLogHandler())
logger.propagate = False
return logger
def init(daemon=False,
logger_file='',
name_dict={},
module_dict={},
module_name='',
handler_class=LogFileHandler):
"""
The common logger helper
:param daemon: True: logging to file, False: logging to console
:param logger_file: File path, required when dameon=True
:param name_dict: name level dict, eg: {'app': logging.INFO}
:param module_dict: module level dict, egg: {app.logger: logging.INFO}
:param module_name: name of module, eg: 'OPENSTACK-AGENT'
:param handler_class: object of class of logging.handler
"""
if daemon:
log_handler = handler_class(logger_file,
when='midnight',
backupCount=365)
else:
log_handler = logging.StreamHandler()
log_formatter = logging.Formatter('%(asctime)s T%(thread)d-%(threadName)s '
'%(levelname)s %(module)s.'
'%(funcName)s.%(lineno)s: %(message)s')
log_handler.setFormatter(log_formatter)
if module_name:
syslog_handler = SysLogHandler(address='/usr/local/services/log',
facility=SysLogHandler.LOG_LOCAL3)
syslog_formatter = logging.Formatter(module_name +
'/%(module)s: %(message)s')
syslog_handler.setFormatter(syslog_formatter)
syslog_filter = logging.Filter()
syslog_filter.filter = lambda record: \
record.levelno == logging.WARNING or \
record.levelno == logging.ERROR
syslog_handler.addFilter(syslog_filter)
_default_name_level = {
__name__: logging.DEBUG,
"__main__": logging.DEBUG,
}
_name_dict = dict()
_name_dict.update(_default_name_level)
_name_dict.update(name_dict)
for name, level in _name_dict.items():
logger = logging.getLogger(name)
logger.setLevel(level)
logger.addHandler(log_handler)
if module_name:
logger.addHandler(syslog_handler)
for module_logger, level in module_dict.items():
module_logger.setLevel(level)
module_logger.addHandler(log_handler)
if module_name:
logger.addHandler(syslog_handler)
def setSyslogHandler():
"""Add a sysloghandler to the root logger with contextinjecting and module level filters"""
root = logging.getLogger()
h = SysLogHandler(address=b"/dev/log", facility=b"local0")
h.setFormatter(AmcatFormatter())
h.addFilter(ContextInjectingFilter())
h.addFilter(ModuleLevelFilter())
root.addHandler(h)
def setSyslogHandler():
"""Add a sysloghandler to the root logger with contextinjecting and module level filters"""
root = logging.getLogger()
h = SysLogHandler(address=b"/dev/log", facility=b"local0")
h.setFormatter(AmcatFormatter())
h.addFilter(ContextInjectingFilter())
h.addFilter(ModuleLevelFilter())
root.addHandler(h)
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 send_alert(hostname, ip):
print("SEND Syslog for " + hostname + "@" + ip + " to " + SYSLOG_SERVER +
":" + str(SYSLOG_PORT))
#syslogger = logging.getLogger('SyslogLogger')
syslog = SysLogHandler(address=(SYSLOG_SERVER, SYSLOG_PORT))
syslog.addFilter(ContextFilter())
format = '%(message)s'
formatter = logging.Formatter(format, datefmt='%b %d %H:%M:%S')
syslog.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(syslog)
logger.setLevel(logging.INFO)
message = "New Beacon,https://" + hostname + "," + ip + ","
logger.info(message)
def setup_papertrail_handler(papertrail_cfg):
import socket
from logging.handlers import SysLogHandler
class ContextFilter(logging.Filter):
hostname = socket.gethostname()
application_name = os.path.splitext(os.path.basename(sys.argv[0]))[0]
def filter(self, record):
record.hostname = ContextFilter.hostname
record.application_name = ContextFilter.application_name
return True
syslog = SysLogHandler(address=(papertrail_cfg["PAPERTRAIL_HOST"], papertrail_cfg["PAPERTRAIL_PORT"]))
syslog.addFilter(ContextFilter())
syslog.setFormatter(logging.Formatter('%(asctime)s - %(hostname)s - %(application_name)s - %(funcName)s - %(levelname)s - %(message)s', datefmt='%b %d %H:%M:%S'))
print(f'Log papertrail: {papertrail_cfg["PAPERTRAIL_HOST"]}:{papertrail_cfg["PAPERTRAIL_PORT"]}')
return syslog
def send_wr_log(log_message):
if LOG_SERVER:
syslogger = logging.getLogger('SyslogLogger')
syslogger.setLevel(logging.INFO)
log_handler = SysLogHandler(address=(LOG_SERVER, 514))
log_handler.addFilter(ContextFilter())
msg_format = '%(asctime)s %(hostname)s %(message)s'
formatter = logging.Formatter(msg_format, datefmt='%b %d %H:%M:%S')
log_handler.setFormatter(formatter)
syslogger.addHandler(log_handler)
syslogger.info(log_message)
# write to a log file
log_date = strftime(DATE_FORMAT, gmtime())
log_line = "{} - {}".format(log_date, log_message)
log_filename = "{}{}".format(LOG_DIR, strftime(NAME_FORMAT, gmtime()))
os.makedirs(os.path.dirname(log_filename), exist_ok=True)
with open(log_filename, "a") as f:
f.write("\n" + log_line)
def __init__(self):
BoxLog.setup()
if not BoxLog.logger:
config_file = BoxLog.getfile()
config = yaml.safe_load(open(config_file, 'r'))
syslog = SysLogHandler(address=(config['hostname'], config['port']))
syslog.addFilter(ContextFilter())
log_format = '%(asctime)s %(hostname)s Boxable: %(message)s'
formatter = logging.Formatter(log_format, datefmt='%b %d %H:%M:%S')
syslog.setFormatter(formatter)
self.logger = logging.getLogger()
self.logger.addHandler(syslog)
self.logger.setLevel(logging.INFO)
BoxLog.logger = self.logger
else:
self.logger = BoxLog.logger
def get_papertrail_stream_logger():
class ContextFilter(logging.Filter):
hostname = socket.gethostname()
def filter(self, record):
record.hostname = ContextFilter.hostname
return True
syslog = SysLogHandler(address=(cfg['external_logging.papertrail.url'],
cfg['external_logging.papertrail.port']))
syslog.addFilter(ContextFilter())
title = cfg['app'].get("title", basedir.split("/")[-1])
format = f'%(asctime)s %(hostname)s {title}: %(message)s'
formatter = logging.Formatter(format, datefmt='%b %d %H:%M:%S')
syslog.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(syslog)
logger.setLevel(logging.INFO)
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)
app.logger.info("Logger started")
def __init__(self, host, port, facility, logdevice, logsocket):
logger = logging.getLogger()
app_filter = AppFilter()
log_format = AppFilter().logformat()
formatter = logging.Formatter(log_format)
if str(logsocket).lower() == 'udp':
handler = SysLogHandler(address=(host, port),
facility=getattr(
SysLogHandler,
'LOG_' + str(facility).upper()),
socktype=socket.SOCK_DGRAM)
elif str(logsocket).lower() == 'dev':
handler = SysLogHandler(logdevice)
handler.addFilter(app_filter)
handler.setFormatter(formatter)
logger.addHandler(handler)
from logging.handlers import SysLogHandler
LOG_PATH = 'src/base/logs/log.txt'
truckID = -1
truckID = config.get_truck_id()
# papertrail logging start
class ContextFilter(logging.Filter):
hostname = socket.gethostname()
def filter(self, record):
record.hostname = ContextFilter.hostname
return True
syslog = SysLogHandler(address=('logs2.papertrailapp.com', ##papertrailID))
syslog.addFilter(ContextFilter())
format = '%(asctime)s %(hostname)s TRUCK{truckID}: %(message)s'.format(truckID=truckID)
formatter = logging.Formatter(format, datefmt='%b %d %H:%M:%S')
syslog.setFormatter(formatter)
logger_pt = logging.getLogger()
logger_pt.addHandler(syslog)
logger_pt.setLevel(logging.INFO)
# papertrail logging end
def log_start():
try:
logger_pt.info('---LOG START---')
if not os.path.exists(LOG_PATH):
img_datas = ""
GPIO_BUTTON_INIT = 23
GPIO_BUTTON_CAPTUER = 24
class ContextFilter(logging.Filter):
hostname = socket.gethostname()
def filter(self, record):
record.hostname = ContextFilter.hostname
return True
syslog = SysLogHandler(address=('ubuntu.local', 514))
syslog.addFilter(ContextFilter())
format = '%(asctime)s %(hostname)s CameraAddjust: %(message)s'
formatter = logging.Formatter(format, datefmt='%b %d %H:%M:%S')
syslog.setFormatter(formatter)
logger = logging.getLogger()
logger.addHandler(syslog)
logger.setLevel(logging.INFO)
logger.info("Start App")
def get_command(device):
rx_buffer = ""
timeout = time.time()
args = parser.parse_args()
if not args.verbose:
args.verbose = 0
# 日志初始化
log_format = u'%(asctime)s %(levelname)s %(message)s'
if args.quiet:
logging.basicConfig(level=logging.WARNING, format=log_format)
elif args.verbose >= VERBOSE_HTTP:
logging.basicConfig(level=logging.DEBUG, format=log_format)
else:
logging.basicConfig(level=logging.INFO, format=log_format)
if hasattr(args, 'log_file') and args.log_file:
if args.log_file == 'SYSLOG':
syslog = SysLogHandler(address='/dev/log')
syslog.ident = '{}: '.format(PROG_NAME)
syslog.setLevel(logging.INFO)
syslog.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))
syslog.addFilter(SyslogFilter())
logger.addHandler(syslog)
else:
logfile = RotatingFileHandler(args.log_file, LOG_FILE_SIZE, LOG_FILE_BACKUP_COUNT, encoding='utf-8')
logger.addHandler(logfile)
main(**vars(args))
import logging
from logging.handlers import SysLogHandler
from logging import StreamHandler
import socket
import typing as t
class ContextFilter(logging.Filter):
hostname = socket.gethostname()
def filter(self, record):
record.hostname = ContextFilter.hostname
return True
log = logging.getLogger()
formatter = logging.Formatter("%(filename)s %(levelname)s - %(message)s")
handler: t.Union[SysLogHandler, StreamHandler]
try:
log_address = (os.environ["loghost"], int(os.environ["logport"]))
handler = SysLogHandler(address=log_address)
handler.addFilter(ContextFilter())
except KeyError:
handler = StreamHandler()
handler.setFormatter(formatter)
log.addHandler(handler)
log.setLevel(os.environ.get("loglevel", "INFO"))
LOG_DIR = "/project/logs/"
class ContextFilter(logging.Filter):
# hostname = socket.gethostname()
hostname = "vpn-otp-server"
def filter(self, record):
record.hostname = ContextFilter.hostname
return True
syslogger = logging.getLogger('SyslogLogger')
syslogger.setLevel(logging.INFO)
log_handler = SysLogHandler(address=(LOG_SERVER, 5044))
log_handler.addFilter(ContextFilter())
msg_format = '%(asctime)s %(hostname)s %(message)s'
formatter = logging.Formatter(msg_format, datefmt='%b %d %H:%M:%S')
log_handler.setFormatter(formatter)
syslogger.addHandler(log_handler)
def send_wr_log(log_message):
if LOG_SERVER:
syslogger.info(log_message)
# write to a log file
log_date = strftime(DATE_FORMAT, gmtime())
log_line = "{} - {}".format(log_date, log_message)
log_filename = "{}{}".format(LOG_DIR, strftime(NAME_FORMAT, gmtime()))
os.makedirs(os.path.dirname(log_filename), exist_ok=True)
