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)
