The resulting authentication attempt has not recorded any…

Error message

The resulting authentication attempt has not recorded any successes or failures. This typically means that no authentication handler could be found to support the authentication request or the credential types provided. The authentication handlers that were examined are: [{}]

What it means

DefaultAuthenticationManager.evaluateFinalAuthentication logs this when the AuthenticationBuilder has neither successes nor failures after running the handler chain: no handler examined supported the credential(s) in the transaction. CAS then publishes a transaction failure event and throws an AuthenticationException.

Solutions

Confirm the handler for the credential type is registered and its support module is a build dependency.
Check the service's authentication policy (RegisteredServiceAuthenticationPolicy) is not excluding all handlers.
Verify the submitted credential type matches what the handler supports (e.g. UsernamePasswordCredential vs. token credentials).
Enable debug logging for org.apereo.cas.authentication to trace which handlers were examined and why they were skipped.

Example fix

// before: no LDAP handler registered, only file-based
// after: add the LDAP authentication handler
@Bean
public AuthenticationHandler ldapAuthenticationHandler(...) {
    val h = new LdapAuthenticationHandler(ldapConnection, ...);
    h.setOrder(0);
    return h;
}

Defensive patterns

Strategy: validation

Validate before calling

boolean anySupports = handlers.stream().anyMatch(h -> h.supports(credential));
if (!anySupports) {
    throw new IllegalStateException("No handler supports " + credential.getClass().getSimpleName());
}

Try / catch

try {
    authenticationManager.authenticate(transaction);
} catch (AuthenticationException e) {
    LOGGER.error("No handler examined supported the credential: {}", e.getHandlerErrors(), e);
}

Prevention

Confirm every credential type in your flows has a registered, on-classpath handler.
Review service-level authentication policies after each services-registry change.

When it happens

Trigger: Authentication transaction presented a credential type that none of the registered authentication handlers supports(); the handler set (filtered per service or registered handlers) is empty or all handlers failed supports() checks.

Common situations: Handler not enabled for the service's registered authentication policy; credential class changed between CAS versions so the handler no longer supports it; relevant support module (e.g. cas-server-support-ldap) not on the classpath; typo in service policy handler names.

Understand the failure class

Background: UnsupportedOperationException and "is not supported" errors: when a library deliberately refuses a call — this error's family across 30 libraries.

Authentication and authorization failures — expired tokens, bad credentials, and missing scopes.

Related errors

AI-assisted analysis of apereo/cas@e7288fc434 (2026-09-08). Data as JSON: /api/errors/fe8f6bb1b6259dc1. Report an issue: GitHub.

Appendix: source

Thrown at core/cas-server-core-authentication-api/src/main/java/org/apereo/cas/authentication/DefaultAuthenticationManager.java:277

            }
            evaluateFinalAuthentication(authenticationBuilder, transaction, handlerSet);
            return authenticationBuilder;
        } finally {
            for (val handler : handlerSet) {
                if (handler.isDisposable() && handler instanceof final DisposableBean db) {
                    db.destroy();
                }
            }
        }
    }

    protected void evaluateFinalAuthentication(final AuthenticationBuilder builder,
                                               final AuthenticationTransaction transaction,
                                               final Set<AuthenticationHandler> authenticationHandlers) throws Throwable {
        val clientInfo = ClientInfoHolder.getClientInfo();
        if (builder.getSuccesses().isEmpty()) {
            if (builder.getFailures().isEmpty()) {
                LOGGER.warn("The resulting authentication attempt has not recorded any successes or failures. This typically means that no authentication handler "
                    + "could be found to support the authentication request or the credential types provided. The authentication handlers that were "
                    + "examined are: [{}]", authenticationHandlers.stream().map(AuthenticationHandler::getName).collect(Collectors.joining(", ")));
            }
            publishEvent(new CasAuthenticationTransactionFailureEvent(this, builder.getFailures(), transaction.getCredentials(), clientInfo));
            throw createAuthenticationException(builder);
        }

        val authentication = builder.build();
        val executionResult = evaluateAuthenticationPolicies(authentication, transaction, authenticationHandlers);
        if (!executionResult.isSuccess()) {
            executionResult.getFailures().forEach(e -> handleAuthenticationException(e, e.getClass().getSimpleName(), builder));
            publishEvent(new CasAuthenticationPolicyFailureEvent(this, builder.getFailures(), transaction, authentication, clientInfo));
            throw createAuthenticationException(builder);
        }
    }

    private static AuthenticationException createAuthenticationException(
        final AuthenticationBuilder builder) {

View on GitHub (pinned to e7288fc434)