}
    } else {
      sumOfProductsOfDeltas = NaN;
    }
    yStats.add(y);
  }

  /**
   * Adds the given statistics to the dataset, as if the individual values used to compute the
   * statistics had been added directly.
   */
  public void addAll(PairedStats values) {
    if (values.count() == 0) {
      return;
    }

    xStats.addAll(values.xStats());

    // Cleanup scheduler
    private final ScheduledExecutorService cleanupScheduler;
    private final AtomicBoolean closed = new AtomicBoolean(false);

    // Statistics
    private final AtomicLong totalAttemptsBlocked = new AtomicLong(0);
    private final AtomicLong totalAccountsLocked = new AtomicLong(0);
    private final AtomicLong totalIpsBlocked = new AtomicLong(0);

    /**

                log.error("Error during resource cleanup", e);
            }
        }, cleanupInterval, cleanupInterval, TimeUnit.MILLISECONDS);
    }

    /**
     * Get resource statistics
     *
     * @return map of statistics
     */
    public Map<String, Object> getStatistics() {
        long active = 0;
        long closed = 0;

        for (ResourceHolder holder : activeResources.values()) {

        Map<EventType, Long> stats = logger.getStatistics();
        assertEquals(Long.valueOf(1), stats.get(EventType.CONFIGURATION_CHANGE), "Should have 1 configuration event");
    }

    @Test
    @DisplayName("Test statistics accumulation")
    void testStatisticsAccumulation() {
        logger.logAuthentication(true, "user1", "DOMAIN", "192.168.1.1");
        logger.logAuthentication(false, "user2", "DOMAIN", "192.168.1.2");

  /** Returns the approximate number of entries in this cache. */
  long size();

  /**
   * Returns a current snapshot of this cache's cumulative statistics, or a set of default values if
   * the cache is not recording statistics. All statistics begin at zero and never decrease over the
   * lifetime of the cache.
   *
   * <p><b>Warning:</b> this cache may not be recording statistical data. For example, a cache

  public void addAll(LongStream values) {
    addAll(values.collect(StatsAccumulator::new, StatsAccumulator::add, StatsAccumulator::addAll));
  }

  /**
   * Adds the given statistics to the dataset, as if the individual values used to compute the
   * statistics had been added directly.
   */
  public void addAll(Stats values) {
    if (values.count() == 0) {
      return;
    }

  }

  /** Returns the number of pairs in the dataset. */
  public long count() {
    return xStats.count();
  }

  /** Returns the statistics on the {@code x} values alone. */
  public Stats xStats() {
    return xStats;
  }

  /** Returns the statistics on the {@code y} values alone. */
  public Stats yStats() {
    return yStats;
  }

  /**

 *
 * <p>The core interface used to represent caches is {@link Cache}. In-memory caches can be
 * configured and created using {@link CacheBuilder}, with cache entries being loaded by {@link
 * CacheLoader}. Statistics about cache performance are exposed using {@link CacheStats}.
 *
 * <p>See the Guava User Guide article on <a
 * href="https://github.com/google/guava/wiki/CachesExplained">caches</a>.
 *

        }
    }

    /**
     * Get validation statistics
     */
    public ValidationStats getStats() {
        return new ValidationStats(totalValidations.get(), failedValidations.get(), bufferOverflowsPrevented.get(),
                integerOverflowsPrevented.get());
    }

    /**
     * Reset statistics
     */
    public void resetStats() {
        totalValidations.set(0);

        t.setDaemon(true);
        return t;
    });
    private volatile boolean asyncLogging = true;
    private volatile boolean shutdown = false;

    // Event statistics
    private final Map<EventType, AtomicLong> eventCounters = new ConcurrentHashMap<>();
    private final Map<EventType, AtomicLong> eventTimings = new ConcurrentHashMap<>();

    // Configuration