helix.fhir.client.sdk 4.2.14__py3-none-any.whl → 4.2.16__py3-none-any.whl

helix_fhir_client_sdk/fhir_merge_resources_mixin.py

@@ -118,7 +118,6 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                 log_all_url_results=self._log_all_response_urls,
                 access_token=self._access_token,
                 access_token_expiry_date=self._access_token_expiry_date,
-                persistent_session=self._persistent_session,
             ) as client:
                 http_post_start = time.time()
                 response: RetryableAioHttpResponse = await client.post(
@@ -312,7 +311,6 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                         log_all_url_results=self._log_all_response_urls,
                         access_token=self._access_token,
                         access_token_expiry_date=self._access_token_expiry_date,
-                        persistent_session=self._persistent_session,
                     ) as client:
                         # should we check if it exists and do a POST then?
                         response: RetryableAioHttpResponse = await client.post(
@@ -529,7 +527,6 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                             log_all_url_results=self._log_all_response_urls,
                             access_token=self._access_token,
                             access_token_expiry_date=self._access_token_expiry_date,
-                            persistent_session=self._persistent_session,
                         ) as client:
                             # should we check if it exists and do a POST then?
                             response: RetryableAioHttpResponse = await client.post(

helix_fhir_client_sdk/fhir_patch_mixin.py

@@ -2,8 +2,12 @@ import json
 import time
 
 from furl import furl
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
 
 from helix_fhir_client_sdk.exceptions.fhir_sender_exception import FhirSenderException
+from helix_fhir_client_sdk.open_telemetry.attribute_names import FhirClientSdkOpenTelemetryAttributeNames
+from helix_fhir_client_sdk.open_telemetry.span_names import FhirClientSdkOpenTelemetrySpanNames
 from helix_fhir_client_sdk.responses.fhir_client_protocol import FhirClientProtocol
 from helix_fhir_client_sdk.responses.fhir_update_response import FhirUpdateResponse
 from helix_fhir_client_sdk.structures.get_access_token_result import (
@@ -18,6 +22,8 @@ from helix_fhir_client_sdk.utilities.retryable_aiohttp_response import (
     RetryableAioHttpResponse,
 )
 
+TRACER = trace.get_tracer(__name__)
+
 
 class FhirPatchMixin(FhirClientProtocol):
     async def send_patch_request_async(self, data: str) -> FhirUpdateResponse:
@@ -33,94 +39,102 @@ class FhirPatchMixin(FhirClientProtocol):
             raise ValueError("update should have only one id")
         if not self._resource:
             raise ValueError("update requires a FHIR resource type")
-        self._internal_logger.debug(
-            f"Calling patch method on {self._url} with client_id={self._client_id} and scopes={self._auth_scopes}"
-        )
-        full_uri: furl = furl(self._url)
-        full_uri /= self._resource
-        full_uri /= self._id
-        request_id: str | None = None
 
-        start_time: float = time.time()
+        with TRACER.start_as_current_span(FhirClientSdkOpenTelemetrySpanNames.PATCH) as span:
+            span.set_attribute(FhirClientSdkOpenTelemetryAttributeNames.URL, self._url or "")
+            span.set_attribute(FhirClientSdkOpenTelemetryAttributeNames.RESOURCE, self._resource or "")
+            try:
+                self._internal_logger.debug(
+                    f"Calling patch method on {self._url} with client_id={self._client_id} and scopes={self._auth_scopes}"
+                )
+                full_uri: furl = furl(self._url)
+                full_uri /= self._resource
+                full_uri /= self._id
+                request_id: str | None = None
 
-        # Set up headers
-        headers = {"Content-Type": "application/json-patch+json"}
-        headers.update(self._additional_request_headers)
-        self._internal_logger.debug(f"Request headers: {headers}")
-        access_token_result: GetAccessTokenResult = await self.get_access_token_async()
-        access_token: str | None = access_token_result.access_token
-        # set access token in request if present
-        if access_token:
-            headers["Authorization"] = f"Bearer {access_token}"
+                start_time: float = time.time()
 
-        response_text: str | None = None
-        response_status: int | None = None
+                # Set up headers
+                headers = {"Content-Type": "application/json-patch+json"}
+                headers.update(self._additional_request_headers)
+                self._internal_logger.debug(f"Request headers: {headers}")
+                access_token_result: GetAccessTokenResult = await self.get_access_token_async()
+                access_token: str | None = access_token_result.access_token
+                # set access token in request if present
+                if access_token:
+                    headers["Authorization"] = f"Bearer {access_token}"
 
-        try:
-            deserialized_data = json.loads(data)
-            # actually make the request
-            async with RetryableAioHttpClient(
-                fn_get_session=lambda: self.create_http_session(),
-                refresh_token_func=self._refresh_token_function,
-                tracer_request_func=self._trace_request_function,
-                retries=self._retry_count,
-                exclude_status_codes_from_retry=self._exclude_status_codes_from_retry,
-                use_data_streaming=self._use_data_streaming,
-                send_data_as_chunked=self._send_data_as_chunked,
-                compress=self._compress,
-                throw_exception_on_error=self._throw_exception_on_error,
-                log_all_url_results=self._log_all_response_urls,
-                access_token=self._access_token,
-                access_token_expiry_date=self._access_token_expiry_date,
-                persistent_session=self._persistent_session,
-            ) as client:
-                response: RetryableAioHttpResponse = await client.patch(
-                    url=full_uri.url, json=deserialized_data, headers=headers
-                )
-                response_status = response.status
-                response_text = await response.get_text_async()
-                request_id = response.response_headers.get("X-Request-ID", None)
-                self._internal_logger.debug(f"X-Request-ID={request_id}")
+                response_text: str | None = None
+                response_status: int | None = None
 
-                if response_status == 200:
-                    if self._logger:
-                        self._logger.info(f"Successfully updated: {full_uri}")
-                elif response_status == 404:
-                    if self._logger:
-                        self._logger.info(f"Request resource was not found: {full_uri}")
+                try:
+                    deserialized_data = json.loads(data)
+                    # actually make the request
+                    async with RetryableAioHttpClient(
+                        fn_get_session=lambda: self.create_http_session(),
+                        refresh_token_func=self._refresh_token_function,
+                        tracer_request_func=self._trace_request_function,
+                        retries=self._retry_count,
+                        exclude_status_codes_from_retry=self._exclude_status_codes_from_retry,
+                        use_data_streaming=self._use_data_streaming,
+                        send_data_as_chunked=self._send_data_as_chunked,
+                        compress=self._compress,
+                        throw_exception_on_error=self._throw_exception_on_error,
+                        log_all_url_results=self._log_all_response_urls,
+                        access_token=self._access_token,
+                        access_token_expiry_date=self._access_token_expiry_date,
+                    ) as client:
+                        response: RetryableAioHttpResponse = await client.patch(
+                            url=full_uri.url, json=deserialized_data, headers=headers
+                        )
+                        response_status = response.status
+                        response_text = await response.get_text_async()
+                        request_id = response.response_headers.get("X-Request-ID", None)
+                        self._internal_logger.debug(f"X-Request-ID={request_id}")
+
+                        if response_status == 200:
+                            if self._logger:
+                                self._logger.info(f"Successfully updated: {full_uri}")
+                        elif response_status == 404:
+                            if self._logger:
+                                self._logger.info(f"Request resource was not found: {full_uri}")
+                        else:
+                            # other HTTP errors
+                            self._internal_logger.info(f"PATCH response for {full_uri.url}: {response_status}")
+                except Exception as e:
+                    raise FhirSenderException(
+                        request_id=request_id,
+                        url=full_uri.url,
+                        headers=headers,
+                        json_data=data,
+                        response_text=response_text,
+                        response_status_code=response_status,
+                        exception=e,
+                        variables=FhirClientLogger.get_variables_to_log(vars(self)),
+                        message=f"Error: {e}",
+                        elapsed_time=time.time() - start_time,
+                    ) from e
+                # check if response is json
+                if response_text:
+                    try:
+                        responses = json.loads(response_text)
+                    except ValueError as e:
+                        responses = {"issue": str(e)}
                 else:
-                    # other HTTP errors
-                    self._internal_logger.info(f"PATCH response for {full_uri.url}: {response_status}")
-        except Exception as e:
-            raise FhirSenderException(
-                request_id=request_id,
-                url=full_uri.url,
-                headers=headers,
-                json_data=data,
-                response_text=response_text,
-                response_status_code=response_status,
-                exception=e,
-                variables=FhirClientLogger.get_variables_to_log(vars(self)),
-                message=f"Error: {e}",
-                elapsed_time=time.time() - start_time,
-            ) from e
-        # check if response is json
-        if response_text:
-            try:
-                responses = json.loads(response_text)
-            except ValueError as e:
-                responses = {"issue": str(e)}
-        else:
-            responses = {}
-        return FhirUpdateResponse(
-            request_id=request_id,
-            url=full_uri.tostr(),
-            responses=json.dumps(responses),
-            error=json.dumps(responses),
-            access_token=access_token,
-            status=response_status if response_status else 500,
-            resource_type=self._resource,
-        )
+                    responses = {}
+                return FhirUpdateResponse(
+                    request_id=request_id,
+                    url=full_uri.tostr(),
+                    responses=json.dumps(responses),
+                    error=json.dumps(responses),
+                    access_token=access_token,
+                    status=response_status if response_status else 500,
+                    resource_type=self._resource,
+                )
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                raise
 
     def send_patch_request(self, data: str) -> FhirUpdateResponse:
         """

helix_fhir_client_sdk/fhir_update_mixin.py

@@ -3,7 +3,11 @@ from collections.abc import AsyncGenerator
 from compressedfhir.fhir.fhir_resource import FhirResource
 from compressedfhir.fhir.fhir_resource_list import FhirResourceList
 from furl import furl
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
 
+from helix_fhir_client_sdk.open_telemetry.attribute_names import FhirClientSdkOpenTelemetryAttributeNames
+from helix_fhir_client_sdk.open_telemetry.span_names import FhirClientSdkOpenTelemetrySpanNames
 from helix_fhir_client_sdk.responses.fhir_client_protocol import FhirClientProtocol
 from helix_fhir_client_sdk.responses.fhir_update_response import FhirUpdateResponse
 from helix_fhir_client_sdk.structures.get_access_token_result import (
@@ -15,6 +19,8 @@ from helix_fhir_client_sdk.utilities.retryable_aiohttp_client import (
 )
 from helix_fhir_client_sdk.validators.async_fhir_validator import AsyncFhirValidator
 
+TRACER = trace.get_tracer(__name__)
+
 
 class FhirUpdateMixin(FhirClientProtocol):
     async def update_single_resource_async(self, *, resource: FhirResource) -> FhirUpdateResponse:
@@ -69,61 +75,69 @@ class FhirUpdateMixin(FhirClientProtocol):
             raise ValueError("update should have only one id")
         if not self._resource:
             raise ValueError("update requires a FHIR resource type")
-        full_uri: furl = furl(self._url)
-        full_uri /= self._resource
-        full_uri /= id_ or self._id
-        # set up headers
-        headers = {"Content-Type": "application/fhir+json"}
-        headers.update(self._additional_request_headers)
-        self._internal_logger.debug(f"Request headers: {headers}")
-
-        access_token_result: GetAccessTokenResult = await self.get_access_token_async()
-        access_token: str | None = access_token_result.access_token
-        # set access token in request if present
-        if access_token:
-            headers["Authorization"] = f"Bearer {access_token}"
-
-        if self._validation_server_url:
-            await AsyncFhirValidator.validate_fhir_resource(
-                fn_get_session=lambda: self.create_http_session(),
-                json_data=json_data,
-                resource_name=self._resource,
-                validation_server_url=self._validation_server_url,
-                access_token=access_token,
-            )
-
-        # actually make the request
-        async with RetryableAioHttpClient(
-            fn_get_session=lambda: self.create_http_session(),
-            refresh_token_func=self._refresh_token_function,
-            tracer_request_func=self._trace_request_function,
-            retries=self._retry_count,
-            exclude_status_codes_from_retry=self._exclude_status_codes_from_retry,
-            use_data_streaming=self._use_data_streaming,
-            send_data_as_chunked=self._send_data_as_chunked,
-            compress=self._compress,
-            throw_exception_on_error=self._throw_exception_on_error,
-            log_all_url_results=self._log_all_response_urls,
-            access_token=self._access_token,
-            access_token_expiry_date=self._access_token_expiry_date,
-            persistent_session=self._persistent_session,
-        ) as client:
-            response = await client.put(url=full_uri.url, data=json_data, headers=headers)
-            request_id = response.response_headers.get("X-Request-ID", None)
-            self._internal_logger.debug(f"X-Request-ID={request_id}")
-            if response.status == 200:
-                if self._logger:
-                    self._logger.info(f"Successfully updated: {full_uri}")
-
-            return FhirUpdateResponse(
-                request_id=request_id,
-                url=full_uri.tostr(),
-                responses=await response.get_text_async(),
-                error=f"{response.status}" if not response.status == 200 else None,
-                access_token=access_token,
-                status=response.status,
-                resource_type=self._resource,
-            )
+
+        with TRACER.start_as_current_span(FhirClientSdkOpenTelemetrySpanNames.UPDATE) as span:
+            span.set_attribute(FhirClientSdkOpenTelemetryAttributeNames.URL, self._url or "")
+            span.set_attribute(FhirClientSdkOpenTelemetryAttributeNames.RESOURCE, self._resource or "")
+            try:
+                full_uri: furl = furl(self._url)
+                full_uri /= self._resource
+                full_uri /= id_ or self._id
+                # set up headers
+                headers = {"Content-Type": "application/fhir+json"}
+                headers.update(self._additional_request_headers)
+                self._internal_logger.debug(f"Request headers: {headers}")
+
+                access_token_result: GetAccessTokenResult = await self.get_access_token_async()
+                access_token: str | None = access_token_result.access_token
+                # set access token in request if present
+                if access_token:
+                    headers["Authorization"] = f"Bearer {access_token}"
+
+                if self._validation_server_url:
+                    await AsyncFhirValidator.validate_fhir_resource(
+                        fn_get_session=lambda: self.create_http_session(),
+                        json_data=json_data,
+                        resource_name=self._resource,
+                        validation_server_url=self._validation_server_url,
+                        access_token=access_token,
+                    )
+
+                # actually make the request
+                async with RetryableAioHttpClient(
+                    fn_get_session=lambda: self.create_http_session(),
+                    refresh_token_func=self._refresh_token_function,
+                    tracer_request_func=self._trace_request_function,
+                    retries=self._retry_count,
+                    exclude_status_codes_from_retry=self._exclude_status_codes_from_retry,
+                    use_data_streaming=self._use_data_streaming,
+                    send_data_as_chunked=self._send_data_as_chunked,
+                    compress=self._compress,
+                    throw_exception_on_error=self._throw_exception_on_error,
+                    log_all_url_results=self._log_all_response_urls,
+                    access_token=self._access_token,
+                    access_token_expiry_date=self._access_token_expiry_date,
+                ) as client:
+                    response = await client.put(url=full_uri.url, data=json_data, headers=headers)
+                    request_id = response.response_headers.get("X-Request-ID", None)
+                    self._internal_logger.debug(f"X-Request-ID={request_id}")
+                    if response.status == 200:
+                        if self._logger:
+                            self._logger.info(f"Successfully updated: {full_uri}")
+
+                    return FhirUpdateResponse(
+                        request_id=request_id,
+                        url=full_uri.tostr(),
+                        responses=await response.get_text_async(),
+                        error=f"{response.status}" if not response.status == 200 else None,
+                        access_token=access_token,
+                        status=response.status,
+                        resource_type=self._resource,
+                    )
+            except Exception as e:
+                span.record_exception(e)
+                span.set_status(Status(StatusCode.ERROR, str(e)))
+                raise
 
     def update(self, json_data: str) -> FhirUpdateResponse:
         """

helix_fhir_client_sdk/open_telemetry/attribute_names.py

@@ -2,3 +2,6 @@ class FhirClientSdkOpenTelemetryAttributeNames:
     """Constants for OpenTelemetry attribute names used in the FHIR Client SDK."""
 
     URL: str = "fhir.client_sdk.url"
+    RESOURCE: str = "fhir.client_sdk.resource"
+    JSON_DATA_COUNT: str = "fhir.client_sdk.json_data.count"
+    BATCH_SIZE: str = "fhir.client_sdk.batch.size"

helix_fhir_client_sdk/open_telemetry/span_names.py

@@ -6,3 +6,7 @@ class FhirClientSdkOpenTelemetrySpanNames:
     GET_ACCESS_TOKEN: str = "fhir.client_sdk.access_token.get"
     HTTP_GET: str = "fhir.client_sdk.http.get"
     HANDLE_RESPONSE: str = "fhir.client_sdk.handle_response"
+    DELETE: str = "fhir.client_sdk.delete"
+    UPDATE: str = "fhir.client_sdk.update"
+    PATCH: str = "fhir.client_sdk.patch"
+    MERGE: str = "fhir.client_sdk.merge"

helix_fhir_client_sdk/queue/request_queue_mixin.py

@@ -130,7 +130,6 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                 log_all_url_results=self._log_all_response_urls,
                 access_token=self._access_token,
                 access_token_expiry_date=self._access_token_expiry_date,
-                persistent_session=self._persistent_session,
             ) as client:
                 while next_url:
                     # set access token in request if present
@@ -299,7 +298,6 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                 log_all_url_results=self._log_all_response_urls,
                 access_token=self._access_token,
                 access_token_expiry_date=self._access_token_expiry_date,
-                persistent_session=self._persistent_session,
             ) as client:
                 while next_url:
                     # set access token in request if present

