rename functions for consistency

sebdiem · sebdiem · commit 0cb6107323a3 · 2024-07-23T19:32:34.000+02:00
We find the same pattern with buffer_log and flush: a sync version and a
version distributed to a thread pool.
This commit harmonizes namings:
- schedule_flush_sync =&gt; flush_with_lock
- try_lock_and_do_flush_request =&gt; flush_sync
diff --git a/logdna/logdna.py b/logdna/logdna.py
@@ -122,20 +122,20 @@ def buffer_log_sync(self, message):
                 self._lock.release()
 
     def flush(self):
-        self.schedule_flush_sync()
+        self.flush_with_lock()
 
-    def schedule_flush_sync(self, should_block=False):
+    def flush_with_lock(self, should_block=False):
         if self.request_thread_pool:
             try:
                 self.request_thread_pool.submit(
-                    self.try_lock_and_do_flush_request, should_block)
+                    self.flush_sync, should_block)
             except RuntimeError:
-                self.try_lock_and_do_flush_request(should_block)
+                self.flush_sync(should_block)
             except Exception as e:
                 self.internalLogger.debug(
                     'Error in calling try_lock_and_do_flush_request: %s', e)
 
-    def try_lock_and_do_flush_request(self, should_block=False):
+    def flush_sync(self, should_block=False):
         local_buf = []
         if self._lock.acquire(blocking=should_block):
             if not self.buf:
@@ -342,7 +342,7 @@ def close(self):
         # application exiting and because the probability of this
         # introducing a noticeable delay is very low because close() is only
         # called when the logger and application are shutting down.
-        self.schedule_flush_sync(should_block=True)
+        self.flush_with_lock(should_block=True)
 
         # Finally, shut down the thread pool that was used to send the log
         # messages to the server. We can assume at this point that all log
diff --git a/tests/test_logger.py b/tests/test_logger.py
@@ -140,7 +140,7 @@ def test_emit(self):
         handler.buffer_log.assert_called_once_with(sample_message)
 
     @mock.patch('time.time', unittest.mock.MagicMock(return_value=now))
-    def test_try_lock_and_do_flush_request(self):
+    def test_flush_sync(self):
         with patch('requests.post') as post_mock:
             handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
             r = requests.Response()
@@ -150,7 +150,7 @@ def test_try_lock_and_do_flush_request(self):
             sample_message['timestamp'] = unittest.mock.ANY
             handler.buf = [sample_message]
             test_buf = handler.buf.copy()
-            handler.try_lock_and_do_flush_request()
+            handler.flush_sync()
             post_mock.assert_called_with(
                 url=handler.url,
                 json={
@@ -255,11 +255,11 @@ def test_close(self):
         handler = LogDNAHandler(LOGDNA_API_KEY, sample_options)
         close_flusher_mock = unittest.mock.Mock()
         close_flusher_mock.side_effect = handler.close_flusher
-        handler.schedule_flush_sync = unittest.mock.Mock()
+        handler.flush_with_lock = unittest.mock.Mock()
         handler.close_flusher = close_flusher_mock
         handler.close()
         handler.close_flusher.assert_called_once_with()
-        handler.schedule_flush_sync.assert_called_once_with(
+        handler.flush_with_lock.assert_called_once_with(
             should_block=True)
         self.assertIsNone(handler.worker_thread_pool)
         self.assertIsNone(handler.request_thread_pool)
