Make "use_logging" parameter global

Author: ildus

README.md

@@ -82,7 +82,7 @@ If you'd like to keep logs, execute `configure_testgres(node_cleanup_full=False)
 
 > Note: context managers (aka `with`) call `stop()` and `cleanup()` automatically.
 
-testgres supports [python logging](https://docs.python.org/3.6/library/logging.html),
+`testgres` supports [python logging](https://docs.python.org/3.6/library/logging.html),
 which means that you can aggregate logs from several nodes into one file:
 
 ```python
@@ -91,13 +91,20 @@ import logging
 # write everything to /tmp/testgres.log
 logging.basicConfig(filename='/tmp/testgres.log')
 
-# create two different nodes with logging
-node1 = testgres.get_new_node(use_logging=True).init().start()
-node2 = testgres.get_new_node(use_logging=True).init().start()
+# enable logging, and create two different nodes
+testgres.configure_testgres(enable_python_logging=True)
+node1 = testgres.get_new_node().init().start()
+node2 = testgres.get_new_node().init().start()
 
 # execute a few queries
 node1.execute('select 1')
 node2.execute('select 2')
+
+# disable logging
+testgres.configure_testgres(enable_python_logging=False)
+
+Look at `tests/test_simple.py` file for a complete example of the logging
+configuration.
 ```
 
 

testgres/api.py

@@ -36,17 +36,16 @@
 from .node import PostgresNode
 
 
-def get_new_node(name=None, base_dir=None, use_logging=False):
+def get_new_node(name=None, base_dir=None):
     """
     Create a new node (select port automatically).
 
     Args:
         name: node's application name.
         base_dir: path to node's data directory.
-        use_logging: enable python logging.
 
     Returns:
         An instance of PostgresNode.
     """
 
-    return PostgresNode(name=name, base_dir=base_dir, use_logging=use_logging)
+    return PostgresNode(name=name, base_dir=base_dir)

testgres/backup.py

@@ -115,14 +115,13 @@ def _prepare_dir(self, destroy):
         # Return path to new node
         return dest_base_dir
 
-    def spawn_primary(self, name=None, destroy=True, use_logging=False):
+    def spawn_primary(self, name=None, destroy=True):
         """
         Create a primary node from a backup.
 
         Args:
             name: primary's application name.
             destroy: should we convert this backup into a node?
-            use_logging: enable python logging.
 
         Returns:
             New instance of PostgresNode.
@@ -134,8 +133,7 @@ def spawn_primary(self, name=None, destroy=True, use_logging=False):
         # Build a new PostgresNode
         from .node import PostgresNode
         node = PostgresNode(name=name,
-                            base_dir=base_dir,
-                            use_logging=use_logging)
+                            base_dir=base_dir)
 
         # New nodes should always remove dir tree
         node._should_rm_dirs = True
@@ -145,23 +143,21 @@ def spawn_primary(self, name=None, destroy=True, use_logging=False):
 
         return node
 
-    def spawn_replica(self, name=None, destroy=True, use_logging=False):
+    def spawn_replica(self, name=None, destroy=True):
         """
         Create a replica of the original node from a backup.
 
         Args:
             name: replica's application name.
             destroy: should we convert this backup into a node?
-            use_logging: enable python logging.
 
         Returns:
             New instance of PostgresNode.
         """
 
         # Build a new PostgresNode
         node = self.spawn_primary(name=name,
-                                  destroy=destroy,
-                                  use_logging=use_logging)
+                                  destroy=destroy)
 
         # Assign it a master and a recovery file (private magic)
         node._assign_master(self.original_node)

testgres/config.py

@@ -11,6 +11,7 @@ class TestgresConfig:
 
         cache_pg_config:    shall we cache pg_config results?
 
+        use_python_logging: use python logging configuration for all nodes.
         error_log_lines:    N of log lines to be included into exception (0=inf).
 
         node_cleanup_full:  shall we remove EVERYTHING (including logs)?
@@ -23,6 +24,7 @@ class TestgresConfig:
 
     cache_pg_config = True
 
+    use_python_logging = False
     error_log_lines = 20
 
     node_cleanup_full = True

testgres/node.py

@@ -70,15 +70,14 @@ def __bool__(self):
 
 
 class PostgresNode(object):
-    def __init__(self, name=None, port=None, base_dir=None, use_logging=False):
+    def __init__(self, name=None, port=None, base_dir=None):
         """
         Create a new node manually.
 
         Args:
             name: node's application name.
             port: port to accept connections.
             base_dir: path to node's data directory.
-            use_logging: enable python logging.
         """
 
         # basic
@@ -94,7 +93,6 @@ def __init__(self, name=None, port=None, base_dir=None, use_logging=False):
 
         # private
         self._should_free_port = port is None
-        self._use_logging = use_logging
         self._logger = None
         self._master = None
 
@@ -205,7 +203,7 @@ def _prepare_dirs(self):
             os.makedirs(self.logs_dir)
 
     def _maybe_start_logger(self):
-        if self._use_logging:
+        if TestgresConfig.use_python_logging:
             # spawn new logger if it doesn't exist or is stopped
             if not self._logger or not self._logger.is_alive():
                 self._logger = TestgresLogger(self.name, self.pg_log_name)
@@ -869,24 +867,20 @@ def backup(self, username=None, xlog_method=DEFAULT_XLOG_METHOD):
     def replicate(self,
                   name=None,
                   username=None,
-                  xlog_method=DEFAULT_XLOG_METHOD,
-                  use_logging=False):
+                  xlog_method=DEFAULT_XLOG_METHOD):
         """
         Create a binary replica of this node.
 
         Args:
             name: replica's application name.
             username: database user name.
             xlog_method: a method for collecting the logs ('fetch' | 'stream').
-            use_logging: enable python logging.
         """
 
         backup = self.backup(username=username, xlog_method=xlog_method)
 
         # transform backup into a replica
-        return backup.spawn_replica(name=name,
-                                    destroy=True,
-                                    use_logging=use_logging)
+        return backup.spawn_replica(name=name, destroy=True)
 
     def catchup(self, dbname=None, username=None):
         """

tests/test_simple.py

@@ -458,9 +458,10 @@ def test_logging(self):
         }
 
         logging.config.dictConfig(log_conf)
+        configure_testgres(use_python_logging=True)
 
         node_name = 'master'
-        with get_new_node(name=node_name, use_logging=True) as master:
+        with get_new_node(name=node_name) as master:
             master.init().start()
 
             # execute a dummy query a few times
@@ -482,6 +483,8 @@ def test_logging(self):
             master.restart()
             self.assertTrue(master._logger.is_alive())
 
+        configure_testgres(use_python_logging=False)
+
     @unittest.skipUnless(
         util_is_executable("pgbench"), "pgbench may be missing")
     def test_pgbench(self):