helix_fhir_client_sdk/responses/fhir_client_protocol.py

@@ -1,5 +1,5 @@
 import uuid
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Callable
 from datetime import datetime
 from logging import Logger
 from threading import Lock
@@ -89,8 +89,6 @@ class FhirClientProtocol(Protocol):
     _send_data_as_chunked: bool = False
     _last_page_lock: Lock
 
-    _persistent_session: ClientSession | None = None
-
     _use_post_for_search: bool = False
 
     _accept: str
@@ -131,6 +129,9 @@ class FhirClientProtocol(Protocol):
     _max_concurrent_requests: int | None
     """ maximum number of concurrent requests to make to the FHIR server """
 
+    _fn_create_http_session: Callable[[], ClientSession] | None
+    """ optional callable to create HTTP sessions """
+
     async def get_access_token_async(self) -> GetAccessTokenResult: ...
 
     async def _send_fhir_request_async(
@@ -214,4 +215,4 @@ class FhirClientProtocol(Protocol):
         # this is just here to tell Python this returns a generator
         yield None  # type: ignore[misc]
 
-    def set_persistent_session(self, session: ClientSession | None) -> "FhirClientProtocol": ...
+    def use_http_session(self, fn_create_http_session: Callable[[], ClientSession] | None) -> "FhirClientProtocol": ...

helix_fhir_client_sdk/utilities/retryable_aiohttp_client.py

@@ -45,11 +45,32 @@ class RetryableAioHttpClient:
         log_all_url_results: bool = False,
         access_token: str | None,
         access_token_expiry_date: datetime | None,
-        persistent_session: ClientSession | None = None,
     ) -> None:
         """
-        RetryableClient provides a way to make HTTP calls with automatic retry and automatic refreshing of access tokens
+        RetryableClient provides a way to make HTTP calls with automatic retry and automatic refreshing of access tokens.
 
+        Session Lifecycle Management:
+        - If fn_get_session is None (default): The SDK creates and manages the session lifecycle.
+          The session will be automatically closed when exiting the context manager.
+        - If fn_get_session is provided: The caller is responsible for managing the session lifecycle.
+          The SDK will NOT close the session - the caller must close it themselves.
+
+        :param retries: Number of retry attempts for failed requests
+        :param timeout_in_seconds: Timeout for HTTP requests
+        :param backoff_factor: Factor for exponential backoff between retries
+        :param retry_status_codes: HTTP status codes that trigger a retry
+        :param refresh_token_func: Function to refresh authentication tokens
+        :param tracer_request_func: Function to trace/log requests
+        :param fn_get_session: Optional callable that returns a ClientSession. If provided,
+                               the caller is responsible for closing the session.
+        :param exclude_status_codes_from_retry: Status codes to exclude from retry logic
+        :param use_data_streaming: Whether to stream response data
+        :param compress: Whether to compress request data
+        :param send_data_as_chunked: Whether to use chunked transfer encoding
+        :param throw_exception_on_error: Whether to raise exceptions on HTTP errors
+        :param log_all_url_results: Whether to log all URL results
+        :param access_token: Access token for authentication
+        :param access_token_expiry_date: Expiry date of the access token
         """
         self.retries: int = retries
         self.timeout_in_seconds: float | None = timeout_in_seconds
