docs: public void processConnectionErrorOccurredEvent(Object handle, Exception ex, boolean logEvent) {
          // Method is not synchronized because of the contract that add/remove event
          // listeners will only be used on ManagedConnection create/destroy, when the
          // ManagedConnection is not used by any other threads. 
  
          // Some object using the physical jdbc connection has received a SQLException that
          // when translated to a ResourceException is determined to be a connection event error.
          // The SQLException is mapped to a StaleConnectionException in the
          // helper.  SCE's will (almost) always be connection errors.
  
          // Track whether a fatal Connection error was detected. 
          // Technically, the Connection Manager is required to be able to handle duplicate
          // events, but since we already have a flag for the occasion, we'll be nice and skip
          // the unnecessary event when convenient.
  
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
  
          if (inCleanup) {
              if (isTraceOn && tc.isDebugEnabled())
                  Tr.debug(this, tc, "An error occured during connection cleanup. Since the container drives " +
                                     "the cleanup op, it will directly receive the exception.");
              return;
          }
          if (connectionErrorDetected) {
              if (isTraceOn && tc.isEventEnabled())
                  Tr.event(this, tc, "CONNECTION_ERROR_OCCURRED event already fired");
  
              return;
          }
  
          if (ex instanceof SQLException && mcf.helper.isAnAuthorizationException((SQLException) ex)) {
              if (isTraceOn && tc.isDebugEnabled())
                  Tr.debug(this, tc, "CONNECTION_ERROR_OCCURRED will fire an event to only purge and destroy this connection");
  
              connectionErrorDetected = true;
  
              closeHandles();
  
              // Create a Connection Error Event with the given SQLException.
              // Reuse a single ConnectionEvent instance.
              //  - Modified to use J2C defined event.
              connEvent.recycle(WSConnectionEvent.SINGLE_CONNECTION_ERROR_OCCURRED, ex, handle);
  
              if (isTraceOn && tc.isEventEnabled())
                  Tr.event(this, tc, "Firing Single CONNECTION_ERROR_OCCURRED", handle);
  
              // loop through the listeners
              for (int i = 0; i < numListeners; i++) {
                  // send Connection Error Occurred event to the current listener
                  ivEventListeners[i].connectionErrorOccurred(connEvent); 
              }
  
              return;
          }
  
          mcf.fatalErrorCount.incrementAndGet();
  
          if (mcf.oracleRACXARetryDelay > 0l) 
              mcf.oracleRACLastStale.set(System.currentTimeMillis()); 
  
          connectionErrorDetected = true;
  
          // The connectionErrorDetected indicator is no longer required for ManagedConnection
          // cleanup since we are now required to invalidate all handles at that point
          // regardless of whether a connection error has occurred. 
  
          // Close all active handles for this ManagedConnection, since we cannot rely on the
          // ConnectionManager to request cleanup/destroy immediately.  The ConnectionManager is
          // required to wait until the transaction has ended. 
  
          closeHandles(); 
  
          // Create a Connection Error Event with the given SQLException.
          // Reuse a single ConnectionEvent instance. 
          //  - Fire the normal logging event if logEvent == true.  Otherwise, fire the non-logging connection error event.
          connEvent.recycle((logEvent ? ConnectionEvent.CONNECTION_ERROR_OCCURRED : WSConnectionEvent.CONNECTION_ERROR_OCCURRED_NO_EVENT),
                            ex, handle);
  
          if (isTraceOn && tc.isEventEnabled())
              Tr.event(this, tc, 
                       "Firing " + (logEvent ? "CONNECTION_ERROR_OCCURRED" : "CONNECTION_ERROR_OCCURRED_NO_EVENT"), handle);
  
          // loop through the listeners
          for (int i = 0; i < numListeners; i++) {
              // send Connection Error Occurred event to the current listener
              ivEventListeners[i].connectionErrorOccurred(connEvent); 
          }
  
          // Replace ConnectionEvent caching with a single reusable instance per
          // ManagedConnection. 
      }