rename complete -> end. the fields were already referring to it as th…

…is, and it's mostly ann internal API, so this is better for long-term consistency.

lithoxyl/_syslog_emitter.py

@@ -50,6 +50,6 @@ def on_warn(self, warn_event, entry):
         priority = self._get_syslog_priority('warn', warn_event)
         syslog.syslog(priority, entry)
 
-    def on_complete(self, complete_event, entry):
-        priority = self._get_syslog_priority('complete', complete_event)
+    def on_end(self, end_event, entry):
+        priority = self._get_syslog_priority('end', end_event)
         syslog.syslog(priority, entry)

lithoxyl/common.py

@@ -3,7 +3,7 @@
 import time
 from functools import total_ordering
 
-EVENTS = ('begin', 'warn', 'complete', 'exception', 'comment')
+EVENTS = ('begin', 'warn', 'end', 'exception', 'comment')
 IMPORT_TIME = time.time()
 
 

lithoxyl/emitters.py

@@ -46,7 +46,7 @@ def __init__(self):
     def emit_entry(self, record, entry):
         self.entries.append((record, entry))
 
-    on_begin = on_warn = on_complete = on_comment = emit_entry
+    on_begin = on_warn = on_end = on_comment = emit_entry
 
 
 class StreamEmitter(object):
@@ -89,7 +89,7 @@ def emit_entry(self, record, entry):
         except Exception as e:
             note('stream_emit', 'got %r on %r.emit_entry()', e, self)
 
-    on_begin = on_warn = on_complete = on_comment = emit_entry
+    on_begin = on_warn = on_end = on_comment = emit_entry
 
     def flush(self):
         stream_flush = getattr(self.stream, 'flush', None)

lithoxyl/fields.py

@@ -100,8 +100,8 @@ def __init__(self, fname, fspec='s', getter=None, **kwargs):
                 _SF('level_number', 'd', lambda e: e.level._value),
                 _SF('begin_message', 's', lambda e: e.begin_event.message),
                 _SF('begin_raw_message', 's', lambda e: e.begin_event.raw_message),
-                _SF('end_message', 's', lambda e: e.complete_event.message),
-                _SF('end_raw_message', 's', lambda e: e.complete_event.raw_message),
+                _SF('end_message', 's', lambda e: e.end_event.message),
+                _SF('end_raw_message', 's', lambda e: e.end_event.raw_message),
                 _SF('begin_timestamp', '.14g', lambda e: e.begin_time),
                 _SF('end_timestamp', '.14g', lambda e: e.end_time),
                 _SF('duration_secs', '.3f', lambda e: e.duration),
