Add property to disable the OpenTelemetry SDK

This uses no-op implementations for the SdkTracerProvider,
SdkLoggerProvider and SdkMeterProvider, but still configures the
propagators.

Additionally, it doesn't create the tracing and logging beans which
would be superfluous for a disabled SDK.

Closes gh-49564

Author: mhalbritter

documentation/spring-boot-docs/src/docs/antora/modules/reference/pages/actuator/observability.adoc

@@ -125,6 +125,17 @@ Exporting OpenTelemetry traces is only auto-configured when used together with x
 
 
 
+[[actuator.observability.opentelemetry.disabling]]
+=== Disabling OpenTelemetry
+
+The OpenTelemetry support can be disabled by setting the configprop:management.opentelemetry.enabled[] property to `false`.
+This behaves similarly to the https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/#general-sdk-configuration[`OTEL_SDK_DISABLED`] environment variable (but negated): when the SDK is disabled, metrics, traces, and logging will use no-op implementations.
+Context propagators are not affected and continue to function normally.
+
+NOTE: Keep in mind that Spring Boot doesn't use OpenTelemetry's metrics functionality, so metrics might still be enabled even when disabling OpenTelemetry.
+
+
+
 [[actuator.observability.opentelemetry.environment-variables]]
 === Environment variables
 

module/spring-boot-micrometer-tracing-opentelemetry/src/main/java/org/springframework/boot/micrometer/tracing/opentelemetry/autoconfigure/OpenTelemetryTracingAutoConfiguration.java

@@ -64,6 +64,7 @@
 import org.springframework.boot.micrometer.tracing.opentelemetry.autoconfigure.OpenTelemetryPropagationConfigurations.PropagationWithoutBaggage;
 import org.springframework.boot.micrometer.tracing.opentelemetry.autoconfigure.OpenTelemetryTracingProperties.Export;
 import org.springframework.boot.micrometer.tracing.opentelemetry.autoconfigure.OpenTelemetryTracingProperties.Limits;
+import org.springframework.boot.opentelemetry.autoconfigure.ConditionalOnEnabledOpenTelemetry;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Import;
 import org.springframework.util.CollectionUtils;