@@ -59,6 +80,8 @@ class RetryableAioHttpClient:
         )
         self.refresh_token_func_async: RefreshTokenFunction | None = refresh_token_func
         self.trace_function_async: TraceRequestFunction | None = tracer_request_func
+        # Automatically determine if a session is caller-managed based on whether fn_get_session is provided
+        self._caller_managed_session: bool = fn_get_session is not None
         self.fn_get_session: Callable[[], ClientSession] = (
             fn_get_session if fn_get_session is not None else lambda: ClientSession()
         )
@@ -71,16 +94,9 @@ class RetryableAioHttpClient:
         self.log_all_url_results: bool = log_all_url_results
         self.access_token: str | None = access_token
         self.access_token_expiry_date: datetime | None = access_token_expiry_date
-        self.persistent_session: ClientSession | None = persistent_session
 
     async def __aenter__(self) -> "RetryableAioHttpClient":
-        # Clear a stale persistent session if closed
-        if self.persistent_session is not None and self.persistent_session.closed:
-            self.persistent_session = None
-
-        # Use an existing persistent session or create a new one
-        self.session = self.persistent_session if self.persistent_session is not None else self.fn_get_session()
-
+        self.session = self.fn_get_session()
         return self
 
     async def __aexit__(
@@ -89,7 +105,9 @@ class RetryableAioHttpClient:
         exc_val: BaseException | None,
         exc_tb: type[BaseException] | None | None,
     ) -> None:
