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

{logtail_python-0.4.1 → logtail_python-0.4.3}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: logtail-python
-Version: 0.4.1
+Version: 0.4.3
 Summary: Better Stack client library
 Home-page: https://github.com/logtail/logtail-python
-Download-URL: https://github.com/logtail/logtail-python/tarball/0.4.1
+Download-URL: https://github.com/logtail/logtail-python/tarball/0.4.3
 Author: Logtail
 Author-email: hello@logtail.com
 License: ISC
@@ -17,6 +17,7 @@ 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 :: 3.15
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10

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

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

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

@@ -100,11 +100,30 @@ class FlushWorker(threading.Thread):
         if shutdown and self.pipe.empty():
             self.should_run = False
 
-    def flush(self):
+    def flush(self, timeout=None):
+        """Block until the worker has drained the queue.
+
+        If ``timeout`` is given (in seconds), return after at most that much
+        wall time has elapsed even if the queue is still non-empty. Returns
+        ``True`` if the queue was drained, ``False`` if the timeout fired.
+
+        The bound matters when the caller holds the global logging lock, as
+        ``logging.config.dictConfig()`` does while it flushes and closes the
+        handlers it replaces: if this worker is inside an upload whose urllib3
+        ``debug()`` call needs that same lock, an unbounded wait deadlocks the
+        process. It also keeps a slow or unreachable endpoint from stalling a
+        shutdown forever.
+        """
         self._flushing = True
-        while not self._clean or not self.pipe.empty():
-            time.sleep(self.check_interval)
-        self._flushing = False
+        try:
+            deadline = None if timeout is None else time.time() + timeout
+            while not self._clean or not self.pipe.empty():
+                if deadline is not None and time.time() >= deadline:
+                    return False
+                time.sleep(self.check_interval)
+            return True
+        finally:
+            self._flushing = False
 
 def in_flush_worker():
     return isinstance(threading.current_thread(), FlushWorker)

{logtail_python-0.4.1 → logtail_python-0.4.3}/logtail/frame.py

@@ -93,4 +93,9 @@ def _relative_to_main_module_if_possible(pathname):
     return _relative_to_main_module(pathname) if has_main_module else pathname
 
 def _relative_to_main_module(pathname):
-    return path.relpath(pathname, path.dirname(__main__.__file__))
+    try:
+        return path.relpath(pathname, path.dirname(__main__.__file__))
+    except ValueError:
+        # Windows has no relative path between drives, and a PyInstaller build unpacks the
+        # script to the system drive while the application may run from another one.
+        return pathname

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

@@ -19,6 +19,8 @@ DEFAULT_RAISE_EXCEPTIONS = False
 DEFAULT_DROP_EXTRA_EVENTS = True
 DEFAULT_INCLUDE_EXTRA_ATTRIBUTES = True
 DEFAULT_TIMEOUT = 30
+DEFAULT_FLUSH_TIMEOUT = 30
+
 
 _handlers = weakref.WeakSet()
 
@@ -35,6 +37,7 @@ class LogtailHandler(logging.Handler):
                  include_extra_attributes=DEFAULT_INCLUDE_EXTRA_ATTRIBUTES,
                  context=DEFAULT_CONTEXT,
                  timeout=DEFAULT_TIMEOUT,
+                 flush_timeout=DEFAULT_FLUSH_TIMEOUT,
                  level=logging.NOTSET):
         super(LogtailHandler, self).__init__(level=level)
         self.source_token = source_token
@@ -51,6 +54,7 @@ class LogtailHandler(logging.Handler):
         self.flush_interval = flush_interval
         self.check_interval = check_interval
         self.raise_exceptions = raise_exceptions
+        self.flush_timeout = flush_timeout
         self.dropcount = 0
         # Do not initialize the flush thread yet because it causes issues on Render.
         self.flush_thread = None
@@ -91,8 +95,16 @@ class LogtailHandler(logging.Handler):
                 raise e
 
     def flush(self):
