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

helix_fhir_client_sdk/graph/simulated_graph_processor_mixin.py

@@ -1,4 +1,3 @@
-import asyncio
 import json
 from abc import ABC
 from collections.abc import AsyncGenerator
@@ -124,23 +123,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         Yields:
             FhirGetResponse objects representing retrieved resources
         """
-        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
-        
-        log_running_tasks(prefix="[PROCESS_SIMULATE_GRAPH START]")
-        
         # Validate graph definition input
         assert graph_json, "Graph JSON must be provided"
         graph_definition: GraphDefinition = GraphDefinition.from_dict(graph_json)
@@ -153,7 +135,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         # Ensure bundle resources are not separated by default
         self.separate_bundle_resources(False)
 
-        start_time = datetime.now()
         # Log initial query parameters for debugging
         if logger:
             logger.info(
@@ -172,8 +153,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         if not isinstance(id_, list):
             id_ = id_.split(",")
 
-        log_running_tasks(prefix="[BEFORE GRAPH PROCESSING]")
-
         # Track resources that don't support ID-based search
         id_search_unsupported_resources: list[str] = []
         cache: RequestCache = input_cache if input_cache is not None else RequestCache()
@@ -193,8 +172,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 compare_hash=compare_hash,
             )
 
-            log_running_tasks(prefix="[AFTER PARENT GET]")
-
             # If no parent resources found, yield empty response and exit
             parent_response_resource_count = parent_response.get_resource_count()
             if parent_response_resource_count == 0:
@@ -230,8 +207,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
             while len(parent_link_map):
                 new_parent_link_map: list[tuple[list[GraphDefinitionLink], FhirBundleEntryList]] = []
 
-                log_running_tasks(prefix="[BEFORE PROCESSING LINKS BATCH]")
-
                 # Parallel processing of links for each parent bundle
                 for link, parent_bundle_entries in parent_link_map:
                     link_responses: list[FhirGetResponse]
@@ -257,18 +232,16 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                     ):
                         child_responses.extend(link_responses)
 
-                log_running_tasks(prefix="[AFTER PROCESSING LINKS BATCH]")
-
                 # Update parent link map for next iteration
                 parent_link_map = new_parent_link_map
 
             # Combine and process responses
             parent_response = cast(FhirGetBundleResponse, parent_response.extend(child_responses))
-            parent_response = parent_response.remove_duplicates()
 
             # Optional resource sorting
             if sort_resources:
                 parent_response = parent_response.sort_resources()
+
             # Prepare final response based on bundling preferences
             full_response: FhirGetResponse
             if separate_bundle_resources:
@@ -288,8 +261,8 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                     f"start={graph_definition.start}, "
                     f"hits: {cache.cache_hits}, "
                     f"misses: {cache.cache_misses}"
-                    f"total_time: {datetime.now() - start_time} in process simulate graph async"
                 )
+
             # Yield the final response
             yield full_response
 
@@ -376,10 +349,11 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         # Log detailed processing information
         if parameters.logger:
             parameters.logger.debug(
-                "Finished Processing link parallel function"
+                "Finished Processing link"
                 + f" | task_index: {context.task_index}/{context.total_task_count}"
                 + (f" | path: {row.path}" if row.path else f" | target: {target_resource_type}")
                 + f" | parallel_processor: {context.name}"
+                + f" | end_time: {end_time}"
                 + f" | duration: {end_time - start_time}"
                 + f" | resource_count: {len(result)}"
             )
@@ -433,30 +407,12 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         Yields:
             FhirGetResponse objects for each processed target
         """
-        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)} | waiting_tasks={len(waiting_tasks)}"
-            )
-            print(f"{prefix} | ASYNC TASKS: Total Running={task_count} | all_tasks={len(all_tasks)} | waiting_tasks={len(waiting_tasks)}")
-            
-            return task_count
-        
         # Validate input link
         assert link, "GraphDefinitionLink must be provided"
 
         if self._logger:
             self._logger.debug(f"Processing link: {link.path} ")
 
