def source_cmd(server, token, monitor, log_to_journal, disk_cache_filename): if log_to_journal: try: from systemd import journal logger.handlers[0] = journal.JournaldLogHandler() except ImportError: logger.error( "Can't enable journal logger, systemd package not found!") src = BacnetSource(token=token, management_url=server, disk_cache_filename=disk_cache_filename) try: if monitor: with aiomonitor.start_monitor(src.event_loop, locals={"source": src}): src.run(cancel_on_exception=True) else: src.run(cancel_on_exception=True) except Exception as exception: logger.error( f"Source stopped by unhandled exception", exc_info=(exception.__class__, exception, exception.__traceback__), ) sys.exit(1)
def log_handlers(self): # Log formats if self.systemd: _jrnlfmt = logging.Formatter(fmt=('{levelname}: {message} ' + '({filename}:{lineno})'), style='{', datefmt='%Y-%m-%d %H:%M:%S') _logfmt = logging.Formatter(fmt=('{asctime}:{levelname}: {message} (' + '{filename}:{lineno})'), style='{', datefmt='%Y-%m-%d %H:%M:%S') # Add handlers _dflthandler = logging.handlers.RotatingFileHandler( self.logfile, encoding='utf8', # 1GB maxBytes=1073741824, backupCount=5) _dflthandler.setFormatter(_logfmt) _dflthandler.setLevel(self.loglvls[self.loglvl]) if self.systemd: from systemd import journal try: h = journal.JournaldLogHandler() except AttributeError: # Uses the other version h = journal.JournalHandler() h.setFormatter(_jrnlfmt) h.setLevel(self.loglvls[self.loglvl]) self.Logger.addHandler(h) self.Logger.addHandler(_dflthandler) self.Logger.info('Logging initialized') return ()
def initialize_logger(logger, debug, log_to_journal, log_to_file, filename=None): logger.setLevel(logging.INFO) if debug: logging.basicConfig(level=logging.DEBUG, format="%(asctime)s:%(levelname)s:%(message)s") logger.setLevel(logging.DEBUG) else: if log_to_journal: handler = journal.JournaldLogHandler() handler.setFormatter( logging.Formatter('%(levelname)s - %(message)s')) handler.setLevel(logging.WARNING) logger.addHandler(handler) if log_to_file: handler = handlers.RotatingFileHandler(filename, maxBytes=1048576, backupCount=2) handler.setFormatter( logging.Formatter('%(asctime)s:%(levelname)s:%(message)s')) logger.addHandler(handler) if not logger.hasHandlers(): logger.addHandler(logging.NullHandler())
def runserver_cmd( management_url, token, management_exchange, debug, log_to_journal, host, port, cors_origin, ): loop = asyncio.get_event_loop() if debug: logger.warn("Using loop debug - this is slow") loop.set_debug(True) if log_to_journal: try: from systemd import journal logger.handlers[0] = journal.JournaldLogHandler() except ImportError: logger.error( "Can't enable journal logger, systemd package not found!") app = create_app(loop, token, management_url, management_exchange, cors_origin) web.run_app(app, host=host, port=port)
def __init__(self, refresh_rate=600, width=240, height=240): self.get_stats_interval_sec = refresh_rate self.width = width self.height = height self.logger = logging.getLogger(__name__) self.logger.propagate = False self.logger.addHandler(journal.JournaldLogHandler()) self.logger.setLevel(logging.INFO) cs_pin = digitalio.DigitalInOut(board.CE0) dc_pin = digitalio.DigitalInOut(board.D25) reset_pin = None BAUDRATE = 64000000 self.display = st7789.ST7789(board.SPI(), cs=cs_pin, dc=dc_pin, rst=reset_pin, baudrate=BAUDRATE, width=width, height=height, y_offset=80, rotation=180) backlight = digitalio.DigitalInOut(board.D22) backlight.switch_to_output() backlight.value = True self.buttonA = digitalio.DigitalInOut(board.D23) self.buttonB = digitalio.DigitalInOut(board.D24) self.buttonA.switch_to_input() self.buttonB.switch_to_input() self._button_hold_time = 2.0 self.image = Image.new("RGB", (width, height)) self.draw = ImageDraw.Draw(self.image) self.draw.rectangle((0, 0, width, height), outline=0, fill=(0, 0, 0)) self.display.image(self.image) #, rotation) self.dejavu = ImageFont.truetype( "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 24) self.roboto = ImageFont.truetype( "/usr/share/fonts/truetype/roboto/unhinted/Roboto-Black.ttf", 24) self.blue = "#007bff" self.indigo = "#6610f2" self.purple = "#6f42c1" self.pink = "#e83e8c" self.red = "#dc3545" self.orange = "#fd7e14" self.yellow = "#ffc107" self.green = "#28a745" self.teal = "#20c997" self.cyan = "#17a2b8" self.gray = "#6c757d" self.gray_dark = "#343a40" self.stats = CovidStats() loop = asyncio.get_event_loop() loop.create_task(self.update_loop())
def _setup_logging(verbose: bool) -> None: level = logging.DEBUG if verbose else logging.INFO console = logging.StreamHandler(stream=sys.stderr) journald = journal.JournaldLogHandler(identifier='pcswrap') logging.basicConfig(level=level, handlers=[console, journald], format='%(asctime)s [%(levelname)s] %(message)s')
def __init__(self): # Enable logging logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO) self.logger = logging.getLogger(__name__) # Systemd journal handler self.logger.addHandler(journal.JournaldLogHandler()) # Initialize engine self.engine = engine.Engine() self.QUESTION, self.SELECTQUESTION, self.SUPPORTCONFIRM, self.SUPPORTSUBMIT, self.SUPPORT = range(5) # Create the Updater and pass it your bot's token. # Make sure to set use_context=True to use the new context based callbacks # Post version 12 this will no longer be necessary # Get the token here _pwd = os.path.dirname(os.path.abspath(__file__)) with open(os.path.join(_pwd, "../api.token"), 'r') as f: botToken = f.readlines()[0].strip() self.updater = Updater(botToken, use_context=True) # Get the dispatcher to register handlers self.dp = self.updater.dispatcher # Add conversation handler with states self.conv_handler = ConversationHandler( entry_points=[CommandHandler('start', self.start)], states={ self.QUESTION: [MessageHandler(Filters.text, self.question)], self.SELECTQUESTION: [MessageHandler(Filters.text, self.selectQuestion)], self.SUPPORTCONFIRM: [MessageHandler(Filters.regex('^(Yes|No)$'), self.supportConfirm), CommandHandler('skip', self.skip_support)], self.SUPPORTSUBMIT: [MessageHandler(Filters.text, self.supportSubmit)] }, fallbacks=[CommandHandler('support', self.support), CommandHandler('cancel', self.cancel), CommandHandler('help', self.help)] ) self.dp.add_handler(self.conv_handler) # log all errors self.dp.add_error_handler(self.error) # Start the Bot self.updater.start_polling() print("Ready") notify(Notification.READY) # Run the bot until you press Ctrl-C or the process receives SIGINT, # SIGTERM or SIGABRT. This should be used most of the time, since # start_polling() is non-blocking and will stop the bot gracefully. self.updater.idle() notify(Notification.STOPPING) print("Ended")
def add_journal_handler(logger): """ Add a log handler that logs to the Systemd journal. :type logger: sigma.core.mechanics.logger.Logger """ handler = journal.JournaldLogHandler(identifier='sigma') log_fmt = '[ {levelname:.1s} | {name:<25.25s} ]: {message:s}' logger.add_handler(handler, log_fmt)
def add_journal_handler(logger): """ Add a log handler that logs to the Systemd journal. :param logger: :return: """ handler = journal.JournaldLogHandler(identifier='sigma') log_fmt = '[ {levelname:.1s} | {name:<25.25s} ]: {message:s}' logger.add_handler(handler, log_fmt)
def myLogger(name): global loggers if loggers.get(name): return loggers.get(name) else: logger = logging.getLogger(name) logger.setLevel(logging.DEBUG) handler = journal.JournaldLogHandler() logger.addHandler(handler) loggers[name] = logger return logger
def main(argv): port = ' ' baud = ' ' logger_name = ' ' try: opts, args = getopt.getopt(argv, "p:b:n:") except getopt.GetoptError: print('log.py -p "TTY port" -b "baudrate" -n "logger name"\n') sys.exit(2) for opt, arg in opts: if opt == '-p': port = arg elif opt == '-b': baud = arg elif opt == '-n': logger_name = arg if port == ' ' or baud == ' ' or logger_name == ' ': print('log.py -p "TTY port" -b "baudrate" -n "logger name"\n') sys.exit(2) logging.basicConfig(level=logging.DEBUG) logger = logging.getLogger(logger_name) logger.addHandler(journal.JournaldLogHandler()) ser = serial.Serial() ser.baudrate = baud ser.port = port ser.timeout = 1 ser.open() lastLine = '' except_lines_left = 0 while True: try: line = ser.readline().decode() if line != '' and line != lastLine: lastLine = line if "reset" in line: except_lines_left = 25 if except_lines_left > 0: logger.error(line.rstrip()) except_lines_left -= 1 else: logger.info(line.rstrip()) except UnicodeDecodeError: logger.info("UnicodeDecodeError. ESP probably restarted")
def setup_logger(self): self.logger = getLogger(__name__) system_log_cf = self.config.items["system log"] if "log_level" in system_log_cf: self.logger.setLevel(system_log_cf["log_level"]) if not "handler" in system_log_cf\ or system_log_cf["handler"] in ["StreamHandler", ""]: self.logger.addHandler(StreamHandler(os.sys.stdout)) elif system_log_cf["handler"] == "JournaldLogHandler": from systemd import journal self.logger.addHandler(journal.JournaldLogHandler()) else: raise DontwiNotImplementedError return False
def log(self, value): """log: логирование результатов работы, может принимать значения: False - не вести лог system - записть в системный лог systemd stdout - вывод в стандартный поток или принимает имя файла для записи лога """ if __name__ == "__main__": journalName = os.path.basename(__file__) else: journalName = __name__ timeformat = "%Y.%m.%d-%H:%M:%S" self.__logger = logging.getLogger(journalName) self.__logger.setLevel(logging.INFO) if value == 'False': # Не вести лог handler = logging.NullHandler() formatter = logging.Formatter() elif value == 'journal': # Запись лога в системный журнал handler = journal.JournaldLogHandler(identifier=journalName) formatter = logging.Formatter('%(levelname)s: %(message)s') elif value == 'stdout': # Вывод лога в stdout handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter( '[%(asctime)s] %(name)s: %(levelname)s: %(message)s', timeformat, ) else: # Запись лога в файл handler = logging.FileHandler(value) formatter = logging.Formatter( '[%(asctime)s] %(name)s: %(levelname)s: %(message)s', timeformat, ) handler.setLevel(logging.INFO) handler.setFormatter(formatter) self.__logger.addHandler(handler)
def log(self, value): """log: логирование результатов работы """ journalName = 'minigstatistic' timeformat = "%Y.%m.%d-%H:%M:%S" self.__logger = logging.getLogger(journalName) self.__logger.setLevel(logging.INFO) if value == 'NO': # Не вести лог handler = logging.NullHandler() formatter = logging.Formatter() elif value == 'SY': # Запись лога в системный журнал handler = journal.JournaldLogHandler(identifier=journalName) formatter = logging.Formatter('%(levelname)s: %(message)s') elif value == 'ST': # Вывод лога в stdout handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter( '[%(asctime)s] %(name)s: %(levelname)s: %(message)s', timeformat, ) else: # Запись лога в файл handler = logging.FileHandler(value) formatter = logging.Formatter( '[%(asctime)s] %(name)s: %(levelname)s: %(message)s', timeformat, ) handler.setLevel(logging.INFO) handler.setFormatter(formatter) self.__logger.addHandler(handler)
logfile = os.path.abspath(os.path.expanduser(logfile)) os.makedirs(os.path.dirname(logfile), exist_ok=True, mode=0o0700) if not os.path.isfile(logfile): with open(logfile, 'w') as fh: fh.write('') os.chmod(logfile, 0o0600) # And set up logging. _cfg_args = {'handlers': [], 'level': logging.DEBUG} if _has_journald: # There were some weird changes somewhere along the line. try: # But it's *probably* this one. h = journal.JournalHandler() except AttributeError: h = journal.JournaldLogHandler() # Systemd includes times, so we don't need to. h.setFormatter( logging.Formatter(style='{', fmt=('{name}:{levelname}:{name}:{filename}:' '{funcName}:{lineno}: {message}'))) _cfg_args['handlers'].append(h) h = logging.handlers.RotatingFileHandler( logfile, encoding='utf8', # Disable rotating for now. # maxBytes = 50000000000, # backupCount = 30 ) h.setFormatter( logging.Formatter(style='{',
def __init__(self): self.logger = logging.getLogger('chestymetrics') self.logger.addHandler(journal.JournaldLogHandler()) self.logger.setLevel(logging.INFO)
debug = False GPIO.setwarnings(True) # Ignore warning for now GPIO.setmode(GPIO.BCM) # Use BCM pin numbering pinID = 16 cadence = args.cadence GPIO.setup(pinID, GPIO.OUT, initial=GPIO.HIGH) # i2c = busio.I2C(board.SCL, board.SDA) bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c, address = 0x77) logBuffer = [] lastUpload = datetime.datetime.now() uploadCadence = args.upload cpuTempPath = "/sys/class/thermal/thermal_zone0/temp" if args.service: log = logging.getLogger('logmeteo.service') log.addHandler(journal.JournaldLogHandler()) log.setLevel(logging.INFO) logLine = "Starting the logmeteo service with a cadence of %d seconds"%cadence log.info(logLine) try: logFile = open("/var/log/meteo.log", "at") except PermissionError: logFile = open("debug.log", "at") print("Not running as root, so can't write to /var/log. Creating a local 'debug.log' file.") debug = True print("Creating logBuffer") logBuffer = logBufferClass(debug=debug) print("Finished creating logBuffer") logBuffer.load()
def __init__(self, log_level='WARNING'): self.log = logging.getLogger('yas') self.log.addHandler(journal.JournaldLogHandler()) self.log.setLevel(logging._nameToLevel[log_level])
if __name__ == '__main__': parser = argparse.ArgumentParser( description='Notify by email when playlists change') parser.add_argument('--daemon', dest='daemon', action='store_const', const=True, default=False, help='Start as daemon and log to journald') parser.add_argument( '-s', '--sleep', dest='sleep', type=int, default=60 * 60, # 1 hour help=('How long to wait between checks.')) args = parser.parse_args() if args.daemon: from systemd import journal # type: ignore with daemon.DaemonContext(working_directory=LOCAL_PATH): logging.basicConfig(level=logging.INFO, handlers=[journal.JournaldLogHandler()]) logging.info('Starting as a daemon') main(args.sleep) else: logging.basicConfig(level=logging.INFO) main(args.sleep)
def add_journal_handler(logger): """Add a log handler that logs to the Systemd journal.""" handler = journal.JournaldLogHandler(identifier='sigma') log_fmt = '[%(name)-10s]: %(message)s' logger.add_handler(handler, log_fmt)