-        if self.flush_thread and self.flush_thread.is_alive():
-             self.flush_thread.flush()
+        if not (self.flush_thread and self.flush_thread.is_alive()):
+            return
+        if logging._lock._is_owned():
+            # logging.config.dictConfig() flushes the handlers it replaces while holding the global
+            # logging lock, and the worker's upload needs that lock whenever urllib3's logger has a
+            # level-cache miss, so waiting here could only deadlock. Nothing is lost: the worker
+            # keeps running and sends what is queued as soon as the lock is released.
+            return
+        if not self.flush_thread.flush(timeout=self.flush_timeout):
+            print('Gave up waiting for Better Stack uploads after {}s, logs are still buffered'.format(self.flush_timeout))
 
     def _reset_after_fork(self):
         # A forked child inherits the parent's queue with whatever was still buffered in it,
@@ -100,7 +112,7 @@ class LogtailHandler(logging.Handler):
         # 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)
+        self.uploader.reset()
 
 
 def _reset_handlers_after_fork():

logtail_python-0.4.3/logtail/uploader.py

@@ -0,0 +1,47 @@
+# coding: utf-8
+from __future__ import print_function, unicode_literals
+import os
+import msgpack
+import requests
+import requests.utils
+
+class Fake500(object):
+    def __init__(self, exception):
+        self.status_code = 500
+        self.exception = exception
+
+class Uploader(object):
+    def __init__(self, source_token, host, timeout):
+        self.source_token = source_token
+        self.host = host
+        self.timeout = timeout
+        # requests would otherwise ask the environment, and on macOS SystemConfiguration, for
+        # proxy settings on every request. Resolving them once here keeps the flush thread out
+        # of CoreFoundation, which refuses to run in a child forked from a multithreaded
+        # process, such as an RQ work horse. The CA bundle variables follow the same rule.
+        self.proxies = requests.utils.get_environ_proxies(host)
+        self.verify = os.environ.get('REQUESTS_CA_BUNDLE') or os.environ.get('CURL_CA_BUNDLE') or True
+        self.headers = {
+            'Authorization': 'Bearer %s' % source_token,
+            'Content-Type': 'application/msgpack',
+        }
+        self.session = self._new_session()
+
+    def __call__(self, frame):
+        data = msgpack.packb(frame, use_bin_type=True)
+        try:
+            return self.session.post(self.host, data=data, headers=self.headers, timeout=self.timeout)
+        except requests.RequestException as e:
+            return Fake500(e)
+
+    def reset(self):
+        # A forked child shares the parent's pooled socket, so it needs a session of its own,
+        # built from the settings resolved above rather than looked up again.
+        self.session = self._new_session()
+
+    def _new_session(self):
+        session = requests.Session()
+        session.trust_env = False
+        session.proxies = self.proxies
+        session.verify = self.verify
+        return session

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: logtail-python
-Version: 0.4.1
+Version: 0.4.3
 Summary: Better Stack client library
 Home-page: https://github.com/logtail/logtail-python
-Download-URL: https://github.com/logtail/logtail-python/tarball/0.4.1
+Download-URL: https://github.com/logtail/logtail-python/tarball/0.4.3
 Author: Logtail
 Author-email: hello@logtail.com
 License: ISC
@@ -17,6 +17,7 @@ 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 :: 3.15
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10

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

@@ -3,7 +3,7 @@ import os
 from setuptools import setup
 
 
