More work on handler and listener

mathom · mathom · commit b356445c4ecc · 2014-10-15T13:19:51.000-05:00
diff --git a/stackify/__init__.py b/stackify/__init__.py
@@ -38,14 +38,18 @@
 from stackify.handler import StackifyHandler
 
 
+# TODO
+# holds our listeners, since more than one handler can service
+# the same listener
+__listener_cache = {}
+
+
 def getLogger(name=None, **kwargs):
+    '''
+    Get a logger and attach a StackifyHandler if needed:w
+    '''
     if not name:
-        try:
-            frame = inspect.stack()[1]
-            module = inspect.getmodule(frame[0])
-            name = module.__name__
-        except IndexError:
-            name = 'stackify-python-unknown'
+        name = getCallerName(2)
 
     logger = logging.getLogger(name)
 
@@ -57,6 +61,35 @@ def getLogger(name=None, **kwargs):
         if logger.getEffectiveLevel() == logging.NOTSET:
             logger.setLevel(DEFAULT_LEVEL)
 
+        handler.listener.start()
+
     return logger
 
+def stopLogging(logger):
+    '''
+    Shut down the StackifyHandler on a given logger. This will block
+    and wait for the queue to finish uploading.
+    '''
+    for handler in getHandlers(logger):
+        handler.listener.stop()
+
+
+def getCallerName(levels=1):
+    '''
+    Gets the name of the module calling this function
+    '''
+    try:
+        frame = inspect.stack()[levels]
+        module = inspect.getmodule(frame[0])
+        name = module.__name__
+    except IndexError:
+        name = 'stackify-python-unknown'
+    return name
+
+
+def getHandlers(logger):
+    '''
+    Return the StackifyHandlers on a given logger
+    '''
+    return [isinstance(x, StackifyHandler) for x in logger.handlers]
 
diff --git a/stackify/handler.py b/stackify/handler.py
@@ -1,5 +1,6 @@
 import logging
 import threading
+import os
 
 try:
     from logging.handlers import QueueHandler, QueueListener
@@ -11,10 +12,11 @@
 except ImportError:
     import queue
 
-from stackify import QUEUE_SIZE
+from stackify import QUEUE_SIZE, API_URL
 from stackify.log import LogMsg
 from stackify.error import ErrorItem
 from stackify.http import HTTPClient
+from stackify.application import ApiConfiguration
 
 
 
@@ -24,13 +26,16 @@ class StackifyHandler(QueueHandler):
     transmission to Stackify servers.
     '''
 
-    def __init__(self, queue_=None):
+    def __init__(self, queue_=None, listener=None **kwargs):
         if queue_ is None:
             queue_ = queue.Queue(QUEUE_SIZE)
 
         super(StackifyHandler, self).__init__(queue_)
 
-        self.listener = StackifyListener(queue_)
+        if listener is None:
+            listener = StackifyListener(queue_, **kwargs)
+
+        self.listener = listener
 
     def enqueue(self, record):
         '''
@@ -47,18 +52,43 @@ def enqueue(self, record):
             self.queue.put_nowait(record)
 
     def prepare(self, record):
-        print(record.__dict__)
         msg = LogMsg()
         msg.from_record(record)
 
         return msg
 
 
+def arg_or_env(name, args, default=None):
+    env_name = 'STACKIFY_{0}'.format(name.upper())
+    try:
+        return args.get(name, os.environ[env_name])
+    except KeyError:
+        if default:
+            return default
+        else:
+            raise NameError('You must specify the keyword argument {0} or environment variable {1}'.format(
+                name, env_name))
+
+
+
 class StackifyListener(QueueListener):
     '''
     A listener to read queued log messages and send them to Stackify.
     '''
 
-    def __init__(self, queue_):
+    def __init__(self, queue_, config=None, **kwargs):
         super(StackifyListener, self).__init__(queue_)
 
+        if config is None:
+            # config not specified, build one with kwargs or environment variables
+            config = ApiConfiguration(
+                application = arg_or_env('application', kwargs),
+                environment = arg_or_env('environment', kwargs),
+                api_key = arg_or_env('api_key', kwargs),
+                api_url = arg_or_env('api_url', kwargs, API_URL))
+
+        self.http = HTTPClient(config)
+
+    def handle(self, record):
+
+
