the filter goes into sensible too, though its internals should be rew…

…orked to work with events

lithoxyl/__init__.py

@@ -3,10 +3,13 @@
 from lithoxyl.context import get_context, set_context
 
 from lithoxyl.logger import Logger, DEBUG, INFO, CRITICAL
-from lithoxyl.filters import ThresholdFilter
 from lithoxyl.emitters import StreamEmitter
 
-from lithoxyl.sensible import SensibleFormatter, SensibleSink
+from lithoxyl.sensible import (SensibleSink,
+                               SensibleFilter,
+                               SensibleFormatter,
+                               SensibleMessageFormatter)
+
 
 from boltons.formatutils import DeferredValue
 from boltons.tbutils import TracebackInfo, ExceptionInfo, Callpoint

lithoxyl/sensible.py

@@ -6,7 +6,7 @@
 
 from boltons.formatutils import tokenize_format_str
 
-from lithoxyl.common import EVENTS
+from lithoxyl.common import EVENTS, MAX_LEVEL, get_level
 from lithoxyl.fields import BUILTIN_FIELD_MAP
 
 
@@ -70,6 +70,31 @@ def __repr__(self):
                 % (cn, self.filters, self.formatter, self.emitter))
 
 
+class SensibleFilter(object):
+    def __init__(self, base=None, **kwargs):
+        # TODO: filter for warnings
+        # TODO: on-bind lookup behaviors?
+        base = get_level(base or MAX_LEVEL)
+
+        self.event_kw_vals = {}
+        for event in ('begin', 'success', 'failure', 'exception'):
+            level = kwargs.pop(event, base)
+            if not level:  # False or explicit None
+                level = MAX_LEVEL  # MAX_LEVEL filters all
+            level = get_level(level)
+            self.event_kw_vals[event] = level
+
+        self.event_thresh_map = dict(self.event_kw_vals)  # TODO
+        if kwargs:
+            raise TypeError('got unexpected keyword arguments: %r' % kwargs)
+
+    def __call__(self, record):
+        try:
+            return record.level >= self.event_thresh_map[record.status]
+        except KeyError:
+            return False
+
+
 class GetterDict(dict):
     """An internal-use-only dict to enable the fetching of values from a
     :class:`~lithoxyl.record.Record`. Tries to fetch a key on a
@@ -260,3 +285,29 @@ def _default_quoter(self, token):
 * quoted, escaped
   (standard for longer strings that might contain whitespace)
 """
+
+
+"""
+
+SensibleLogger has two sinks:
+
+ * (1) statistical (counter or stats aggregator)
+ * (1) persistent (stream/file)
+
+For each combination of level and status, choose whether to count or
+count+log. The following matrix shows the default log level:
+
++------------+-------+-------+---------+
+|level/status|success|failure|exception|
++------------+-------+-------+---------+
+|debug       | count | count |   log   |
++------------+-------+-------+---------+
+|info        | count |  log  |   log   |
++------------+-------+-------+---------+
+|critical    |  log  |  log  |   log   |
++------------+-------+-------+---------+
+
+Higher verbosity moves the spread of "log" actions diagonally up and
+to the left, and lower verbosity, down and to the right.
+
+"""

lithoxyl/tests/test_formatters.py

@@ -2,7 +2,7 @@
 
 from lithoxyl import DeferredValue
 from lithoxyl.logger import Logger, Record, DEBUG
-from lithoxyl.sensible import SensibleEventFormatter as SEF
+from lithoxyl.sensible import SensibleFormatter as SF
 
 
 
@@ -26,14 +26,14 @@
 
 
 def test_formatter_basic():
-    forming = SEF(template)
+    forming = SF(template)
     output = forming.on_end(t_riker.end_event)
     expected = '"1off" - success - "Riker"'
     print output
     assert output[-len(expected):] == expected
 
     rec = Record(t_log, 'DEBUG', 'Wharf')
-    robf = SEF(template)
+    robf = SF(template)
     rec.success('Mr. Wolf')
     ret = robf.on_end(rec.end_event)
     print ret
@@ -43,7 +43,7 @@ def test_formatter_basic():
 def test_individual_fields():
     for record, field_pairs in zip(RECS, TCS):
         for field_tmpl, result in field_pairs:
-            forming = SEF(field_tmpl)
+            forming = SF(field_tmpl)
             output = forming.on_end(record.end_event)
             assert output == result
     return
@@ -54,7 +54,7 @@ def test_deferred():
     expensive_ops = [(lambda: 5, '"oh, 5"'),
                      (lambda: 'hi', '"oh, hi"'),
                      (lambda: 2.0, '"oh, 2.0"')]
-    formatter = SEF('{end_message}')
+    formatter = SF('{end_message}')
 
     for eo, expected in expensive_ops:
         rec = Record(t_log, 'DEBUG', 'spendy').success('oh, {dv}', dv=DV(eo))

lithoxyl/tests/test_sinks.py

@@ -1,14 +1,14 @@
 # -*- coding: utf-8 -*-
 
-from lithoxyl.sensible import (SensibleSink,
-                               SensibleFormatter as SF,
-                               SensibleEventFormatter as SEF)
+from lithoxyl import (SensibleSink,
+                      SensibleFilter,
+                      SensibleFormatter as SF,
+                      SensibleMessageFormatter as SMF)
 from lithoxyl.emitters import StreamEmitter, AggregateEmitter
-from lithoxyl.filters import ThresholdFilter
 from lithoxyl.logger import Logger
 
 
-fmtr = SEF('{status_char}{begin_timestamp}')
+fmtr = SF('{status_char}{begin_timestamp}')
 strm_emtr = StreamEmitter('stderr')
 aggr_emtr = AggregateEmitter()
 strm_sink = SensibleSink(formatter=fmtr, emitter=strm_emtr)
@@ -65,7 +65,7 @@ def _test_exception():
              ' - {func_name}:{line_number} - {exc_tb_list}')
     sink = SensibleSink(SF(_tmpl),
                         StreamEmitter('stderr'),
-                        filters=[ThresholdFilter(exception=0)])
+                        filters=[SensibleFilter(exception=0)])
     logger = Logger('excelsilog', [sink])
     with logger.info('A for Effort', reraise=False) as tr:
         print tr