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

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: logtail-python
-Version: 0.4.3
+Version: 0.5.0
 Summary: Better Stack client library
 Home-page: https://github.com/logtail/logtail-python
-Download-URL: https://github.com/logtail/logtail-python/tarball/0.4.3
+Download-URL: https://github.com/logtail/logtail-python/tarball/0.5.0
 Author: Logtail
 Author-email: hello@logtail.com
 License: ISC

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

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

{logtail_python-0.4.3 → logtail_python-0.5.0}/logtail/compat.py

@@ -4,4 +4,4 @@ from __future__ import print_function, unicode_literals
 try:
     import queue
 except ImportError:
-    import Queue as queue
+    import Queue as queue # type: ignore[import-not-found, no-redef]

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

@@ -3,13 +3,14 @@ from __future__ import print_function, unicode_literals
 
 import threading
 import time
+from typing import Any, Callable, Optional
 
 from .compat import queue
 
 RETRY_SCHEDULE = (1, 10, 60)  # seconds
 
 
-class TransportFrame(dict):
+class TransportFrame(dict[str, Any]):
     """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
@@ -18,7 +19,7 @@ class TransportFrame(dict):
 
 
 class FlushWorker(threading.Thread):
-    def __init__(self, upload, pipe, buffer_capacity, flush_interval, check_interval):
+    def __init__(self, upload: Callable[[list[Any]], Any], pipe: 'queue.Queue[Any]', buffer_capacity: int, flush_interval: float, check_interval: float) -> None:
         threading.Thread.__init__(self)
         self.parent_thread = threading.current_thread()
         self.upload = upload
@@ -30,11 +31,11 @@ class FlushWorker(threading.Thread):
         self._flushing = False
         self._clean = True
 
-    def run(self):
+    def run(self) -> None:
         while self.should_run:
             self.step()
 
-    def _is_parent_alive(self):
+    def _is_parent_alive(self) -> bool:
         try:
             return self.parent_thread.is_alive()
         except RuntimeError:
@@ -44,10 +45,10 @@ class FlushWorker(threading.Thread):
             # interpreter shutdown). Treat that as "no longer alive".
             return False
 
-    def step(self):
+    def step(self) -> None:
         last_flush = time.time()
         time_remaining = _initial_time_remaining(self.flush_interval)
-        frame = []
+        frame: list[Any] = []
         self._clean = True
 
         # If the parent thread has exited but there are still outstanding
@@ -80,7 +81,7 @@ class FlushWorker(threading.Thread):
         # request fails in a way that can be retried, it is retried with an
         # exponential backoff in between attempts.
         if frame and not all(isinstance(entry, TransportFrame) for entry in frame):
-            response = None
+            response: Any = None
             for delay in RETRY_SCHEDULE + (None, ):
                 response = self.upload(frame)
                 if not _should_retry(response.status_code):
@@ -100,7 +101,7 @@ class FlushWorker(threading.Thread):
         if shutdown and self.pipe.empty():
             self.should_run = False
 
-    def flush(self, timeout=None):
+    def flush(self, timeout: Optional[float] = None) -> bool:
         """Block until the worker has drained the queue.
 
         If ``timeout`` is given (in seconds), return after at most that much
@@ -125,19 +126,19 @@ class FlushWorker(threading.Thread):
         finally:
             self._flushing = False
 
-def in_flush_worker():
+def in_flush_worker() -> bool:
     return isinstance(threading.current_thread(), FlushWorker)
 
 
-def _initial_time_remaining(flush_interval):
+def _initial_time_remaining(flush_interval: float) -> float:
     return flush_interval
 
 
-def _calculate_time_remaining(last_flush, flush_interval):
+def _calculate_time_remaining(last_flush: float, flush_interval: float) -> float:
     elapsed = time.time() - last_flush
     time_remaining = max(flush_interval - elapsed, 0)
     return time_remaining
 
 
-def _should_retry(status_code):
+def _should_retry(status_code: int) -> bool:
     return 500 <= status_code < 600

{logtail_python-0.4.3 → logtail_python-0.5.0}/logtail/formatter.py

@@ -2,21 +2,22 @@
 from __future__ import print_function, unicode_literals
 import logging
 import json
+from typing import Any, Callable, Optional
 
-from .helpers import DEFAULT_CONTEXT
+from .helpers import DEFAULT_CONTEXT, LogtailContext
 from .frame import create_frame
 
 
 class LogtailFormatter(logging.Formatter):
     def __init__(self,
-                 context=DEFAULT_CONTEXT,
-                 json_default=None,
-                 json_encoder=None):
+                 context: LogtailContext = DEFAULT_CONTEXT,
+                 json_default: Optional[Callable[[Any], Any]] = None,
+                 json_encoder: Optional[type[json.JSONEncoder]] = None) -> None:
         self.context = context
         self.json_default = json_default
         self.json_encoder = json_encoder
 
