docs: @Override
      public boolean accept(RepositoryLogRecord record) {
          /*
           * Logic operates under assumption that record will be accepted by default, therefore
           * filtering check if record should be excluded
           */
  
          // Filtering by threadID
          if (filterThread) {
              if (intThreadID != record.getThreadID()) {
                  return false; // no need to continue, this record does not pass
              }
          }
  
          // Filtering by level
          if (filterLevel) {
              if (minLevel != null) {
                  if (record.getLevel().intValue() < minLevel.intValue()) {
                      return false; // no need to continue, this record does not pass
                  }
              }
              if (maxLevel != null) {
                  if (record.getLevel().intValue() > maxLevel.intValue()) {
                      return false; // no need to continue, this record does not pass
                  }
              }
          }
  
          // Filtering by Date/Time
          if (filterTime) {
              Date recordDate = new Date();
              recordDate.setTime(record.getMillis());
              if (startDate != null) {
                  if (recordDate.before(startDate)) {
                      return false; // no need to continue, this record does not
                      // pass
                  }
              }
              if (stopDate != null) {
                  if (recordDate.after(stopDate)) {
                      return false; // no need to continue, this record does not
                      // pass
                  }
              }
          }
  
          // Filtering by Logger
          if (filterLoggers) {
              /*
               * Can't return false at first filter out in case of loggers cause it's possible
               * that a more specific include could over-ride the exclude. So we check them all -
               * and track the highest include and exclude matches. If there are no matches for
               * either include or exclude default is to exclude it.
               */
              int excludeMatchLevel = -1;
              int includeMatchLevel = -1;
  
              if (excludeLoggers != null) {
                  for (String x : exLoggers) {
                      if (record.getLoggerName() != null && record.getLoggerName().matches(x.replace("*", ".*"))) {
                          int tmpInt = x.split("\\.").length;
                          if (tmpInt > excludeMatchLevel)
                              // This match is higher than any previous matches
                              excludeMatchLevel = tmpInt;
                      }
                  }
              } else
                  excludeMatchLevel = 0; // Equivalent of excludeLoggers="*"
  
              if (includeLoggers != null) {
                  for (String x : inLoggers) {
                      if (record.getLoggerName() != null && record.getLoggerName().matches(x.replace("*", ".*"))) {
                          int tmpInt = x.split("\\.").length;
                          if (tmpInt > includeMatchLevel)
                              // This match is higher than any previous matches
                              includeMatchLevel = tmpInt;
                      }
                  }
              } else
                  includeMatchLevel = 0; // Equivalent of includeLoggers="*"
  
              // Only want to accept the record if it matches an include, and does
              // not match an exclude (of greater value if it matches both).
              if (includeLoggers == null) {
                  // default include is *
              }
  
              // Using equals on match level, so default will be to exclude a record if user has
              // defined both include and exclude Logger criteria and we did not match on either
              // case
              if (includeMatchLevel <= excludeMatchLevel)
                  return false;
          }
  
          // Filtering by message
          if (filterMessage) {
              String recordMessage = (record.getFormattedMessage() != null) ? record.getFormattedMessage() : record.getRawMessage();
  
              if (recordMessage == null) {
                  return false;
              }
  
              recordMessage = recordMessage.replace("\n", "").replace("\r", "");
  
              if (messageRegExp != null) {
                  boolean foundmessagekey = messageRegExp.matcher(recordMessage).find();
                  if (!foundmessagekey) {
                      return false;
                  }
              }
  
              if (excludeMessages != null) {
                  for (Pattern p : excludeMessagesRegExpPatterns) {
                      boolean excludeMsg = p.matcher(recordMessage).find();
                      if (excludeMsg) {
                          // The Log record message will be excluded from the Log viewer.
                          return false;
                      }
                  }
              }
  
          }
  
          // Filtering by extension
          if (extensions != null) {
              boolean match = false;
              for (Extension extension : extensions) {
                  String value = record.getExtension(extension.key);
                  if (value != null) {
  
                      if (extension.value == null || includeExtensionRegExpPatterns.get(includeExtensionRegExpKeys.indexOf(extension.key)).matcher(value).find()) {
                          match = true;
                          break;
                      }
                  }
              }
              if (!match) {
                  return false;
              }
          }
  
          // if we made it this far, then the record should be good.
          return true;
      }