datadog-async-handler 0.1.3__tar.gz → 0.1.4__tar.gz

{datadog_async_handler-0.1.3 → datadog_async_handler-0.1.4}/CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.4] - 2026-09-02
+
+### Fixed
+- Fork safety: a process that called `fork()` while the worker thread was inside a TLS
+  send handed the child OpenSSL state mid-update, and the child deadlocked on its own
+  first TLS handshake (observed with Celery prefork workers). `os.register_at_fork`
+  hooks now hold the send lock across `fork()` and give the child a fresh queue, lock,
+  and worker thread. The lock covers only the network attempt, not retry back-off.
+- The worker thread is named `datadog-http-handler`.
+
 ## [0.1.2] - 2025-08-25
 
 ### Added

{datadog_async_handler-0.1.3 → datadog_async_handler-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: datadog-async-handler
-Version: 0.1.3
+Version: 0.1.4
 Summary: High-performance async HTTP logging handler for Datadog with batching and retry logic
 Project-URL: Homepage, https://github.com/enlyft/datadog-async-handler
 Project-URL: Documentation, https://enlyft.github.io/datadog-async-handler
@@ -53,7 +53,7 @@ Description-Content-Type: text/markdown
 
 # Datadog Async Handler
 
-[![PyPI version](https://badge.fury.io/py/datadog-async-handler.svg)](https://badge.fury.io/py/datadog-async-handler)
+[![PyPI version](https://img.shields.io/pypi/v/datadog-async-handler)](https://pypi.org/project/datadog-async-handler/)
 [![Python versions](https://img.shields.io/pypi/pyversions/datadog-async-handler.svg)](https://pypi.org/project/datadog-async-handler/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Code style: ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

{datadog_async_handler-0.1.3 → datadog_async_handler-0.1.4}/README.md

@@ -1,6 +1,6 @@
 # Datadog Async Handler
 
-[![PyPI version](https://badge.fury.io/py/datadog-async-handler.svg)](https://badge.fury.io/py/datadog-async-handler)
+[![PyPI version](https://img.shields.io/pypi/v/datadog-async-handler)](https://pypi.org/project/datadog-async-handler/)
 [![Python versions](https://img.shields.io/pypi/pyversions/datadog-async-handler.svg)](https://pypi.org/project/datadog-async-handler/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Code style: ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

{datadog_async_handler-0.1.3 → datadog_async_handler-0.1.4}/src/datadog_http_handler/handler.py

@@ -9,6 +9,7 @@ import logging
 import os
 import threading
 import time
+import weakref
 from queue import Empty, Queue
 from typing import Optional
 
@@ -18,6 +19,17 @@ from datadog_api_client.v2.model.http_log import HTTPLog
 from datadog_api_client.v2.model.http_log_item import HTTPLogItem
 
 
+def _at_fork(ref: "weakref.ReferenceType[DatadogHTTPHandler]", method: str) -> None:
+    """Dispatch an ``os.register_at_fork`` callback to a handler that is still alive.
+
+    ``os.register_at_fork`` keeps its callables for the life of the process, so the
+    hooks hold only a weak reference and become no-ops once the handler is collected.
+    """
+    handler = ref()
+    if handler is not None:
+        getattr(handler, method)()
+
+
 class DatadogHTTPHandler(logging.Handler):
     """
     High-performance logging handler that sends logs to Datadog via HTTP API.
@@ -26,6 +38,12 @@ class DatadogHTTPHandler(logging.Handler):
     the main application thread. It includes retry logic with exponential backoff,
     comprehensive error handling, and support for all Datadog sites.
 
+    The handler is fork-safe. Its worker thread sends over TLS, and a child forked
+    while that handshake is in flight inherits OpenSSL state mid-update and deadlocks
+    on its own first TLS handshake. ``os.register_at_fork`` hooks hold a send lock
+    across ``fork()`` so no child is forked mid-send, and give the child a fresh
+    queue, lock, and worker thread (threads do not survive ``fork()``).
+
     Args:
         api_key: Datadog API key (or set DD_API_KEY env var)
         site: Datadog site (default: datadoghq.com)
@@ -60,6 +78,9 @@ class DatadogHTTPHandler(logging.Handler):
         >>> logger.addHandler(handler)
     """
 
+    # Bounded so a worker wedged inside C can never freeze the parent's fork() forever.
+    _FORK_WAIT_SECONDS = 15.0
+
     def __init__(
         self,
         api_key: Optional[str] = None,
@@ -103,7 +124,16 @@ class DatadogHTTPHandler(logging.Handler):
         self._log_queue: Queue[HTTPLogItem] = Queue()
         self._stop_event = threading.Event()
         self._worker_thread: Optional[threading.Thread] = None
+        self._send_lock = threading.Lock()
+        self._fork_lock_held = False
         self._start_worker()
+        if hasattr(os, "register_at_fork"):  # POSIX only
+            ref = weakref.ref(self)
+            os.register_at_fork(
+                before=lambda: _at_fork(ref, "_before_fork"),
+                after_in_parent=lambda: _at_fork(ref, "_after_fork_in_parent"),
+                after_in_child=lambda: _at_fork(ref, "_after_fork_in_child"),
+            )
 
     def _setup_api_client(self) -> None:
         """Setup the Datadog API client."""
@@ -117,7 +147,9 @@ class DatadogHTTPHandler(logging.Handler):
     def _start_worker(self) -> None:
         """Start the background worker thread."""
         if self._worker_thread is None or not self._worker_thread.is_alive():
-            self._worker_thread = threading.Thread(target=self._worker, daemon=True)
+            self._worker_thread = threading.Thread(
+                target=self._worker, daemon=True, name="datadog-http-handler"
+            )
             self._worker_thread.start()
 
     def _worker(self) -> None:
@@ -161,7 +193,8 @@ class DatadogHTTPHandler(logging.Handler):
         for attempt in range(self.max_retries + 1):
             try:
                 http_log = HTTPLog(batch)
-                self.logs_api.submit_log(body=http_log)
+                with self._send_lock:  # fork() waits for this, not for back-off
+                    self.logs_api.submit_log(body=http_log)
                 return  # Success
 
             except Exception as e:
@@ -174,6 +207,33 @@ class DatadogHTTPHandler(logging.Handler):
                     # Wait before retry (exponential backoff)
                     time.sleep(2**attempt)
 
+    def _before_fork(self) -> None:
+        """Hold the send lock across ``fork()`` so no child is forked mid-send."""
+        self._fork_lock_held = self._send_lock.acquire(timeout=self._FORK_WAIT_SECONDS)
+        if not self._fork_lock_held:
+            self._handle_error(
+                "forking while a log send is wedged; the child's TLS may deadlock"
+            )
+
+    def _after_fork_in_parent(self) -> None:
+        """Release the lock taken by ``_before_fork``."""
+        if self._fork_lock_held:
+            self._fork_lock_held = False
+            self._send_lock.release()
+
+    def _after_fork_in_child(self) -> None:
+        """Give the child a fresh lock, queue, and worker thread.
+
+        The parent's worker thread does not exist in the child, and the inherited
+        lock may still be held by it.
+        """
+        self._send_lock = threading.Lock()
+        self._fork_lock_held = False
+        self._log_queue = Queue()
+        self._stop_event = threading.Event()
+        self._worker_thread = None
+        self._start_worker()
+
     def _handle_error(self, message: str) -> None:
         """Handle errors that occur during log submission."""
         # Log to stderr to avoid infinite recursion