docs: void remove() throws InternalLogException
      {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "remove", this);
  
          // If the parent recovery log instance has experienced a serious internal error then prevent
          // this operation from executing.
          if (_recLog.failed())
          {
              if (tc.isEntryEnabled())
                  Tr.exit(tc, "remove", this);
              throw new InternalLogException(null);
          }
  
          if (_storedOnDisk)
          {
              // There is information relating to this recoverable unit stored in the underlying
              // recovery log. We must write a deletion record to indicate that this is no longer
              // valid.
              try
              {
                  if (tc.isDebugEnabled())
                      Tr.debug(tc, "Creating deletion record for recoverable unit '" + _identity + "'");
  
                  final WriteableLogRecord logRecord = _logHandle.getWriteableLogRecord(_removalHeaderSize);
  
                  // A null log record returned by the log handle indicates that the request to get
                  // a new writeable log record resulted in a keypoint occuring. As this recoverable
                  // unit has already been removed from the map it will not have been written as part
                  // of the keypoint process and no longer exists in the log. Therefore there is no
                  // need to write the deletion record for this recoverable unit.
                  if (logRecord != null)
                  {
                      writeRecordHeader(logRecord, RECORDTYPEDELETED);
  
                      // Tell the WritableLogRecord that we have finished building the removal record. This
                      // will cause it to add the appropriate record tail to the underlying recovery log.
                      logRecord.close();
  
                      _logHandle.writeLogRecord(logRecord);
                  }
              } catch (Throwable exc)
              {
                  FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.RecoverableUnitImpl.remove", "801", this);
                  if (tc.isEventEnabled())
                      Tr.event(tc, "An unexpected error occurred whilst formatting the recovery log buffer");
                  _recLog.markFailed(exc); /* @MD19484C */
                  if (tc.isEntryEnabled())
                      Tr.exit(tc, "remove", "InternalLogException");
                  throw new InternalLogException(exc);
              }
          }
          else
          {
              // There is no trace of this recoverable unit in the underlying recovery log and so there is
              // no further action to take.
              if (tc.isDebugEnabled())
                  Tr.debug(tc, "Not writing deletion record because RecoverableUnit '" + _identity + "' is not on disk");
          }
  
          // Inform the recovery log of the reduction in the data payload due to this unit being deleted.
          if (_unwrittenDataSize > 0)
          {
              _recLog.payloadDeleted(_totalDataSize + _totalHeaderSize, _unwrittenDataSize + _totalHeaderSize);
          }
          else
          {
              _recLog.payloadDeleted(_totalDataSize + _totalHeaderSize, _unwrittenDataSize);
          }
  
          // Next, "forget" all stored recoverable unit sections. This will ensure that no further
          // reference to this recoverable unit can be written to disk even if the client service
          // invokes a write or force method on it in the future. We also need to clear out the 
          // total and unwritten data size fields to ensure that we don't attempt to begin
          // writing even when there are no sections to write.
          if (tc.isEventEnabled())
              Tr.event(tc, "Remove completed for recoverable unit " + _identity + ". Clear internal state");
          _recoverableUnitSections.clear();
          _totalDataSize = 0;
          _unwrittenDataSize = 0;
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "remove");
      }