Add Cassandra driver Actuator metrics

spring-boot-project/spring-boot-actuator-autoconfigure/build.gradle

@@ -30,6 +30,7 @@ dependencies {
 
 	optional("ch.qos.logback:logback-classic")
 	optional("com.datastax.oss:java-driver-core")
+	optional("com.datastax.oss:java-driver-metrics-micrometer")
 	optional("com.fasterxml.jackson.dataformat:jackson-dataformat-xml")
 	optional("com.github.ben-manes.caffeine:caffeine")
 	optional("com.hazelcast:hazelcast")
@@ -140,6 +141,8 @@ dependencies {
 	testImplementation("org.springframework.restdocs:spring-restdocs-mockmvc")
 	testImplementation("org.springframework.restdocs:spring-restdocs-webtestclient")
 	testImplementation("org.springframework.security:spring-security-test")
+	testImplementation("org.testcontainers:cassandra")
+	testImplementation("org.testcontainers:junit-jupiter")
 	testImplementation("org.yaml:snakeyaml")
 
 	testRuntimeOnly("org.junit.platform:junit-platform-launcher")

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/metrics/cassandra/CassandraMetricsAutoConfiguration.java

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.boot.actuate.autoconfigure.metrics.cassandra;
+
+import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
+import com.datastax.oss.driver.internal.metrics.micrometer.MicrometerDriverContext;
+import io.micrometer.core.instrument.MeterRegistry;
+
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.boot.actuate.autoconfigure.metrics.MetricsAutoConfiguration;
+import org.springframework.boot.actuate.autoconfigure.metrics.export.simple.SimpleMetricsExportAutoConfiguration;
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.AutoConfigureBefore;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration;
+import org.springframework.boot.autoconfigure.cassandra.CassandraProperties;
+import org.springframework.boot.autoconfigure.cassandra.CqlSessionBuilderCustomizer;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * {@link EnableAutoConfiguration Auto-configuration} for metrics on all available
+ * {@link CqlSession Cassandra sessions}.
+ *
+ * @author Erik Merkle
+ * @since 2.4.0
+ */
+@Configuration
+@AutoConfigureAfter({ MetricsAutoConfiguration.class, SimpleMetricsExportAutoConfiguration.class })
+@AutoConfigureBefore({ CassandraAutoConfiguration.class })
+@ConditionalOnClass({ MeterRegistry.class, MicrometerDriverContext.class })
+@ConditionalOnBean({ MeterRegistry.class })
+public class CassandraMetricsAutoConfiguration {
+
+	@Bean
+	public CassandraMetricsPostProcessor cassandraMetricsPostProcessor(ApplicationContext context,
+			CassandraProperties properties, DriverConfigLoader driverConfigLoader,
+			ObjectProvider<CqlSessionBuilderCustomizer> builderCustomizers) {
+		return new CassandraMetricsPostProcessor(context, properties, driverConfigLoader, builderCustomizers);
+	}
+
+}

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/metrics/cassandra/CassandraMetricsPostProcessor.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.boot.actuate.autoconfigure.metrics.cassandra;
+
+import java.security.NoSuchAlgorithmException;
+
+import javax.net.ssl.SSLContext;
+
+import com.datastax.oss.driver.api.core.CqlSessionBuilder;
+import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
+import com.datastax.oss.driver.api.core.context.DriverContext;
+import com.datastax.oss.driver.api.core.session.ProgrammaticArguments;
+import com.datastax.oss.driver.internal.metrics.micrometer.MicrometerDriverContext;
+import io.micrometer.core.instrument.MeterRegistry;
+
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.boot.autoconfigure.cassandra.CassandraProperties;
+import org.springframework.boot.autoconfigure.cassandra.CqlSessionBuilderCustomizer;
+import org.springframework.context.ApplicationContext;
+import org.springframework.core.Ordered;
+
+/**
+ * {@link BeanPostProcessor} that configures Cassandra metrics. This is necessary as the
+ * CqlSessionBuilder bean provided by {@link CassandraAutoConfigure} must be overridden in
+ * order to enable driver metrics. The post-processing here will do just that.
+ *
+ * @author Erik Merkle
+ */
+class CassandraMetricsPostProcessor implements BeanPostProcessor, Ordered {
+
+	private final ApplicationContext context;
+
+	private final CassandraProperties cassandraProperties;
+
+	private final DriverConfigLoader driverConfigLoader;
+
+	private final ObjectProvider<CqlSessionBuilderCustomizer> builderCustomizers;
+
+	CassandraMetricsPostProcessor(ApplicationContext context, CassandraProperties cassandraProperties,
+			DriverConfigLoader driverConfigLoader, ObjectProvider<CqlSessionBuilderCustomizer> builderCustomizers) {
+		this.context = context;
+		this.cassandraProperties = cassandraProperties;
+		this.driverConfigLoader = driverConfigLoader;
+		this.builderCustomizers = builderCustomizers;
+	}
+
+	@Override
+	public Object postProcessAfterInitialization(Object bean, String beanName) {
+		if (bean instanceof CqlSessionBuilder) {
+			MetricsSessionBuilder builder = new MetricsSessionBuilder(this.context.getBean(MeterRegistry.class));
+			// the Metrics enabled builder will need all of the same config as a regular
+			// CqlSessionBUilder
+			builder.withConfigLoader(this.driverConfigLoader);
+			configureAuthentication(this.cassandraProperties, builder);
+			configureSsl(this.cassandraProperties, builder);
+			builder.withKeyspace(this.cassandraProperties.getKeyspaceName());
+			this.builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
+			// override the builder bean
+			return builder;
+		}
+		return bean;
+	}
+
+	private void configureAuthentication(CassandraProperties properties, MetricsSessionBuilder builder) {
+		if (properties.getUsername() != null) {
+			builder.withAuthCredentials(properties.getUsername(), properties.getPassword());
+		}
+	}
+
+	private void configureSsl(CassandraProperties properties, MetricsSessionBuilder builder) {
+		if (properties.isSsl()) {
+			try {
+				builder.withSslContext(SSLContext.getDefault());
+			}
+			catch (NoSuchAlgorithmException ex) {
+				throw new IllegalStateException("Could not setup SSL default context for Cassandra", ex);
+			}
+		}
+	}
+
+	@Override
+	public int getOrder() {
+		return Ordered.HIGHEST_PRECEDENCE;
+	}
+
+	static class MetricsSessionBuilder extends CqlSessionBuilder {
+
+		private final MeterRegistry registry;
+
+		MetricsSessionBuilder(MeterRegistry registry) {
+			this.registry = registry;
+		}
+
+		@Override
+		protected DriverContext buildContext(DriverConfigLoader configLoader,
+				ProgrammaticArguments programmaticArguments) {
+			return new MicrometerDriverContext(configLoader, programmaticArguments, this.registry);
+		}
+
+	}
+
+}

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/java/org/springframework/boot/actuate/autoconfigure/metrics/cassandra/package-info.java

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Auto-configuration for Cassandra metrics.
+ */
+package org.springframework.boot.actuate.autoconfigure.metrics.cassandra;

spring-boot-project/spring-boot-actuator-autoconfigure/src/main/resources/META-INF/spring.factories

@@ -49,6 +49,7 @@ org.springframework.boot.actuate.autoconfigure.metrics.MetricsEndpointAutoConfig
 org.springframework.boot.actuate.autoconfigure.metrics.SystemMetricsAutoConfiguration,\
 org.springframework.boot.actuate.autoconfigure.metrics.amqp.RabbitMetricsAutoConfiguration,\
 org.springframework.boot.actuate.autoconfigure.metrics.cache.CacheMetricsAutoConfiguration,\
+org.springframework.boot.actuate.autoconfigure.metrics.cassandra.CassandraMetricsAutoConfiguration,\
 org.springframework.boot.actuate.autoconfigure.metrics.export.appoptics.AppOpticsMetricsExportAutoConfiguration,\
 org.springframework.boot.actuate.autoconfigure.metrics.export.atlas.AtlasMetricsExportAutoConfiguration,\
 org.springframework.boot.actuate.autoconfigure.metrics.export.datadog.DatadogMetricsExportAutoConfiguration,\

spring-boot-project/spring-boot-actuator-autoconfigure/src/test/java/org/springframework/boot/actuate/autoconfigure/metrics/cassandra/CassandraMetricsAutoConfigurationIntegrationTests.java

@@ -0,0 +1,149 @@
+/*
+ * Copyright 2020 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.boot.actuate.autoconfigure.metrics.cassandra;
+
+import java.net.InetSocketAddress;
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+
+import com.datastax.oss.driver.api.core.ConsistencyLevel;
+import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.CqlSessionBuilder;
+import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
+import com.datastax.oss.driver.api.core.cql.SimpleStatement;
+import com.datastax.oss.driver.api.core.metrics.DefaultNodeMetric;
+import com.datastax.oss.driver.api.core.metrics.DefaultSessionMetric;
+import io.micrometer.core.instrument.MeterRegistry;
+import org.junit.jupiter.api.Test;
+import org.rnorth.ducttape.TimeoutException;
+import org.rnorth.ducttape.unreliables.Unreliables;
+import org.testcontainers.containers.CassandraContainer;
+import org.testcontainers.containers.ContainerLaunchException;
+import org.testcontainers.containers.wait.strategy.AbstractWaitStrategy;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import org.springframework.boot.actuate.autoconfigure.metrics.test.MetricsRun;
+import org.springframework.boot.autoconfigure.AutoConfigurations;
+import org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration;
+import org.springframework.boot.autoconfigure.cassandra.DriverConfigLoaderBuilderCustomizer;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Tests for {@link CassandraMetricsAutoConfiguration}.
+ *
+ * @author Erik Merkle
+ */
+@Testcontainers(disabledWithoutDocker = true)
+public class CassandraMetricsAutoConfigurationIntegrationTests {
+
+	@Container
+	static final CassandraContainer<?> cassandra = new CassandraContainer<>().withStartupAttempts(5)
+			.withStartupTimeout(Duration.ofMinutes(10)).waitingFor(new CassandraWaitStrategy());
+
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner().with(MetricsRun.simple())
+			.withConfiguration(
+					AutoConfigurations.of(CassandraMetricsAutoConfiguration.class, CassandraAutoConfiguration.class))
+			.withPropertyValues(
+					"spring.data.cassandra.contact-points:" + cassandra.getHost() + ":"
+							+ cassandra.getFirstMappedPort(),
+					"spring.data.cassandra.local-datacenter=datacenter1", "spring.data.cassandra.read-timeout=20s",
+					"spring.data.cassandra.connect-timeout=10s");
+
+	/**
+	 * Cassandra driver metrics should be enabled by default as long as the desired
+	 * metrics are enabled in the Driver's configuration.
+	 */
+	@Test
+	void autoConfiguredCassandraIsInstrumented() {
+		this.contextRunner.withUserConfiguration(SimpleDriverConfigLoaderBuilderMetricsConfig.class).run((context) -> {
+			CqlSessionBuilder builder = context.getBean(CqlSessionBuilder.class);
+			assertThat(builder).isInstanceOf(CassandraMetricsPostProcessor.MetricsSessionBuilder.class);
+			MeterRegistry registry = context.getBean(MeterRegistry.class);
+			// execute queries to peg metrics
+			CqlSession session = context.getBean(CqlSession.class);
+			SimpleStatement statement = SimpleStatement.newInstance("SELECT release_version FROM system.local")
+					.setConsistencyLevel(ConsistencyLevel.LOCAL_ONE);
+			for (int i = 0; i < 10; ++i) {
+				assertThat(session.execute(statement).one()).isNotNull();
+			}
+			// assert Session metrics
+			String sessionMetricPrefix = session.getContext().getSessionName() + ".";
+			assertThat(
+					registry.get(sessionMetricPrefix + DefaultSessionMetric.CONNECTED_NODES.getPath()).gauge().value())
+							.isEqualTo(1d);
+			assertThat(registry.get(sessionMetricPrefix + DefaultSessionMetric.CQL_REQUESTS.getPath()).timer().count())
+					.isEqualTo(10L);
+			assertThat(registry.get(sessionMetricPrefix + DefaultSessionMetric.BYTES_SENT.getPath()).counter().count())
+					.isGreaterThan(1d);
+			assertThat(
+					registry.get(sessionMetricPrefix + DefaultSessionMetric.BYTES_RECEIVED.getPath()).counter().count())
+							.isGreaterThan(1d);
+			// assert Node metrics
+			String nodeMetricPrefix = sessionMetricPrefix + "nodes." + cassandra.getHost() + ":"
+					+ cassandra.getMappedPort(9042) + ".";
+			assertThat(registry.get(nodeMetricPrefix + DefaultNodeMetric.BYTES_SENT.getPath()).counter().count())
+					.isGreaterThan(1d);
+
+		});
+	}
+
+	@Configuration(proxyBeanMethods = false)
+	static class SimpleDriverConfigLoaderBuilderMetricsConfig {
+
+		@Bean
+		DriverConfigLoaderBuilderCustomizer customizer() {
+			return (builder) -> builder
+					.withStringList(DefaultDriverOption.METRICS_SESSION_ENABLED, Arrays.asList(
+							DefaultSessionMetric.CONNECTED_NODES.getPath(), DefaultSessionMetric.CQL_REQUESTS.getPath(),
+							DefaultSessionMetric.BYTES_SENT.getPath(), DefaultSessionMetric.BYTES_RECEIVED.getPath()))
+					.withStringList(DefaultDriverOption.METRICS_NODE_ENABLED,
+							Arrays.asList(DefaultNodeMetric.BYTES_SENT.getPath()));
+		}
+
+	}
+
+	static final class CassandraWaitStrategy extends AbstractWaitStrategy {
+
+		@Override
+		protected void waitUntilReady() {
+			try {
+				Unreliables.retryUntilSuccess((int) this.startupTimeout.getSeconds(), TimeUnit.SECONDS, () -> {
+					getRateLimiter().doWhenReady(() -> cqlSessionBuilder().build());
+					return true;
+				});
+			}
+			catch (TimeoutException ex) {
+				throw new ContainerLaunchException(
+						"Timed out waiting for Cassandra to be accessible for query execution");
+			}
+		}
+
+		private CqlSessionBuilder cqlSessionBuilder() {
+			return CqlSession.builder()
+					.addContactPoint(new InetSocketAddress(this.waitStrategyTarget.getHost(),
+							this.waitStrategyTarget.getFirstMappedPort()))
+					.withLocalDatacenter("datacenter1").withAuthCredentials("cassandra", "cassandra");
+		}
+
+	}
+
+}