Log no websocket connection as error, not debug

src/_ert_job_runner/client.py

@@ -29,7 +29,7 @@
     def __enter__(self) -> Self:
         return self
 
     def __exit__(self, exc_type: Any, exc_value: Any, exc_traceback: Any) -> None:
         if self.websocket is not None:
             self.loop.run_until_complete(self.websocket.close())
         self.loop.close()
@@ -109,7 +109,8 @@
                 if retry == self._max_retries:
                     _error_msg = (
                         f"Not able to establish the "
                         f"websocket connection {self.url}! Max retries reached!"
+                        " Check for firewall issues."
                         f" Exception from {type(exception)}: {str(exception)}"
                     )
                     raise ClientConnectionError(_error_msg) from exception
@@ -128,7 +129,7 @@
         self.loop.run_until_complete(self._send(msg))
 
     def send_event(
         self, ev_type: str, ev_source: str, ev_data: Optional[Dict[str, Any]] = None
     ) -> None:
         if ev_data is None:
             ev_data = {}

src/_ert_job_runner/reporting/event.py

@@ -43,13 +43,13 @@
     "report" to the given connection information.
 
     An Init event must provided as the first message, which starts reporting,
     and a Finish event will signal the reporter that the last event has been reported.
 
     If event fails to be sent (eg. due to connection error) it does not proceed to the
     next event but instead tries to re-send the same event.
 
     Whenever the Finish event (when all the jobs have exited) is provided
     the reporter will try to send all remaining events for a maximum of 60 seconds
     before stopping the reporter. Any remaining events will not be sent.
     """
 
@@ -65,18 +65,18 @@
 
         self._statemachine = StateMachine()
         self._statemachine.add_handler((Init,), self._init_handler)
         self._statemachine.add_handler((Start, Running, Exited), self._job_handler)
         self._statemachine.add_handler((Finish,), self._finished_handler)
 
         self._ens_id = None
         self._real_id = None
         self._step_id = None
         self._event_queue = queue.Queue()
         self._event_publisher_thread = threading.Thread(target=self._event_publisher)
         self._sentinel = object()  # notifying the queue's ended
         self._timeout_timestamp = None
         self._timestamp_lock = threading.Lock()
         # seconds to timeout the reporter the thread after Finish() was received
         self._reporter_timeout = 60
 
     def _event_publisher(self):
@@ -106,7 +106,7 @@
                     event = None
                 except ClientConnectionError as exception:
                     # Possible intermittent failure, we retry sending the event
-                    logger.debug(str(exception))
+                    logger.error(str(exception))
                     pass
                 except ClientConnectionClosedOK as exception:
                     # The receiving end has closed the connection, we stop
@@ -126,7 +126,7 @@
         self._event_queue.put(event)
 
     def _step_path(self):
         return f"/ert/ensemble/{self._ens_id}/real/{self._real_id}/step/{self._step_id}"
 
     def _init_handler(self, msg):
         self._ens_id = msg.ens_id