@@ -125,36 +125,36 @@ def __init__(self, fname, fspec='s', getter=None, **kwargs):
     _SF('iso_begin', 's',
         lambda e: timestamp2iso8601(e.record.begin_event.etime)),
     _SF('iso_end', 's',
-        lambda e: timestamp2iso8601(e.record.complete_event.etime)),
+        lambda e: timestamp2iso8601(e.record.end_event.etime)),
     _SF('iso_begin_notz', 's',
         lambda e: timestamp2iso8601(e.record.begin_event.etime,
                                     with_tz=False)),
     _SF('iso_end_notz', 's',
-        lambda e: timestamp2iso8601(e.record.complete_event.etime,
+        lambda e: timestamp2iso8601(e.record.end_event.etime,
                                     with_tz=False)),
     _SF('iso_begin_local', 's',
         lambda e: timestamp2iso8601(e.record.begin_event.etime,
                                     local=True)),
     _SF('iso_end_local', 's',
-        lambda e: timestamp2iso8601(e.record.complete_event.etime,
+        lambda e: timestamp2iso8601(e.record.end_event.etime,
                                     local=True)),
     _SF('iso_begin_local_notz', 's',
         lambda e: timestamp2iso8601(e.record.begin_event.etime,
                                     local=True, with_tz=False)),
     _SF('iso_end_local_notz', 's',
-        lambda e: timestamp2iso8601(e.record.complete_event.etime,
+        lambda e: timestamp2iso8601(e.record.end_event.etime,
                                     local=True, with_tz=False)),
     _SF('iso_begin_local_noms', 's',
         lambda e: timestamp2iso8601_noms(e.record.begin_event.etime,
                                          local=True)),
     _SF('iso_end_local_noms', 's',
-        lambda e: timestamp2iso8601_noms(e.record.complete_event.etime,
+        lambda e: timestamp2iso8601_noms(e.record.end_event.etime,
                                          local=True)),
     _SF('iso_begin_local_noms_notz', 's',
         lambda e: timestamp2iso8601_noms(e.record.begin_event.etime,
                                          local=True, with_tz=False)),
     _SF('iso_end_local_noms_notz', 's',
-        lambda e: timestamp2iso8601_noms(e.record.complete_event.etime,
+        lambda e: timestamp2iso8601_noms(e.record.end_event.etime,
                                          local=True, with_tz=False))]
 
 # using the T separator means no whitespace and thus no quoting

lithoxyl/logger.py

@@ -14,7 +14,7 @@
 from lithoxyl.utils import wraps
 from lithoxyl.context import get_context
 from lithoxyl.common import DEBUG, INFO, CRITICAL
-from lithoxyl.record import Record, BeginEvent, CompleteEvent, CommentEvent
+from lithoxyl.record import Record, BeginEvent, EndEvent, CommentEvent
 
 
 QUEUE_LIMIT = 10000
@@ -129,9 +129,9 @@ def flush(self):
                 if ev_type == 'begin':
                     for begin_hook in self._begin_hooks:
                         begin_hook(ev)
-                elif ev_type == 'complete':
-                    for complete_hook in self._complete_hooks:
-                        complete_hook(ev)
+                elif ev_type == 'end':
+                    for end_hook in self._end_hooks:
+                        end_hook(ev)
                 elif ev_type == 'warn':
                     for warn_hook in self._warn_hooks:
                         warn_hook(ev)
@@ -157,7 +157,7 @@ def set_sinks(self, sinks):
         self._all_sinks = []
         self._begin_hooks = []
         self._warn_hooks = []
-        self._complete_hooks = []
+        self._end_hooks = []
         self._exc_hooks = []
         self._comment_hooks = []
         for s in sinks:
@@ -180,9 +180,9 @@ def add_sink(self, sink):
         warn_hook = getattr(sink, 'on_warn', None)
         if callable(warn_hook):
             self._warn_hooks.append(warn_hook)
-        complete_hook = getattr(sink, 'on_complete', None)
-        if callable(complete_hook):
-            self._complete_hooks.append(complete_hook)
+        end_hook = getattr(sink, 'on_end', None)
+        if callable(end_hook):
+            self._end_hooks.append(end_hook)
         exc_hook = getattr(sink, 'on_exception', None)
         if callable(exc_hook):
             self._exc_hooks.append(exc_hook)
@@ -192,13 +192,13 @@ def add_sink(self, sink):
         # TODO: also pull flush methods?
         self._all_sinks.append(sink)
 
-    def on_complete(self, complete_event):
-        "Publish *complete_event* to all sinks with ``on_complete()`` hooks."
+    def on_end(self, end_event):
+        "Publish *end_event* to all sinks with ``on_end()`` hooks."
         if self.async_mode:
-            self.event_queue.append(('complete', complete_event))
+            self.event_queue.append(('end', end_event))
         else:
-            for complete_hook in self._complete_hooks:
-                complete_hook(complete_event)
+            for end_hook in self._end_hooks:
+                end_hook(end_event)
         return
 
     def on_begin(self, begin_event):
@@ -231,8 +231,8 @@ def comment(self, message, *a, **kw):
         rec = rec_type(logger=self, level=CRITICAL, name='comment', data=kw)
         cur_time = time.time()
         rec.begin_event = BeginEvent(rec, cur_time, 'comment', ())
-        rec.complete_event = CompleteEvent(rec, cur_time,
-                                           'comment', (), 'success')
+        rec.end_event = EndEvent(rec, cur_time,
+                                 'comment', (), 'success')
         event = CommentEvent(rec, cur_time, message, a)
         if self.async_mode:
             self.event_queue.append(('comment', event))

lithoxyl/record.py

@@ -85,7 +85,7 @@ def __init__(self, logger, level, name,
         self.callpoint = Callpoint.from_frame(frame)
 
         self.begin_event = None
-        self.complete_event = None
+        self.end_event = None
         # these can go internal and be lazily created through properties
         self.warn_events = []
         self.exc_events = []
@@ -105,14 +105,14 @@ def level_name(self):
     @property
     def status(self):
         try:
-            return self.complete_event.status
+            return self.end_event.status
         except AttributeError:
             return 'begin'
 
     @property
     def duration(self):
         try:
-            return self.complete_event.etime - self.begin_event.etime
+            return self.end_event.etime - self.begin_event.etime
         except Exception:
             return 0.0
 
@@ -134,27 +134,27 @@ def warn(self, message, *a, **kw):
         return self
 
     def success(self, message=None, *a, **kw):
-        """Mark this Record as complete and successful. Also set the Record's
+        """Mark this Record successful. Also set the Record's
         *message* template. Positional and keyword arguments will be
         used to generate the formatted message. Keyword arguments will
         also be added to the Record's ``data_map`` attribute.
         """
         if not message:
             message = self.name + ' succeeded'
-        return self._complete('success', message, a, kw)
+        return self._end('success', message, a, kw)
 
     def failure(self, message=None, *a, **kw):
-        """Mark this Record as complete and failed. Also set the Record's
+        """Mark this Record failed. Also set the Record's
         *message* template. Positional and keyword arguments will be
         used to generate the formatted message. Keyword arguments will
         also be added to the Record's ``data_map`` attribute.
         """
         if not message:
             message = self.name + ' failed'
-        return self._complete('failure', message, a, kw)
+        return self._end('failure', message, a, kw)
 
     def exception(self, message=None, *a, **kw):
-        """Mark this Record as complete and having had an exception. Also
+        """Mark this Record as having had an exception. Also
         sets the Record's *message* template similar to
         :meth:`Record.success` and :meth:`Record.failure`.
 
@@ -180,11 +180,10 @@ def _exception(self, exc_type, exc_val, exc_tb, message, fargs, data):
         self.exc_event = ExceptionEvent(self, etime, message, fargs, exc_info)
         self.logger.on_exception(self.exc_event, exc_type, exc_val, exc_tb)
 
-        return self._complete('exception', message, fargs, data,
-                              etime, exc_info)
+        return self._end('exception', message, fargs, data,
+                         etime, exc_info)
 
-    def _complete(self, status, message, fargs, data,
-                  end_time=None, exc_info=None):
+    def _end(self, status, message, fargs, data, end_time=None, exc_info=None):
         self.data_map.update(data)
 
         if self._is_trans:
@@ -194,11 +193,11 @@ def _complete(self, status, message, fargs, data,
                 self.begin()
             end_time = self.begin_event.etime
 
-        self.complete_event = CompleteEvent(self, end_time, message,
-                                            fargs, status, exc_info)
+        self.end_event = EndEvent(self, end_time, message,
+                                  fargs, status, exc_info)
 
         if not self._defer_publish and self.logger:
-            self.logger.on_complete(self.complete_event)
+            self.logger.on_end(self.end_event)
 
         return self
 
@@ -216,10 +215,10 @@ def __exit__(self, exc_type, exc_val, exc_tb):
             except Exception as e:
                 note('record_exit',
                      'got %r while already handling exception %r', e, exc_val)
-                pass  # TODO: still have to create complete_event
+                pass  # TODO: still have to create end_event
         else:
-            if self.complete_event:
-                self.logger.on_complete(self.complete_event)
+            if self.end_event:
+                self.logger.on_end(self.end_event)
             else:
                 # now that _defer_publish=False, this will also publish
                 self.success()
@@ -340,7 +339,7 @@ def __init__(self, record, etime, raw_message, fargs, exc_info):
         self.exc_info = exc_info
 
 
-class CompleteEvent(Event):
+class EndEvent(Event):
     def __init__(self, record, etime, raw_message, fargs, status,
                  exc_info=None):
         self.record = record
@@ -382,7 +381,7 @@ def __init__(self, record, etime, raw_message, fargs):
         self.fargs = fargs
 
 
-"""What to do on multiple begins and multiple completes?
+"""What to do on multiple begins and multiple ends?
 
 If a record is atomic (i.e., never entered/begun), then should it fire
 a logger on_begin? Leaning no.

lithoxyl/sensible.py

@@ -35,8 +35,8 @@ def __init__(self, formatter=None, emitter=None, filters=None, on=EVENTS):
             self.on_begin = self._on_begin
         if 'warn' in self._events:
             self.on_warn = self._on_warn
-        if 'complete' in self._events:
-            self.on_complete = self._on_complete
+        if 'end' in self._events:
+            self.on_end = self._on_end
         if 'comment' in self._events:
             self.on_comment = self._on_comment
 
@@ -52,11 +52,11 @@ def _on_warn(self, event):
         entry = self.formatter.on_warn(event)
         return self.emitter.on_warn(event, entry)
 
-    def _on_complete(self, event):
+    def _on_end(self, event):
         if self.filters and not all([f(event) for f in self.filters]):
             return
-        entry = self.formatter.on_complete(event)
-        return self.emitter.on_complete(event, entry)
+        entry = self.formatter.on_end(event)
+        return self.emitter.on_end(event, entry)
 
     def _on_comment(self, event):
         if self.filters and not all([f(event) for f in self.filters]):
@@ -116,9 +116,9 @@ def on_warn(self, warn_event):
         rf = self.event_formatters['warn']
         return rf(warn_event)
 
-    def on_complete(self, complete_event):
-        rf = self.event_formatters['complete']
-        return rf(complete_event)
+    def on_end(self, end_event):
+        rf = self.event_formatters['end']
+        return rf(end_event)
 
     def on_comment(self, comment_event):
         rf = self.event_formatters['comment']