Spring Boot Auto-Configuration: Missing HikariCP, No Error — The Silent Killer

@AutoConfiguration
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class, DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {

    @Configuration
    @ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class)
    static class Tomcat {
        @Bean
        @ConditionalOnMissingBean(DataSource.class)
        DataSource dataSource(DataSourceProperties properties) {
            return properties.initializeDataSourceBuilder()
                    .type(org.apache.tomcat.jdbc.pool.DataSource.class).build();
        }
    }

    @Configuration
    @ConditionalOnClass(HikariDataSource.class)
    static class Hikari {
        @Bean
        @ConditionalOnMissingBean(DataSource.class)
        DataSource dataSource(DataSourceProperties properties) {
            return properties.initializeDataSourceBuilder()
                    .type(HikariDataSource.class).build();
        }
    }
}

# WRONG: This is silent failure mode
# No spring.datasource.url set
# App starts, but no DataSource

# RIGHT: Force failure if HikariCP is missing
spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=user
spring.datasource.password=pass

# Also enable debug logging to see condition evaluation
logging.level.org.springframework.boot.autoconfigure=DEBUG

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>silent-killer</artifactId>
    <version>1.0.0</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!-- HikariCP is included transitively, but we exclude it -->
            <exclusions>
                <exclusion>
                    <groupId>com.zaxxer</groupId>
                    <artifactId>HikariCP</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- No database driver or connection pool -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
    </dependencies>
</project>

import org.springframework.boot.actuate.condition.ConditionsReportEndpoint;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class DiagnosticController {

    private final ConditionsReportEndpoint conditionsEndpoint;

    public DiagnosticController(ConditionsReportEndpoint conditionsEndpoint) {
        this.conditionsEndpoint = conditionsEndpoint;
    }

    @GetMapping("/diagnose/datasource")
    public String diagnoseDataSource() {
        var report = conditionsEndpoint.conditions();
        var contexts = report.getContexts();
        var dataSourceCondition = contexts.values().stream()
            .flatMap(ctx -> ctx.getPositiveMatches().entrySet().stream())
            .filter(entry -> entry.getKey().contains("DataSourceAutoConfiguration"))
            .findFirst();
        
        if (dataSourceCondition.isPresent()) {
            return "DataSource auto-configuration is active: " + dataSourceCondition.get().getKey();
        } else {
            return "DataSource auto-configuration is NOT active. Check negative matches.";
        }
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;

@Component
public class CriticalBeanValidator implements ApplicationRunner {

    private static final Logger log = LoggerFactory.getLogger(CriticalBeanValidator.class);

    @Autowired
    private ApplicationContext applicationContext;

    @Override
    public void run(ApplicationArguments args) {
        validateBean(DataSource.class, "DataSource");
        // Add more critical beans as needed
        log.info("All critical beans validated successfully.");
    }

    private void validateBean(Class<?> beanClass, String beanName) {
        try {
            Object bean = applicationContext.getBean(beanClass);
            log.debug("Bean '{}' found: {}", beanName, bean);
        } catch (NoSuchBeanDefinitionException e) {
            String errorMsg = String.format(
                "CRITICAL: Bean '%s' of type '%s' is missing from the application context. " +
                "This indicates a missing dependency or failed auto-configuration. " +
                "Application will shut down.",
                beanName, beanClass.getSimpleName());
            log.error(errorMsg);
            throw new IllegalStateException(errorMsg, e);
        }
    }
}

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;

import javax.sql.DataSource;

@Configuration
@Profile("dev")  // Only in development profile
public class FallbackDataSourceConfig {

    @Bean
    @ConditionalOnMissingBean(DataSource.class)
    public DataSource fallbackDataSource() {
        System.err.println("WARNING: No DataSource bean found. Creating embedded H2 fallback. " +
            "This should NOT be used in production!");
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .build();
    }
}

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.TestPropertySource;

import javax.sql.DataSource;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;

@SpringBootTest
@TestPropertySource(properties = {
    "spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration"
})
public class AutoConfigurationTest {

    @Test
    void testDataSourceIsMissingWhenExcluded(ApplicationContext context) {
        assertThrows(NoSuchBeanDefinitionException.class, () -> {
            context.getBean(DataSource.class);
        }, "DataSource should not be present when auto-configuration is excluded");
    }

    @Test
    void testCriticalBeanValidatorFailsStartup(AssertableApplicationContext context) {
        // The validator should have thrown an exception, so context should be in failed state
        assertThat(context).hasFailed();
        assertThat(context.getStartupFailure()).hasMessageContaining("DataSource");
    }
}

# Force DataSource configuration to fail loudly if HikariCP is missing
spring.datasource.url=jdbc:postgresql://prod-db:5432/mydb
spring.datasource.username=${DB_USER}
spring.datasource.password=${DB_PASS}
spring.datasource.hikari.maximum-pool-size=20

# Enable conditions endpoint for production monitoring
management.endpoints.web.exposure.include=health,conditions,info
management.endpoint.conditions.enabled=true

# Log auto-configuration decisions at startup (optional, can be verbose)
# logging.level.org.springframework.boot.autoconfigure=INFO

# Fail fast if any required bean is missing
spring.main.allow-bean-definition-overriding=false