-VERSION = '0.4.1'
+VERSION = '0.4.3'
 ROOT_DIR = os.path.dirname(__file__)
 
 REQUIREMENTS = [
@@ -40,6 +40,7 @@ setup(
           'Programming Language :: Python :: 3.12',
           'Programming Language :: Python :: 3.13',
           'Programming Language :: Python :: 3.14',
+          'Programming Language :: Python :: 3.15',
           'Programming Language :: Python',
           'Topic :: Software Development :: Libraries :: Python Modules',
     ],

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

@@ -233,3 +233,33 @@ class TestFlushWorker(unittest.TestCase):
         self.assertFalse(threading.excepthook.called)
 
         threading.excepthook = original_excepthook
+
+    def test_flush_returns_immediately_on_empty_clean_queue(self):
+        _, _, fw = self._setup_worker()
+        # _clean defaults to True and pipe is empty — flush should return at once.
+        t1 = time.time()
+        result = fw.flush()
+        elapsed = time.time() - t1
+        self.assertTrue(result)
+        self.assertLess(elapsed, 0.1)
+
+    def test_flush_with_timeout_returns_false_when_queue_not_drained(self):
+        pipe, _, fw = self._setup_worker()
+        # Put an item in but never start the worker thread → queue stays full,
+        # so flush() will spin until the timeout fires.
+        pipe.put(object(), block=False)
+
+        t1 = time.time()
+        result = fw.flush(timeout=0.05)
+        elapsed = time.time() - t1
+
+        self.assertFalse(result)
+        # Bounded: should return shortly after the timeout, not block forever.
+        self.assertLess(elapsed, 1.0)
+        self.assertGreaterEqual(elapsed, 0.04)
+
+    def test_flush_clears_flushing_flag_even_on_timeout(self):
+        pipe, _, fw = self._setup_worker()
+        pipe.put(object(), block=False)
+        fw.flush(timeout=0.05)
+        self.assertFalse(fw._flushing)

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

@@ -4,9 +4,12 @@ from logtail.frame import create_frame
 from logtail.handler import LogtailHandler
 from logtail.helpers import LogtailContext
 import datetime
+import ntpath
 import unittest
 import logging
 
+from unittest.mock import patch
+
 class TestLogtailLogEntry(unittest.TestCase):
     def test_create_frame_happy_path(self):
         handler = LogtailHandler(source_token="some-source-token")
@@ -36,3 +39,15 @@ class TestLogtailLogEntry(unittest.TestCase):
 
         frame = create_frame(log_record, log_record.getMessage(), LogtailContext(), include_extra_attributes=True)
         self.assertIn('non_dict_key', frame)
+
+    @patch('logtail.frame.path', ntpath)
+    @patch('logtail.frame.__main__')
+    def test_create_frame_keeps_the_absolute_path_when_the_file_is_on_another_drive(self, main):
+        # PyInstaller unpacks the script to the system drive while the application's files stay
+        # on the drive it was started from, and Windows has no relative path between drives.
+        main.__file__ = 'C:\\Users\\zi\\AppData\\Local\\Temp\\_MEI61722\\main.py'
+        log_record = logging.LogRecord("logtail-test", 20, 'D:\\workspace\\app\\main.py', 10, "Some log message", [], None)
+
+        frame = create_frame(log_record, log_record.getMessage(), LogtailContext())
+
+        self.assertEqual(frame['context']['runtime']['file'], 'D:\\workspace\\app\\main.py')

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

@@ -27,11 +27,49 @@ class TestLogtailHandler(unittest.TestCase):
         # Test default timeout
         handler = LogtailHandler(source_token=self.source_token, host=self.host)
         self.assertEqual(handler.uploader.timeout, 30)
-        
+
         # Test custom timeout
         handler = LogtailHandler(source_token=self.source_token, host=self.host, timeout=10)
         self.assertEqual(handler.uploader.timeout, 10)
 
+    @patch('logtail.handler.FlushWorker')
+    def test_handler_stores_flush_timeout(self, MockWorker):
+        # Default
+        handler = LogtailHandler(source_token=self.source_token, host=self.host)
+        self.assertEqual(handler.flush_timeout, 30)
+        # Custom
+        handler = LogtailHandler(source_token=self.source_token, host=self.host, flush_timeout=2)
+        self.assertEqual(handler.flush_timeout, 2)
+        # Explicit None disables the timeout (legacy unbounded wait)
+        handler = LogtailHandler(source_token=self.source_token, host=self.host, flush_timeout=None)
+        self.assertIsNone(handler.flush_timeout)
+
+    @patch('logtail.handler.FlushWorker')
+    def test_handler_passes_flush_timeout_to_worker(self, MockWorker):
+        handler = LogtailHandler(source_token=self.source_token, host=self.host, flush_timeout=7)
+        # Trigger flush_thread creation by emitting once.
+        logger = logging.getLogger(__name__)
+        logger.handlers = []
+        logger.addHandler(handler)
+        logger.critical('hello')
+        # The mocked FlushWorker is alive by default; flush() forwards timeout.
+        handler.flush()
+        handler.flush_thread.flush.assert_called_with(timeout=7)
+
+    @patch('logtail.handler.print', create=True)
+    @patch('logtail.handler.FlushWorker')
+    def test_flush_reports_giving_up(self, MockWorker, mock_print):
+        handler = LogtailHandler(source_token=self.source_token, host=self.host, flush_timeout=3)
+        logger = logging.getLogger(__name__)
+        logger.handlers = []
+        logger.addHandler(handler)
+        logger.critical('hello')
+        handler.flush_thread.flush.return_value = False
+
+        handler.flush()
+
+        mock_print.assert_called_once_with('Gave up waiting for Better Stack uploads after 3s, logs are still buffered')
+
     @patch('logtail.handler.FlushWorker')
     def test_handler_creates_pipe_from_args(self, MockWorker):
         buffer_capacity = 9
@@ -285,11 +323,15 @@ class TestLogtailHandler(unittest.TestCase):
         logger.handlers = []
         logger.addHandler(handler)
         logger.critical('queued in the parent')
-        parent_session = handler.uploader.session
+        uploader = handler.uploader
+        parent_session = 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
+            # The child gets its own session, but never resolves proxy settings again: on macOS
+            # that means SystemConfiguration, which refuses to run in a forked child.
+            fresh = (handler.pipe.empty() and handler.flush_thread is None and handler.uploader is uploader
+                     and uploader.session is not parent_session and uploader.session.trust_env is False)
             os._exit(0 if fresh else 1)
         _, status = os.waitpid(pid, 0)
 
@@ -369,6 +411,35 @@ class TestLogtailHandler(unittest.TestCase):
         self.assertEqual(uploads, [['hello']])
         self.assertTrue(handler.pipe.empty())
 
+    def test_flush_does_not_wait_while_the_caller_holds_the_logging_lock(self):
+        # logging.config.dictConfig() flushes the handlers it replaces while holding the global
+        # logging lock, and the worker's upload needs that lock whenever urllib3's logger has a
+        # level-cache miss, so waiting for the worker there can only deadlock.
+        logger = logging.getLogger(__name__)
+        logger.handlers = []
+        logger.setLevel(logging.INFO)
+        handler = LogtailHandler(source_token=self.source_token, flush_interval=0.01, check_interval=0.01, flush_timeout=2)
+        uploads = []
+        in_upload = threading.Event()
+
+        def upload(frame):
+            in_upload.set()
+            with logging._lock:  # what urllib3's isEnabledFor() does on a level-cache miss
+                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)
+
+        with logging._lock:
+            logger.info('hello')
+            self.assertTrue(in_upload.wait(2))
+            started = time.time()
+            handler.flush()
+            self.assertLess(time.time() - started, 0.5, 'flush() waited for a worker that needs the lock we hold')
+        self._wait_until(lambda: uploads == [['hello']])
+
     def _wait_until(self, condition):
         deadline = time.time() + 2
         while not condition() and time.time() < deadline:

