helix.fhir.client.sdk 4.1.67__py3-none-any.whl → 4.2.18__py3-none-any.whl

helix_fhir_client_sdk/queue/request_queue_mixin.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import asyncio
 import json
 import logging
 import time
@@ -70,18 +69,22 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
         :param additional_parameters: additional parameters to add to the request
         :return: response
         """
-        # TIME: Track overall method execution
-        method_start_time = time.time()
-        
         assert self._url, "No FHIR server url was set"
         assert resource_type or self._resource, "No Resource was set"
         request_id: str | None = None
         total_results = 0  # total number of resources returned so far
 
+        limit_count: int | None = self._limit
+
+        # if _count parameter is present in additional_parameters then set limit_count to it
+        if additional_parameters:
+            for param in additional_parameters:
+                if self._limit is None:
+                    if param.startswith("_count="):
+                        limit_count = int(param.split("=")[1])
+
         # create url and query to request from FHIR server
         resources_json: str = ""
-        
-        # TIME: Track URL building
         full_url = await self.build_url(
             ids=ids,
             id_above=id_above,
@@ -104,10 +107,6 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
         last_status_code: int | None = None
         last_response_text: str | None = None
         next_url: str | None = full_url
-        page_count = 0
-        total_http_time = 0.0
-        total_response_processing_time = 0.0
-        
         try:
             await FhirResponseProcessor.log_request(
                 full_url=full_url,
@@ -120,7 +119,8 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
             )
 
             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,
@@ -133,9 +133,6 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                 access_token_expiry_date=self._access_token_expiry_date,
             ) as client:
                 while next_url:
-                    page_count += 1
-                    page_start_time = time.time()
-                    
                     # set access token in request if present
                     access_token_result: GetAccessTokenResult = await self.get_access_token_async()
                     access_token: str | None = access_token_result.access_token
@@ -146,18 +143,16 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                         next_url = UrlChecker.convert_relative_url_to_absolute_url(
                             base_url=self._url, relative_url=next_url
                         )
-                    
-                    # TIME: Track HTTP request
-                    http_request_start = time.time()
+                    else:
+                        # INC-285: Preserve port from base URL when next_url is absolute
+                        # but missing the port (FHIR server bug workaround)
+                        next_url = UrlChecker.preserve_port_from_base_url(base_url=self._url, next_url=next_url)
                     response: RetryableAioHttpResponse = await self._send_fhir_request_async(
                         client=client,
                         full_url=next_url,
                         headers=headers,
                         payload=payload,
                     )
-                    http_request_duration = time.time() - http_request_start
-                    total_http_time += http_request_duration
-                    
                     assert isinstance(response, RetryableAioHttpResponse)
 
                     if response.access_token:
@@ -180,10 +175,8 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                     )
 
                     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}")
 
-                    # TIME: Track response processing
-                    response_processing_start = time.time()
                     async for r in FhirResponseProcessor.handle_response(
                         internal_logger=self._internal_logger,
                         access_token=access_token,
@@ -212,46 +205,17 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                         total_results += resource_count
 
                         # Stop if limit reached
-                        if self._limit and total_results >= self._limit:
+                        if limit_count and total_results >= limit_count:
                             self._internal_logger.info(
-                                f"Reached limit={self._limit} after collecting {total_results} "
+                                f"Reached limit={limit_count} after collecting {total_results} "
                                 f"resources, stopping pagination"
                             )
                             return
 
                         # Update next_url for the next loop iteration
                         next_url = r.next_url
-                    
-                    response_processing_duration = time.time() - response_processing_start
-                    total_response_processing_time += response_processing_duration
-                    
-                    page_duration = time.time() - page_start_time
-                    self._internal_logger.info(
-                        f"[PERF] _get_with_session_async page {page_count} completed in {page_duration:.3f}s | "
-                        f"http_request={http_request_duration:.3f}s | "
-                        f"response_processing={response_processing_duration:.3f}s | "
-                        f"resources_in_page={resource_count} | "
-                        f"total_resources={total_results}"
-                    )
-
-            # Log overall method performance
-            method_total_duration = time.time() - method_start_time
-            self._internal_logger.info(
-                f"[PERF] _get_with_session_async TOTAL completed in {method_total_duration:.3f}s | "
-                f"resource_type={resource_type or self._resource} | "
-                f"total_http_time={total_http_time:.3f}s ({total_http_time/method_total_duration*100:.1f}%) | "
-                f"total_response_processing={total_response_processing_time:.3f}s ({total_response_processing_time/method_total_duration*100:.1f}%) | "
-                f"pages={page_count} | "
-                f"total_resources={total_results}"
-            )
 
         except Exception as ex:
-            method_duration = time.time() - method_start_time
-            self._internal_logger.error(
-                f"[PERF] _get_with_session_async FAILED after {method_duration:.3f}s | "
-                f"resource_type={resource_type or self._resource} | "
-                f"error={str(ex)}"
-            )
             raise FhirSenderException(
                 request_id=request_id,
                 exception=ex,
@@ -324,7 +288,8 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
             )
 
             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,
@@ -347,6 +312,10 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                         next_url = UrlChecker.convert_relative_url_to_absolute_url(
                             base_url=self._url, relative_url=next_url
                         )
+                    else:
+                        # INC-285: Preserve port from base URL when next_url is absolute
+                        # but missing the port (FHIR server bug workaround)
+                        next_url = UrlChecker.preserve_port_from_base_url(base_url=self._url, next_url=next_url)
                     response: RetryableAioHttpResponse = await self._send_fhir_request_async(
                         client=client,
                         full_url=next_url,
@@ -375,7 +344,7 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
                     )
 
                     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.status == 200:
                         response_next_url = None
@@ -460,32 +429,14 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
         :param headers: headers to send
         :param payload: payload to send
         """
