docs: protected WriteableLogRecord getWriteableLogRecord(int recordLength) throws InternalLogException
      {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "getWriteableLogRecord", new Object[] { this, recordLength });
  
          WriteableLogRecord writeableLogRecord = null;
  
          boolean keyPointRequired = false;
  
          synchronized (this)
          {
              if (_activeFile.freeBytes() < (recordLength + WriteableLogRecord.HEADER_SIZE))
              {
                  // There is insufficient space in the active file to accomodate a record
                  // of the requested size. We must perform a keypoint operation instead. 
                  // We can't perform this directly as we are synchronized under this object
                  // so make a note of this fact here instead. This causes a keypoint to
                  // occur outside this sync block below.
                  keyPointRequired = true;
              }
              else
              {
                  try
                  {
                      writeableLogRecord = _activeFile.getWriteableLogRecord(recordLength, _recordSequenceNumber++);
                  } catch (InternalLogException exc)
                  {
                      FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.getWriteableLogRecord", "1112", this);
                      if (tc.isEntryEnabled())
                          Tr.exit(tc, "getWriteableLogRecord", exc);
                      throw exc;
                  }
              }
          }
  
          if (keyPointRequired)
          {
              // There is insufficient space in the active file to accomodate a record
              // of the requested size. We must perform a keypoint operation instead.
              try
              {
                  _recoveryLog.keypoint();
              } catch (LogClosedException exc)
              {
                  FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.getWriteableLogRecord", "1129", this);
                  if (tc.isEntryEnabled())
                      Tr.exit(tc, "getWriteableLogRecord", "InternalLogException");
                  throw new InternalLogException(exc);
              } catch (InternalLogException exc)
              {
                  FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.getWriteableLogRecord", "1135", this);
                  if (tc.isEntryEnabled())
                      Tr.exit(tc, "getWriteableLogRecord", exc);
                  throw exc;
              } catch (LogIncompatibleException exc)
              {
                  FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.getWriteableLogRecord", "1204", this);
                  if (tc.isEntryEnabled())
                      Tr.exit(tc, "getWriteableLogRecord", exc);
                  throw new InternalLogException(exc);
              }
  
              // Return null to the caller. This indicates that the recovery log now contains
              // a persistent record of all active data and the write operation is no longer
              // required.
              writeableLogRecord = null;
          }
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "getWriteableLogRecord", writeableLogRecord);
          return writeableLogRecord;
      }