-        log_running_tasks(prefix="[PROCESS_LINK START]")
-        start_time: datetime = datetime.now()
-
         # Extract targets from the link
         targets: list[GraphDefinitionTarget] = link.target
         target_responses: list[FhirGetResponse]
@@ -488,13 +444,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
             for target_response in target_responses:
                 yield target_response
 
-        end_time: datetime = datetime.now()
-        if logger:
-            logger.debug(
-                f"Finished Processing link async in {end_time - start_time} for path: {link.path}"
-            )
-        log_running_tasks(prefix="[PROCESS_LINK END]")
-
     # noinspection PyUnusedLocal
     async def process_target_async_parallel_function(
         self,
@@ -535,7 +484,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
 
         # Process the target asynchronously and collect responses
         target_result: FhirGetResponse
-        start_time: datetime = datetime.now()
         async for target_result in self._process_target_async(
             # Target to process
             target=row,
@@ -565,9 +513,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
             # Collect each target result
             result.append(target_result)
 
-        end_time: datetime = datetime.now()
-        if parameters.logger:
-            parameters.logger.debug(f"Completed process_target_async_parallel_function for target for {row} in {end_time - start_time}")
         # Return the list of retrieved responses
         return result
 
@@ -615,24 +560,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         Returns:
             FhirGetResponse containing retrieved child resources
         """
-        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)} | waiting_tasks={len(waiting_tasks)}"
-            )
-            print(f"{prefix} | ASYNC TASKS: Total Running={task_count} | all_tasks={len(all_tasks)} | waiting_tasks={len(waiting_tasks)}")
-            
-            return task_count
-        
-        log_running_tasks(prefix="[PROCESS_CHILD_GROUP START]")
-
-        start_time: datetime = datetime.now()
         # Retrieve resources using async method with parameters
         (
             child_response,  # Retrieved child resources
@@ -655,9 +582,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
             add_cached_bundles_to_result=add_cached_bundles_to_result,
         )
 
-        log_running_tasks(prefix="[PROCESS_CHILD_GROUP END]")
-
-        end_time: datetime = datetime.now()
         # Log detailed retrieval information if logger is available
         if logger:
             logger.info(
@@ -668,7 +592,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 + f", count:{len(child_response.get_resource_type_and_ids())}"
                 + f", cached:{cache_hits}"
                 + f", {','.join(child_response.get_resource_type_and_ids())}"
-                + f", duration:{end_time - start_time}"
             )
 
         # Return the retrieved child resources
@@ -705,22 +628,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         :param ifModifiedSince: ifModifiedSince to use
         :return: list of FhirGetResponse objects
         """
-        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)} | waiting_tasks={len(waiting_tasks)}"
-            )
-            print(f"{prefix} | ASYNC TASKS: Total Running={task_count} | all_tasks={len(all_tasks)} | waiting_tasks={len(waiting_tasks)}")
-            
-            return task_count
-        
-        start_time: datetime = datetime.now() 
         children: list[FhirBundleEntry] = []
         child_response: FhirGetResponse
         target_type: str | None = target.type_
@@ -736,8 +643,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 f"params: {target.params}"
             )
 
-        log_running_tasks(prefix="[PROCESS_TARGET START]")
-
         # forward link and iterate over list
         if path and "[x]" in path and parent_bundle_entries:
             child_ids = []
@@ -773,7 +678,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                                 ):
                                     child_ids.append(reference_parts[-2])
                         if request_size and len(child_ids) == request_size:
-                            log_running_tasks(prefix="[BEFORE PROCESS_CHILD_GROUP]")
                             child_response = await self._process_child_group(
                                 resource_type=target_type,
                                 id_=child_ids,
@@ -786,13 +690,11 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                                 id_search_unsupported_resources=id_search_unsupported_resources,
                                 add_cached_bundles_to_result=add_cached_bundles_to_result,
                             )
