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 ._journal import __version__, sendv, stream_fd
from ._reader import (_Reader, NOP, APPEND, INVALIDATE,
- LOCAL_ONLY, RUNTIME_ONLY, SYSTEM_ONLY,
- get_catalog)
+ LOCAL_ONLY, RUNTIME_ONLY,
+ SYSTEM, SYSTEM_ONLY, CURRENT_USER,
+ _get_catalog)
from . import id128 as _id128
if _sys.version_info >= (3,):
def _convert_timestamp(s):
return _datetime.datetime.fromtimestamp(int(s) / 1000000)
+def _convert_trivial(x):
+ return x
+
if _sys.version_info >= (3,):
def _convert_uuid(s):
return _uuid.UUID(s.decode())
'__REALTIME_TIMESTAMP': _convert_realtime,
'_SOURCE_MONOTONIC_TIMESTAMP': _convert_source_monotonic,
'__MONOTONIC_TIMESTAMP': _convert_monotonic,
+ '__CURSOR': _convert_trivial,
'COREDUMP': bytes,
'COREDUMP_PID': int,
'COREDUMP_UID': int,
'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
See systemd.journal-fields(7) for more info on typical fields
found in the journal.
"""
- def __init__(self, flags=0, path=None, converters=None):
+ def __init__(self, flags=0, path=None, files=None, converters=None):
"""Create an instance of Reader, which allows filtering and
return of journal entries.
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)
+ super(Reader, self).__init__(flags, path, files)
if _sys.version_info >= (3,3):
self.converters = _ChainMap()
if converters is not None:
result[key] = self._convert_field(key, value)
return result
+ def __iter__(self):
+ """Part of iterator protocol.
+ Returns self.
+ """
+ return self
+
+ def __next__(self):
+ """Part of iterator protocol.
+ Returns self.get_next() or raises StopIteration.
+ """
+ ans = self.get_next()
+ if ans:
+ return ans
+ else:
+ raise StopIteration()
+
+ if _sys.version_info < (3,):
+ next = __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,
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`.
have been added or removed).
"""
us = -1 if timeout is None else int(timeout * 1000000)
- return super(Reader, self).wait(timeout)
+ return super(Reader, self).wait(us)
def seek_realtime(self, realtime):
"""Seek to a matching journal entry nearest to `realtime` time.
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
>>> 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:
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.
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)
~ianmdlvl / elogind.git / blobdiff