helix.fhir.client.sdk 4.2.3__py3-none-any.whl → 4.2.19__py3-none-any.whl

helix_fhir_client_sdk/fhir_merge_resources_mixin.py

@@ -2,9 +2,7 @@ import json
 import time
 from collections import deque
 from collections.abc import AsyncGenerator
-from typing import (
-    cast,
-)
+from typing import Any, cast
 from urllib import parse
 
 import requests
@@ -45,6 +43,195 @@ from helix_fhir_client_sdk.validators.async_fhir_validator import AsyncFhirValid
 
 
 class FhirMergeResourcesMixin(FhirClientProtocol):
+    async def merge_bundle_uncompressed(
+        self,
+        id_: str | None,
+        bundle: FhirBundle,
+    ) -> FhirMergeResourceResponse:
+        """
+        Optimized variant of :meth:`merge_bundle_async` that bypasses storage-mode handling.
+        Use this method when you do not need storage-mode behavior, or features such as request/response compression.
+        :param id_: id of the resource to merge
+        :param bundle: FHIR Bundle to merge
+        :return: FhirMergeResourceResponse
+        """
+        # Initialize profiling dictionary
+        profiling: dict[str, float] = {
+            "total_time": 0.0,
+            "build_url": 0.0,
+            "get_access_token": 0.0,
+            "prepare_payload": 0.0,
+            "http_post": 0.0,
+            "parse_response": 0.0,
+            "create_response_objects": 0.0,
+        }
+
+        merge_start_time = time.time()
+
+        request_id: str | None = None
+        response_status: int = 500
+
+        # Build URL
+        build_url_start = time.time()
+        full_uri: furl = furl(self._url)
+        full_uri /= self._resource
+
+        # Prepare headers
+        headers = {"Content-Type": "application/fhir+json"}
+        headers.update(self._additional_request_headers)
+        profiling["build_url"] = time.time() - build_url_start
+
+        # Get access token
+        get_token_start = time.time()
+        access_token_result: GetAccessTokenResult = await self.get_access_token_async()
+        access_token: str | None = access_token_result.access_token
+        if access_token:
+            headers["Authorization"] = f"Bearer {access_token}"
+        profiling["get_access_token"] = time.time() - get_token_start
+
+        # Prepare JSON payload
+        prepare_payload_start = time.time()
+        first_resource: FhirResource | None = bundle.entry[0].resource
+        assert first_resource is not None
+        json_payload: str = first_resource.json() if len(bundle.entry) == 1 else bundle.json()
+
+        # Build merge URL
+        obj_id: str = id_ or "1"
+        resource_uri: furl = full_uri / parse.quote(str(obj_id), safe="") / "$merge"
+        profiling["prepare_payload"] = time.time() - prepare_payload_start
+
+        response_text: str | None = None
+        responses: list[dict[str, Any]] = []
+        errors: list[dict[str, Any]] = []
+
+        try:
+            async with RetryableAioHttpClient(
+                fn_get_session=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:
+                http_post_start = time.time()
+                response: RetryableAioHttpResponse = await client.post(
+                    url=resource_uri.url,
+                    data=json_payload,
+                    headers=headers,
+                )
+                profiling["http_post"] = time.time() - http_post_start
+
+                response_status = response.status
+                request_id = response.response_headers.get("X-Request-ID", None)
+
+                parse_response_start = time.time()
+                if response.status == 200:
+                    response_text = await response.get_text_async()
+                    if response_text:
+                        try:
+                            # Parse response as plain dicts for speed
+                            parsed_response = json.loads(response_text)
+                            if isinstance(parsed_response, list):
+                                responses = parsed_response
+                            else:
+                                responses = [parsed_response]
+                        except (ValueError, json.JSONDecodeError) as e:
+                            errors.append(
+                                {
+                                    "issue": [
+                                        {
+                                            "severity": "error",
+                                            "code": "exception",
+                                            "diagnostics": f"Failed to parse response: {str(e)}",
+                                        }
+                                    ]
+                                }
+                            )
+                else:
+                    # HTTP error
+                    response_text = await response.get_text_async()
+                    errors.append(
+                        {
+                            "issue": [
+                                {
+                                    "severity": "error",
+                                    "code": "exception",
+                                    "diagnostics": response_text or f"HTTP {response.status}",
+                                }
+                            ]
+                        }
+                    )
+                profiling["parse_response"] = time.time() - parse_response_start
+
+        except requests.exceptions.HTTPError as e:
+            raise FhirSenderException(
+                request_id=request_id,
+                url=resource_uri.url,
+                headers=headers,
+                json_data=json_payload,
+                response_text=response_text,
+                response_status_code=response_status,
+                exception=e,
+                variables=FhirClientLogger.get_variables_to_log(vars(self)),
+                message=f"HttpError: {e}",
+                elapsed_time=time.time() - merge_start_time,
+            ) from e
+        except Exception as e:
+            raise FhirSenderException(
+                request_id=request_id,
+                url=resource_uri.url,
+                headers=headers,
+                json_data=json_payload,
+                response_text=response_text,
+                response_status_code=response_status,
+                exception=e,
+                variables=FhirClientLogger.get_variables_to_log(vars(self)),
+                message=f"Unknown Error: {e}",
+                elapsed_time=time.time() - merge_start_time,
+            ) from e
+
+        # Convert dict responses to proper objects using fast method
+        create_objects_start = time.time()
+        response_entries: deque[BaseFhirMergeResourceResponseEntry] = deque()
+
+        for resp_dict in responses:
+            response_entries.append(FhirMergeResourceResponseEntry.from_dict_uncompressed(resp_dict))
+
+        for error_dict in errors:
+            response_entries.append(FhirMergeResponseEntryError.from_dict(error_dict, storage_mode=self._storage_mode))
+        profiling["create_response_objects"] = time.time() - create_objects_start
+
+        profiling["total_time"] = time.time() - merge_start_time
+
+        # Log profiling information if logger is available
+        if self._logger:
+            self._logger.debug(
+                f"merge_bundle_without_storage profiling: "
+                f"total={profiling['total_time']:.3f}s, "
+                f"build_url={profiling['build_url']:.3f}s, "
+                f"get_token={profiling['get_access_token']:.3f}s, "
+                f"prepare_payload={profiling['prepare_payload']:.3f}s, "
+                f"http_post={profiling['http_post']:.3f}s, "
+                f"parse_response={profiling['parse_response']:.3f}s, "
+                f"create_objects={profiling['create_response_objects']:.3f}s"
+            )
+
+        return FhirMergeResourceResponse(
+            request_id=request_id,
+            url=resource_uri.url,
+            responses=response_entries,
+            error=None if response_status == 200 else (response_text or f"HTTP {response_status}"),
+            access_token=self._access_token,
+            status=response_status,
+            response_text=response_text,
+        )
+
     async def merge_bundle_async(
         self,
         id_: str | None,
@@ -112,7 +299,8 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                 response_text: str | None = None
                 try:
                     async with RetryableAioHttpClient(
-                        fn_get_session=lambda: self.create_http_session(),
+                        fn_get_session=self._fn_create_http_session or self.create_http_session,
+                        caller_managed_session=self._fn_create_http_session is not None,
                         refresh_token_func=self._refresh_token_function,
                         tracer_request_func=self._trace_request_function,
                         retries=self._retry_count,
@@ -124,9 +312,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,
-                        use_persistent_session=self._use_persistent_session,
-                        close_session_on_exit=self._close_session,
                     ) as client:
                         # should we check if it exists and do a POST then?
                         response: RetryableAioHttpResponse = await client.post(
@@ -136,7 +321,7 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                         )
                         response_status = response.status
                         request_id = response.response_headers.get("X-Request-ID", None)
-                        self._internal_logger.info(f"X-Request-ID={request_id}")
+                        self._internal_logger.debug(f"X-Request-ID={request_id}")
                         if response and response.status == 200:
                             response_text = await response.get_text_async()
                             if response_text:
@@ -331,7 +516,8 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                     response_text: str | None = None
                     try:
                         async with RetryableAioHttpClient(
-                            fn_get_session=lambda: self.create_http_session(),
+                            fn_get_session=self._fn_create_http_session or self.create_http_session,
+                            caller_managed_session=self._fn_create_http_session is not None,
                             refresh_token_func=self._refresh_token_function,
                             tracer_request_func=self._trace_request_function,
                             retries=self._retry_count,
@@ -343,9 +529,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,
-                            close_session_on_exit=self._close_session,
-                            persistent_session=self._persistent_session,
-                            use_persistent_session=self._use_persistent_session,
                         ) as client:
                             # should we check if it exists and do a POST then?
                             response: RetryableAioHttpResponse = await client.post(
@@ -355,7 +538,7 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                             )
                             response_status = response.status
                             request_id = response.response_headers.get("X-Request-ID", None)
-                            self._internal_logger.info(f"X-Request-ID={request_id}")
+                            self._internal_logger.debug(f"X-Request-ID={request_id}")
                             if response and response.status == 200:
                                 response_text = await response.get_text_async()
                                 if response_text:
@@ -494,11 +677,12 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                     access_token: str | None = access_token_result.access_token
 
                     await AsyncFhirValidator.validate_fhir_resource(
-                        fn_get_session=lambda: self.create_http_session(),
+                        fn_get_session=self._fn_create_http_session or self.create_http_session,
                         json_data=resource.json(),
                         resource_name=cast(str | None, resource.get("resourceType")) or self._resource or "",
                         validation_server_url=self._validation_server_url,
                         access_token=access_token,
+                        caller_managed_session=self._fn_create_http_session is not None,
                     )
                     resource_json_list_clean.append(resource)
             except FhirValidationException as e:
@@ -519,11 +703,12 @@ class FhirMergeResourcesMixin(FhirClientProtocol):
                 try:
                     with resource.transaction():
                         await AsyncFhirValidator.validate_fhir_resource(
-                            fn_get_session=lambda: self.create_http_session(),
+                            fn_get_session=self._fn_create_http_session or self.create_http_session,
                             json_data=resource.json(),
                             resource_name=resource.get("resourceType") or self._resource or "",
                             validation_server_url=self._validation_server_url,
                             access_token=access_token1,
+                            caller_managed_session=self._fn_create_http_session is not None,
                         )
                         resource_json_list_clean.append(resource)
                 except FhirValidationException as e:

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,96 +39,103 @@ 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,
-                use_persistent_session=self._use_persistent_session,
-                close_session_on_exit=self._close_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.info(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=self._fn_create_http_session or self.create_http_session,
+                        caller_managed_session=self._fn_create_http_session is not None,
+                        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,63 +75,71 @@ 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,
-            use_persistent_session=self._use_persistent_session,
-            close_session_on_exit=self._close_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.info(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=self._fn_create_http_session or self.create_http_session,
+                        json_data=json_data,
+                        resource_name=self._resource,
+                        validation_server_url=self._validation_server_url,
+                        access_token=access_token,
+                        caller_managed_session=self._fn_create_http_session is not None,
+                    )
+
+                # actually make the request
+                async with RetryableAioHttpClient(
+                    fn_get_session=self._fn_create_http_session or self.create_http_session,
+                    caller_managed_session=self._fn_create_http_session is not None,
+                    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:
         """