-                            log_running_tasks(prefix="[AFTER PROCESS_CHILD_GROUP]")
                             yield child_response
                             children.extend(child_response.get_bundle_entries())
                             child_ids = []
                             parent_ids = []
             if child_ids:
-                log_running_tasks(prefix="[BEFORE FINAL_PROCESS_CHILD_GROUP]")
                 child_response = await self._process_child_group(
                     resource_type=target_type,
                     id_=child_ids,
@@ -805,7 +707,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                     id_search_unsupported_resources=id_search_unsupported_resources,
                     add_cached_bundles_to_result=add_cached_bundles_to_result,
                 )
-                log_running_tasks(prefix="[AFTER FINAL_PROCESS_CHILD_GROUP]")
                 yield child_response
                 children.extend(child_response.get_bundle_entries())
         elif path and parent_bundle_entries and target_type:
@@ -832,7 +733,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                                 ):
                                     child_ids.append(reference_parts[-2])
                             if request_size and len(child_ids) == request_size:
-                                log_running_tasks(prefix="[BEFORE PROCESS_CHILD_GROUP]")
                                 child_response = await self._process_child_group(
                                     resource_type=target_type,
                                     id_=child_ids,
@@ -845,13 +745,11 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                                     id_search_unsupported_resources=id_search_unsupported_resources,
                                     add_cached_bundles_to_result=add_cached_bundles_to_result,
                                 )
-                                log_running_tasks(prefix="[AFTER PROCESS_CHILD_GROUP]")
                                 yield child_response
                                 children.extend(child_response.get_bundle_entries())
                                 child_ids = []
                                 parent_ids = []
             if child_ids:
-                log_running_tasks(prefix="[BEFORE FINAL_PROCESS_CHILD_GROUP]")
                 child_response = await self._process_child_group(
                     resource_type=target_type,
                     id_=child_ids,
@@ -864,7 +762,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                     id_search_unsupported_resources=id_search_unsupported_resources,
                     add_cached_bundles_to_result=add_cached_bundles_to_result,
                 )
-                log_running_tasks(prefix="[AFTER FINAL_PROCESS_CHILD_GROUP]")
                 yield child_response
                 children.extend(child_response.get_bundle_entries())
 
@@ -901,7 +798,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                             parent_ids.append(parent_id)
                     if request_size and len(parent_ids) == request_size:
                         request_parameters = [f"{property_name}={','.join(parent_ids)}"] + additional_parameters
-                        log_running_tasks(prefix="[BEFORE PROCESS_CHILD_GROUP]")
                         child_response = await self._process_child_group(
                             resource_type=target_type,
                             parent_ids=parent_ids,
@@ -914,13 +810,11 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                             id_search_unsupported_resources=id_search_unsupported_resources,
                             add_cached_bundles_to_result=add_cached_bundles_to_result,
                         )
-                        log_running_tasks(prefix="[AFTER PROCESS_CHILD_GROUP]")
                         yield child_response
                         children.extend(child_response.get_bundle_entries())
                         parent_ids = []
                 if parent_ids:
                     request_parameters = [f"{property_name}={','.join(parent_ids)}"] + additional_parameters
-                    log_running_tasks(prefix="[BEFORE FINAL_PROCESS_CHILD_GROUP]")
                     child_response = await self._process_child_group(
                         resource_type=target_type,
                         parent_ids=parent_ids,
@@ -933,25 +827,11 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                         id_search_unsupported_resources=id_search_unsupported_resources,
                         add_cached_bundles_to_result=add_cached_bundles_to_result,
                     )
-                    log_running_tasks(prefix="[AFTER FINAL_PROCESS_CHILD_GROUP]")
                     yield child_response
                     children.extend(child_response.get_bundle_entries())
         if target.link:
             parent_link_map.append((target.link, children))
 
