ipAttempts.entrySet().removeIf(entry -> {
            IpAttempts ip = entry.getValue();
            return !ip.isBlocked() && ip.getLastAttempt().plus(cleanupInterval).isBefore(now);
        });

        log.debug("Cleaned up rate limiter entries. Accounts: {}, IPs: {}", accountAttempts.size(), ipAttempts.size());
    }

    /**
     * Manually unlock an account
     *
     * @param username the username to unlock

It can be used by the frontend team (that can also be yourself).

It can be used by third party applications and systems.

And it can also be used by yourself, to debug, check and test the same application.

## The `password` flow { #the-password-flow }

Now let's go back a bit and understand what is all that.

        State currentState = evaluateState();

        if (currentState == State.OPEN) {
            rejectedCalls.incrementAndGet();
            if (fallback != null) {
                log.debug("Circuit breaker {} is open, using fallback", name);
                return fallback.call();
            }
            throw new CircuitBreakerOpenException("Circuit breaker " + name + " is open");
        }

            extractContent(element, currentKey, textBuilder, metadataMap, depth + 1);
        }

        if (node.size() > maxArrayElements) {
            if (logger.isDebugEnabled()) {
                logger.debug("Array at {} has {} elements, only first {} extracted", parentKey, node.size(), maxArrayElements);
            }
        }
    }

    /**
     * Extracts a primitive value from a JSON node.
     *

    }

  /**
   * Returns an OkHttpClient for tests to use as a starting point.
   *
   * The returned client installs a default event listener that gathers debug information. This will
   * be logged if the test fails.
   *
   * This client is also configured to be slightly more deterministic, returning a single IP

                    Thread.currentThread().interrupt();
                    break;
                } catch (Exception e) {
                    if (handle.isActive()) {
                        log.debug("Change notification failed for: " + handle.getDirectoryPath(), e);
                        incrementFailureCount(handle);
                        // Exponential backoff with max 8 seconds delay (up to MAX_RETRY_DELAY)

    }
  }

  @Test fun goAwayWithoutDebugDataRoundTrip() {
    val expectedError = ErrorCode.PROTOCOL_ERROR
    writeMedium(frame, 8) // Without debug data there's only 2 32-bit fields.
    frame.writeByte(TYPE_GOAWAY)
    frame.writeByte(FLAG_NONE)
    frame.writeInt(0) // connection-scope
    frame.writeInt(expectedStreamId) // last good stream.

        try {
            if (initialToken != null && initialToken.length > 0) {
                NegTokenInit tok = new NegTokenInit(initialToken);
                if (log.isDebugEnabled()) {
                    log.debug("Have initial token " + tok);
                }
                if (tok.getMechanisms() != null) {
                    Set<ASN1ObjectIdentifier> mechs = new HashSet<>(Arrays.asList(tok.getMechanisms()));

     */
    public synchronized void putToInfoMap(final String key, final String value) {
        if (infoMap == null) {
            infoMap = Collections.synchronizedMap(new LinkedHashMap<>());
        }
        logger.debug("infoMap: {}={} => {}", key, value, infoMap);
        infoMap.put(key, value);
    }

    /**
     * Updates crawling information parameters for the specified session.

            } catch (final Exception e) {
                // Failed to decode URL, using original URL as-is
                if (getLogger().isDebugEnabled()) {
                    getLogger().debug("Failed to decode URL with encoding {}: {}", enc, url, e);
                }
            }
        }

        return abbreviateSite(url);
    }

    /**