X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fpython-systemd%2Fjournal.py;h=892a56ff23730932bcfdbc16e7a5ad51cedc7b4c;hp=60c8111d239a49c17ce92f237cdcfb2a236dda44;hb=2c07646764384545e5303222729d5ff93dec4347;hpb=301ae164b7478ee1f153ddd529093dcf0e61933d diff --git a/src/python-systemd/journal.py b/src/python-systemd/journal.py index 60c8111d2..892a56ff2 100644 --- a/src/python-systemd/journal.py +++ b/src/python-systemd/journal.py @@ -19,14 +19,15 @@ # You should have received a copy of the GNU Lesser General Public License # along with systemd; If not, see . -import datetime -import functools -import sys -import uuid +import sys as _sys +import datetime as _datetime +import functools as _functools +import uuid as _uuid import traceback as _traceback import os as _os +from os import SEEK_SET, SEEK_CUR, SEEK_END import logging as _logging -if sys.version_info >= (3,): +if _sys.version_info >= (3,): from collections import ChainMap from syslog import (LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR, LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG) @@ -35,10 +36,12 @@ from ._reader import (_Journal, NOP, APPEND, INVALIDATE, LOCAL_ONLY, RUNTIME_ONLY, SYSTEM_ONLY) from . import id128 as _id128 -_MONOTONIC_CONVERTER = lambda x: datetime.timedelta(microseconds=float(x)) -_REALTIME_CONVERTER = lambda x: datetime.datetime.fromtimestamp(float(x)/1E6) +_MONOTONIC_CONVERTER = lambda x: _datetime.timedelta(microseconds=float(x)) +_REALTIME_CONVERTER = lambda x: _datetime.datetime.fromtimestamp(float(x)/1E6) DEFAULT_CONVERTERS = { - 'MESSAGE_ID': uuid.UUID, + 'MESSAGE_ID': _uuid.UUID, + '_MACHINE_ID': _uuid.UUID, + '_BOOT_ID': _uuid.UUID, 'PRIORITY': int, 'LEADER': int, 'SESSION_ID': int, @@ -70,38 +73,70 @@ DEFAULT_CONVERTERS = { 'COREDUMP_TIMESTAMP': _REALTIME_CONVERTER, } -if sys.version_info >= (3,): - _convert_unicode = functools.partial(str, encoding='utf-8') +if _sys.version_info >= (3,): + _convert_unicode = _functools.partial(str, encoding='utf-8') else: - _convert_unicode = functools.partial(unicode, encoding='utf-8') + _convert_unicode = _functools.partial(unicode, encoding='utf-8') class Journal(_Journal): - def __init__(self, converters=None, *args, **kwargs): - super(Journal, self).__init__(*args, **kwargs) - if sys.version_info >= (3,3): + """Journal allows the access and filtering of systemd journal + entries. Note that in order to access the system journal, a + non-root user must be in the `adm` group. + + Example usage to print out all error or higher level messages + for systemd-udevd for the boot: + + >>> myjournal = journal.Journal() + >>> myjournal.add_boot_match(journal.CURRENT_BOOT) + >>> myjournal.add_loglevel_matches(journal.LOG_ERR) + >>> myjournal.add_match(_SYSTEMD_UNIT="systemd-udevd.service") + >>> for entry in myjournal: + ... print(entry['MESSAGE']) + + See systemd.journal-fields(7) for more info on typical fields + found in the journal. + """ + def __init__(self, converters=None, flags=LOCAL_ONLY, path=None): + """Creates instance of Journal, which allows filtering and + return of journal entries. + Argument `converters` is a dictionary which updates the + DEFAULT_CONVERTERS to convert journal field values. + Argument `flags` sets open flags of the journal, which can be one + of, or ORed combination of constants: LOCAL_ONLY (default) opens + journal on local machine only; RUNTIME_ONLY opens only + volatile journal files; and SYSTEM_ONLY opens only + journal files of system services and the kernel. + Argument `path` is the directory of journal files. Note that + currently flags are ignored when `path` is present as they are + currently not relevant. + """ + super(Journal, self).__init__(flags, path) + if _sys.version_info >= (3,3): self.converters = ChainMap() if converters is not None: self.converters.maps.append(converters) self.converters.maps.append(DEFAULT_CONVERTERS) else: - # suitable fallback, e.g. self.converters = DEFAULT_CONVERTERS.copy() if converters is not None: self.converters.update(converters) def _convert_field(self, key, value): + """Convert value based on callable from self.converters + based of field/key""" try: result = self.converters[key](value) except: # Default conversion in unicode try: result = _convert_unicode(value) - except: + except UnicodeDecodeError: # Leave in default bytes result = value return result def _convert_entry(self, entry): + """Convert entire journal entry utilising _covert_field""" result = {} for key, value in entry.items(): if isinstance(value, list): @@ -111,41 +146,91 @@ class Journal(_Journal): return result 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, + and matches of the same field are automatically combined in a + logical OR. + Matches can be passed as strings of form "FIELD=value", or + keyword arguments FIELD="value". + """ args = list(args) args.extend(_make_line(key, val) for key, val in kwargs.items()) for arg in args: super(Journal, self).add_match(arg) def get_next(self, skip=1): + """Return the next log entry as a dictionary of fields. + + Optional skip value will return the `skip`\-th log entry. + + Entries will be processed with converters specified during + Journal creation. + """ return self._convert_entry( super(Journal, self).get_next(skip)) - def query_unique(self, key): - return set(self._convert_field(key, value) - for value in super(Journal, self).query_unique(key)) + def query_unique(self, field): + """Return unique values appearing in the Journal for given `field`. - def seek_realtime(self, timestamp): - if isinstance(timestamp, datetime.datetime): - timestamp = float(timestamp.strftime("%s.%f")) - return super(Journal, self).seek_realtime(timestamp) + Note this does not respect any journal matches. + + Entries will be processed with converters specified during + Journal creation. + """ + return set(self._convert_field(field, value) + for value in super(Journal, self).query_unique(field)) + + def seek_realtime(self, realtime): + """Seek to a matching journal entry nearest to `realtime` time. + + Argument `realtime` must be either an integer unix timestamp + or datetime.datetime instance. + """ + if isinstance(realtime, _datetime.datetime): + realtime = float(realtime.strftime("%s.%f")) + return super(Journal, self).seek_realtime(realtime) - def seek_monotonic(self, timestamp, bootid=None): - if isinstance(timestamp, datetime.timedelta): - timestamp = timestamp.totalseconds() - return super(Journal, self).seek_monotonic(timestamp, bootid) + def seek_monotonic(self, monotonic, bootid=None): + """Seek to a matching journal entry nearest to `monotonic` time. + + Argument `monotonic` is a timestamp from boot in either + seconds or a datetime.timedelta instance. Argument `bootid` + is a string or UUID representing which boot the monotonic time + is reference to. Defaults to current bootid. + """ + if isinstance(monotonic, _datetime.timedelta): + monotonic = monotonic.totalseconds() + if isinstance(bootid, _uuid.UUID): + bootid = bootid.get_hex() + return super(Journal, self).seek_monotonic(monotonic, bootid) def log_level(self, level): - """Sets maximum log level by setting matches for PRIORITY.""" + """Set maximum log `level` by setting matches for PRIORITY. + """ if 0 <= level <= 7: for i in range(level+1): self.add_match(PRIORITY="%s" % i) else: raise ValueError("Log level must be 0 <= level <= 7") + def messageid_match(self, messageid): + """Add match for log entries with specified `messageid`. + + `messageid` can be string of hexadicimal digits or a UUID + instance. Standard message IDs can be found in systemd.id128. + + Equivalent to add_match(MESSAGE_ID=`messageid`). + """ + if isinstance(messageid, _uuid.UUID): + messageid = messageid.get_hex() + self.add_match(MESSAGE_ID=messageid) + def this_boot(self, bootid=None): """Add match for _BOOT_ID equal to current boot ID or the specified boot ID. - bootid should be either a UUID or a 32 digit hex number. + If specified, bootid should be either a UUID or a 32 digit hex number. + + Equivalent to add_match(_BOOT_ID='bootid'). """ if bootid is None: bootid = _id128.get_boot().hex @@ -156,7 +241,9 @@ class Journal(_Journal): def this_machine(self, machineid=None): """Add match for _MACHINE_ID equal to the ID of this machine. - bootid should be either a UUID or a 32 digit hex number. + If specified, machineid should be either a UUID or a 32 digit hex number. + + Equivalent to add_match(_MACHINE_ID='machineid'). """ if machineid is None: machineid = _id128.get_machine().hex