an actually working api + sync implementation of tree stuff

lithoxyl/context.py

@@ -4,6 +4,7 @@
 import sys
 import atexit
 import signal
+import weakref
 
 from lithoxyl.actors import IntervalThreadActor
 
@@ -31,6 +32,30 @@ def note(name, message, *a, **kw):
     return get_context().note(name, message, *a, **kw)
 
 
+_SYNC_REC_TREE = weakref.WeakKeyDictionary()
+_SYNC_ACTIVE_REC_MAP = weakref.WeakKeyDictionary()
+
+
+def _sync_get_parent_record(record):
+    logger = record.logger
+
+    try:
+        rec_tree = _SYNC_REC_TREE[logger]
+    except KeyError:
+        rec_tree = _SYNC_REC_TREE[logger] = weakref.WeakKeyDictionary()
+
+    try:
+        ret = rec_tree[record]
+    except KeyError:
+        ret = rec_tree[record] = _SYNC_ACTIVE_REC_MAP.get(logger)
+    return ret
+
+
+def _sync_set_active_record(logger, value):
+    _SYNC_ACTIVE_REC_MAP[logger] = value
+    return
+
+
 class LithoxylContext(object):
     def __init__(self, **kwargs):
         self.loggers = []
@@ -42,6 +67,11 @@ def __init__(self, **kwargs):
 
         self.note_handlers = []
 
+        self.get_parent_record = kwargs.pop('get_parent_record',
+                                            _sync_get_parent_record)
+        self.set_active_record = kwargs.get('set_active_record',
+                                            _sync_set_active_record)
+
     def note(self, name, message, *a, **kw):
         """Lithoxyl can't use itself internally. This is a hook for recording
         all of those error conditions that need to be robustly
@@ -59,37 +89,6 @@ def note(self, name, message, *a, **kw):
             nh(name, message)
         return
 
-    def _sync_parent_getter(self, record):
-        import weakref
-
-        logger = record.logger
-
-        try:
-            rec_tree = self._record_tree[logger]
-        except AttributeError:
-            self._record_tree = {}
-            rec_tree = self._record_tree[logger] = weakref.WeakKeyDictionary()
-            self._last_logged = weakref.WeakKeyDictionary({logger: None})
-        except KeyError:
-            rec_tree = self._record_tree[logger] = weakref.WeakKeyDictionary()
-
-        try:
-            ret = rec_tree[record]
-        except KeyError:
-            # haven't seen this one before
-            if self._last_logged.get(logger):
-                ret = self._last_logged[logger]
-                # TODO: might be belt and braces
-                if ret.record_id < record.record_id:
-                    self._last_logged[logger] = record
-            else:
-                # nothing logged yet
-                ret = None
-                self._last_logged[logger] = record
-
-            rec_tree[record] = ret
-        return ret
-
     def enable_async(self, **kwargs):
         update_loggers = kwargs.pop('update_loggers', True)
         update_sigterm = kwargs.pop('update_sigterm', True)

lithoxyl/record.py

@@ -91,7 +91,7 @@ def __init__(self, logger, level, name,
         self.warn_events = []
         self.exc_events = []
 
-        self.parent_record = self.logger.context._sync_parent_getter(self)
+        self.parent_record = self.logger.context.get_parent_record(self)
         return
 
     def __repr__(self):
@@ -206,6 +206,7 @@ def _complete(self, status, message, fargs, data,
 
     def __enter__(self):
         self._is_trans = self._defer_publish = True
+        self.logger.context.set_active_record(self.logger, self.parent_record)
         return self.begin()
 
     def __exit__(self, exc_type, exc_val, exc_tb):
@@ -225,9 +226,10 @@ def __exit__(self, exc_type, exc_val, exc_tb):
                 # now that _defer_publish=False, this will also publish
                 self.success()
 
+        self.logger.context.set_active_record(self.logger, self.parent_record)
+
         if self._reraise is False:
             return True  # ignore exception
-
         return
 
     def __getitem__(self, key):

playground.py

@@ -3,11 +3,13 @@
 # import faulthandler
 # faulthandler.enable()
 
+import lithoxyl
 from lithoxyl import (Logger,
                       SensibleSink,
                       ThresholdFilter,
                       StreamEmitter,
                       Formatter)
+import itertools
 
 stderr_fmt = Formatter(begin='{status_char}{begin_local_iso8601_noms_notz} - {begin_message}',
                        complete='{status_char}{end_local_iso8601_noms_notz} - {duration_msecs}ms - {end_message}')
@@ -37,11 +39,22 @@
 
 #context.get_context().enable_async()
 
-log = Logger('test', sinks=[stderr_sink])
+log = Logger('test')  # , sinks=[stderr_sink])
+
+
+def one_two():
+    with log.critical('first'):
+        with log.critical('second'):
+            print 'did some work'
+    return
+
+
+for i in range(2000):
+    one_two()
+
+
+print 'recs tracked:', len(lithoxyl.context._SYNC_REC_TREE[log])
 
-with log.critical('first') as lr1:
-    with log.critical('second') as lr2:
-        print 'did some work'
 
 import os
 print os.getpid()