-    def format(self, record):
+    def format(self, record: logging.LogRecord) -> str:
         # Because the formatter does not have an underlying format string for
         # which `extra` may be used to substitute arguments (see
         # https://docs.python.org/2/library/logging.html#logging.debug ), we

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

@@ -1,24 +1,29 @@
 # coding: utf-8
 from __future__ import print_function, unicode_literals
 from datetime import datetime, timezone
-
+import logging
 from os import path
+from typing import Any, Optional
 import __main__
 
-def create_frame(record, message, context, include_extra_attributes=False):
+from .helpers import LogtailContext
+
+def create_frame(record: logging.LogRecord, message: str, context: LogtailContext, include_extra_attributes: bool = False) -> dict[str, Any]:
     r = record.__dict__
     # Django sends a request object in the record, which is not JSON serializable
     if "request" in r and not isinstance(r["request"], (dict, list, bool, int, float, str)) :
         del r["request"]
-    frame = {}
+    frame: dict[str, Any] = {}
     frame['dt'] = datetime.fromtimestamp(r['created'], timezone.utc).isoformat()
     frame['level'] = _levelname(r['levelname'])
     frame['severity'] = int(r['levelno'] / 10)
     frame['message'] = message
-    frame['context'] = ctx = {}
+    ctx: dict[str, Any] = {}
+    frame['context'] = ctx
 
     # Runtime context
-    ctx['runtime'] = runtime = {}
+    runtime: dict[str, Any] = {}
+    ctx['runtime'] = runtime
     runtime['function'] = r['funcName']
     runtime['file'] = _relative_to_main_module_if_possible(r['pathname'])
     runtime['line'] = r['lineno']
@@ -27,7 +32,8 @@ def create_frame(record, message, context, include_extra_attributes=False):
     runtime['logger_name'] = r['name']
 
     # Runtime context
-    ctx['system'] = system = {}
+    system: dict[str, Any] = {}
+    ctx['system'] = system
     system['pid'] = r['process']
     system['process_name'] = r['processName']
 
@@ -41,14 +47,14 @@ def create_frame(record, message, context, include_extra_attributes=False):
 
     return _remove_circular_dependencies(frame)
 
-def _parse_custom_events(record, include_extra_attributes):
+def _parse_custom_events(record: logging.LogRecord, include_extra_attributes: bool) -> dict[str, Any]:
     default_keys = {
         'args', 'asctime', 'created', 'exc_info', 'exc_text', 'pathname',
         'funcName', 'levelname', 'levelno', 'lineno', 'module', 'msecs',
         'message', 'msg', 'name', 'process', 'processName',
         'relativeCreated', 'thread', 'threadName'
     }
-    events = {}
+    events: dict[str, Any] = {}
     for key, val in record.__dict__.items():
         if key in default_keys:
             continue
@@ -57,7 +63,7 @@ def _parse_custom_events(record, include_extra_attributes):
         events[key] = val
     return events
 
-def _remove_circular_dependencies(obj, memo=None):
+def _remove_circular_dependencies(obj: Any, memo: Optional[set[int]] = None) -> Any:
     if memo is None:
         memo = set()
 
@@ -85,14 +91,14 @@ def _remove_circular_dependencies(obj, memo=None):
     else:
         return obj
 
-def _levelname(level):
+def _levelname(level: str) -> str:
     return level.lower()
 
-def _relative_to_main_module_if_possible(pathname):
+def _relative_to_main_module_if_possible(pathname: str) -> str:
     has_main_module = hasattr(__main__, '__file__')
     return _relative_to_main_module(pathname) if has_main_module else pathname
 
-def _relative_to_main_module(pathname):
+def _relative_to_main_module(pathname: str) -> str:
     try:
         return path.relpath(pathname, path.dirname(__main__.__file__))
     except ValueError:

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

@@ -4,9 +4,10 @@ import logging
 import json
 import os
 import weakref
+from typing import Any, Optional, Union
 
 from .compat import queue
-from .helpers import DEFAULT_CONTEXT
+from .helpers import DEFAULT_CONTEXT, LogtailContext
 from .flusher import FlushWorker, TransportFrame, in_flush_worker
 from .uploader import Uploader
 from .frame import create_frame
@@ -22,23 +23,23 @@ DEFAULT_TIMEOUT = 30
 DEFAULT_FLUSH_TIMEOUT = 30
 
 