-        if not self.persistent_session and self.session is not None:
+        # Only close the session if SDK created it (fn_get_session was not provided)
+        # If the caller provided fn_get_session, they are responsible for closing the session
+        if not self._caller_managed_session and self.session is not None:
             await self.session.close()
 
     @staticmethod
@@ -123,7 +141,7 @@ class RetryableAioHttpClient:
             try:
                 if headers:
                     kwargs["headers"] = headers
-                # if there is no data then remove from kwargs so as not to confuse aiohttp
+                # if there is no data, then remove from kwargs so as not to confuse aiohttp
                 if "data" in kwargs and kwargs["data"] is None:
                     del kwargs["data"]
                 # compression and chunked can only be enabled if there is content sent
@@ -407,7 +425,7 @@ class RetryableAioHttpClient:
         if retry_after_text:
             # noinspection PyBroadException
             try:
-                if retry_after_text.isnumeric():  # it is number of seconds
+                if retry_after_text.isnumeric():  # it is a number of seconds
                     await asyncio.sleep(int(retry_after_text))
                 else:
                     wait_till: datetime = datetime.strptime(retry_after_text, "%a, %d %b %Y %H:%M:%S GMT")
@@ -421,7 +439,7 @@ class RetryableAioHttpClient:
                     if time_diff > 0:
                         await asyncio.sleep(time_diff)
             except Exception:
