return false;
        }

        // Check per-account limit
        if (username != null) {
            AccountAttempts account = accountAttempts.computeIfAbsent(username, k -> new AccountAttempts());
            if (account.isLockedOut()) {
                if (account.getLockoutExpiry().isAfter(Instant.now())) {
                    totalAttemptsBlocked.incrementAndGet();

        vFrom.setCompareScope(scopedVertices);

        List<MetadataGraphEdge> exList = excidentEdges.computeIfAbsent(vFrom, k -> new ArrayList<>());

        if (!exList.contains(e)) {
            exList.add(e);
        }

        List<MetadataGraphEdge> inList = incidentEdges.computeIfAbsent(vTo, k -> new ArrayList<>());

        if (!inList.contains(e)) {
            inList.add(e);
        }

        }

        private LongAdder getCounter(BuilderProblem.Severity severity) {
            return counters.computeIfAbsent(severity, k -> new LongAdder());
        }

        private List<P> getProblems(BuilderProblem.Severity severity) {
            return problems.computeIfAbsent(severity, k -> new CopyOnWriteArrayList<>());
        }

            }

            if (cls.isArray()) {
                evaluateArray(target);
            } else if (isQualifiedForInterpolation(cls)) {
                Field[] fields = FIELDS_BY_CLASS.computeIfAbsent(cls, k -> cls.getDeclaredFields());

                for (Field field : fields) {
                    Class<?> type = field.getType();
                    if (isQualifiedForInterpolation(field, type)) {

        
        // Mark channel as failed
        failedChannel.setState(ChannelState.FAILED);
        
        // Get or create failover state
        FailoverState state = failoverStates.computeIfAbsent(
            failedChannel.getChannelId(), 
            FailoverState::new
        );
        
        // Redistribute pending operations
        redistributePendingOperations(failedChannel);
        

        }

        // Track connection metrics
        String key = getConnectionKey(address, port);
        connectionMetrics.computeIfAbsent(key, k -> new ConnectionMetrics()).recordConnection();
        activeConnections.incrementAndGet();

        if (nonPooled) {
            this.nonPooledConnections.offer(conn);
        } else {

        // Mark channel as failed
        failedChannel.setState(ChannelState.FAILED);

        // Get or create failover state
        FailoverState state = failoverStates.computeIfAbsent(failedChannel.getChannelId(), FailoverState::new);

        // Redistribute pending operations
        redistributePendingOperations(failedChannel);

        if (StringUtil.isBlank(value)) {
            return Collections.emptyList();
        }
        return split(value, ",").get(stream -> stream.map(String::trim)//
                .map(s -> clientRuleCache.computeIfAbsent(s, t -> {
                    final String[] values = t.split(":", 2);
                    if (values.length != 2) {
                        return null;
                    }

                responseHeaders.put(name, values);
            }

            @Override
            public void addHeader(String name, String value) {
                responseHeaders.computeIfAbsent(name, k -> new ArrayList<>()).add(value);
            }

            @Override
            public void setIntHeader(String name, int value) {
            }

            @Override

        String key = type.name();
        long currentWindow = System.currentTimeMillis() / rateLimitWindow;
        String windowKey = key + "_" + currentWindow;

        AtomicLong counter = rateLimitCounters.computeIfAbsent(windowKey, k -> new AtomicLong(0));
        long currentCount = counter.incrementAndGet();

        // Clean up old windows periodically
        if (currentCount == 1) {