Called when logs fail. Provides more comprehensive FFDC - PI45254.
this is NOT synchronized to avoid deadlocks.
975289
@Override
    public void provideServiceability() {
        Exception e = new Exception();
        try {
            FFDCFilter.processException(e, "com.ibm.ws.recoverylog.custom.jdbc.impl.SQLMultiScopeRecoveryLog.provideServiceability", "3624", this);
            HashMap<Long, RecoverableUnit> rus = _recoverableUnits;
            if (rus != null)
                FFDCFilter.processException(e, "com.ibm.ws.recoverylog.custom.jdbc.impl.SQLMultiScopeRecoveryLog.provideServiceability", "3628", rus);
        } catch (Exception ex) {
            // Do nothing
        }
    }
992544
public synchronized void waitOnIgnoringInterruptions()
   {
      if (tc.isEntryEnabled()) SibTr.entry(tc, "waitOnIgnoringInterruptions");

      boolean interrupted;
      do
      {
         interrupted = false;
         try
         {
            waitOn();
         }
         catch (InterruptedException e)
         {
            // No FFDC code needed
            interrupted = true;
         }
      }
      while(interrupted);

      if (tc.isEntryEnabled()) SibTr.exit(tc, "waitOnIgnoringInterruptions");
   }
886532
def _retry_failed_log(failed_trigger_log):
    
    model = type(failed_trigger_log)
    try:
        failed_trigger_log = (
            model.objects
            .select_for_update()
            .get(
                id=failed_trigger_log.id,
                state=TRIGGER_LOG_STATE['FAILED'],
            )
        )
    except model.DoesNotExist:
        return False
    failed_trigger_log.redo()
    return True
574796
private boolean shouldBeLogged(Throwable t, OSGiTraceComponent tc, ExtendedLogEntry logEntry) {
        while (t != null) {
            if (t instanceof IllegalStateException && COULD_NOT_OBTAIN_LOCK_EXCEPTION.equals(t.getMessage())) {
                if (tc.isDebugEnabled()) {
                    Tr.debug(tc, "DS could not obtain a lock. This is not an error, but may indicate high system load",
                            getObjects(logEntry, false));
                }
                return false;
            }
            t = t.getCause();
        }
        return true;
    }
662012
boolean failure(Throwable failure) {
        State<T> oldState;
        synchronized (mutex) {
            if (state.isCompleted()) {
                return false;
            }
            oldState = state;
            state = state.getFailureState(failure);
        }
        oldState.callFailureCallbacks(failure);
        return true;
    }
411065
public synchronized boolean log(WsByteBuffer data) {
        if (null == data) {
            // return failure
            return false;
        }
        // if we've stopped then there is no worker to hand this to; however, the
        // caller does not expect to have to release buffers handed to the
        // logger so do that here first
        if (State.RUNNING != this.state) {
            data.release();
            return false;
        }
        int length = data.remaining();
        if (isOverFileLimit(length)) {
            rotate();
        }
        boolean rc = true;
        int bytesWritten = 0;
        try {
            ByteBuffer buffer = data.getWrappedByteBuffer();
            while (bytesWritten < length) {
                bytesWritten += this.myChannel.write(buffer);
            }
        } catch (Exception e) {
            FFDCFilter.processException(e, getClass().getName() + ".log", "166", this);
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
                Tr.event(tc, getFileName() + ": error writing to log; " + e);
            }
            rc = false;
        } finally {
            data.release();
        }
        return rc;
    }
940004
function onCollectionRetrievalFailure( serverResponse ) {
			self.logInterface.error( self.logPrefix + "Unable to retrieve the collection from the server.",
				serverResponse );
			self.__entityCacheRaw = null;

			self.scope.$emit( "absyncError", serverResponse );

			if( self.throwFailures ) {
				throw serverResponse;
			}
		}
1331499
def on_failure(self, exc, task_id, args, kwargs, einfo):
        """"""
        super().on_failure(exc, task_id, args, kwargs, einfo)
        if isinstance(exc, OperationRunDoesNotExist):
            return
        self._operation_run.on_failure()
526796
def print_failed(self, stream=sys.stderr):
        
        for job_key, job_details in sorted(self.scatter_link.jobs.items()):
            if job_details.status == JobStatus.failed:
                stream.write("Failed job %s\n  log = %s\n" %
                             (job_key, job_details.logfile))