-                # if there was some exception parsing the Retry-After header, sleep for 60 seconds
+                # if there was some exception, parsing the Retry-After header, sleep for 60 seconds
                 await asyncio.sleep(60)
         else:
             await asyncio.sleep(60)

{helix_fhir_client_sdk-4.2.14.dist-info → helix_fhir_client_sdk-4.2.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: helix.fhir.client.sdk
-Version: 4.2.14
+Version: 4.2.16
 Summary: helix.fhir.client.sdk
 Home-page: https://github.com/icanbwell/helix.fhir.client.sdk
 Author: Imran Qureshi
@@ -111,9 +111,46 @@ response: Optional[FhirGetResponse] = await FhirGetResponse.from_async_generator
 ```
 
 # Data Streaming
-For FHIR servers that support data streaming (e.g., b.well FHIR server), you can just set the `use_data_streaming` parameter to stream the data as it i received.
+For FHIR servers that support data streaming (e.g., b.well FHIR server), you can just set the `use_data_streaming` parameter to stream the data as it is received.
 The data will be streamed in AsyncGenerators as described above.
 
+# Persistent Sessions (Connection Reuse)
+By default, the SDK creates a new HTTP session for each request. For better performance (~4× faster), 
+you can use persistent sessions to reuse connections across multiple requests.
+
+**Important**: When you provide a custom session factory using `use_http_session()`, YOU are responsible 
+for managing the session lifecycle, including closing it when done. The SDK will NOT automatically close 
+user-provided sessions.
+
+```python
+import aiohttp
+from helix_fhir_client_sdk.fhir_client import FhirClient
+
+# Create a persistent session for connection reuse
+session = aiohttp.ClientSession()
+
+try:
+    # Configure FhirClient to use persistent session
+    fhir_client = (
+        FhirClient()
+        .url("https://fhir.example.com")
+        .resource("Patient")
+        .use_http_session(lambda: session)  # User provides session factory
+    )
+    
+    # Multiple requests reuse the same connection (~4× performance boost)
+    response1 = await fhir_client.get_async()
+    response2 = await fhir_client.clone().resource("Observation").get_async()
+    
+finally:
+    # User must close the session when done
+    await session.close()
+```
+
+**Session Lifecycle Rules**:
+- **No custom factory** (default): SDK creates and closes the session automatically
+- **Custom factory provided**: User is responsible for closing the session
+
 # Storage Compression
 The FHIR client SDK supports two types of compression: