X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fpython-systemd%2Fjournal.py;h=23e1d657473a778c90d0884b948967d93ac7e596;hb=d611dadcc74db10ba533ee6859308f5fc505aee1;hp=d61c30e1244c825ac3054443fbeb82cf52713963;hpb=89d9a233890a11eb4e6bd3960fff20d8a5afd8ae;p=elogind.git diff --git a/src/python-systemd/journal.py b/src/python-systemd/journal.py index d61c30e12..23e1d6574 100644 --- a/src/python-systemd/journal.py +++ b/src/python-systemd/journal.py @@ -19,6 +19,8 @@ # You should have received a copy of the GNU Lesser General Public License # along with systemd; If not, see . +from __future__ import division + import sys as _sys import datetime as _datetime import functools as _functools @@ -28,16 +30,22 @@ import os as _os from os import SEEK_SET, SEEK_CUR, SEEK_END import logging as _logging if _sys.version_info >= (3,): - from collections import ChainMap + 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 (_Journal, NOP, APPEND, INVALIDATE, +from ._reader import (_Reader, 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) +if _sys.version_info >= (3,): + from ._reader import Monotonic +else: + Monotonic = tuple + +_MONOTONIC_CONVERTER = lambda p: Monotonic((_datetime.timedelta(microseconds=p[0]), + _uuid.UUID(bytes=p[1]))) +_REALTIME_CONVERTER = lambda x: _datetime.datetime.fromtimestamp(x / 1E6) DEFAULT_CONVERTERS = { 'MESSAGE_ID': _uuid.UUID, '_MACHINE_ID': _uuid.UUID, @@ -78,9 +86,26 @@ if _sys.version_info >= (3,): else: _convert_unicode = _functools.partial(unicode, encoding='utf-8') -class Journal(_Journal): +class Reader(_Reader): + """Reader 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.Reader() + >>> 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 + """Create an instance of Reader, which allows filtering and return of journal entries. Argument `converters` is a dictionary which updates the DEFAULT_CONVERTERS to convert journal field values. @@ -93,9 +118,9 @@ class Journal(_Journal): currently flags are ignored when `path` is present as they are currently not relevant. """ - super(Journal, self).__init__(flags, path) + super(Reader, self).__init__(flags, path) if _sys.version_info >= (3,3): - self.converters = ChainMap() + self.converters = _ChainMap() if converters is not None: self.converters.maps.append(converters) self.converters.maps.append(DEFAULT_CONVERTERS) @@ -105,7 +130,7 @@ class Journal(_Journal): self.converters.update(converters) def _convert_field(self, key, value): - """ Convert value based on callable from self.converters + """Convert value based on callable from self.converters based of field/key""" try: result = self.converters[key](value) @@ -113,13 +138,13 @@ class Journal(_Journal): # 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""" + """Convert entire journal entry utilising _covert_field""" result = {} for key, value in entry.items(): if isinstance(value, list): @@ -131,52 +156,65 @@ class Journal(_Journal): 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 smae field are automatically combined in a + 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".""" + 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) + super(Reader, self).add_match(arg) def get_next(self, skip=1): - """Return dictionary of the next log entry. Optional skip value - will return the `skip`th log entry. - Returned will be journal entry dictionary processed with - converters.""" + """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 + Reader creation. + """ return self._convert_entry( - super(Journal, self).get_next(skip)) + super(Reader, self).get_next(skip)) def query_unique(self, field): - """Returns a set of unique values in journal for given `field`, - processed with converters. - Note this does not respect any journal matches.""" + """Return unique values appearing in the journal for given `field`. + + Note this does not respect any journal matches. + + Entries will be processed with converters specified during + Reader creation. + """ return set(self._convert_field(field, value) - for value in super(Journal, self).query_unique(field)) + for value in super(Reader, self).query_unique(field)) def seek_realtime(self, realtime): - """Seek to nearest matching journal entry to `realtime`. - Argument `realtime` can must be either an integer unix timestamp - or datetime.datetime instance.""" + """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) + return super(Reader, self).seek_realtime(realtime) def seek_monotonic(self, monotonic, bootid=None): - """Seek to nearest matching journal entry to `monotonic`. - 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.""" + """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) + return super(Reader, 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) @@ -184,10 +222,13 @@ class Journal(_Journal): raise ValueError("Log level must be 0 <= level <= 7") def messageid_match(self, messageid): - """Sets match filter for log entries for specified `messageid`. - `messageid` can be string or UUID instance. - Standard message IDs can be found in systemd.id128 - Equivalent to add_match(MESSAGE_ID=`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)