Added batchspanprocessor support; fixes gh-51

Author: marcingrzejszczak

docs/src/main/asciidoc/_configprops.adoc

@@ -18,6 +18,10 @@
 |spring.sleuth.otel.log.exporter.enabled | `false` | Enable log exporter for OTel.
 |spring.sleuth.otel.log.slf4j.enabled | `false` | Enable slf4j support for OTel.
 |spring.sleuth.otel.multiple-tracer-configs-detector-enabled | `true` | Enable detection of autoconfiguration for multiple tracers (i.e.: Brave and OTel); only one of them should be used.
+|spring.sleuth.otel.processor.batch.exporter-timeout |  | Exporter timeout in millis.
+|spring.sleuth.otel.processor.batch.max-export-batch-size |  | Max export batch size.
+|spring.sleuth.otel.processor.batch.max-queue-size |  | Max queue size.
+|spring.sleuth.otel.processor.batch.schedule-delay |  | Schedule delay in millis.
 |spring.sleuth.otel.propagation.composite-text-map-propagator.enabled | `true` | Enable a composite text map propagator that can combine multiple propagation types into a single text map propagator.
 |spring.sleuth.otel.propagation.sleuth-baggage.enabled | `true` | Enable propagating baggage in a Sleuth compatible way (baggage key & value pair means e.g. a key & value HTTP pair).
 |spring.sleuth.otel.resource.enabled | `true` | Enables default {@link Resource} implementations.

spring-cloud-sleuth-otel-autoconfigure/src/main/java/org/springframework/cloud/sleuth/autoconfig/otel/OtelAutoConfiguration.java

@@ -18,6 +18,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
@@ -32,6 +33,8 @@
 import io.opentelemetry.sdk.trace.SdkTracerProviderBuilder;
 import io.opentelemetry.sdk.trace.SpanLimits;
 import io.opentelemetry.sdk.trace.SpanProcessor;
+import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
+import io.opentelemetry.sdk.trace.export.BatchSpanProcessorBuilder;
 import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
 import io.opentelemetry.sdk.trace.export.SpanExporter;
 import io.opentelemetry.sdk.trace.samplers.Sampler;
@@ -41,6 +44,7 @@
 import org.springframework.boot.autoconfigure.AutoConfigureBefore;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.sleuth.autoconfig.SleuthAnnotationConfiguration;
@@ -70,7 +74,7 @@
 @ConditionalOnProperty(value = "spring.sleuth.enabled", matchIfMissing = true)
 @ConditionalOnMissingBean(org.springframework.cloud.sleuth.Tracer.class)
 @EnableConfigurationProperties({ OtelProperties.class, SleuthSpanFilterProperties.class, SleuthBaggageProperties.class,
-		SleuthTracerProperties.class })
+		SleuthTracerProperties.class, OtelProcessorProperties.class })
 @Import({ OtelBridgeConfiguration.class, OtelPropagationConfiguration.class, TraceConfiguration.class,
 		SleuthAnnotationConfiguration.class, OtelResourceConfiguration.class })
 @AutoConfigureBefore(BraveAutoConfiguration.class)