logtail_python-0.4.3/tests/test_uploader.py

@@ -0,0 +1,66 @@
+# coding: utf-8
+from __future__ import print_function, unicode_literals
+import msgpack
+import mock
+import unittest
+
+from unittest.mock import patch
+
+from logtail.uploader import Uploader
+
+
+class TestUploader(unittest.TestCase):
+    host = 'https://in.logtail.com'
+    source_token = 'dummy_source_token'
+    frame = [1, 2, 3]
+    timeout = 30
+
+    @patch('logtail.uploader.requests.Session.post')
+    def test_call(self, post):
+        def mock_post(endpoint, data=None, headers=None, timeout=None):
+            # Check that the data is sent to ther correct endpoint
+            self.assertEqual(endpoint, self.host)
+            # Check the content-type
+            self.assertIsInstance(headers, dict)
+            self.assertIn('Authorization', headers)
+            self.assertEqual('application/msgpack', headers.get('Content-Type'))
+            # Check the content was msgpacked correctly
+            self.assertEqual(msgpack.unpackb(data, raw=False), self.frame)
+            # Check that timeout is passed to the request
+            self.assertEqual(timeout, 30)
+
+        post.side_effect = mock_post
+        u = Uploader(self.source_token, self.host, self.timeout)
+        u(self.frame)
+
+        self.assertTrue(post.called)
+
+    @patch('logtail.uploader.requests.utils.get_environ_proxies', return_value={'https': 'http://proxy.internal:3128'})
+    def test_resolves_proxy_settings_once_instead_of_on_every_request(self, get_environ_proxies):
+        u = Uploader(self.source_token, self.host, self.timeout)
+
+        with patch('logtail.uploader.requests.Session.post'):
+            u(self.frame)
+            u(self.frame)
+
+        get_environ_proxies.assert_called_once_with(self.host)
+        self.assertEqual(u.session.proxies, {'https': 'http://proxy.internal:3128'})
+        self.assertFalse(u.session.trust_env)
+
+    @patch.dict('os.environ', {'REQUESTS_CA_BUNDLE': '/etc/ssl/corporate-ca.pem'})
+    def test_uses_the_ca_bundle_from_the_environment(self):
+        u = Uploader(self.source_token, self.host, self.timeout)
+
+        self.assertEqual(u.session.verify, '/etc/ssl/corporate-ca.pem')
+
+    @patch('logtail.uploader.requests.utils.get_environ_proxies', return_value={'https': 'http://proxy.internal:3128'})
+    def test_reset_replaces_the_session_but_keeps_the_resolved_settings(self, get_environ_proxies):
+        u = Uploader(self.source_token, self.host, self.timeout)
+        session = u.session
+
+        u.reset()
+
+        self.assertIsNot(u.session, session)
+        self.assertEqual(u.session.proxies, {'https': 'http://proxy.internal:3128'})
+        self.assertFalse(u.session.trust_env)
+        get_environ_proxies.assert_called_once_with(self.host)

