logtail-python 0.3.4__tar.gz → 0.4.1__tar.gz

{logtail_python-0.3.4/logtail_python.egg-info → logtail_python-0.4.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: logtail-python
-Version: 0.3.4
-Summary: Logtail.com client library
+Version: 0.4.1
+Summary: Better Stack client library
 Home-page: https://github.com/logtail/logtail-python
-Download-URL: https://github.com/logtail/logtail-python/tarball/0.3.4
+Download-URL: https://github.com/logtail/logtail-python/tarball/0.4.1
 Author: Logtail
 Author-email: hello@logtail.com
 License: ISC
@@ -12,13 +12,14 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: ISC License (ISCL)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: requests>=2.18.4
@@ -34,6 +35,7 @@ Dynamic: keywords
 Dynamic: license
 Dynamic: license-file
 Dynamic: requires-dist
+Dynamic: requires-python
 Dynamic: summary
 
 # [Better Stack](https://betterstack.com/logs) Python client

{logtail_python-0.3.4 → logtail_python-0.4.1}/logtail/__init__.py

@@ -5,6 +5,6 @@ from .handler import LogtailHandler
 from .helpers import LogtailContext, DEFAULT_CONTEXT
 from .formatter import LogtailFormatter
 
-__version__ = '0.3.4'
+__version__ = '0.4.1'
 
 context = DEFAULT_CONTEXT

{logtail_python-0.3.4 → logtail_python-0.4.1}/logtail/flusher.py

@@ -9,6 +9,14 @@ from .compat import queue
 RETRY_SCHEDULE = (1, 10, 60)  # seconds
 
 
+class TransportFrame(dict):
+    """A record logged by a flush worker itself, i.e. urllib3 describing our own upload.
+
+    It rides along with the next batch of regular records but never triggers an upload
+    on its own, since that upload would log again and the queue would never drain.
+    """
+
+
 class FlushWorker(threading.Thread):
     def __init__(self, upload, pipe, buffer_capacity, flush_interval, check_interval):
         threading.Thread.__init__(self)
@@ -26,6 +34,16 @@ class FlushWorker(threading.Thread):
         while self.should_run:
             self.step()
 
+    def _is_parent_alive(self):
+        try:
+            return self.parent_thread.is_alive()
+        except RuntimeError:
+            # Starting with Python 3.14, calling is_alive() on an
+            # already-terminated thread raises a RuntimeError instead of
+            # returning False (see the parent thread being torn down during
+            # interpreter shutdown). Treat that as "no longer alive".
+            return False
+
     def step(self):
         last_flush = time.time()
         time_remaining = _initial_time_remaining(self.flush_interval)
@@ -34,7 +52,7 @@ class FlushWorker(threading.Thread):
 
         # If the parent thread has exited but there are still outstanding
         # events, attempt to send them before exiting.
-        shutdown = not self.parent_thread.is_alive()
+        shutdown = not self._is_parent_alive()
 
         # Fill phase: take events out of the queue and group them for sending.
         # Takes up to `buffer_capacity` events out of the queue and groups them
@@ -54,14 +72,14 @@ class FlushWorker(threading.Thread):
             except queue.Empty:
                 if shutdown or self._flushing:
                     break
-            shutdown = not self.parent_thread.is_alive()
+            shutdown = not self._is_parent_alive()
             time_remaining = _calculate_time_remaining(last_flush, self.flush_interval)
 
         # Send phase: takes the outstanding events (up to `buffer_capacity`
-        # count) and sends them to the Logtail endpoint all at once. If the
+        # count) and sends them to the Better Stack endpoint all at once. If the
         # request fails in a way that can be retried, it is retried with an
         # exponential backoff in between attempts.
-        if frame:
+        if frame and not all(isinstance(entry, TransportFrame) for entry in frame):
             response = None
             for delay in RETRY_SCHEDULE + (None, ):
                 response = self.upload(frame)
@@ -70,7 +88,12 @@ class FlushWorker(threading.Thread):
                 if delay is not None:
                     time.sleep(delay)
 
-            if response.status_code == 500 and getattr(response, "exception") != None:
+            # A network error surfaces as a Fake500 that carries an `exception`
+            # attribute; a genuine server HTTP 500 is a real `requests.Response`
+            # that has no such attribute. Use a default so the latter doesn't
+            # raise AttributeError here and kill the flush thread (dropping all
+            # subsequent logs for the life of the process).
+            if response.status_code == 500 and getattr(response, "exception", None) is not None:
                 print('Failed to send logs to Better Stack after {} retries: {}'.format(len(RETRY_SCHEDULE), response.exception))
 
         self._clean = True
@@ -83,6 +106,10 @@ class FlushWorker(threading.Thread):
             time.sleep(self.check_interval)
         self._flushing = False
 
+def in_flush_worker():
+    return isinstance(threading.current_thread(), FlushWorker)
+
+
 def _initial_time_remaining(flush_interval):
     return flush_interval
 

{logtail_python-0.3.4 → logtail_python-0.4.1}/logtail/handler.py

@@ -2,10 +2,12 @@
 from __future__ import print_function, unicode_literals
 import logging
 import json
+import os
+import weakref
 
 from .compat import queue
 from .helpers import DEFAULT_CONTEXT
-from .flusher import FlushWorker
+from .flusher import FlushWorker, TransportFrame, in_flush_worker
 from .uploader import Uploader
 from .frame import create_frame
 
@@ -18,6 +20,8 @@ DEFAULT_DROP_EXTRA_EVENTS = True
 DEFAULT_INCLUDE_EXTRA_ATTRIBUTES = True
 DEFAULT_TIMEOUT = 30
 
+_handlers = weakref.WeakSet()
+
 
 class LogtailHandler(logging.Handler):
     def __init__(self,
@@ -50,6 +54,7 @@ class LogtailHandler(logging.Handler):
         self.dropcount = 0
         # Do not initialize the flush thread yet because it causes issues on Render.
         self.flush_thread = None
+        _handlers.add(self)
 
     def ensure_flush_thread_alive(self):
         if self.flush_thread and self.flush_thread.is_alive():
@@ -71,8 +76,12 @@ class LogtailHandler(logging.Handler):
             message = self.format(record)
             frame = create_frame(record, message, self.context, include_extra_attributes=self.include_extra_attributes)
             serializable_frame = json.loads(json.dumps(frame, default=str))
+            transport = in_flush_worker()
+            if transport:
+                serializable_frame = TransportFrame(serializable_frame)
             try:
-                self.pipe.put(serializable_frame, block=(not self.drop_extra_events))
+                # The flush worker must never block on its own queue, so its records are dropped when full.
+                self.pipe.put(serializable_frame, block=(not self.drop_extra_events) and not transport)
             except queue.Full:
                 # Only raised when not blocking, which means that extra events
                 # should be dropped.
@@ -84,3 +93,20 @@ class LogtailHandler(logging.Handler):
     def flush(self):
         if self.flush_thread and self.flush_thread.is_alive():
              self.flush_thread.flush()
+
+    def _reset_after_fork(self):
+        # A forked child inherits the parent's queue with whatever was still buffered in it,
+        # a flush thread object whose thread does not exist in the child, and an HTTP session
+        # whose socket it shares with the parent, so it starts over with fresh ones.
+        self.pipe = queue.Queue(maxsize=self.buffer_capacity)
+        self.flush_thread = None
+        self.uploader = Uploader(self.source_token, self.host, self.uploader.timeout)
+
+
+def _reset_handlers_after_fork():
+    for handler in _handlers:
+        handler._reset_after_fork()
+
+
+if hasattr(os, 'register_at_fork'):
+    os.register_at_fork(after_in_child=_reset_handlers_after_fork)

logtail_python-0.4.1/logtail/rq.py

@@ -0,0 +1,29 @@
+# coding: utf-8
+from __future__ import print_function, unicode_literals
+import logging
+
+import rq
+
+from .handler import LogtailHandler
+
+
+class Worker(rq.Worker):
+    """An RQ worker that sends buffered log records after every job.
+
+    RQ runs each job in a forked work horse and ends it with os._exit(), which skips the
+    interpreter shutdown that would otherwise let LogtailHandler flush. Use it with
+    `rq worker --worker-class logtail.rq.Worker` or `RQ = {"WORKER_CLASS": "logtail.rq.Worker"}`
+    in django-rq.
+    """
+
+    def perform_job(self, job, queue):
+        try:
+            return super(Worker, self).perform_job(job, queue)
+        finally:
+            for handler in _logtail_handlers():
+                handler.flush()
+
+
+def _logtail_handlers():
+    loggers = [logging.getLogger()] + [logger for logger in logging.Logger.manager.loggerDict.values() if isinstance(logger, logging.Logger)]
+    return {handler for logger in loggers for handler in logger.handlers if isinstance(handler, LogtailHandler)}

{logtail_python-0.3.4 → logtail_python-0.4.1/logtail_python.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: logtail-python
-Version: 0.3.4
-Summary: Logtail.com client library
+Version: 0.4.1
+Summary: Better Stack client library
 Home-page: https://github.com/logtail/logtail-python
-Download-URL: https://github.com/logtail/logtail-python/tarball/0.3.4
+Download-URL: https://github.com/logtail/logtail-python/tarball/0.4.1
 Author: Logtail
 Author-email: hello@logtail.com
 License: ISC
@@ -12,13 +12,14 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: ISC License (ISCL)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: requests>=2.18.4
@@ -34,6 +35,7 @@ Dynamic: keywords
 Dynamic: license
 Dynamic: license-file
 Dynamic: requires-dist
+Dynamic: requires-python
 Dynamic: summary
 
 # [Better Stack](https://betterstack.com/logs) Python client

{logtail_python-0.3.4 → logtail_python-0.4.1}/logtail_python.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ logtail/formatter.py
 logtail/frame.py
 logtail/handler.py
 logtail/helpers.py
+logtail/rq.py
 logtail/uploader.py
 logtail_python.egg-info/PKG-INFO
 logtail_python.egg-info/SOURCES.txt
@@ -24,11 +25,5 @@ tests/test_formatter.py
 tests/test_frame.py
 tests/test_handler.py
 tests/test_helpers.py
-tests/test_uploader.py
-tests/__pycache__/__init__.cpython-311.pyc
-tests/__pycache__/test_flusher.cpython-311.pyc
-tests/__pycache__/test_formatter.cpython-311.pyc
-tests/__pycache__/test_frame.cpython-311.pyc
-tests/__pycache__/test_handler.cpython-311.pyc
-tests/__pycache__/test_helpers.cpython-311.pyc
-tests/__pycache__/test_uploader.cpython-311.pyc
+tests/test_rq.py
+tests/test_uploader.py

{logtail_python-0.3.4 → logtail_python-0.4.1}/setup.py

@@ -3,7 +3,7 @@ import os
 from setuptools import setup
 
 
-VERSION = '0.3.4'
+VERSION = '0.4.1'
 ROOT_DIR = os.path.dirname(__file__)
 
 REQUIREMENTS = [
@@ -20,13 +20,14 @@ setup(
     packages=['logtail'],
     include_package_data=True,
     license='ISC',
-    description='Logtail.com client library',
+    description='Better Stack client library',
     long_description=long_description,
     long_description_content_type='text/markdown',
     url='https://github.com/logtail/logtail-python',
     download_url='https://github.com/logtail/logtail-python/tarball/%s' % (VERSION),
     keywords=['api', 'logtail', 'logging', 'client'],
     install_requires=REQUIREMENTS,
+    python_requires='>=3.10',
     author='Logtail',
     author_email='hello@logtail.com',
     classifiers=[
@@ -34,11 +35,11 @@ setup(
           'License :: OSI Approved :: ISC License (ISCL)',
           'Operating System :: OS Independent',
           'Programming Language :: Python :: 3',
-          'Programming Language :: Python :: 3.7',
-          'Programming Language :: Python :: 3.8',
-          'Programming Language :: Python :: 3.9',
           'Programming Language :: Python :: 3.10',
           'Programming Language :: Python :: 3.11',
+          'Programming Language :: Python :: 3.12',
+          'Programming Language :: Python :: 3.13',
+          'Programming Language :: Python :: 3.14',
           'Programming Language :: Python',
           'Topic :: Software Development :: Libraries :: Python Modules',
     ],

{logtail_python-0.3.4 → logtail_python-0.4.1}/test-requirements.txt

@@ -2,3 +2,4 @@ coverage>=3.7.1
 httpretty>=0.9.4
 nose-py3
 mock>=1.0.1
+rq

{logtail_python-0.3.4 → logtail_python-0.4.1}/tests/test_flusher.py

@@ -1,7 +1,7 @@
 # coding: utf-8
 from __future__ import print_function, unicode_literals
 import mock
-import sys
+import requests
 import time
 import threading
 import unittest
@@ -124,6 +124,48 @@ class TestFlushWorker(unittest.TestCase):
         self.assertEqual(self.uploader_calls, len(RETRY_SCHEDULE) + 1)
         self.assertEqual(self.sleep_calls, len(RETRY_SCHEDULE))
 
+    @patch('logtail.flusher.time.sleep')
+    def test_step_does_not_crash_on_real_server_500(self, _mock_sleep):
+        # Regression: a genuine server HTTP 500 returns a real requests.Response,
+        # which (unlike the network-error Fake500) has no `.exception` attribute.
+        # `getattr(response, "exception")` without a default raised AttributeError
+        # here, which propagates out of step()/run() and kills the flush thread —
+        # every subsequent log is then queued but never sent. (Note: MagicMock
+        # would auto-vivify `.exception` and hide the bug, so use a real Response.)
+        first_frame = list(range(self.buffer_capacity))
+
+        def uploader(frame):
+            resp = requests.models.Response()
+            resp.status_code = 500
+            return resp
+
+        pipe, _, fw = self._setup_worker(uploader)
+        for log in first_frame:
+            pipe.put(log, block=False)
+
+        fw.step()  # must not raise AttributeError
+
+        self.assertTrue(fw._clean)
+
+    @patch('logtail.flusher.time.sleep')
+    def test_step_still_logs_network_error_fake500(self, _mock_sleep):
+        # The network-error path (Fake500 carrying an exception) must still log.
+        from logtail.uploader import Fake500
+
+        first_frame = list(range(self.buffer_capacity))
+
+        def uploader(frame):
+            return Fake500(Exception('network is down'))
+
+        pipe, _, fw = self._setup_worker(uploader)
+        for log in first_frame:
+            pipe.put(log, block=False)
+
+        with patch('builtins.print') as mock_print:
+            fw.step()
+
+        mock_print.assert_called_once()
+
     def test_shutdown_condition_empties_queue_and_shuts_down(self):
         self.buffer_capacity = 10
         num_items = 5
@@ -146,8 +188,39 @@ class TestFlushWorker(unittest.TestCase):
         self.assertEqual(self.upload_calls, 1)
         self.assertFalse(fw.should_run)
 
-    # test relies on overriding excepthook which is available from 3.8+
-    @unittest.skipIf(sys.version_info < (3, 8), "Test skipped because overriding excepthook is only available on Python 3.8+")
+    def test_is_parent_alive_handles_runtime_error(self):
+        # Starting with Python 3.14, is_alive() raises RuntimeError when
+        # called on an already-terminated thread instead of returning False.
+        # The worker must treat that as the parent no longer being alive.
+        _, _, fw = self._setup_worker()
+        fw.parent_thread = mock.MagicMock()
+        fw.parent_thread.is_alive.side_effect = RuntimeError('cannot join current thread')
+
+        self.assertFalse(fw._is_parent_alive())
+
+    def test_shutdown_condition_when_parent_is_alive_raises(self):
+        self.buffer_capacity = 10
+        num_items = 5
+        first_frame = list(range(self.buffer_capacity))
+        self.assertLess(num_items, self.buffer_capacity)
+
+        self.upload_calls = 0
+        def uploader(frame):
+            self.upload_calls += 1
+            self.assertEqual(frame, first_frame[:num_items])
+            return mock.MagicMock(status_code=202)
+
+        pipe, _, fw = self._setup_worker(uploader)
+        fw.parent_thread = mock.MagicMock()
+        fw.parent_thread.is_alive.side_effect = RuntimeError('cannot join current thread')
+
+        for i in range(num_items):
+            pipe.put(first_frame[i], block=False)
+
+        fw.step()
+        self.assertEqual(self.upload_calls, 1)
+        self.assertFalse(fw.should_run)
+
     def test_shutdown_dont_raise_exception_in_thread(self):
         original_excepthook = threading.excepthook
         threading.excepthook = mock.Mock()

{logtail_python-0.3.4 → logtail_python-0.4.1}/tests/test_frame.py

@@ -3,7 +3,6 @@
 from logtail.frame import create_frame
 from logtail.handler import LogtailHandler
 from logtail.helpers import LogtailContext
-from sys import version_info
 import datetime
 import unittest
 import logging
@@ -17,11 +16,8 @@ class TestLogtailLogEntry(unittest.TestCase):
         # ISO timestamp must end with timezone info
         self.assertTrue(frame['dt'].endswith("+00:00"))
 
-        # These tests require Python >= 3.7
-        if version_info.major == 2 or version_info.minor <= 6:
-            return
         # Sent date matches log record date
-        date_ref = datetime.datetime.utcfromtimestamp(log_record.created).replace(tzinfo=datetime.timezone.utc)
+        date_ref = datetime.datetime.fromtimestamp(log_record.created, datetime.timezone.utc)
         date_sent = datetime.datetime.fromisoformat(frame['dt'])
         self.assertEqual(date_ref, date_sent)
 

{logtail_python-0.3.4 → logtail_python-0.4.1}/tests/test_handler.py

@@ -1,6 +1,7 @@
 # coding: utf-8
 from __future__ import print_function, unicode_literals
 import mock
+import os
 import time
 import threading
 import unittest
@@ -277,6 +278,107 @@ class TestLogtailHandler(unittest.TestCase):
         self.assertEqual(log_entry['context']['data']['egg']['chicken']['egg'], "<omitted circular reference>")
         self.assertTrue(handler.pipe.empty())
 
+    @patch('logtail.handler.FlushWorker')
+    def test_forked_child_starts_with_a_fresh_queue_thread_and_session(self, MockWorker):
+        handler = LogtailHandler(source_token=self.source_token)
+        logger = logging.getLogger(__name__)
+        logger.handlers = []
+        logger.addHandler(handler)
+        logger.critical('queued in the parent')
+        parent_session = handler.uploader.session
+
+        pid = os.fork()
+        if pid == 0:
+            fresh = handler.pipe.empty() and handler.flush_thread is None and handler.uploader.session is not parent_session
+            os._exit(0 if fresh else 1)
+        _, status = os.waitpid(pid, 0)
+
+        self.assertEqual(os.waitstatus_to_exitcode(status), 0)
+        self.assertEqual(handler.pipe.get(block=False)['message'], 'queued in the parent')
+
+    def test_flush_returns_when_the_upload_itself_logs_to_the_handler(self):
+        logger = logging.getLogger(__name__)
+        logger.handlers = []
+        logger.setLevel(logging.DEBUG)
+        handler = LogtailHandler(source_token=self.source_token, flush_interval=0.01, check_interval=0.01)
+        uploads = []
+
+        def upload(frame):
+            uploads.append(frame)
+            # urllib3 logs every request it makes at DEBUG, and a handler on the
+            # root logger receives that record.
+            logger.debug('http://in.logs.betterstack.com:443 "POST / HTTP/1.1" 202 0')
+            return mock.MagicMock(status_code=202)
+
+        handler.uploader = upload
+        logger.addHandler(handler)
+        logger.info('hello')
+        self.addCleanup(self._stop_flush_worker, handler)
+
+        flushed = threading.Event()
+        threading.Thread(target=lambda: (handler.flush(), flushed.set()), daemon=True).start()
+
+        self.assertTrue(flushed.wait(2), 'flush() did not return')
+        self.assertEqual([f['message'] for frame in uploads for f in frame], ['hello'])
+
+    def test_records_logged_by_the_upload_ride_along_with_the_next_batch(self):
+        logger = logging.getLogger(__name__)
+        logger.handlers = []
+        logger.setLevel(logging.DEBUG)
+        # Only a full buffer sends a batch within the test.
+        handler = LogtailHandler(source_token=self.source_token, buffer_capacity=2, flush_interval=1000, check_interval=0.01)
+        uploads = []
+
+        def upload(frame):
+            logger.debug('POST / 202')  # what urllib3 does, still inside the request
+            uploads.append([f['message'] for f in frame])
+            return mock.MagicMock(status_code=202)
+
+        handler.uploader = upload
+        logger.addHandler(handler)
+        self.addCleanup(self._stop_flush_worker, handler)
+
+        logger.info('hello')
+        logger.info('hello again')
+        self._wait_until(lambda: len(uploads) == 1)
+        logger.info('world')
+        self._wait_until(lambda: len(uploads) == 2)
+
+        self.assertEqual(uploads, [['hello', 'hello again'], ['POST / 202', 'world']])
+
+    def test_a_batch_of_only_the_uploads_own_records_is_dropped_not_sent(self):
+        logger = logging.getLogger(__name__)
+        logger.handlers = []
+        logger.setLevel(logging.DEBUG)
+        handler = LogtailHandler(source_token=self.source_token, flush_interval=0.01, check_interval=0.01)
+        uploads = []
+
+        def upload(frame):
+            logger.debug('POST / 202')
+            uploads.append([f['message'] for f in frame])
+            return mock.MagicMock(status_code=202)
+
+        handler.uploader = upload
+        logger.addHandler(handler)
+        self.addCleanup(self._stop_flush_worker, handler)
+
+        logger.info('hello')
+        self._wait_until(lambda: len(uploads) == 1)
+        time.sleep(0.1)  # several flush intervals, enough for the loop to show if it existed
+
+        self.assertEqual(uploads, [['hello']])
+        self.assertTrue(handler.pipe.empty())
+
+    def _wait_until(self, condition):
+        deadline = time.time() + 2
+        while not condition() and time.time() < deadline:
+            time.sleep(0.01)
+        self.assertTrue(condition())
+
+    def _stop_flush_worker(self, handler):
+        handler.flush_thread.should_run = False
+        handler.flush_thread.join(1)
+
 
 class UnserializableObject(object):
     """ Because this is a custom class, it cannot be serialized into JSON. """

logtail_python-0.4.1/tests/test_rq.py

@@ -0,0 +1,81 @@
+# coding: utf-8
+from __future__ import print_function, unicode_literals
+import json
+import logging
+import mock
+import os
+import unittest
+
+from unittest.mock import patch
+
+import rq
+
+from logtail import LogtailHandler
+from logtail.rq import Worker
+
+
+class TestWorker(unittest.TestCase):
+    source_token = 'dummy_source_token'
+
+    def setUp(self):
+        self.logger = logging.getLogger(__name__)
+        self.logger.handlers = []
+        self.logger.setLevel(logging.DEBUG)
+        self.uploads = []
+        # Only an explicit flush can send anything within the test.
+        self.handler = LogtailHandler(source_token=self.source_token, flush_interval=1000, check_interval=0.01)
+        self.handler.uploader = self._upload
+        self.logger.addHandler(self.handler)
+        connection = mock.MagicMock()
+        connection.connection_pool.connection_kwargs = {}
+        self.worker = Worker(['default'], connection=connection, prepare_for_work=False)
+
+    def tearDown(self):
+        if self.handler.flush_thread:
+            self.handler.flush_thread.should_run = False
+            self.handler.flush_thread.join(1)
+
+    def _upload(self, frame):
+        self.uploads.append([f['message'] for f in frame])
+        return mock.MagicMock(status_code=202)
+
+    def test_is_an_rq_worker(self):
+        self.assertIsInstance(self.worker, rq.Worker)
+
+    @patch.object(rq.Worker, 'perform_job')
+    def test_flushes_logtail_handlers_after_the_job(self, perform_job):
+        perform_job.side_effect = lambda job, queue: self.logger.info('inside the job') or True
+
+        self.assertTrue(self.worker.perform_job(mock.sentinel.job, mock.sentinel.queue))
+
+        perform_job.assert_called_once_with(mock.sentinel.job, mock.sentinel.queue)
+        self.assertEqual(self.uploads, [['inside the job']])
+
+    @patch.object(rq.Worker, 'perform_job')
+    def test_flushes_logtail_handlers_when_the_job_raises(self, perform_job):
+        def fail(job, queue):
+            self.logger.error('the job blew up')
+            raise ValueError('boom')
+        perform_job.side_effect = fail
+
+        with self.assertRaises(ValueError):
+            self.worker.perform_job(mock.sentinel.job, mock.sentinel.queue)
+
+        self.assertEqual(self.uploads, [['the job blew up']])
+
+    @patch.object(rq.Worker, 'perform_job')
+    def test_records_logged_in_the_work_horse_are_sent_before_it_exits(self, perform_job):
+        # RQ forks a work horse per job and ends it with os._exit(), which skips
+        # the interpreter shutdown that would otherwise flush the handler.
+        perform_job.side_effect = lambda job, queue: self.logger.info('inside the work horse')
+        read_end, write_end = os.pipe()
+        self.handler.uploader = lambda frame: os.write(write_end, json.dumps([f['message'] for f in frame]).encode()) and mock.MagicMock(status_code=202)
+
+        pid = os.fork()
+        if pid == 0:
+            self.worker.main_work_horse(mock.MagicMock(), mock.MagicMock())
+        os.waitpid(pid, 0)
+        os.close(write_end)
+        os.set_blocking(read_end, False)
+
+        self.assertEqual(json.loads(os.read(read_end, 4096)), ['inside the work horse'])