-_handlers = weakref.WeakSet()
+_handlers: 'weakref.WeakSet[LogtailHandler]' = weakref.WeakSet()
 
 
 class LogtailHandler(logging.Handler):
     def __init__(self,
-                 source_token,
-                 host=DEFAULT_HOST,
-                 buffer_capacity=DEFAULT_BUFFER_CAPACITY,
-                 flush_interval=DEFAULT_FLUSH_INTERVAL,
-                 check_interval=DEFAULT_CHECK_INTERVAL,
-                 raise_exceptions=DEFAULT_RAISE_EXCEPTIONS,
-                 drop_extra_events=DEFAULT_DROP_EXTRA_EVENTS,
-                 include_extra_attributes=DEFAULT_INCLUDE_EXTRA_ATTRIBUTES,
-                 context=DEFAULT_CONTEXT,
-                 timeout=DEFAULT_TIMEOUT,
-                 flush_timeout=DEFAULT_FLUSH_TIMEOUT,
-                 level=logging.NOTSET):
+                 source_token: str,
+                 host: str = DEFAULT_HOST,
+                 buffer_capacity: int = DEFAULT_BUFFER_CAPACITY,
+                 flush_interval: float = DEFAULT_FLUSH_INTERVAL,
+                 check_interval: float = DEFAULT_CHECK_INTERVAL,
+                 raise_exceptions: bool = DEFAULT_RAISE_EXCEPTIONS,
+                 drop_extra_events: bool = DEFAULT_DROP_EXTRA_EVENTS,
+                 include_extra_attributes: bool = DEFAULT_INCLUDE_EXTRA_ATTRIBUTES,
+                 context: LogtailContext = DEFAULT_CONTEXT,
+                 timeout: Union[float, tuple[float, float], None] = DEFAULT_TIMEOUT,
+                 flush_timeout: Optional[float] = DEFAULT_FLUSH_TIMEOUT,
+                 level: Union[int, str] = logging.NOTSET) -> None:
         super(LogtailHandler, self).__init__(level=level)
         self.source_token = source_token
         if host.startswith('https://') or host.startswith('http://'):
@@ -46,7 +47,7 @@ class LogtailHandler(logging.Handler):
         else:
             self.host = "https://" + host
         self.context = context
-        self.pipe = queue.Queue(maxsize=buffer_capacity)
+        self.pipe: 'queue.Queue[dict[str, Any]]' = queue.Queue(maxsize=buffer_capacity)
         self.uploader = Uploader(self.source_token, self.host, timeout)
         self.drop_extra_events = drop_extra_events
         self.include_extra_attributes = include_extra_attributes
@@ -57,10 +58,10 @@ class LogtailHandler(logging.Handler):
         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
+        self.flush_thread: Optional[FlushWorker] = None
         _handlers.add(self)
 
-    def ensure_flush_thread_alive(self):
+    def ensure_flush_thread_alive(self) -> None:
         if self.flush_thread and self.flush_thread.is_alive():
             return
 
@@ -73,7 +74,7 @@ class LogtailHandler(logging.Handler):
         )
         self.flush_thread.start()
 
-    def emit(self, record):
+    def emit(self, record: logging.LogRecord) -> None:
         try:
             self.ensure_flush_thread_alive()
 
@@ -94,10 +95,10 @@ class LogtailHandler(logging.Handler):
             if self.raise_exceptions:
                 raise e
 
-    def flush(self):
+    def flush(self) -> None:
         if not (self.flush_thread and self.flush_thread.is_alive()):
             return
-        if logging._lock._is_owned():
+        if logging._lock._is_owned():  # type: ignore[attr-defined]  # private, see below
             # 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
@@ -106,7 +107,7 @@ class LogtailHandler(logging.Handler):
         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):
+    def _reset_after_fork(self) -> None:
         # 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.
@@ -115,7 +116,7 @@ class LogtailHandler(logging.Handler):
         self.uploader.reset()
 
 
-def _reset_handlers_after_fork():
+def _reset_handlers_after_fork() -> None:
     for handler in _handlers:
         handler._reset_after_fork()
 

{logtail_python-0.4.3 → logtail_python-0.5.0}/logtail/helpers.py

@@ -1,12 +1,14 @@
 # coding: utf-8
 from __future__ import print_function, unicode_literals
+from types import TracebackType
+from typing import Any, Optional
 
 
 class LogtailContext(object):
-    def __init__(self):
-        self.extras = []
+    def __init__(self) -> None:
+        self.extras: list[dict[str, dict[str, Any]]] = []
 