logtail_python-0.4.1/logtail/uploader.py

@@ -1,27 +0,0 @@
-# coding: utf-8
-from __future__ import print_function, unicode_literals
-import msgpack
-import requests
-
-class Fake500(object):
-    def __init__(self, exception):
-        self.status_code = 500
-        self.exception = exception
-
-class Uploader(object):
-    def __init__(self, source_token, host, timeout):
-        self.source_token = source_token
-        self.host = host
-        self.timeout = timeout
-        self.session = requests.Session()
-        self.headers = {
-            'Authorization': 'Bearer %s' % source_token,
-            'Content-Type': 'application/msgpack',
-        }
-
-    def __call__(self, frame):
-        data = msgpack.packb(frame, use_bin_type=True)
-        try:
-            return self.session.post(self.host, data=data, headers=self.headers, timeout=self.timeout)
-        except requests.RequestException as e:
-            return Fake500(e)

logtail_python-0.4.1/tests/test_uploader.py

@@ -1,36 +0,0 @@
-# coding: utf-8
-from __future__ import print_function, unicode_literals
-import msgpack
-import mock
-import unittest
-
-from unittest.mock import patch
-
-from logtail.uploader import Uploader
-
-
-class TestUploader(unittest.TestCase):
-    host = 'https://in.logtail.com'
-    source_token = 'dummy_source_token'
-    frame = [1, 2, 3]
-    timeout = 30
-
-    @patch('logtail.uploader.requests.Session.post')
-    def test_call(self, post):
-        def mock_post(endpoint, data=None, headers=None, timeout=None):
-            # Check that the data is sent to ther correct endpoint
-            self.assertEqual(endpoint, self.host)
-            # Check the content-type
-            self.assertIsInstance(headers, dict)
-            self.assertIn('Authorization', headers)
-            self.assertEqual('application/msgpack', headers.get('Content-Type'))
-            # Check the content was msgpacked correctly
-            self.assertEqual(msgpack.unpackb(data, raw=False), self.frame)
-            # Check that timeout is passed to the request
-            self.assertEqual(timeout, 30)
-
-        post.side_effect = mock_post
-        u = Uploader(self.source_token, self.host, self.timeout)
-        u(self.frame)
-
-        self.assertTrue(post.called)