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_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 __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)