SubRecords are events now, and every file that used them (almost ever…

…y file) now reflects that. Tests pass, as well. Also fixed the LazyExtrasDict, which needs a better name.

lithoxyl/_syslog_emitter.py

@@ -42,14 +42,14 @@ def _get_syslog_priority(self, event_name, record):
             status = record.status
         return self.priority_map[level][status]
 
-    def on_begin(self, begin_record, entry):
-        priority = self._get_syslog_priority('begin', begin_record)
+    def on_begin(self, begin_event, entry):
+        priority = self._get_syslog_priority('begin', begin_event)
         syslog.syslog(priority, entry)
 
-    def on_warn(self, warn_record, entry):
-        priority = self._get_syslog_priority('warn', warn_record)
+    def on_warn(self, warn_event, entry):
+        priority = self._get_syslog_priority('warn', warn_event)
         syslog.syslog(priority, entry)
 
-    def on_complete(self, complete_record, entry):
-        priority = self._get_syslog_priority('complete', complete_record)
+    def on_complete(self, complete_event, entry):
+        priority = self._get_syslog_priority('complete', complete_event)
         syslog.syslog(priority, entry)

lithoxyl/fields.py

@@ -88,35 +88,35 @@ def __init__(self, fname, fspec='s',
 
 # default, fmt_specs
 FF = FormatField
-BASIC_FIELDS = [FF('logger_name', 's', lambda r: r.logger.name),
-                FF('logger_id', 'd', lambda r: r.logger.logger_id),
-                FF('record_name', 's', lambda r: r.name),
-                FF('record_id', 'd', lambda r: r.record_id),
-                FF('status_str', 's', lambda r: r.status, quote=False),
-                FF('status_char', 's', lambda r: r.status_char, quote=False),
-                FF('warn_char', 's', lambda r: r.warn_char, quote=False),
-                FF('level_name', 's', lambda r: r.level_name, quote=False),
-                FF('extras', 's', lambda r: json.dumps(r.extras, sort_keys=True), quote=False),
-                FF('level_name_upper', 's', lambda r: r.level_name.upper(), quote=False),
-                FF('level_char', 's', lambda r: r.level_name.upper()[0], quote=False),
-                FF('level_number', 'd', lambda r: r.level._value),
-                FF('begin_message', 's', lambda r: r.begin_record.message),
-                FF('begin_raw_message', 's', lambda r: r.begin_record.raw_message),
-                FF('end_message', 's', lambda r: r.complete_record.message),
-                FF('end_raw_message', 's', lambda r: r.complete_record.raw_message),
-                FF('begin_timestamp', '.14g', lambda r: r.begin_time),
-                FF('end_timestamp', '.14g', lambda r: r.end_time),
-                FF('duration_secs', '.3f', lambda r: r.duration),
-                FF('duration_msecs', '.3f', lambda r: r.duration * 1000.0),
-                FF('module_name', 's', lambda r: r.callpoint.module_name),
-                FF('module_path', 's', lambda r: r.callpoint.module_path),
-                FF('func_name', 's', lambda r: r.callpoint.func_name, quote=False),
-                FF('line_number', 'd', lambda r: r.callpoint.lineno),
-                FF('exc_type', 's', lambda r: r.exc_info.exc_type, quote=False),
-                FF('exc_message', 's', lambda r: r.exc_info.exc_msg),
-                FF('exc_tb_str', 's', lambda r: str(r.exc_info.tb_info)),
-                FF('exc_tb_list', 's', lambda r: r.exc_info.tb_info.frames),
-                FF('process_id', 'd', lambda r: os.getpid())]
+BASIC_FIELDS = [FF('logger_name', 's', lambda e: e.logger.name),
+                FF('logger_id', 'd', lambda e: e.logger.logger_id),
+                FF('record_name', 's', lambda e: e.name),
+                FF('record_id', 'd', lambda e: e.record_id),
+                FF('status_str', 's', lambda e: e.status, quote=False),
+                FF('status_char', 's', lambda e: e.status_char, quote=False),
+                FF('warn_char', 's', lambda e: e.warn_char, quote=False),
+                FF('level_name', 's', lambda e: e.level_name, quote=False),
+                FF('extras', 's', lambda e: json.dumps(e.extras, sort_keys=True), quote=False),
+                FF('level_name_upper', 's', lambda e: e.level_name.upper(), quote=False),
+                FF('level_char', 's', lambda e: e.level_name.upper()[0], quote=False),
+                FF('level_number', 'd', lambda e: e.level._value),
+                FF('begin_message', 's', lambda e: e.begin_event.message),
+                FF('begin_raw_message', 's', lambda e: e.begin_event.raw_message),
+                FF('end_message', 's', lambda e: e.complete_event.message),
+                FF('end_raw_message', 's', lambda e: e.complete_event.raw_message),
+                FF('begin_timestamp', '.14g', lambda e: e.begin_time),
+                FF('end_timestamp', '.14g', lambda e: e.end_time),
+                FF('duration_secs', '.3f', lambda e: e.duration),
+                FF('duration_msecs', '.3f', lambda e: e.duration * 1000.0),
+                FF('module_name', 's', lambda e: e.callpoint.module_name),
+                FF('module_path', 's', lambda e: e.callpoint.module_path),
+                FF('func_name', 's', lambda e: e.callpoint.func_name, quote=False),
+                FF('line_number', 'd', lambda e: e.callpoint.lineno),
+                FF('exc_type', 's', lambda e: e.exc_info.exc_type, quote=False),
+                FF('exc_message', 's', lambda e: e.exc_info.exc_msg),
+                FF('exc_tb_str', 's', lambda e: str(e.exc_info.tb_info)),
+                FF('exc_tb_list', 's', lambda e: e.exc_info.tb_info.frames),
+                FF('process_id', 'd', lambda e: os.getpid())]
 
 # ISO8601 and variants. combinations of:
 #   * begin/end
@@ -126,38 +126,38 @@ def __init__(self, fname, fspec='s',
 # TODO: rename to just ISO
 ISO8601_FIELDS = [
     FF('begin_iso8601', 's',
-       lambda r: timestamp2iso8601(r.root.begin_record.ctime)),
+       lambda e: timestamp2iso8601(e.record.begin_event.ctime)),
     FF('end_iso8601', 's',
-       lambda r: timestamp2iso8601(r.root.complete_record.ctime)),
+       lambda e: timestamp2iso8601(e.record.complete_event.ctime)),
     FF('begin_iso8601_notz', 's',
-       lambda r: timestamp2iso8601(r.root.begin_record.ctime,
+       lambda e: timestamp2iso8601(e.record.begin_event.ctime,
                                    with_tz=False)),
     FF('end_iso8601_notz', 's',
-       lambda r: timestamp2iso8601(r.root.complete_record.ctime,
+       lambda e: timestamp2iso8601(e.record.complete_event.ctime,
                                    with_tz=False)),
     FF('begin_local_iso8601', 's',
-       lambda r: timestamp2iso8601(r.root.begin_record.ctime,
+       lambda e: timestamp2iso8601(e.record.begin_event.ctime,
                                    local=True)),
     FF('end_local_iso8601', 's',
-       lambda r: timestamp2iso8601(r.root.complete_record.ctime,
+       lambda e: timestamp2iso8601(e.record.complete_event.ctime,
                                    local=True)),
     FF('begin_local_iso8601_notz', 's',
-       lambda r: timestamp2iso8601(r.root.begin_record.ctime,
+       lambda e: timestamp2iso8601(e.record.begin_event.ctime,
                                    local=True, with_tz=False)),
     FF('end_local_iso8601_notz', 's',
-       lambda r: timestamp2iso8601(r.root.complete_record.ctime,
+       lambda e: timestamp2iso8601(e.record.complete_event.ctime,
                                    local=True, with_tz=False)),
     FF('begin_local_iso8601_noms', 's',
-       lambda r: timestamp2iso8601_noms(r.root.begin_record.ctime,
+       lambda e: timestamp2iso8601_noms(e.record.begin_event.ctime,
                                         local=True)),
     FF('end_local_iso8601_noms', 's',
-       lambda r: timestamp2iso8601_noms(r.root.complete_record.ctime,
+       lambda e: timestamp2iso8601_noms(e.record.complete_event.ctime,
                                         local=True)),
     FF('begin_local_iso8601_noms_notz', 's',
-       lambda r: timestamp2iso8601_noms(r.root.begin_record.ctime,
+       lambda e: timestamp2iso8601_noms(e.record.begin_event.ctime,
                                         local=True, with_tz=False)),
     FF('end_local_iso8601_noms_notz', 's',
-       lambda r: timestamp2iso8601_noms(r.root.complete_record.ctime,
+       lambda e: timestamp2iso8601_noms(e.record.complete_event.ctime,
                                         local=True, with_tz=False))]
 
 # using the T separator means no whitespace and thus no quoting
@@ -166,8 +166,8 @@ def __init__(self, fname, fspec='s',
 
 
 DELTA_FIELDS = [
-    FF('import_delta', '0.6f', lambda r: r.ctime - IMPORT_TIME),
-    FF('import_delta_ms', '0.4f', lambda r: (r.ctime - IMPORT_TIME) * 1000)]
+    FF('import_delta', '0.6f', lambda e: e.ctime - IMPORT_TIME),
+    FF('import_delta_ms', '0.4f', lambda e: (e.ctime - IMPORT_TIME) * 1000)]
 
 
 for f in BASIC_FIELDS:

lithoxyl/filters.py

@@ -30,7 +30,7 @@
 
 class ThresholdFilter(object):
     def __init__(self, base=None, **kwargs):
-        # TODO: filter for warnings?
+        # TODO: filter for warnings
         # TODO: on-bind lookup behaviors?
         base = LEVEL_ALIAS_MAP[base or MAX_LEVEL]
 

lithoxyl/formatters.py

@@ -34,7 +34,7 @@ def __missing__(self, key):
         try:
             getter = self.getters[key]
         except KeyError:
-            return self.record.extras.get(key)
+            return self.record.data_map.get(key)
         else:
             return getter(self.record)
 
@@ -55,17 +55,17 @@ def __init__(self, base=None, **kwargs):
             self.event_formatters[event] = rf
         return
 
-    def on_begin(self, begin_record):
+    def on_begin(self, begin_event):
         rf = self.event_formatters['begin']
-        return rf(begin_record)
+        return rf(begin_event)
 
-    def on_warn(self, warn_record):
+    def on_warn(self, warn_event):
         rf = self.event_formatters['warn']
-        return rf(warn_record)
+        return rf(warn_event)
 
-    def on_complete(self, complete_record):
+    def on_complete(self, complete_event):
         rf = self.event_formatters['complete']
-        return rf(complete_record)
+        return rf(complete_event)
 
 
 class RecordFormatter(object):

lithoxyl/logger.py

@@ -12,7 +12,7 @@
 from threading import RLock
 
 from utils import wraps
-from record import Record, BeginRecord, CompleteRecord, CommentRecord
+from record import Record, BeginEvent, CompleteEvent, CommentEvent
 from context import get_context
 from common import DEBUG, INFO, CRITICAL
 
@@ -93,7 +93,7 @@ def __init__(self, name, sinks=None, **kwargs):
         self.context = kwargs.pop('context', None) or get_context()
         self.context.add_logger(self)
         # TODO context-configurable
-        self.record_queue = deque(maxlen=QUEUE_LIMIT)
+        self.event_queue = deque(maxlen=QUEUE_LIMIT)
         self.async_mode = kwargs.pop('async', self.context.async_mode)
         self.async_lock = RLock()
         self.preflush_hooks = []
@@ -123,24 +123,24 @@ def flush(self):
                 except Exception as e:
                     self.context.note('preflush', 'hook %r got exception %r',
                                       preflush_hook, e)
-            queue = self.record_queue
+            queue = self.event_queue
             while queue:
-                rec_type, rec = queue.popleft()
-                if rec_type == 'begin':
+                ev_type, ev = queue.popleft()
+                if ev_type == 'begin':
                     for begin_hook in self._begin_hooks:
-                        begin_hook(rec)
-                elif rec_type == 'complete':
+                        begin_hook(ev)
+                elif ev_type == 'complete':
                     for complete_hook in self._complete_hooks:
-                        complete_hook(rec)
-                elif rec_type == 'warn':
+                        complete_hook(ev)
+                elif ev_type == 'warn':
                     for warn_hook in self._warn_hooks:
-                        warn_hook(rec)
-                elif rec_type == 'comment':
+                        warn_hook(ev)
+                elif ev_type == 'comment':
                     for comment_hook in self._comment_hooks:
-                        comment_hook(rec)
+                        comment_hook(ev)
                 else:
                     self.context.note('flush', 'unknown event type: %r %r',
-                                      rec_type, rec)
+                                      ev_type, ev)
         self.last_flush = time.time()
         return
 
@@ -192,74 +192,74 @@ def add_sink(self, sink):
         # TODO: also pull flush methods?
         self._all_sinks.append(sink)
 
-    def on_complete(self, complete_record):
-        "Publish *record* to all sinks with ``on_complete()`` hooks."
+    def on_complete(self, complete_event):
+        "Publish *complete_event* to all sinks with ``on_complete()`` hooks."
         if self.async_mode:
-            self.record_queue.append(('complete', complete_record))
+            self.event_queue.append(('complete', complete_event))
         else:
             for complete_hook in self._complete_hooks:
-                complete_hook(complete_record)
+                complete_hook(complete_event)
         return
 
-    def on_begin(self, begin_record):
-        "Publish *record* to all sinks with ``on_begin()`` hooks."
+    def on_begin(self, begin_event):
+        "Publish *begin_event* to all sinks with ``on_begin()`` hooks."
         if self.async_mode:
-            self.record_queue.append(('begin', begin_record))
+            self.event_queue.append(('begin', begin_event))
         else:
             for begin_hook in self._begin_hooks:
-                begin_hook(begin_record)
+                begin_hook(begin_event)
         return
 
-    def on_warn(self, warn_record):
-        "Publish *record* to all sinks with ``on_warn()`` hooks."
+    def on_warn(self, warn_event):
+        "Publish *warn_event* to all sinks with ``on_warn()`` hooks."
         if self.async_mode:
-            self.record_queue.append(('warn', warn_record))
+            self.event_queue.append(('warn', warn_event))
         else:
             for warn_hook in self._warn_hooks:
-                warn_hook(warn_record)
+                warn_hook(warn_event)
         return
 
-    def on_exception(self, exc_record, exc_type, exc_obj, exc_tb):
-        "Publish *record* to all sinks with ``on_exception()`` hooks."
+    def on_exception(self, exc_event, exc_type, exc_obj, exc_tb):
+        "Publish *exc_event* to all sinks with ``on_exception()`` hooks."
         # async handling doesn't make sense here
         for exc_hook in self._exc_hooks:
-            exc_hook(exc_record, exc_type, exc_obj, exc_tb)
+            exc_hook(exc_event, exc_type, exc_obj, exc_tb)
         return
 
     def comment(self, message, *a, **kw):
-        root_type = self.record_type
-        root = root_type(logger=self, level=CRITICAL, name='comment', data=kw)
+        rec_type = self.record_type
+        rec = rec_type(logger=self, level=CRITICAL, name='comment', data=kw)
         cur_time = time.time()
-        root.begin_record = BeginRecord(root, cur_time, 'comment', ())
-        root.complete_record = CompleteRecord(root, cur_time,
-                                              'comment', (), 'success')
-        rec = CommentRecord(root, cur_time, message, a)
+        rec.begin_event = BeginEvent(rec, cur_time, 'comment', ())
+        rec.complete_event = CompleteEvent(rec, cur_time,
+                                           'comment', (), 'success')
+        event = CommentEvent(rec, cur_time, message, a)
         if self.async_mode:
-            self.record_queue.append(('comment', rec))
+            self.event_queue.append(('comment', event))
         else:
             for comment_hook in self._comment_hooks:
-                comment_hook(rec)
+                comment_hook(event)
 
     def debug(self, name, **kw):
-        "Create and return a new :data:`DEBUG`-level :class:`Record` named *name*."
+        "Returns a new :data:`DEBUG`-level :class:`Record` named *name*."
         return self.record_type(logger=self, level=DEBUG, name=name,
                                 data=kw, reraise=kw.pop('reraise', None),
                                 frame=sys._getframe(1))
 
     def info(self, name, **kw):
-        "Create and return a new :data:`INFO`-level :class:`Record` named *name*."
+        "Returns a new :data:`INFO`-level :class:`Record` named *name*."
         return self.record_type(logger=self, level=INFO, name=name,
                                 data=kw, reraise=kw.pop('reraise', None),
                                 frame=sys._getframe(1))
 
     def critical(self, name, **kw):
-        "Create and return a new :data:`CRITICAL`-level :class:`Record` named *name*."
+        "Returns a new :data:`CRITICAL`-level :class:`Record` named *name*."
         return self.record_type(logger=self, level=CRITICAL, name=name,
                                 data=kw, reraise=kw.pop('reraise', None),
                                 frame=sys._getframe(1))
 
     def record(self, level, name, **kw):
-        "Create and return a new :class:`Record` named *name* classified as *level*."
+        "Return a new :class:`Record` named *name* classified as *level*."
         return self.record_type(logger=self, level=level, name=name,
                                 data=kw, reraise=kw.pop('reraise', None),
                                 frame=sys._getframe(1))