docs: @Override
      public void closeLog() throws InternalLogException
      {
          if (tc.isEntryEnabled())
              Tr.entry(tc, "closeLog", this);
  
          if (_logHandle != null)
          {
              // Only try to keypoint the recovery log if its in a valid state. If the service
              // is closing the log in response to a failure, we do not want to make things worse
              // by performing a keypoint operation and corrupting the log. Same applies to
              // the compatibility test.
              if (!failed() && !incompatible())
              {
                  try
                  {
                      keypoint();
                  } catch (LogClosedException exc)
                  {
                      // The log is already closed so absorb the exception.
                      FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.closeLog", "944", this);
                  } catch (InternalLogException exc)
                  {
                      FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.closeLog", "948", this);
                      markFailed(exc); /* @MD19484C */
                      if (tc.isEntryEnabled())
                          Tr.exit(tc, "closeLog", exc);
                      throw exc;
                  } catch (Throwable exc)
                  {
                      FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.closeLog", "955", this);
                      markFailed(exc); /* @MD19484C */
                      if (tc.isEntryEnabled())
                          Tr.exit(tc, "closeLog", "InternalLogException");
                      throw new InternalLogException(exc);
                  }
              }
  
              synchronized (this)
              {
                  _closesRequired--;
  
                  if (_closesRequired <= 0)
                  {
                      try
                      {
                          _logHandle.closeLog();
                      } catch (InternalLogException exc)
                      {
                          FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.closeLog", "974", this);
                          markFailed(exc); /* @MD19484C */
                          if (tc.isEntryEnabled())
                              Tr.exit(tc, "closeLog", exc);
                          throw exc;
                      } catch (Throwable exc)
                      {
                          FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.MultiScopeRecoveryLog.closeLog", "981", this);
                          markFailed(exc); /* @MD19484C */
                          if (tc.isEntryEnabled())
                              Tr.exit(tc, "closeLog", "InternalLogException");
                          throw new InternalLogException(exc);
                      }
  
                      // Reset the internal state so that a subsequent open operation does not
                      // occurs with a "clean" environment.
                      _logHandle = null;
                      _recoverableUnits = null;
                      _closesRequired = 0;
                      _unwrittenDataSize.set(0);
                      _totalDataSize = 0;
                      _failed = false;
                  }
              }
          }
  
          if (tc.isDebugEnabled())
              Tr.debug(tc, "Closes required: " + _closesRequired);
  
          if (tc.isEntryEnabled())
              Tr.exit(tc, "closeLog");
      }