-        def log_running_tasks(prefix: str = "") -> int:
-            """Log currently running asyncio tasks"""
-            all_tasks = asyncio.all_tasks()
-            running_tasks = [t for t in all_tasks if not t.done()]
-            task_count = len(running_tasks)
-            waiting_tasks = [t for t in running_tasks if t._coro.cr_await is not None]
-            
-            self._internal_logger.info(
-                f"{prefix} | ASYNC TASKS: Total Running={task_count} | "
-                f"all_tasks={len(all_tasks)} | "
-            )
-            print(f"{prefix} | ASYNC TASKS: Total Running={task_count} | all_tasks={len(all_tasks)} | waiting_tasks={len(waiting_tasks)}")
-            
-            return task_count
-        
         if self._max_concurrent_requests_semaphore:
-            log_running_tasks(prefix="[BEFORE SEMAPHORE ACQUIRE]")
             async with self._max_concurrent_requests_semaphore:
-                log_running_tasks(prefix="[AFTER SEMAPHORE ACQUIRE]")
-                result = await self._send_fhir_request_internal_async(
+                return await self._send_fhir_request_internal_async(
                     client=client,
                     full_url=full_url,
                     headers=headers,
                     payload=payload,
                 )
-                return result
         else:
             return await self._send_fhir_request_internal_async(
                 client=client, full_url=full_url, headers=headers, payload=payload
@@ -514,52 +465,28 @@ class RequestQueueMixin(ABC, FhirClientProtocol):
         if payload:
             assert isinstance(payload, dict)
 
-        # Start timing the request
-        request_start_time = time.time()
-
-        try:
-            if self._action == "$graph":
+        if self._action == "$graph":
+            if self._logger:
+                self._logger.info(
+                    f"sending a post: {full_url} with client_id={self._client_id} and scopes={self._auth_scopes}"
+                )
+            logging.info(f"sending a post: {full_url} with client_id={self._client_id} and scopes={self._auth_scopes}")
+            if payload:
+                return await client.post(url=full_url, headers=headers, json=payload)
+            else:
+                raise Exception(
+                    "$graph needs a payload to define the returning response (use action_payload parameter)"
+                )
+        else:
+            if self._log_level == "DEBUG":
                 if self._logger:
                     self._logger.info(
-                        f"sending a post: {full_url} with client_id={self._client_id} and scopes={self._auth_scopes}"
+                        f"sending a get: {full_url} with client_id={self._client_id} "
+                        + f"and scopes={self._auth_scopes} instance_id={self._uuid}"
                     )
-                logging.info(f"sending a post: {full_url} with client_id={self._client_id} and scopes={self._auth_scopes}")
-                if payload:
-                    response = await client.post(url=full_url, headers=headers, json=payload)
                 else:
-                    raise Exception(
-                        "$graph needs a payload to define the returning response (use action_payload parameter)"
+                    self._internal_logger.info(
+                        f"sending a get: {full_url} with client_id={self._client_id} "
+                        + f"and scopes={self._auth_scopes} instance_id={self._uuid}"
                     )
-            else:
-                if self._log_level == "DEBUG":
-                    if self._logger:
-                        self._logger.info(
-                            f"sending a get: {full_url} with client_id={self._client_id} "
-                            + f"and scopes={self._auth_scopes} instance_id={self._uuid}"
-                        )
-                    else:
-                        self._internal_logger.info(
-                            f"sending a get: {full_url} with client_id={self._client_id} "
-                            + f"and scopes={self._auth_scopes} instance_id={self._uuid}"
-                        )
-                response = await client.get(url=full_url, headers=headers, data=payload)
-            
-            # Log request duration
-            request_duration = time.time() - request_start_time
-            self._internal_logger.info(
-                f"Request completed in {request_duration:.3f}s | "
-                f"URL: {full_url} | "
-                f"Status: {response.status}"
-            )
-            
-            return response
-            
-        except Exception as e:
-            # Log request duration even on error
-            request_duration = time.time() - request_start_time
-            self._internal_logger.error(
-                f"Request failed after {request_duration:.3f}s | "
-                f"URL: {full_url} | "
-                f"Error: {str(e)}"
-            )
-            raise
+            return await client.get(url=full_url, headers=headers, data=payload)

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
@@ -126,6 +126,12 @@ class FhirClientProtocol(Protocol):
     _create_operation_outcome_for_error: bool | None
     """ whether to create OperationOutcome resource for errors """
 
+    _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(
@@ -208,3 +214,5 @@ class FhirClientProtocol(Protocol):
     ) -> AsyncGenerator[FhirMergeResourceResponse, None]:
         # this is just here to tell Python this returns a generator
         yield None  # type: ignore[misc]
+
+    def use_http_session(self, fn_create_http_session: Callable[[], ClientSession] | None) -> "FhirClientProtocol": ...

helix_fhir_client_sdk/responses/fhir_response_processor.py

@@ -11,10 +11,13 @@ from aiohttp.streams import AsyncStreamIterator
 from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
     CompressedDictStorageMode,
 )
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
 
 from helix_fhir_client_sdk.function_types import (
     HandleStreamingChunkFunction,
 )
+from helix_fhir_client_sdk.open_telemetry.span_names import FhirClientSdkOpenTelemetrySpanNames
 from helix_fhir_client_sdk.responses.bundle_expander import (
     BundleExpander,
     BundleExpanderResult,
@@ -37,6 +40,8 @@ from helix_fhir_client_sdk.utilities.retryable_aiohttp_response import (
     RetryableAioHttpResponse,
 )
 
+TRACER = trace.get_tracer(__name__)
+
 
 class FhirResponseProcessor:
     """
@@ -93,60 +98,74 @@ class FhirResponseProcessor:
 
         :return: An async generator of FhirGetResponse objects.
         """
-        # if request is ok (200) then return the data
-        if response.ok:
-            async for r in FhirResponseProcessor._handle_response_200(
-                full_url=full_url,
-                request_id=request_id,
-                response=response,
-                response_headers=response_headers,
-                fn_handle_streaming_chunk=fn_handle_streaming_chunk,
-                access_token=access_token,
-                resources_json=resources_json,
-                resource=resource,
-                id_=id_,
-                logger=logger,
-                use_data_streaming=use_data_streaming,
-                chunk_size=chunk_size,
-                extra_context_to_return=extra_context_to_return,
-                expand_fhir_bundle=expand_fhir_bundle,
-                url=url,
-                separate_bundle_resources=separate_bundle_resources,
-                storage_mode=storage_mode,
-                create_operation_outcome_for_error=create_operation_outcome_for_error,
-            ):
-                yield r
-        elif response.status == 404:  # not found
-            async for r in FhirResponseProcessor._handle_response_404(
-                full_url=full_url,
-                request_id=request_id,
-                response=response,
-                response_headers=response_headers,
-                extra_context_to_return=extra_context_to_return,
-                resource=resource,
-                logger=logger,
-                id_=id_,
-                access_token=access_token,
-                storage_mode=storage_mode,
-                create_operation_outcome_for_error=create_operation_outcome_for_error,
-            ):
-                yield r
-        else:  # unknown response
-            async for r in FhirResponseProcessor._handle_response_unknown(
-                full_url=full_url,
-                request_id=request_id,
-                response=response,
-                response_headers=response_headers,
-                resource=resource,
-                logger=logger,
-                access_token=access_token,
-                extra_context_to_return=extra_context_to_return,
-                id_=id_,
-                internal_logger=internal_logger,
-                storage_mode=storage_mode,
-                create_operation_outcome_for_error=create_operation_outcome_for_error,
-            ):
-                yield r
+        span = TRACER.start_span(FhirClientSdkOpenTelemetrySpanNames.HANDLE_RESPONSE)
+        try:
+            # if request is ok (200) then return the data
+            if response.ok:
+                async for r in FhirResponseProcessor._handle_response_200(
+                    full_url=full_url,
+                    request_id=request_id,
+                    response=response,
+                    response_headers=response_headers,
+                    fn_handle_streaming_chunk=fn_handle_streaming_chunk,
+                    access_token=access_token,
+                    resources_json=resources_json,
+                    resource=resource,
+                    id_=id_,
+                    logger=logger,
+                    use_data_streaming=use_data_streaming,
+                    chunk_size=chunk_size,
+                    extra_context_to_return=extra_context_to_return,
+                    expand_fhir_bundle=expand_fhir_bundle,
+                    url=url,
+                    separate_bundle_resources=separate_bundle_resources,
+                    storage_mode=storage_mode,
+                    create_operation_outcome_for_error=create_operation_outcome_for_error,
+                ):
+                    yield r
+            elif response.status == 404:  # not found
+                async for r in FhirResponseProcessor._handle_response_404(
+                    full_url=full_url,
+                    request_id=request_id,
+                    response=response,
+                    response_headers=response_headers,
+                    extra_context_to_return=extra_context_to_return,
+                    resource=resource,
+                    logger=logger,
+                    id_=id_,
+                    access_token=access_token,
+                    storage_mode=storage_mode,
+                    create_operation_outcome_for_error=create_operation_outcome_for_error,
+                ):
+                    yield r
+            else:  # unknown response
+                async for r in FhirResponseProcessor._handle_response_unknown(
+                    full_url=full_url,
+                    request_id=request_id,
+                    response=response,
+                    response_headers=response_headers,
+                    resource=resource,
+                    logger=logger,
+                    access_token=access_token,
+                    extra_context_to_return=extra_context_to_return,
+                    id_=id_,
+                    internal_logger=internal_logger,
+                    storage_mode=storage_mode,
+                    create_operation_outcome_for_error=create_operation_outcome_for_error,
+                ):
+                    yield r
+            # Mark span as successful
+            span.set_status(Status(StatusCode.OK))
+
+        except Exception as e:
+            # Record exception in span
+            span.record_exception(e)
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            raise
+
+        finally:
+            # Ensure span is ended after generator is exhausted or error occurs
+            span.end()
 
     @staticmethod
     async def _handle_response_unknown(

helix_fhir_client_sdk/responses/get/fhir_get_bundle_response.py

@@ -278,7 +278,6 @@ class FhirGetBundleResponse(FhirGetResponse):
             resource_type_plus_id_seen: set[str] = set()
             entry_request_url_seen: set[str] = set()
             i = 0
-            print(f"Initial bundle entries count: {len(self._bundle_entries)}")
             while i < len(self._bundle_entries):
                 if self._bundle_entries[i] is not None:
                     # Create a tuple of values for specified keys
@@ -302,7 +301,6 @@ class FhirGetBundleResponse(FhirGetResponse):
                         else:
                             resource_type_plus_id_seen.add(resource_type_plus_id)
                 i += 1
-            print(f"Final bundle entries count: {len(self._bundle_entries)}")
             return self
         except Exception as e:
             raise Exception(f"Could not get parse json from: {bundle}") from e

helix_fhir_client_sdk/responses/merge/fhir_merge_resource_response_entry.py

@@ -75,6 +75,36 @@ class FhirMergeResourceResponseEntry(BaseFhirMergeResourceResponseEntry):
             status=data.get("status"),
         )
 
+    @classmethod
+    def from_dict_uncompressed(cls, data: dict[str, Any]) -> "FhirMergeResourceResponseEntry":
+        """
+        Creates a FhirMergeResourceResponseEntry from a dictionary without storage_mode overhead.
+        Uses FhirResource.construct for faster object creation.
+
+        :param data: Dictionary containing the response entry data
+        :return: FhirMergeResourceResponseEntry instance
+        """
+        resource_payload = data.get("resource")
+        resource_obj: FhirResource | None = (
+            FhirResource.construct(**resource_payload) if isinstance(resource_payload, dict) else None
+        )
+        return FhirMergeResourceResponseEntry(
+            created=data.get("created"),
+            updated=data.get("updated"),
+            deleted=data.get("deleted"),
+            id_=data.get("id"),
+            uuid=data.get("uuid"),
+            resource_type=data.get("resourceType"),
+            source_assigning_authority=data.get("source_assigning_authority"),
+            resource_version=data.get("resource_version"),
+            message=data.get("message"),
+            issue=data.get("issue"),
+            error=data.get("error"),
+            token=data.get("token"),
+            resource=resource_obj,
+            status=data.get("status"),
+        )
+
     @classmethod
     @override
     def from_json(

helix_fhir_client_sdk/utilities/async_parallel_processor/v1/async_parallel_processor.py

@@ -7,7 +7,6 @@ from typing import (
     Protocol,
     runtime_checkable,
 )
-import logging
 
 
 @dataclass(slots=True)
@@ -113,25 +112,7 @@ class AsyncParallelProcessor:
         async def process_with_semaphore_async(
             *, name: str, row1: TInput, task_index: int, total_task_count: int
         ) -> TOutput:
-            def log_tasks(prefix: str = "") -> int:
-                """Log currently running asyncio tasks"""
-                all_tasks = asyncio.all_tasks()
-                running_tasks = [t for t in all_tasks if not t.done()]
-                task_count = len(running_tasks)
-                waiting_tasks = [t for t in running_tasks if t._coro.cr_await is not None]
-                
-                # Log using standard logging module
-                logger = logging.getLogger(__name__)
-                logger.info(
-                    f"{prefix} | ASYNC TASKS: Total Running={task_count} | "
-                    f"all_tasks={len(all_tasks)} | "
-                    f"waiting_tasks={len(waiting_tasks)}"
-                )
-                
-                return task_count
-            
             if self.semaphore is None:
-                log_tasks(prefix="[NO SEMAPHORE IN PROCESSOR]")
                 return await process_row_fn(
                     context=ParallelFunctionContext(
                         name=name,
@@ -144,10 +125,8 @@ class AsyncParallelProcessor:
                     additional_parameters=kwargs,
                 )
             else:
-                log_tasks(prefix="[BEFORE PROCESSOR SEMAPHORE ACQUIRE]")
                 async with self.semaphore:
-                    log_tasks(prefix="[AFTER PROCESSOR SEMAPHORE ACQUIRE]")
-                    result = await process_row_fn(
+                    return await process_row_fn(
                         context=ParallelFunctionContext(
                             name=name,
                             log_level=log_level,
@@ -158,8 +137,6 @@ class AsyncParallelProcessor:
                         parameters=parameters,
                         additional_parameters=kwargs,
                     )
-                    log_tasks(prefix="[BEFORE PROCESSOR SEMAPHORE RELEASE]")
-                    return result
 
         total_task_count: int = len(rows)