rp_python_sdk 1.5.0__tar.gz → 1.5.2__tar.gz

{rp_python_sdk-1.5.0 → rp_python_sdk-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rp_python_sdk
-Version: 1.5.0
+Version: 1.5.2
 Summary: Python SDK for Relying Parties to enable simple integration with the Digital Identity ecosystem
 License: Proprietary
 Author: Erik Pragt
@@ -419,27 +419,9 @@ with a unique `x-fapi-interaction-id` that was used for this request to the auth
 ## Telemetry
 
 The SDK emits non-sensitive telemetry about its PAR, Token and UserInfo endpoint interactions to the
-centralized ConnectID telemetry service over mTLS. Telemetry is **enabled by default** and requires no
-configuration. It is controlled through a `TelemetryConfig` supplied on `CustomConfig`.
+centralized ConnectID telemetry service over mTLS. Telemetry is controlled through a `TelemetryConfig` supplied on `CustomConfig`.
 
-### Opting out
-
-To disable telemetry, set `enabled=False` on the `TelemetryConfig`:
-
-```python
-from rp_python_sdk.relying_party_client_sdk import RelyingPartyClientSdk
-from rp_python_sdk.sdk_config import SdkConfig, CustomConfig
-from rp_python_sdk.telemetry.telemetry_config import TelemetryConfig
-
-client = RelyingPartyClientSdk(
-    config=SdkConfig(
-        # ... other SdkConfig fields ...
-        custom_config=CustomConfig(
-            telemetry_config=TelemetryConfig(enabled=False)
-        )
-    ),
-)
-```
+> **Note:** Telemetry is **enabled by default**. To opt out, set `TelemetryConfig(enabled=False)` on your `CustomConfig`.
 
 When telemetry is disabled the SDK constructs no transport, session, dispatcher, token provider or worker
 threads, so there is no overhead.
@@ -620,6 +602,14 @@ poetry publish
 
 ## Release Notes
 
+### 1.5.2 (Sep 30, 2026)
+- **Telemetry re-enabled by default**: Telemetry is now enabled by default again after the concurrency and shutdown bugfixes below. Opt out with `TelemetryConfig(enabled=False)`.
+- **Concurrent telemetry session isolation**: Fixed a race condition where overlapping SDK operations could share or corrupt telemetry session state.
+- **Daemon thread shutdown with atexit handler**: Fixed an issue where daemon worker threads were not cleaned up when `close()` was not called explicitly, by registering an `atexit` handler for graceful shutdown.
+
+### 1.5.1 (Sep 25, 2026)
+- **Telemetry disabled by default**: Telemetry was temporarily disabled while a bugfix was in progress.
+
 ### 1.5.0 (Sep 22, 2026)
 - **SDK Telemetry**: Added opt-out telemetry for PAR, Token, and UserInfo endpoint calls — see the [Telemetry](#telemetry) section for full details
   - Supports ASYNC (default) and SYNC delivery modes

{rp_python_sdk-1.5.0 → rp_python_sdk-1.5.2}/README.md

@@ -396,27 +396,9 @@ with a unique `x-fapi-interaction-id` that was used for this request to the auth
 ## Telemetry
 
 The SDK emits non-sensitive telemetry about its PAR, Token and UserInfo endpoint interactions to the
-centralized ConnectID telemetry service over mTLS. Telemetry is **enabled by default** and requires no
-configuration. It is controlled through a `TelemetryConfig` supplied on `CustomConfig`.
+centralized ConnectID telemetry service over mTLS. Telemetry is controlled through a `TelemetryConfig` supplied on `CustomConfig`.
 
-### Opting out
-
-To disable telemetry, set `enabled=False` on the `TelemetryConfig`:
-
-```python
-from rp_python_sdk.relying_party_client_sdk import RelyingPartyClientSdk
-from rp_python_sdk.sdk_config import SdkConfig, CustomConfig
-from rp_python_sdk.telemetry.telemetry_config import TelemetryConfig
-
-client = RelyingPartyClientSdk(
-    config=SdkConfig(
-        # ... other SdkConfig fields ...
-        custom_config=CustomConfig(
-            telemetry_config=TelemetryConfig(enabled=False)
-        )
-    ),
-)
-```
+> **Note:** Telemetry is **enabled by default**. To opt out, set `TelemetryConfig(enabled=False)` on your `CustomConfig`.
 
 When telemetry is disabled the SDK constructs no transport, session, dispatcher, token provider or worker
 threads, so there is no overhead.
@@ -597,6 +579,14 @@ poetry publish
 
 ## Release Notes
 
+### 1.5.2 (Sep 30, 2026)
+- **Telemetry re-enabled by default**: Telemetry is now enabled by default again after the concurrency and shutdown bugfixes below. Opt out with `TelemetryConfig(enabled=False)`.
+- **Concurrent telemetry session isolation**: Fixed a race condition where overlapping SDK operations could share or corrupt telemetry session state.
+- **Daemon thread shutdown with atexit handler**: Fixed an issue where daemon worker threads were not cleaned up when `close()` was not called explicitly, by registering an `atexit` handler for graceful shutdown.
+
+### 1.5.1 (Sep 25, 2026)
+- **Telemetry disabled by default**: Telemetry was temporarily disabled while a bugfix was in progress.
+
 ### 1.5.0 (Sep 22, 2026)
 - **SDK Telemetry**: Added opt-out telemetry for PAR, Token, and UserInfo endpoint calls — see the [Telemetry](#telemetry) section for full details
   - Supports ASYNC (default) and SYNC delivery modes

{rp_python_sdk-1.5.0 → rp_python_sdk-1.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rp_python_sdk"
-version = "1.5.0"
+version = "1.5.2"
 description = "Python SDK for Relying Parties to enable simple integration with the Digital Identity ecosystem"
 authors = ["Erik Pragt <erik.pragt@connectid.com.au>"]
 license = "Proprietary"

rp_python_sdk-1.5.2/rp_python_sdk/endpoints/util/version_info.py

@@ -0,0 +1,2 @@
+def get_version_info() -> str:
+    return "1.5.2"  # Version number

{rp_python_sdk-1.5.0 → rp_python_sdk-1.5.2}/rp_python_sdk/relying_party_client_sdk.py

@@ -25,13 +25,24 @@ def _create_telemetry_sender(config: SdkConfig) -> TelemetrySender:
         logger.info("Telemetry is disabled; no telemetry events will be sent.")
         return NoopTelemetrySender.instance()
 
-    logger.info("Telemetry is enabled; telemetry events will be sent to the telemetry service.")
-    transport = TelemetryTransport.create(config)
-    if telemetry.delivery_mode is TelemetryDeliveryMode.SYNC:
-        return SyncTelemetrySender(transport, telemetry.sync_send_budget_seconds)
+    transport: Optional[TelemetryTransport] = None
+    try:
+        transport = TelemetryTransport.create(config)
+        if telemetry.delivery_mode is TelemetryDeliveryMode.SYNC:
+            sender: TelemetrySender = SyncTelemetrySender(
+                transport, telemetry.sync_send_budget_seconds)
+        else:
+            dispatcher = TelemetryDispatcher(
+                telemetry.queue_capacity, telemetry.max_concurrent_sends)
+            sender = AsyncTelemetrySender(transport, dispatcher)
+    except Exception as exception:
+        if transport is not None:
+            transport.close()
+        logger.warning(f"Failed to initialise telemetry; telemetry is disabled: {exception}")
+        return NoopTelemetrySender.instance()
 
-    dispatcher = TelemetryDispatcher(telemetry.queue_capacity, telemetry.max_concurrent_sends)
-    return AsyncTelemetrySender(transport, dispatcher)
+    logger.info("Telemetry is enabled; telemetry events will be sent to the telemetry service.")
+    return sender
 
 
 def _close_telemetry_sender(sender: TelemetrySender) -> None:

{rp_python_sdk-1.5.0 → rp_python_sdk-1.5.2}/rp_python_sdk/telemetry/telemetry_dispatcher.py

@@ -1,14 +1,41 @@
+import atexit
 import queue
 import threading
 import time
+import weakref
 from typing import Callable, List
 
 from rp_python_sdk.setup_logger import logger
 
 DEFAULT_GRACE_PERIOD_SECONDS = 2.0
+DEFAULT_EXIT_GRACE_PERIOD_SECONDS = 12.0
 DEFAULT_IDLE_TIMEOUT_SECONDS = 30.0
 POLL_INTERVAL_SECONDS = 0.1
 
+# Weak references to all live dispatchers. The atexit handler iterates these and
+# calls close() on any that are still alive, ensuring daemon worker threads are
+# joined before the interpreter tears down — preventing the
+# 'Fatal Python error: Aborted' on Python 3.12/Linux when threads are in C-level SSL code.
+_live_dispatchers: weakref.WeakSet["TelemetryDispatcher"] = weakref.WeakSet()
+_atexit_registered = False
+_atexit_lock = threading.Lock()
+
+
+def _shutdown_all_dispatchers() -> None:
+    for dispatcher in list(_live_dispatchers):
+        try:
+            dispatcher.close(grace_period_seconds=DEFAULT_EXIT_GRACE_PERIOD_SECONDS)
+        except Exception as exception:
+            logger.debug(f"Ignoring error while closing telemetry dispatcher at exit: {exception}")
+
+
+def _register_atexit_hook() -> None:
+    global _atexit_registered
+    with _atexit_lock:
+        if not _atexit_registered:
+            atexit.register(_shutdown_all_dispatchers)
+            _atexit_registered = True
+
 
 class TelemetryDispatcher:
 
@@ -32,6 +59,9 @@ class TelemetryDispatcher:
         # Monotonic so a replacement worker never reuses a retired worker's thread name.
         self._next_worker_number = 0
 
+        _live_dispatchers.add(self)
+        _register_atexit_hook()
+
     def enqueue(self, task: Callable[[], None]) -> bool:
         """Queues a task for background execution, returning False when it was dropped.
 
@@ -54,11 +84,15 @@ class TelemetryDispatcher:
 
     def close(self, grace_period_seconds: float = DEFAULT_GRACE_PERIOD_SECONDS) -> None:
         with self._lock:
+            if self._shutdown.is_set():
+                return
             self._shutdown.set()
             self._discard_pending()
             workers = list(self._workers)
             self._workers.clear()
 
+        _live_dispatchers.discard(self)
+
         deadline = time.monotonic() + grace_period_seconds
         for worker in workers:
             remaining = max(0.0, deadline - time.monotonic())

rp_python_sdk-1.5.2/rp_python_sdk/telemetry/telemetry_session_pool.py

@@ -0,0 +1,81 @@
+import queue
+import threading
+from typing import Iterable, Optional
+
+import requests
+
+from rp_python_sdk.setup_logger import logger
+
+
+class TelemetrySessionPool:
+    """Hands each telemetry send exclusive ownership of one HTTP session.
+
+    ``requests.Session`` contains mutable adapter and connection-pool state. A session therefore
+    stays leased to one worker for the complete token-and-event exchange. Shutdown closes idle
+    sessions immediately, while a leased session is closed by the worker that returns it. This
+    keeps shutdown bounded without closing TLS resources underneath an in-flight request.
+    """
+
+    def __init__(self, sessions: Iterable[requests.Session]) -> None:
+        available_sessions = list(sessions)
+        if not available_sessions:
+            raise ValueError("At least one telemetry session is required")
+
+        self._available: queue.LifoQueue[requests.Session] = queue.LifoQueue(
+            maxsize=len(available_sessions)
+        )
+        for session in available_sessions:
+            self._available.put_nowait(session)
+
+        self._lock = threading.Lock()
+        self._closed = False
+
+    def acquire(self) -> Optional[requests.Session]:
+        """Returns an exclusively leased session, or None without blocking."""
+        with self._lock:
+            if self._closed:
+                return None
+            try:
+                return self._available.get_nowait()
+            except queue.Empty:
+                return None
+
+    def release(self, session: requests.Session) -> None:
+        """Returns a lease, closing it instead when pool shutdown has begun."""
+        close_session = False
+        with self._lock:
+            if self._closed:
+                close_session = True
+            else:
+                try:
+                    self._available.put_nowait(session)
+                except queue.Full:
+                    # A duplicate release is a lifecycle bug, but telemetry cleanup must not
+                    # surface it to application code. Close the redundant resource instead.
+                    close_session = True
+
+        if close_session:
+            self._close_session(session)
+
+    def close(self) -> None:
+        """Prevents new leases and closes idle resources without waiting for active sends."""
+        idle_sessions: list[requests.Session] = []
+        with self._lock:
+            if self._closed:
+                return
+            self._closed = True
+            while True:
+                try:
+                    idle_sessions.append(self._available.get_nowait())
+                except queue.Empty:
+                    break
+
+        for session in idle_sessions:
+            self._close_session(session)
+
+    @staticmethod
+    def _close_session(session: requests.Session) -> None:
+        try:
+            session.close()
+        except Exception as exception:
+            logger.debug(f"Ignoring error while closing telemetry HTTP session: {exception}")

{rp_python_sdk-1.5.0 → rp_python_sdk-1.5.2}/rp_python_sdk/telemetry/telemetry_token_provider.py

@@ -27,22 +27,24 @@ class TelemetryTokenProvider:
         self._expires_at: float = 0.0
         self._discovery_document: Optional[dict[str, Any]] = None
 
-    def get_access_token(self, timeout: RequestsTimeout) -> Optional[str]:
+    def get_access_token(self, timeout: RequestsTimeout,
+                         session: Optional[requests.Session] = None) -> Optional[str]:
         if self._is_token_valid():
             return self._access_token
 
         with self._lock:
             if self._is_token_valid():
                 return self._access_token
-            return self._refresh_token(timeout)
+            selected_session = session if session is not None else self._session
+            return self._refresh_token(timeout, selected_session)
 
     def _is_token_valid(self) -> bool:
         return (self._access_token is not None
                 and time.time() + self.TOKEN_REFRESH_BUFFER_SECONDS < self._expires_at)
 
-    def _refresh_token(self, timeout: RequestsTimeout) -> Optional[str]:
+    def _refresh_token(self, timeout: RequestsTimeout, session: requests.Session) -> Optional[str]:
         try:
-            discovery_document = self._get_discovery_document(timeout)
+            discovery_document = self._get_discovery_document(timeout, session)
             token_endpoint = self._resolve_token_endpoint(discovery_document)
             audience = discovery_document.get("issuer") or token_endpoint
 
@@ -57,7 +59,7 @@ class TelemetryTokenProvider:
                 "client_assertion_type": _CLIENT_ASSERTION_TYPE,
             }
 
-            response = self._session.post(token_endpoint, data=data, timeout=timeout)
+            response = session.post(token_endpoint, data=data, timeout=timeout)
             response.raise_for_status()
             token_response = response.json()
 
@@ -73,11 +75,12 @@ class TelemetryTokenProvider:
             self._expires_at = 0.0
             return None
 
-    def _get_discovery_document(self, timeout: RequestsTimeout) -> dict[str, Any]:
+    def _get_discovery_document(self, timeout: RequestsTimeout,
+                                session: requests.Session) -> dict[str, Any]:
         if self._discovery_document is not None:
             return self._discovery_document
 
-        response = self._session.get(self._registry_discovery_url, timeout=timeout)
+        response = session.get(self._registry_discovery_url, timeout=timeout)
         response.raise_for_status()
         discovery_document: dict[str, Any] = response.json()
 
@@ -89,4 +92,3 @@ class TelemetryTokenProvider:
         mtls_aliases = discovery_document.get("mtls_endpoint_aliases") or {}
         token_endpoint = mtls_aliases.get("token_endpoint") or discovery_document["token_endpoint"]
         return str(token_endpoint)
-

{rp_python_sdk-1.5.0 → rp_python_sdk-1.5.2}/rp_python_sdk/telemetry/telemetry_transport.py

@@ -1,5 +1,5 @@
 import json
-from typing import Any, Optional
+from typing import Any, Optional, Sequence
 
 import requests
 
@@ -7,6 +7,7 @@ from rp_python_sdk.sdk_config import SdkConfig
 from rp_python_sdk.setup_logger import logger
 from rp_python_sdk.telemetry.telemetry_event import TelemetryEvent
 from rp_python_sdk.telemetry.telemetry_session import create_telemetry_session
+from rp_python_sdk.telemetry.telemetry_session_pool import TelemetrySessionPool
 from rp_python_sdk.telemetry.telemetry_token_provider import (
     TelemetryTokenProvider,
     RequestsTimeout,
@@ -19,19 +20,34 @@ _JSON_MEDIA_TYPE = "application/json"
 
 class TelemetryTransport:
     def __init__(self, session: requests.Session, token_provider: TelemetryTokenProvider,
-                 telemetry_endpoint_url: str) -> None:
-        self._session = session
+                 telemetry_endpoint_url: str,
+                 additional_sessions: Sequence[requests.Session] = ()) -> None:
+        self._sessions = TelemetrySessionPool([session, *additional_sessions])
         self._token_provider = token_provider
         self._telemetry_endpoint_url = telemetry_endpoint_url
 
     @classmethod
     def create(cls, config: SdkConfig) -> "TelemetryTransport":
         telemetry_urls = resolve_telemetry_urls(config)
-        session = create_telemetry_session(config, config.custom_config.telemetry_config.max_concurrent_sends)
-        token_provider = TelemetryTokenProvider(session, config,
-                                                telemetry_urls.registry_discovery_document_url)
-
-        return cls(session, token_provider, telemetry_urls.telemetry_endpoint_url)
+        session_count = config.custom_config.telemetry_config.max_concurrent_sends
+        sessions: list[requests.Session] = []
+        try:
+            # A session is never shared between workers. Each session needs only one connection
+            # slot because the dispatcher already bounds the number of concurrent sends.
+            for _ in range(session_count):
+                sessions.append(create_telemetry_session(config, pool_size=1))
+            token_provider = TelemetryTokenProvider(
+                sessions[0], config, telemetry_urls.registry_discovery_document_url)
+            return cls(sessions[0], token_provider, telemetry_urls.telemetry_endpoint_url,
+                       additional_sessions=sessions[1:])
+        except Exception:
+            for session in sessions:
+                try:
+                    session.close()
+                except Exception as close_error:
+                    logger.debug(f"Ignoring error while cleaning up telemetry HTTP session: "
+                                 f"{close_error}")
+            raise
 
     @property
     def token_provider(self) -> TelemetryTokenProvider:
@@ -39,13 +55,20 @@ class TelemetryTransport:
 
     def send(self, event: TelemetryEvent, timeout: RequestsTimeout,
              token: Optional[str] = None) -> None:
+        session = self._sessions.acquire()
+        if session is None:
+            logger.debug(f"Skipping telemetry event type {event.type} "
+                         f"(x-fapi-interaction-id: {event.x_fapi_interaction_id}): "
+                         f"no exclusive HTTP session is available.")
+            return
+
         try:
             logger.info(f"Dispatching telemetry event type {event.type} "
                         f"(x-fapi-interaction-id: {event.x_fapi_interaction_id}) "
                         f"to {self._telemetry_endpoint_url}")
 
             if token is None:
-                token = self._token_provider.get_access_token(timeout)
+                token = self._token_provider.get_access_token(timeout, session)
             if token is None:
                 logger.warning(f"Skipping telemetry event type {event.type} "
                                f"(x-fapi-interaction-id: {event.x_fapi_interaction_id}): "
@@ -59,9 +82,9 @@ class TelemetryTransport:
                 _FAPI_INTERACTION_ID_HEADER: event.x_fapi_interaction_id,
             }
 
-            response = self._session.post(self._telemetry_endpoint_url, data=body,
-                                          headers=headers,
-                                          timeout=timeout)
+            response = session.post(self._telemetry_endpoint_url, data=body,
+                                    headers=headers,
+                                    timeout=timeout)
 
             if not response.ok:
                 logger.warning(f"Telemetry send for event type {event.type} "
@@ -74,6 +97,8 @@ class TelemetryTransport:
         except Exception as exception:
             logger.warning(f"Failed to send telemetry event type {event.type} "
                            f"(x-fapi-interaction-id: {event.x_fapi_interaction_id}): {exception}")
+        finally:
+            self._sessions.release(session)
 
     def close(self) -> None:
-        self._session.close()
+        self._sessions.close()

rp_python_sdk-1.5.0/rp_python_sdk/endpoints/util/version_info.py

@@ -1,2 +0,0 @@
-def get_version_info() -> str:
-    return "1.5.0"  # Version number