1033127
public void reportFailure(E failureException) {
        assert failureException != null;
        connectionLock.lock();
        try {
            state = State.Failure;
            this.failureException = failureException;
            condition.signalAll();
        }
        finally {
            connectionLock.unlock();
        }
    }
1224785
def log_errors(self):
        
        for result in self._stored.values():
            failure = result.original_failure()
            if failure is not None:
                log.err(failure, "Unhandled error in stashed EventualResult:")
584769
public void onFail()
  {
    _lastFailTime = CurrentTime.currentTime();
    
    if (_firstFailTime == 0) {
      _firstFailTime = _lastFailTime;
    }
    _firstSuccessTime = 0;
    
    toState(State.FAIL);
    
    long recoverTimeout = _dynamicRecoverTimeout.get();
    
    long nextRecoverTimeout = Math.min(recoverTimeout + 1000L, _recoverTimeout);
    
    _dynamicRecoverTimeout.compareAndSet(recoverTimeout, nextRecoverTimeout);
  }
1054841
def on_failure(self, metadata):
        
        self.connection.reset()
        handler = self.handlers.get("on_failure")
        if callable(handler):
            handler(metadata)
        handler = self.handlers.get("on_summary")
        if callable(handler):
            handler()
        raise CypherError.hydrate(**metadata)
1275819
public void clientFailedToLogon (Client client, Exception cause)
    {
        if (cause instanceof ConnectException) {
            // we'll reconnect at most one minute later in refreshPeers()
            log.info("Peer not online " + _record + ": " + cause.getMessage());
        } else {
            log.warning("Peer logon attempt failed " + _record + ": " + cause);
        }
    }
637814
private void handleLogRequest(VoltMessage message)
    {
        Iv2RepairLogRequestMessage req = (Iv2RepairLogRequestMessage)message;
        // It is possible for a dead host to queue messages after a repair request is processed
        // so make sure this can't happen by re-queuing this message after we know the dead host is gone
        // Since we are not checking validateForeignHostId on the PicoNetwork thread, it is possible for
        // the PicoNetwork thread to validateForeignHostId and queue a message behind this repair message.
        // Further, we loose visibility to the ForeignHost as soon as HostMessenger marks the host invalid
        // even though the PicoNetwork thread could still be alive so we will skeptically
        int deadHostId = req.getDeadHostId();
        if (deadHostId != Integer.MAX_VALUE) {
            if (m_messenger.canCompleteRepair(deadHostId)) {
                // Make sure we are the last in the task queue when we know the ForeignHost is gone
                req.disableDeadHostCheck();
                deliver(message);
            }
            else {
                if (req.getRepairRetryCount() > 100 && req.getRepairRetryCount() % 100 == 0) {
                    hostLog.warn("Repair Request for dead host " + deadHostId +
                            " has not been processed yet because connection has not closed");
                }
                Runnable retryRepair = new Runnable() {
                    @Override
                    public void run() {
                        InitiatorMailbox.this.deliver(message);
                    }
                };
                VoltDB.instance().scheduleWork(retryRepair, 10, -1, TimeUnit.MILLISECONDS);
                // the repair message will be resubmitted shortly when the ForeignHosts to the dead host have been removed
            }
            return;
        }

        List<Iv2RepairLogResponseMessage> logs = m_repairLog.contents(req.getRequestId(),
                req.isMPIRequest());

        if (req.isMPIRequest()) {
            m_scheduler.cleanupTransactionBacklogOnRepair();
        }
        for (Iv2RepairLogResponseMessage log : logs) {
            send(message.m_sourceHSId, log);
        }
    }
151745
public void onFailure() throws InterruptedException {
        int val = currentFailureCount.incrementAndGet();
        if (val > 50) {
            currentFailureCount.compareAndSet(val, MAX_FAILURE_COUNT);
            val = MAX_FAILURE_COUNT;
        }

        int delay = MIN_DELAY + ((MAX_DELAY - MIN_DELAY) / MAX_FAILURE_COUNT) * val;

        synchronized (this) {
            Logger.d(TAG, "onFailure: wait " + delay + " ms");
            wait(delay);
        }
    }
1251999
def failed(self, **kwargs):
        """"""
        self.finished = datetime.now()
        self.status = 'failed'
        self.information.update(kwargs)
        self.logger.info("Failed - took %f seconds.", self.duration())
        self.update_report_collector(int(time.mktime(self.finished.timetuple())))