-        log_running_tasks(prefix="[PROCESS_TARGET END]")
-        end_time: datetime = datetime.now()
-        if logger:  
-            logger.debug(
-                "Finished Processing target"
-                + f" | target_type: {target_type}"
-                + f" | path: {path}"
-                + f" | start_time: {start_time}"
-                + f" | end_time: {end_time}"
-                + f" | duration: {end_time - start_time}"
-                + f" | resource_count: {len(children)}"
-            )
-
     async def _get_resources_by_id_one_by_one_async(
         self,
         *,
@@ -965,7 +845,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         result: FhirGetResponse | None = None
         non_cached_id_list: list[str] = []
         # first check to see if we can find these in the cache
-        start_time = datetime.now() 
         if ids:
             for resource_id in ids:
                 cache_entry: RequestCacheEntry | None = await cache.get_async(
@@ -1026,17 +905,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                     )
                     if cache_updated and logger:
                         logger.info(f"Inserted {result2.status} for {resource_type}/{single_id} into cache (1by1)")
-        end_time = datetime.now()
-        if logger:
-            logger.info(
-                "Completed fetching resources one by one"
-                + f" | resource_type: {resource_type}"
-                + f" | ids: {ids}"
-                + f" | fetched_count: {len(non_cached_id_list)}"
-                + f" | start_time: {start_time}"
-                + f" | end_time: {end_time}"
-                + f" | duration: {end_time - start_time}"
-            )
+
         return result
 
     async def _get_resources_by_parameters_async(
@@ -1052,26 +921,7 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
         add_cached_bundles_to_result: bool = True,
         compare_hash: bool = True,
     ) -> tuple[FhirGetResponse, int]:
-        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)} | waiting_tasks={len(waiting_tasks)}"
-            )
-            print(f"{prefix} | ASYNC TASKS: Total Running={task_count} | all_tasks={len(all_tasks)} | waiting_tasks={len(waiting_tasks)}")
-            
-            return task_count
-        
         assert resource_type
-        
-        log_running_tasks(prefix="[GET_RESOURCES_BY_PARAMS START]")
-        
-        start_time = datetime.now() 
         if not scope_parser.scope_allows(resource_type=resource_type):
             if logger:
                 logger.debug(f"Skipping resource {resource_type} due to scope")
@@ -1122,9 +972,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                     non_cached_id_list.append(resource_id)
 
         all_result: FhirGetResponse | None = None
-        
-        log_running_tasks(prefix="[BEFORE HTTP FETCH]")
-        
         # either we have non-cached ids or this is a query without id but has other parameters
         if (
             (len(non_cached_id_list) > 1 and resource_type.lower() not in id_search_unsupported_resources)
@@ -1191,8 +1038,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 compare_hash=compare_hash,
             )
 
-        log_running_tasks(prefix="[AFTER HTTP FETCH]")
-
         # This list tracks the non-cached ids that were found
         found_non_cached_id_list: list[str] = []
         # Cache the fetched entries
@@ -1285,20 +1130,6 @@ class SimulatedGraphProcessorMixin(ABC, FhirClientProtocol):
                 storage_mode=self._storage_mode,
             )
         )
-        
-        log_running_tasks(prefix="[GET_RESOURCES_BY_PARAMS END]")
-        
-        end_time = datetime.now()
-        if logger:
-            logger.info(
-                "Completed fetching resources by parameters"
-                + f" | resource_type: {resource_type}"
-                + f" | ids: {id_}"
-                + f" | fetched_count: {len(found_non_cached_id_list)}"
-                + f" | start_time: {start_time}"
-                + f" | end_time: {end_time}"
-                + f" | duration: {end_time - start_time}"
-            )
         return bundle_response, cache.cache_hits
 
     # noinspection PyPep8Naming

helix_fhir_client_sdk/open_telemetry/attribute_names.py

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,12 @@
+class FhirClientSdkOpenTelemetrySpanNames:
+    """Span names for OpenTelemetry tracing in the FHIR Client SDK."""
+
+    GET: str = "fhir.client_sdk.get"
+    GET_STREAMING: str = "fhir.client_sdk.streaming.get"
+    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"