X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fpython-systemd%2Fjournal.py;h=9e40cbc57e9384f7710dee0b68b66a174615633e;hp=146f59f220e1d14a072b1d513000ada835972c43;hb=d2bbca6855b174fb7ea90b4767a886bb88bd2400;hpb=614e5fbb8ba192526990a840eef382d0ee94b22d diff --git a/src/python-systemd/journal.py b/src/python-systemd/journal.py index 146f59f22..9e40cbc57 100644 --- a/src/python-systemd/journal.py +++ b/src/python-systemd/journal.py @@ -23,18 +23,18 @@ from __future__ import division import sys as _sys import datetime as _datetime -import functools as _functools import uuid as _uuid import traceback as _traceback import os as _os import logging as _logging -if _sys.version_info >= (3,): +if _sys.version_info >= (3,3): from collections import ChainMap as _ChainMap from syslog import (LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR, LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG) from ._journal import sendv, stream_fd from ._reader import (_Reader, NOP, APPEND, INVALIDATE, - LOCAL_ONLY, RUNTIME_ONLY, SYSTEM_ONLY) + LOCAL_ONLY, RUNTIME_ONLY, SYSTEM_ONLY, + _get_catalog) from . import id128 as _id128 if _sys.version_info >= (3,): @@ -50,10 +50,10 @@ def _convert_source_monotonic(s): return _datetime.timedelta(microseconds=int(s)) def _convert_realtime(t): - return _datetime.datetime.fromtimestamp(t / 1E6) + return _datetime.datetime.fromtimestamp(t / 1000000) def _convert_timestamp(s): - return _datetime.datetime.fromtimestamp(int(s) / 1E6) + return _datetime.datetime.fromtimestamp(int(s) / 1000000) if _sys.version_info >= (3,): def _convert_uuid(s): @@ -96,6 +96,11 @@ DEFAULT_CONVERTERS = { 'COREDUMP_TIMESTAMP': _convert_timestamp, } +_IDENT_LETTER = set('ABCDEFGHIJKLMNOPQRTSUVWXYZ_') + +def _valid_field_name(s): + return not (set(s) - _IDENT_LETTER) + class Reader(_Reader): """Reader allows the access and filtering of systemd journal entries. Note that in order to access the system journal, a @@ -136,6 +141,9 @@ class Reader(_Reader): the conversion fails with a ValueError, unconverted bytes object will be returned. (Note that ValueEror is a superclass of UnicodeDecodeError). + + Reader implements the context manager protocol: the journal + will be closed when exiting the block. """ super(Reader, self).__init__(flags, path) if _sys.version_info >= (3,3): @@ -173,6 +181,25 @@ class Reader(_Reader): result[key] = self._convert_field(key, value) return result + def __iter__(self): + """Part of iterator protocol. + Returns self. + """ + return self + + if _sys.version_info >= (3,): + def __next__(self): + """Part of iterator protocol. + Returns self.get_next(). + """ + return self.get_next() + else: + def next(self): + """Part of iterator protocol. + Returns self.get_next(). + """ + return self.get_next() + def add_match(self, *args, **kwargs): """Add one or more matches to the filter journal log entries. All matches of different field are combined in a logical AND, @@ -187,15 +214,35 @@ class Reader(_Reader): super(Reader, self).add_match(arg) def get_next(self, skip=1): - """Return the next log entry as a dictionary of fields. + """Return the next log entry as a mapping type, currently + a standard dictionary of fields. Optional skip value will return the `skip`\-th log entry. Entries will be processed with converters specified during Reader creation. """ - return self._convert_entry( - super(Reader, self).get_next(skip)) + if super(Reader, self)._next(skip): + entry = super(Reader, self)._get_all() + if entry: + entry['__REALTIME_TIMESTAMP'] = self._get_realtime() + entry['__MONOTONIC_TIMESTAMP'] = self._get_monotonic() + entry['__CURSOR'] = self._get_cursor() + return self._convert_entry(entry) + return dict() + + def get_previous(self, skip=1): + """Return the previous log entry as a mapping type, + currently a standard dictionary of fields. + + Optional skip value will return the -`skip`\-th log entry. + + Entries will be processed with converters specified during + Reader creation. + + Equivalent to get_next(-skip). + """ + return self.get_next(-skip) def query_unique(self, field): """Return unique values appearing in the journal for given `field`. @@ -208,6 +255,17 @@ class Reader(_Reader): return set(self._convert_field(field, value) for value in super(Reader, self).query_unique(field)) + def wait(self, timeout=None): + """Wait for a change in the journal. `timeout` is the maximum + time in seconds to wait, or None, to wait forever. + + Returns one of NOP (no change), APPEND (new entries have been + added to the end of the journal), or INVALIDATE (journal files + have been added or removed). + """ + us = -1 if timeout is None else int(timeout * 1000000) + return super(Reader, self).wait(us) + def seek_realtime(self, realtime): """Seek to a matching journal entry nearest to `realtime` time. @@ -215,8 +273,8 @@ class Reader(_Reader): or datetime.datetime instance. """ if isinstance(realtime, _datetime.datetime): - realtime = float(realtime.strftime("%s.%f")) - return super(Reader, self).seek_realtime(realtime) + realtime = float(realtime.strftime("%s.%f")) * 1000000 + return super(Reader, self).seek_realtime(int(realtime)) def seek_monotonic(self, monotonic, bootid=None): """Seek to a matching journal entry nearest to `monotonic` time. @@ -228,6 +286,7 @@ class Reader(_Reader): """ if isinstance(monotonic, _datetime.timedelta): monotonic = monotonic.totalseconds() + monotonic = int(monotonic * 1000000) if isinstance(bootid, _uuid.UUID): bootid = bootid.get_hex() return super(Reader, self).seek_monotonic(monotonic, bootid) @@ -280,6 +339,11 @@ class Reader(_Reader): self.add_match(_MACHINE_ID=machineid) +def get_catalog(mid): + if isinstance(mid, _uuid.UUID): + mid = mid.get_hex() + return _get_catalog(mid) + def _make_line(field, value): if isinstance(value, bytes): return field.encode('utf-8') + b'=' + value @@ -391,12 +455,6 @@ class JournalHandler(_logging.Handler): >>> log.setLevel(logging.DEBUG) - To attach journal MESSAGE_ID, an extra field is supported: - - >>> import uuid - >>> mid = uuid.UUID('0123456789ABCDEF0123456789ABCDEF') - >>> log.warn("Message with ID", extra={'MESSAGE_ID': mid}) - To redirect all logging messages to journal regardless of where they come from, attach it to the root logger: @@ -407,12 +465,36 @@ class JournalHandler(_logging.Handler): handler class. Only standard handler configuration options are supported: `level`, `formatter`, `filters`. + To attach journal MESSAGE_ID, an extra field is supported: + + >>> import uuid + >>> mid = uuid.UUID('0123456789ABCDEF0123456789ABCDEF') + >>> log.warn("Message with ID", extra={'MESSAGE_ID': mid}) + + Fields to be attached to all messages sent through this + handler can be specified as keyword arguments. This probably + makes sense only for SYSLOG_IDENTIFIER and similar fields + which are constant for the whole program: + + >>> journal.JournalHandler(SYSLOG_IDENTIFIER='my-cool-app') + The following journal fields will be sent: `MESSAGE`, `PRIORITY`, `THREAD_NAME`, `CODE_FILE`, `CODE_LINE`, `CODE_FUNC`, `LOGGER` (name as supplied to getLogger call), - `MESSAGE_ID` (optional, see above). + `MESSAGE_ID` (optional, see above), `SYSLOG_IDENTIFIER` (defaults + to sys.argv[0]). """ + def __init__(self, level=_logging.NOTSET, **kwargs): + super(JournalHandler, self).__init__(level) + + for name in kwargs: + if not _valid_field_name(name): + raise ValueError('Invalid field name: ' + name) + if 'SYSLOG_IDENTIFIER' not in kwargs: + kwargs['SYSLOG_IDENTIFIER'] = _sys.argv[0] + self._extra = kwargs + def emit(self, record): """Write record as journal event. @@ -433,7 +515,8 @@ class JournalHandler(_logging.Handler): THREAD_NAME=record.threadName, CODE_FILE=record.pathname, CODE_LINE=record.lineno, - CODE_FUNC=record.funcName) + CODE_FUNC=record.funcName, + **self._extra) except Exception: self.handleError(record)