docs: @Override
      public void removeRecoverableUnit(long identity) throws LogClosedException, InvalidRecoverableUnitException, InternalLogException, LogIncompatibleException {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "removeRecoverableUnit", new Object[] { identity, this });
  
          // If this recovery log instance has been marked as incompatible then throw an exception
          // accordingly.
          if (incompatible()) {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", "LogIncompatibleException");
              throw new LogIncompatibleException();
          }
  
          // If this recovery log instance has experienced a serious internal error then prevent this operation from
          // executing.
          if (failed()) {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", this);
              throw new InternalLogException(null);
          }
  
          // Ensure the log is actually open.
          if (_closesRequired == 0) {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", "LogClosedException");
              throw new LogClosedException(null);
          }
  
          SQLRecoverableUnitImpl recoverableUnit = null;
  
          synchronized (this) {
              // REQD Thread safety
              recoverableUnit = removeRecoverableUnitMapEntries(identity);
          }
  
          // If the RecoverableUnit corresponding to 'identity' was not found in the map then throw an exception
          if (recoverableUnit == null) {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", "InvalidRecoverableUnitException");
              throw new InvalidRecoverableUnitException(null);
          }
  
          // Inform the recoverable unit that it is being deleted. This enables it to write a "DELETED" entry in the
          // recovery log (unforced) to ensure that a previous instance of this recoverable unit does not get confused with
          // a newer instance (otherwise the recovey logic would have no way of distinguising between older, deleted information
          // and newer recoverable information)
          try {
              recoverableUnit.remove();
  
              // Store data in case a DB transient error occurs
              synchronized (this) {
                  ruForReplay deleteRU = new ruForReplay(identity, 0, 0, null);
                  _cachedRemoves.add(deleteRU);
                  _removes++;
              }
          } catch (InternalLogException exc) {
              FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.SQLMultiScopeRecoveryLog.removeRecoverableUnit", "1182", this);
  
              markFailed(exc); /* @MD19484C */
  
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", exc);
              throw exc;
          } catch (Exception e) {
              FFDCFilter.processException(e, "com.ibm.ws.recoverylog.spi.SQLMultiScopeRecoveryLog.removeRecoverableUnit", "1186", this);
  
              markFailed(e); /* @MD19484C */
  
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "removeRecoverableUnit", e);
              throw new InternalLogException(e);
          }
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "removeRecoverableUnit");
      }