@@ -99,6 +100,7 @@ public final class OpenTelemetryTracingAutoConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
+	@ConditionalOnEnabledOpenTelemetry
 	SdkTracerProvider otelSdkTracerProvider(Resource resource, SpanProcessors spanProcessors, Sampler sampler,
 			ObjectProvider<SdkTracerProviderBuilderCustomizer> customizers, SpanLimits spanLimits) {
 		SdkTracerProviderBuilder builder = SdkTracerProvider.builder()
@@ -112,6 +114,7 @@ SdkTracerProvider otelSdkTracerProvider(Resource resource, SpanProcessors spanPr
 
 	@Bean
 	@ConditionalOnMissingBean
+	@ConditionalOnEnabledOpenTelemetry
 	SpanLimits otelSpanLimits() {
 		Limits limits = this.openTelemetryTracingProperties.getLimits();
 		return SpanLimits.builder()
@@ -132,6 +135,7 @@ ContextPropagators otelContextPropagators(ObjectProvider<TextMapPropagator> text
 
 	@Bean
 	@ConditionalOnMissingBean
+	@ConditionalOnEnabledOpenTelemetry
 	Sampler otelSampler() {
 		return switch (this.openTelemetryTracingProperties.getSampler()) {
 			case ALWAYS_ON -> Sampler.alwaysOn();
@@ -146,12 +150,14 @@ Sampler otelSampler() {
 
 	@Bean
 	@ConditionalOnMissingBean
+	@ConditionalOnEnabledOpenTelemetry
 	SpanProcessors spanProcessors(ObjectProvider<SpanProcessor> spanProcessors) {
 		return SpanProcessors.of(spanProcessors.orderedStream().toList());
 	}
 
 	@Bean
 	@ConditionalOnMissingBean
+	@ConditionalOnEnabledOpenTelemetry
 	BatchSpanProcessor otelSpanProcessor(SpanExporters spanExporters,
 			ObjectProvider<SpanExportingPredicate> spanExportingPredicates, ObjectProvider<SpanReporter> spanReporters,
 			ObjectProvider<SpanFilter> spanFilters, ObjectProvider<MeterProvider> meterProvider) {
@@ -171,6 +177,7 @@ BatchSpanProcessor otelSpanProcessor(SpanExporters spanExporters,
 
 	@Bean
 	@ConditionalOnMissingBean
+	@ConditionalOnEnabledOpenTelemetry
 	SpanExporters spanExporters(ObjectProvider<SpanExporter> spanExporters) {
 		return SpanExporters.of(spanExporters.orderedStream().toList());
 	}

module/spring-boot-micrometer-tracing-opentelemetry/src/test/java/org/springframework/boot/micrometer/tracing/opentelemetry/autoconfigure/OpenTelemetryTracingAutoConfigurationTests.java

@@ -485,6 +485,31 @@ void batchSpanProcessorShouldBeConfiguredWithDefaultProperties() {
 		});
 	}
 
+	@Test
+	void whenOpenTelemetryIsDisabledDoesNotProvideTracingSignalBeans() {
+		this.contextRunner.withPropertyValues("management.opentelemetry.enabled=false").run((context) -> {
+			assertThat(context).doesNotHaveBean(SdkTracerProvider.class);
+			assertThat(context).doesNotHaveBean(SpanLimits.class);
+			assertThat(context).doesNotHaveBean(Sampler.class);
+			assertThat(context).doesNotHaveBean(SpanProcessors.class);
+			assertThat(context).doesNotHaveBean(SpanExporters.class);
+			assertThat(context).doesNotHaveBean(BatchSpanProcessor.class);
+		});
+	}
+
+	@Test
+	void whenOpenTelemetryIsDisabledStillProvidesBridgeAndPropagationBeans() {
+		this.contextRunner.withPropertyValues("management.opentelemetry.enabled=false").run((context) -> {
+			assertThat(context).hasSingleBean(OtelTracer.class);
+			assertThat(context).hasSingleBean(OtelPropagator.class);
+			assertThat(context).hasSingleBean(OtelCurrentTraceContext.class);
+			assertThat(context).hasSingleBean(Slf4JEventListener.class);
+			assertThat(context).hasSingleBean(OtelSpanCustomizer.class);
+			assertThat(context).hasSingleBean(ContextPropagators.class);
+			assertThat(context).hasSingleBean(TextMapPropagator.class);
+		});
+	}
+
 	@Test // gh-41439
 	@ForkedClassPath
 	void shouldPublishEventsWhenContextStorageIsInitializedEarly() {

module/spring-boot-opentelemetry/src/main/java/org/springframework/boot/opentelemetry/autoconfigure/ConditionalOnEnabledOpenTelemetry.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2012-present 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.opentelemetry.autoconfigure;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnBooleanProperty;
+import org.springframework.context.annotation.Conditional;
+
+/**
+ * {@link Conditional @Conditional} that checks whether OpenTelemetry is enabled. It
+ * matches if the value of the {@code management.opentelemetry.enabled} property is
+ * {@code true} or if it is not configured.
+ *
+ * @author Moritz Halbritter
+ * @since 4.1.0
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ ElementType.TYPE, ElementType.METHOD })
+@Documented
+@ConditionalOnBooleanProperty(name = "management.opentelemetry.enabled", matchIfMissing = true)
+public @interface ConditionalOnEnabledOpenTelemetry {
+
+}

module/spring-boot-opentelemetry/src/main/java/org/springframework/boot/opentelemetry/autoconfigure/OpenTelemetryProperties.java

@@ -30,11 +30,26 @@
 @ConfigurationProperties("management.opentelemetry")
 public class OpenTelemetryProperties {
 
+	/**
+	 * Whether OpenTelemetry should be enabled. If OpenTelemetry is disabled, only
+	 * propagators are configured. Metrics, traces, and logging will use no-op
+	 * implementations.
+	 */
+	private boolean enabled = true;
+
 	/**
 	 * Resource attributes.
 	 */
 	private Map<String, String> resourceAttributes = new HashMap<>();
 
+	public boolean isEnabled() {
+		return this.enabled;
+	}
+
+	public void setEnabled(boolean enabled) {
+		this.enabled = enabled;
+	}
+
 	public Map<String, String> getResourceAttributes() {
 		return this.resourceAttributes;
 	}

module/spring-boot-opentelemetry/src/main/java/org/springframework/boot/opentelemetry/autoconfigure/OpenTelemetrySdkAutoConfiguration.java

@@ -31,8 +31,10 @@
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.NoneNestedConditions;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Conditional;
 import org.springframework.core.env.Environment;
 
 /**
@@ -51,6 +53,7 @@ public final class OpenTelemetrySdkAutoConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean(OpenTelemetry.class)
+	@ConditionalOnEnabledOpenTelemetry
 	OpenTelemetrySdk openTelemetrySdk(ObjectProvider<SdkTracerProvider> openTelemetrySdkTracerProvider,
 			ObjectProvider<ContextPropagators> openTelemetryContextPropagators,
 			ObjectProvider<SdkLoggerProvider> openTelemetrySdkLoggerProvider,
@@ -63,6 +66,15 @@ OpenTelemetrySdk openTelemetrySdk(ObjectProvider<SdkTracerProvider> openTelemetr
 		return builder.build();
 	}
 
+	@Bean
+	@ConditionalOnMissingBean(OpenTelemetry.class)
+	@Conditional(OnDisabledOpenTelemetryCondition.class)
+	OpenTelemetrySdk disabledOpenTelemetrySdk(ObjectProvider<ContextPropagators> openTelemetryContextPropagators) {
+		OpenTelemetrySdkBuilder builder = OpenTelemetrySdk.builder();
+		openTelemetryContextPropagators.ifAvailable(builder::setPropagators);
+		return builder.build();
+	}
+
 	@Bean
 	@ConditionalOnMissingBean
 	Resource openTelemetryResource(Environment environment, OpenTelemetryProperties properties) {
@@ -75,4 +87,17 @@ private Resource toResource(Environment environment, OpenTelemetryProperties pro
 		return builder.build();
 	}
 
+	static class OnDisabledOpenTelemetryCondition extends NoneNestedConditions {
+
+		OnDisabledOpenTelemetryCondition() {
+			super(ConfigurationPhase.PARSE_CONFIGURATION);
+		}
+
+		@ConditionalOnEnabledOpenTelemetry
+		static class EnabledCondition {
+
+		}
+
+	}
+
 }

module/spring-boot-opentelemetry/src/main/java/org/springframework/boot/opentelemetry/autoconfigure/logging/OpenTelemetryLoggingAutoConfiguration.java

@@ -31,6 +31,7 @@
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.boot.opentelemetry.autoconfigure.ConditionalOnEnabledOpenTelemetry;
 import org.springframework.boot.opentelemetry.autoconfigure.OpenTelemetrySdkAutoConfiguration;
 import org.springframework.boot.opentelemetry.autoconfigure.logging.OpenTelemetryLoggingProperties.Export;
 import org.springframework.boot.opentelemetry.autoconfigure.logging.OpenTelemetryLoggingProperties.Limits;
@@ -44,6 +45,7 @@
  */
 @AutoConfiguration(after = OpenTelemetrySdkAutoConfiguration.class)
 @ConditionalOnClass(SdkLoggerProvider.class)
+@ConditionalOnEnabledOpenTelemetry
 @EnableConfigurationProperties(OpenTelemetryLoggingProperties.class)
 public final class OpenTelemetryLoggingAutoConfiguration {
 

module/spring-boot-opentelemetry/src/test/java/org/springframework/boot/opentelemetry/autoconfigure/OpenTelemetrySdkAutoConfigurationTests.java

@@ -180,6 +180,57 @@ void whenHasSdkMeterProviderProvidesMeterProvider() {
 		});
 	}
 
+	@Test
+	void whenOpenTelemetryIsDisabledStillProvidesOpenTelemetrySdk() {
+		this.contextRunner.withPropertyValues("management.opentelemetry.enabled=false").run((context) -> {
+			assertThat(context).hasSingleBean(OpenTelemetrySdk.class);
+			assertThat(context).hasBean("disabledOpenTelemetrySdk");
+		});
+	}
+
+	@Test
+	void whenOpenTelemetryIsDisabledStillConfiguresPropagators() {
+		this.contextRunner.withPropertyValues("management.opentelemetry.enabled=false")
+			.withBean(ContextPropagators.class, ContextPropagators::noop)
+			.run((context) -> {
+				OpenTelemetry openTelemetry = context.getBean(OpenTelemetry.class);
+				assertThat(openTelemetry.getPropagators()).isNotNull();
+			});
+	}
+
+	@Test
+	void whenOpenTelemetryIsDisabledDoesNotUseTracerProvider() {
+		SdkTracerProvider tracerProvider = SdkTracerProvider.builder().build();
+		this.contextRunner.withPropertyValues("management.opentelemetry.enabled=false")
+			.withBean(SdkTracerProvider.class, () -> tracerProvider)
+			.run((context) -> {
+				OpenTelemetrySdk openTelemetry = context.getBean(OpenTelemetrySdk.class);
+				assertThat(openTelemetry.getSdkTracerProvider()).isNotSameAs(tracerProvider);
+			});
+	}
+
+	@Test
+	void whenOpenTelemetryIsDisabledDoesNotUseLoggerProvider() {
+		SdkLoggerProvider loggerProvider = SdkLoggerProvider.builder().build();
+		this.contextRunner.withPropertyValues("management.opentelemetry.enabled=false")
+			.withBean(SdkLoggerProvider.class, () -> loggerProvider)
+			.run((context) -> {
+				OpenTelemetrySdk openTelemetry = context.getBean(OpenTelemetrySdk.class);
+				assertThat(openTelemetry.getSdkLoggerProvider()).isNotSameAs(loggerProvider);
+			});
+	}
+
+	@Test
+	void whenOpenTelemetryIsDisabledDoesNotUseMeterProvider() {
+		SdkMeterProvider meterProvider = SdkMeterProvider.builder().build();
+		this.contextRunner.withPropertyValues("management.opentelemetry.enabled=false")
+			.withBean(SdkMeterProvider.class, () -> meterProvider)
+			.run((context) -> {
+				OpenTelemetrySdk openTelemetry = context.getBean(OpenTelemetrySdk.class);
+				assertThat(openTelemetry.getSdkMeterProvider()).isNotSameAs(meterProvider);
+			});
+	}
+
 	@Configuration(proxyBeanMethods = false)
 	static class UserConfiguration {
 

module/spring-boot-opentelemetry/src/test/java/org/springframework/boot/opentelemetry/autoconfigure/logging/OpenTelemetryLoggingAutoConfigurationTests.java

@@ -70,6 +70,15 @@ void providesBeans() {
 		});
 	}
 
+	@Test
+	void whenOpenTelemetryIsDisabledDoesNotProvideBeans() {
+		this.contextRunner.withPropertyValues("management.opentelemetry.enabled=false").run((context) -> {
+			assertThat(context).doesNotHaveBean(BatchLogRecordProcessor.class);
+			assertThat(context).doesNotHaveBean(SdkLoggerProvider.class);
+			assertThat(context).doesNotHaveBean(LogLimits.class);
+		});
+	}
+
 	@Test
 	void whenOpenTelemetryLogsIsNotOnClasspathDoesNotProvideBeans() {
 		this.contextRunner.withClassLoader(new FilteredClassLoader("io.opentelemetry.sdk.logs")).run((context) -> {