-    def context(self, *args, **kwargs):
+    def context(self, *args: Any, **kwargs: dict[str, Any]) -> 'LogtailContext':
         if args:
             raise ValueError(
                 'All contexts must be passed by name as keyword arguments'
@@ -19,23 +21,21 @@ class LogtailContext(object):
         self.extras.append(kwargs)
         return self
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args: Any, **kwargs: dict[str, Any]) -> 'LogtailContext':
         return self.context(*args, **kwargs)
 
-    def __enter__(self):
+    def __enter__(self) -> 'LogtailContext':
         return self
 
-    def __exit__(self, type_, value, traceback):
-        if type_ is not None:
-            return False
-        self.extras.pop()
-        return self
+    def __exit__(self, type_: Optional[type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]) -> None:
+        if type_ is None:
+            self.extras.pop()
 
-    def exists(self):
+    def exists(self) -> bool:
         return bool(self.extras)
 
-    def collapse(self):
-        x = {}
+    def collapse(self) -> dict[str, dict[str, Any]]:
+        x: dict[str, dict[str, Any]] = {}
         for contexts in self.extras:
             for name, data in contexts.items():
                 x.setdefault(name, {}).update(data)

{logtail_python-0.4.3 → logtail_python-0.5.0}/logtail/rq.py

@@ -16,7 +16,7 @@ class Worker(rq.Worker):
     in django-rq.
     """
 
-    def perform_job(self, job, queue):
+    def perform_job(self, job: rq.job.Job, queue: rq.Queue) -> bool:
         try:
             return super(Worker, self).perform_job(job, queue)
         finally:
@@ -24,6 +24,6 @@ class Worker(rq.Worker):
                 handler.flush()
 
 
-def _logtail_handlers():
+def _logtail_handlers() -> set[LogtailHandler]:
     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.4.3 → logtail_python-0.5.0}/logtail/uploader.py

@@ -1,17 +1,18 @@
 # coding: utf-8
 from __future__ import print_function, unicode_literals
 import os
+from typing import Any, Union
 import msgpack
 import requests
 import requests.utils
 
 class Fake500(object):
-    def __init__(self, exception):
+    def __init__(self, exception: Exception) -> None:
         self.status_code = 500
         self.exception = exception
 
 class Uploader(object):
-    def __init__(self, source_token, host, timeout):
+    def __init__(self, source_token: str, host: str, timeout: Union[float, tuple[float, float], None]) -> None:
         self.source_token = source_token
         self.host = host
         self.timeout = timeout
@@ -27,19 +28,19 @@ class Uploader(object):
         }
         self.session = self._new_session()
 
-    def __call__(self, frame):
+    def __call__(self, frame: list[dict[str, Any]]) -> Union[requests.Response, Fake500]:
         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):
+    def reset(self) -> None:
         # 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):
+    def _new_session(self) -> requests.Session:
         session = requests.Session()
         session.trust_env = False
         session.proxies = self.proxies

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: logtail-python
-Version: 0.4.3
+Version: 0.5.0
 Summary: Better Stack client library
 Home-page: https://github.com/logtail/logtail-python
-Download-URL: https://github.com/logtail/logtail-python/tarball/0.4.3
+Download-URL: https://github.com/logtail/logtail-python/tarball/0.5.0
 Author: Logtail
 Author-email: hello@logtail.com
 License: ISC

{logtail_python-0.4.3 → logtail_python-0.5.0}/logtail_python.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ logtail/formatter.py
 logtail/frame.py
 logtail/handler.py
 logtail/helpers.py
+logtail/py.typed
 logtail/rq.py
 logtail/uploader.py
 logtail_python.egg-info/PKG-INFO

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

@@ -3,7 +3,7 @@ import os
 from setuptools import setup
 
 
-VERSION = '0.4.3'
+VERSION = '0.5.0'
 ROOT_DIR = os.path.dirname(__file__)
 
 REQUIREMENTS = [
@@ -18,6 +18,7 @@ setup(
     name='logtail-python',
     version=VERSION,
     packages=['logtail'],
+    package_data={'logtail': ['py.typed']},
     include_package_data=True,
     license='ISC',
     description='Better Stack client library',

logtail_python-0.5.0/test-requirements.txt

@@ -0,0 +1,8 @@
+coverage>=3.7.1
+httpretty>=0.9.4
+nose-py3
+mock>=1.0.1
+rq
+mypy>=1.13.0
+msgpack-types>=0.5.0
+types-requests>=2.32.0.20241016

logtail_python-0.4.3/test-requirements.txt

@@ -1,5 +0,0 @@
-coverage>=3.7.1
-httpretty>=0.9.4
-nose-py3
-mock>=1.0.1
-rq