chore: add logs to ensure task A actually completes

Author: karenc-bq

aws_advanced_python_wrapper/writer_failover_handler.py

@@ -124,15 +124,19 @@ def get_result_from_future(self, current_topology: Tuple[HostInfo, ...]) -> Writ
                     futures = [executor.submit(self.reconnect_to_writer, writer_host),
                                executor.submit(self.wait_for_new_writer, current_topology, writer_host)]
                     for future in as_completed(futures, timeout=self._max_failover_timeout_sec):
+                        logger.info("future completed")
                         result = future.result()
                         if result.is_connected:
                             self.log_task_success(result)
                             return result
                         if result.exception is not None:
                             return result
                 except TimeoutError:
+                    logger.info("futures timed out")
+                    logger.info("setting timeout_event 1")
                     self._timeout_event.set()
                 finally:
+                    logger.info("setting timeout_event 2")
                     self._timeout_event.set()
             finally:
                 executor.shutdown(wait=False)
@@ -181,12 +185,15 @@ def reconnect_to_writer(self, initial_writer_host: HostInfo):
                     if not self._plugin_service.is_network_exception(ex):
                         logger.debug("WriterFailoverHandler.TaskAEncounteredException", ex)
                         return WriterFailoverResult(False, False, None, None, "TaskA", ex)
+                    else:
+                        logger.info("[WriterFailoverHandler] [TaskA] encountered a network exception: " + str(ex))
 
                 if latest_topology is None or len(latest_topology) == 0:
+                    logger.debug("sleeping because latest_topology is " + ("none" if latest_topology is None else str(len(latest_topology))))
                     sleep(self._reconnect_writer_interval_sec)
-                else:
-                    success = self.is_current_host_writer(latest_topology, initial_writer_host)
 
+            success = self.is_current_host_writer(latest_topology, initial_writer_host)
+            logger.debug("[TaskA] success: " + str(success))
             self._plugin_service.set_availability(initial_writer_host.as_aliases(), HostAvailability.AVAILABLE)
             return WriterFailoverResult(success, False, latest_topology, conn if success else None, "TaskA", None)
 
@@ -197,10 +204,14 @@ def reconnect_to_writer(self, initial_writer_host: HostInfo):
         finally:
             try:
                 if conn is not None and not success:
+                    logger.info("Task A ending but didn't succeed, closing connection")
                     conn.close()
-            except Exception:
+            except Exception as e:
+                logger.error("Encountered error while closing connection: " + str(e))
                 pass
             logger.debug("WriterFailoverHandler.TaskAFinished")
+            logger.info("returning from reconnect_to_writer")
+
 
     def is_current_host_writer(self, latest_topology: Tuple[HostInfo, ...], initial_writer_host: HostInfo) -> bool:
         latest_writer: Optional[HostInfo] = self.get_writer(latest_topology)
@@ -239,6 +250,7 @@ def wait_for_new_writer(self, current_topology: Tuple[HostInfo, ...], current_ho
         finally:
             self.cleanup()
             logger.debug("WriterFailoverHandler.TaskBFinished")
+            logger.info("returning from wait_for_new_writer")
 
     def connect_to_reader(self) -> None:
         while not self._timeout_event.is_set():