src/python-systemd/journal.py

   1 #  -*- Mode: python; coding:utf-8; indent-tabs-mode: nil -*- */
   2 #
   3 #  This file is part of systemd.
   4 #
   5 #  Copyright 2012 David Strauss <david@davidstrauss.net>
   6 #  Copyright 2012 Zbigniew Jędrzejewski-Szmek <zbyszek@in.waw.pl>
   7 #  Copyright 2012 Marti Raudsepp <marti@juffo.org>
   8 #
   9 #  systemd is free software; you can redistribute it and/or modify it
  10 #  under the terms of the GNU Lesser General Public License as published by
  11 #  the Free Software Foundation; either version 2.1 of the License, or
  12 #  (at your option) any later version.
  13 #
  14 #  systemd is distributed in the hope that it will be useful, but
  15 #  WITHOUT ANY WARRANTY; without even the implied warranty of
  16 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17 #  Lesser General Public License for more details.
  18 #
  19 #  You should have received a copy of the GNU Lesser General Public License
  20 #  along with systemd; If not, see <http://www.gnu.org/licenses/>.
  21
  22 import datetime
  23 import functools
  24 import sys
  25 import uuid
  26 import traceback as _traceback
  27 import os as _os
  28 import logging as _logging
  29 from syslog import (LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
  30                     LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG)
  31 from ._journal import sendv, stream_fd
  32 from ._reader import (_Journal, NOP, APPEND, INVALIDATE,
  33                       LOCAL_ONLY, RUNTIME_ONLY, SYSTEM_ONLY)
  34
  35 _MONOTONIC_CONVERTER = lambda x: datetime.timedelta(microseconds=float(x))
  36 _REALTIME_CONVERTER = lambda x: datetime.datetime.fromtimestamp(float(x)/1E6)
  37 DEFAULT_CONVERTERS = {
  38     'MESSAGE_ID': uuid.UUID,
  39     'PRIORITY': int,
  40     'LEADER': int,
  41     'SESSION_ID': int,
  42     'USERSPACE_USEC': int,
  43     'INITRD_USEC': int,
  44     'KERNEL_USEC': int,
  45     '_UID': int,
  46     '_GID': int,
  47     '_PID': int,
  48     'SYSLOG_FACILITY': int,
  49     'SYSLOG_PID': int,
  50     '_AUDIT_SESSION': int,
  51     '_AUDIT_LOGINUID': int,
  52     '_SYSTEMD_SESSION': int,
  53     '_SYSTEMD_OWNER_UID': int,
  54     'CODE_LINE': int,
  55     'ERRNO': int,
  56     'EXIT_STATUS': int,
  57     '_SOURCE_REALTIME_TIMESTAMP': _REALTIME_CONVERTER,
  58     '__REALTIME_TIMESTAMP': _REALTIME_CONVERTER,
  59     '_SOURCE_MONOTONIC_TIMESTAMP': _MONOTONIC_CONVERTER,
  60     '__MONOTONIC_TIMESTAMP': _MONOTONIC_CONVERTER,
  61     'COREDUMP': bytes,
  62     'COREDUMP_PID': int,
  63     'COREDUMP_UID': int,
  64     'COREDUMP_GID': int,
  65     'COREDUMP_SESSION': int,
  66     'COREDUMP_SIGNAL': int,
  67     'COREDUMP_TIMESTAMP': _REALTIME_CONVERTER,
  68 }
  69
  70 if sys.version_info >= (3,):
  71     _convert_unicode = functools.partial(str, encoding='utf-8')
  72 else:
  73     _convert_unicode = functools.partial(unicode, encoding='utf-8')
  74
  75 class Journal(_Journal):
  76     def __init__(self, converters=None, *args, **kwargs):
  77         super(Journal, self).__init__(*args, **kwargs)
  78         if sys.version_info >= (3,3):
  79             self.converters = ChainMap()
  80             if converters is not None:
  81                 self.converters.maps.append(converters)
  82             self.converters.maps.append(DEFAULT_CONVERTERS)
  83         else:
  84             # suitable fallback, e.g.
  85             self.converters = DEFAULT_CONVERTERS.copy()
  86             if converters is not None:
  87                 self.converters.update(converters)
  88
  89     def _convert_field(self, key, value):
  90         try:
  91             result = self.converters[key](value)
  92         except KeyError:
  93             # Default conversion in unicode
  94             try:
  95                 result = _convert_unicode(value)
  96             except:
  97                 # Leave in default bytes
  98                 result = value
  99         return result
 100
 101     def _convert_entry(self, entry):
 102         result = {}
 103         for key, value in entry.iteritems():
 104             if isinstance(value, list):
 105                 result[key] = [self._convert_field(key, val) for val in value]
 106             else:
 107                 result[key] = self._convert_field(key, value)
 108         return result
 109
 110     def get_next(self, *args, **kwargs):
 111         return self._convert_entry(
 112             super(Journal, self).get_next(*args, **kwargs))
 113
 114     def query_unique(self, key, *args, **kwargs):
 115         return set(self._convert_field(key, value)
 116             for value in super(Journal, self).query_unique(key, *args, **kwargs))
 117
 118 def _make_line(field, value):
 119         if isinstance(value, bytes):
 120                 return field.encode('utf-8') + b'=' + value
 121         else:
 122                 return field + '=' + value
 123
 124 def send(MESSAGE, MESSAGE_ID=None,
 125          CODE_FILE=None, CODE_LINE=None, CODE_FUNC=None,
 126          **kwargs):
 127         r"""Send a message to the journal.
 128
 129         >>> journal.send('Hello world')
 130         >>> journal.send('Hello, again, world', FIELD2='Greetings!')
 131         >>> journal.send('Binary message', BINARY=b'\xde\xad\xbe\xef')
 132
 133         Value of the MESSAGE argument will be used for the MESSAGE=
 134         field. MESSAGE must be a string and will be sent as UTF-8 to
 135         the journal.
 136
 137         MESSAGE_ID can be given to uniquely identify the type of
 138         message. It must be a string or a uuid.UUID object.
 139
 140         CODE_LINE, CODE_FILE, and CODE_FUNC can be specified to
 141         identify the caller. Unless at least on of the three is given,
 142         values are extracted from the stack frame of the caller of
 143         send(). CODE_FILE and CODE_FUNC must be strings, CODE_LINE
 144         must be an integer.
 145
 146         Additional fields for the journal entry can only be specified
 147         as keyword arguments. The payload can be either a string or
 148         bytes. A string will be sent as UTF-8, and bytes will be sent
 149         as-is to the journal.
 150
 151         Other useful fields include PRIORITY, SYSLOG_FACILITY,
 152         SYSLOG_IDENTIFIER, SYSLOG_PID.
 153         """
 154
 155         args = ['MESSAGE=' + MESSAGE]
 156
 157         if MESSAGE_ID is not None:
 158                 id = getattr(MESSAGE_ID, 'hex', MESSAGE_ID)
 159                 args.append('MESSAGE_ID=' + id)
 160
 161         if CODE_LINE == CODE_FILE == CODE_FUNC == None:
 162                 CODE_FILE, CODE_LINE, CODE_FUNC = \
 163                         _traceback.extract_stack(limit=2)[0][:3]
 164         if CODE_FILE is not None:
 165                 args.append('CODE_FILE=' + CODE_FILE)
 166         if CODE_LINE is not None:
 167                 args.append('CODE_LINE={:d}'.format(CODE_LINE))
 168         if CODE_FUNC is not None:
 169                 args.append('CODE_FUNC=' + CODE_FUNC)
 170
 171         args.extend(_make_line(key, val) for key, val in kwargs.items())
 172         return sendv(*args)
 173
 174 def stream(identifier, priority=LOG_DEBUG, level_prefix=False):
 175         r"""Return a file object wrapping a stream to journal.
 176
 177         Log messages written to this file as simple newline sepearted
 178         text strings are written to the journal.
 179
 180         The file will be line buffered, so messages are actually sent
 181         after a newline character is written.
 182
 183         >>> stream = journal.stream('myapp')
 184         >>> stream
 185         <open file '<fdopen>', mode 'w' at 0x...>
 186         >>> stream.write('message...\n')
 187
 188         will produce the following message in the journal::
 189
 190           PRIORITY=7
 191           SYSLOG_IDENTIFIER=myapp
 192           MESSAGE=message...
 193
 194         Using the interface with print might be more convinient:
 195
 196         >>> from __future__ import print_function
 197         >>> print('message...', file=stream)
 198
 199         priority is the syslog priority, one of `LOG_EMERG`,
 200         `LOG_ALERT`, `LOG_CRIT`, `LOG_ERR`, `LOG_WARNING`,
 201         `LOG_NOTICE`, `LOG_INFO`, `LOG_DEBUG`.
 202
 203         level_prefix is a boolean. If true, kernel-style log priority
 204         level prefixes (such as '<1>') are interpreted. See
 205         sd-daemon(3) for more information.
 206         """
 207
 208         fd = stream_fd(identifier, priority, level_prefix)
 209         return _os.fdopen(fd, 'w', 1)
 210
 211 class JournalHandler(_logging.Handler):
 212         """Journal handler class for the Python logging framework.
 213
 214         Please see the Python logging module documentation for an
 215         overview: http://docs.python.org/library/logging.html.
 216
 217         To create a custom logger whose messages go only to journal:
 218
 219         >>> log = logging.getLogger('custom_logger_name')
 220         >>> log.propagate = False
 221         >>> log.addHandler(journal.JournalHandler())
 222         >>> log.warn("Some message: %s", detail)
 223
 224         Note that by default, message levels `INFO` and `DEBUG` are
 225         ignored by the logging framework. To enable those log levels:
 226
 227         >>> log.setLevel(logging.DEBUG)
 228
 229         To attach journal MESSAGE_ID, an extra field is supported:
 230
 231         >>> import uuid
 232         >>> mid = uuid.UUID('0123456789ABCDEF0123456789ABCDEF')
 233         >>> log.warn("Message with ID", extra={'MESSAGE_ID': mid})
 234
 235         To redirect all logging messages to journal regardless of where
 236         they come from, attach it to the root logger:
 237
 238         >>> logging.root.addHandler(journal.JournalHandler())
 239
 240         For more complex configurations when using `dictConfig` or
 241         `fileConfig`, specify `systemd.journal.JournalHandler` as the
 242         handler class.  Only standard handler configuration options
 243         are supported: `level`, `formatter`, `filters`.
 244
 245         The following journal fields will be sent:
 246         `MESSAGE`, `PRIORITY`, `THREAD_NAME`, `CODE_FILE`, `CODE_LINE`,
 247         `CODE_FUNC`, `LOGGER` (name as supplied to getLogger call),
 248         `MESSAGE_ID` (optional, see above).
 249         """
 250
 251         def emit(self, record):
 252                 """Write record as journal event.
 253
 254                 MESSAGE is taken from the message provided by the
 255                 user, and PRIORITY, LOGGER, THREAD_NAME,
 256                 CODE_{FILE,LINE,FUNC} fields are appended
 257                 automatically. In addition, record.MESSAGE_ID will be
 258                 used if present.
 259                 """
 260                 try:
 261                         msg = self.format(record)
 262                         pri = self.mapPriority(record.levelno)
 263                         mid = getattr(record, 'MESSAGE_ID', None)
 264                         send(msg,
 265                              MESSAGE_ID=mid,
 266                              PRIORITY=format(pri),
 267                              LOGGER=record.name,
 268                              THREAD_NAME=record.threadName,
 269                              CODE_FILE=record.pathname,
 270                              CODE_LINE=record.lineno,
 271                              CODE_FUNC=record.funcName)
 272                 except Exception:
 273                         self.handleError(record)
 274
 275         @staticmethod
 276         def mapPriority(levelno):
 277                 """Map logging levels to journald priorities.
 278
 279                 Since Python log level numbers are "sparse", we have
 280                 to map numbers in between the standard levels too.
 281                 """
 282                 if levelno <= _logging.DEBUG:
 283                         return LOG_DEBUG
 284                 elif levelno <= _logging.INFO:
 285                         return LOG_INFO
 286                 elif levelno <= _logging.WARNING:
 287                         return LOG_WARNING
 288                 elif levelno <= _logging.ERROR:
 289                         return LOG_ERR
 290                 elif levelno <= _logging.CRITICAL:
 291                         return LOG_CRIT
 292                 else:
 293                         return LOG_ALERT