Created exchange logger which appends the name of the exchange to the logs

stacktach/stacklog.py

@@ -36,31 +36,33 @@ def set_default_logger_name(name):
     default_logger_name = name
 
 
-def _make_logger(name):
+def _logger_factory(exchange, name):
-    log = logging.getLogger(__name__)
+    if exchange:
-    log.setLevel(logging.DEBUG)
+        return ExchangeLogger(exchange, name)
-    handler = logging.handlers.TimedRotatingFileHandler(default_logger_location % name,
+    else:
-                                            when='midnight', interval=1, backupCount=3)
+        logger = logging.getLogger(__name__)
-    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        _configure(logger, name)
-    handler.setFormatter(formatter)
+        return logger
-    log.addHandler(handler)
+
-    log.handlers[0].doRollover()
+
+def _make_logger(name, exchange=None):
+    log = _logger_factory(exchange, name)
     return log
 
 
-def init_logger(name=None):
+def init_logger(name=None, exchange=None):
     global LOGGERS
     if name is None:
         name = default_logger_name
     if name not in LOGGERS:
-        LOGGERS[name] = _make_logger(name)
+        LOGGERS[name] = _make_logger(name, exchange)
 
 
-def get_logger(name=None):
+def get_logger(name=None, exchange=None):
     global LOGGERS
     if name is None:
         name = default_logger_name
-    init_logger(name=name)
+    init_logger(name=name, exchange=exchange)
     return LOGGERS[name]
 
 
@@ -80,3 +82,38 @@ def info(msg, name=None):
     if name is None:
         name = default_logger_name
     get_logger(name=name).info(msg)
+
+
+def _configure(logger, name):
+        logger.setLevel(logging.DEBUG)
+        handler = logging.handlers.TimedRotatingFileHandler(
+            default_logger_location % name,
+            when='midnight', interval=1, backupCount=3)
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        logger.handlers[0].doRollover()
+
+
+class ExchangeLogger():
+    def __init__(self, exchange, name='stacktach-default'):
+        self.logger = logging.getLogger(name)
+        _configure(self.logger, name)
+        self.exchange = exchange
+
+    def info(self, msg, *args, **kwargs):
+        msg = self.exchange + ': ' + msg
+        self.logger.info(msg, *args, **kwargs)
+
+    def warn(self, msg, *args, **kwargs):
+        msg = self.exchange + ': ' + msg
+        self.logger.warn(msg, *args, **kwargs)
+
+    def error(self, msg, *args, **kwargs):
+        msg = self.exchange + ': ' + msg
+        self.logger.error(msg, *args, **kwargs)
+
+    def exception(self, msg, *args, **kwargs):
+        msg = self.exchange + ': ' + msg
+        self.logger.error(msg, *args, **kwargs)

tests/unit/test_stacklog.py

@@ -0,0 +1,102 @@
+import glob
+import logging
+import os
+from unittest import TestCase
+import mox
+from stacktach import stacklog
+import __builtin__
+from stacktach.stacklog import ExchangeLogger
+
+
+class StacklogTestCase(TestCase):
+    def setUp(self):
+        self.mox = mox.Mox()
+
+    def tearDown(self):
+        self.mox.UnsetStubs()
+
+    def test_get_logger_should_get_exchange_logger_if_exchange_provided(self):
+        filename = 'filename'
+        logger = stacklog.get_logger(filename, 'nova')
+        self.assertIsInstance(logger, ExchangeLogger)
+        for file in glob.glob('{0}.log*'.format(filename)):
+            os.remove(file)
+
+    def test_get_logger_should_get_default_logger_if_exchange_not_provided(self):
+        filename = 'default_logger'
+        logger = stacklog.get_logger(filename)
+        self.assertIsInstance(logger, logging.Logger)
+        for file in glob.glob('{0}.log*'.format(filename)):
+            os.remove(file)
+
+
+class ExchangeLoggerTestCase(TestCase):
+    def setUp(self):
+        self.mox = mox.Mox()
+
+    def tearDown(self):
+        self.mox.UnsetStubs()
+
+    def _setup_logger_mocks(self, name='name'):
+        mock_logger = self.mox.CreateMockAnything()
+        self.mox.StubOutWithMock(logging, 'getLogger')
+        logging.getLogger(name).AndReturn(mock_logger)
+        mock_logger.setLevel(logging.DEBUG)
+        self.mox.StubOutClassWithMocks(logging.handlers,
+                                       'TimedRotatingFileHandler')
+        filename = "{0}.log".format(name)
+        handler = logging.handlers.TimedRotatingFileHandler(
+            filename, backupCount=3, interval=1, when='midnight')
+        self.mox.StubOutClassWithMocks(logging, 'Formatter')
+        mock_formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+        handler.setFormatter(mock_formatter)
+        mock_logger.addHandler(handler)
+        mock_logger.handlers = [handler]
+        handler.doRollover()
+        return mock_logger
+
+    def test_exchange_logger_should_append_exchange_name_to_info(self):
+        mock_logger = self._setup_logger_mocks()
+        mock_logger.info('exchange: Log %s', 'args', xyz='xyz')
+        self.mox.ReplayAll()
+
+        log = ExchangeLogger('exchange', 'name')
+        log.info("Log %s", 'args', xyz='xyz')
+        self.mox.VerifyAll()
+
+    def test_exchange_logger_should_append_exchange_name_to_warn(self):
+        mock_logger = self._setup_logger_mocks()
+        mock_logger.warn('exchange: Log %s', 'args', xyz='xyz')
+        self.mox.ReplayAll()
+
+        logger = ExchangeLogger('exchange', 'name')
+        logger.warn("Log %s", 'args', xyz='xyz')
+        self.mox.VerifyAll()
+
+    def test_exchange_logger_should_append_exchange_name_to_error(self):
+        mock_logger = self._setup_logger_mocks()
+        mock_logger.error('exchange: Log %s', 'args', xyz='xyz')
+        self.mox.ReplayAll()
+
+        logger = ExchangeLogger('exchange', 'name')
+        logger.error("Log %s", 'args', xyz='xyz')
+        self.mox.VerifyAll()
+
+    def test_exchange_logger_should_append_exchange_name_to_exception(self):
+        mock_logger = self._setup_logger_mocks()
+        mock_logger.error('exchange: Log %s', 'args', xyz='xyz')
+        self.mox.ReplayAll()
+
+        logger = ExchangeLogger('exchange', 'name')
+        logger.exception("Log %s", 'args', xyz='xyz')
+        self.mox.VerifyAll()
+
+    def test_exchange_logger_should_use_default_name_if_not_provided(self):
+        self._setup_logger_mocks('stacktach-default')
+        self.mox.ReplayAll()
+
+        ExchangeLogger('exchange')
+        self.mox.VerifyAll()
+
+