@@ -86,17 +90,56 @@ OpenTelemetry otel(SdkTracerProvider tracerProvider, ContextPropagators contextP
 	@ConditionalOnMissingBean
 	SdkTracerProvider otelTracerProvider(SpanLimits spanLimits, ObjectProvider<List<SpanProcessor>> spanProcessors,
 			SpanExporterCustomizer spanExporterCustomizer, ObjectProvider<List<SpanExporter>> spanExporters,
-			Sampler sampler, Resource resource) {
+			Sampler sampler, Resource resource, SpanProcessorProvider spanProcessorProvider) {
 		SdkTracerProviderBuilder sdkTracerProviderBuilder = SdkTracerProvider.builder().setResource(resource)
 				.setSampler(sampler).setSpanLimits(spanLimits);
 		List<SpanProcessor> processors = spanProcessors.getIfAvailable(ArrayList::new);
 		processors.addAll(spanExporters.getIfAvailable(ArrayList::new).stream()
-				.map(e -> SimpleSpanProcessor.create(spanExporterCustomizer.customize(e)))
+				.map(e -> spanProcessorProvider.toSpanProcessor(spanExporterCustomizer.customize(e)))
 				.collect(Collectors.toList()));
 		processors.forEach(sdkTracerProviderBuilder::addSpanProcessor);
 		return sdkTracerProviderBuilder.build();
 	}
 
+	@Bean
+	@ConditionalOnClass(name = "io.opentelemetry.api.metrics.GlobalMeterProvider")
+	@ConditionalOnMissingBean
+	SpanProcessorProvider otelBatchSpanProcessorProvider(OtelProcessorProperties otelProcessorProperties) {
+		return new SpanProcessorProvider() {
+			@Override
+			public SpanProcessor toSpanProcessor(SpanExporter spanExporter) {
+				BatchSpanProcessorBuilder builder = BatchSpanProcessor.builder(spanExporter);
+				setBuilderProperties(otelProcessorProperties, builder);
+				return builder.build();
+			}
+
+			private void setBuilderProperties(OtelProcessorProperties otelProcessorProperties,
+					BatchSpanProcessorBuilder builder) {
+				if (otelProcessorProperties.getBatch().getExporterTimeout() != null) {
+					builder.setExporterTimeout(otelProcessorProperties.getBatch().getExporterTimeout(),
+							TimeUnit.MILLISECONDS);
+				}
+				if (otelProcessorProperties.getBatch().getMaxExportBatchSize() != null) {
+					builder.setMaxExportBatchSize(otelProcessorProperties.getBatch().getMaxExportBatchSize());
+				}
+				if (otelProcessorProperties.getBatch().getMaxQueueSize() != null) {
+					builder.setMaxQueueSize(otelProcessorProperties.getBatch().getMaxQueueSize());
+				}
+				if (otelProcessorProperties.getBatch().getScheduleDelay() != null) {
+					builder.setScheduleDelay(otelProcessorProperties.getBatch().getScheduleDelay(),
+							TimeUnit.MILLISECONDS);
+				}
+			}
+		};
+	}
+
+	@Bean
+	@ConditionalOnMissingClass("io.opentelemetry.api.metrics.GlobalMeterProvider")
+	@ConditionalOnMissingBean
+	SpanProcessorProvider otelSimpleSpanProcessorProvider() {
+		return SimpleSpanProcessor::create;
+	}
+
 	@Bean
 	@ConditionalOnMissingBean
 	Resource otelResource(Environment env, ObjectProvider<List<Supplier<Resource>>> resourceProviders) {

spring-cloud-sleuth-otel-autoconfigure/src/main/java/org/springframework/cloud/sleuth/autoconfig/otel/OtelProcessorProperties.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2013-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.cloud.sleuth.autoconfig.otel;
+
+import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * OpenTelemetry span process properties.
+ *
+ * @author Marcin Grzejszczak
+ * @since 1.0.0
+ */
+@ConfigurationProperties("spring.sleuth.otel.processor")
+public class OtelProcessorProperties {
+
+	private Batch batch = new Batch();
+
+	public Batch getBatch() {
+		return this.batch;
+	}
+
+	public void setBatch(Batch batch) {
+		this.batch = batch;
+	}
+
+	/**
+	 * Configuration of the {@link BatchSpanProcessor}.
+	 */
+	public static class Batch {
+
+		/**
+		 * Schedule delay in millis.
+		 */
+		private Long scheduleDelay;
+
+		/**
+		 * Max queue size.
+		 */
+		private Integer maxQueueSize;
+
+		/**
+		 * Max export batch size.
+		 */
+		private Integer maxExportBatchSize;
+
+		/**
+		 * Exporter timeout in millis.
+		 */
+		private Long exporterTimeout;
+
+		public Long getScheduleDelay() {
+			return scheduleDelay;
+		}
+
+		public void setScheduleDelay(long scheduleDelay) {
+			this.scheduleDelay = scheduleDelay;
+		}
+
+		public Integer getMaxQueueSize() {
+			return maxQueueSize;
+		}
+
+		public void setMaxQueueSize(int maxQueueSize) {
+			this.maxQueueSize = maxQueueSize;
+		}
+
+		public Integer getMaxExportBatchSize() {
+			return maxExportBatchSize;
+		}
+
+		public void setMaxExportBatchSize(int maxExportBatchSize) {
+			this.maxExportBatchSize = maxExportBatchSize;
+		}
+
+		public Long getExporterTimeout() {
+			return exporterTimeout;
+		}
+
+		public void setExporterTimeout(long exporterTimeout) {
+			this.exporterTimeout = exporterTimeout;
+		}
+
+	}
+
+}

spring-cloud-sleuth-otel-autoconfigure/src/main/java/org/springframework/cloud/sleuth/autoconfig/otel/SpanProcessorProvider.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2013-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.cloud.sleuth.autoconfig.otel;
+
+import io.opentelemetry.sdk.trace.SpanProcessor;
+import io.opentelemetry.sdk.trace.export.SpanExporter;
+
+/**
+ * Converts {@link SpanExporter} to {@link SpanProcessor}.
+ *
+ * @author Marcin Grzejszczak
+ * @since 1.0.0
+ */
+public interface SpanProcessorProvider {
+
+	/**
+	 * @param spanExporter span exporter
+	 * @return converted span processor
+	 */
+	SpanProcessor toSpanProcessor(SpanExporter spanExporter);
+
+}