This is an automated email from the ASF dual-hosted git repository.
albumenj pushed a commit to branch 3.2
in repository https://gitbox.apache.org/repos/asf/dubbo.git
The following commit(s) were added to refs/heads/3.2 by this push:
new 2324db0805 :bug:Compatible with old and new versions of micrometer
(#11922)
2324db0805 is described below
commit 2324db0805c78e684e50e542396fa04104769527
Author: songxiaosheng <[email protected]>
AuthorDate: Fri Apr 7 21:19:02 2023 +0800
:bug:Compatible with old and new versions of micrometer (#11922)
* :bug:Compatible with old and new versions of micrometer
* :bug:Compatible with old and new versions of micrometer
* :bug:Compatible with old and new versions of micrometer
* :wrench: support micrometer low version
* :wrench: support micrometer low version
* :twisted_rightwards_arrows: merge observabilit code
* :pencil2: request metrics type to counter
* 🐛Compatible with old and new versions of micrometer
* 🐛Compatible with old and new versions of micrometer
* :white_check_mark: fix metrics sample test
* :sparkles: add metrics description
---------
Co-authored-by: Albumen Kevin <[email protected]>
---
.../cluster/filter/MetricsClusterFilterTest.java | 3 +-
.../collector/sample/MethodMetricsSampler.java | 59 +++++----
.../dubbo/metrics/filter/MetricsFilterTest.java | 12 +-
.../collector/DefaultMetricsCollectorTest.java | 24 +++-
.../DubboMicrometerTracingAutoConfiguration.java | 33 ++---
.../DubboObservationAutoConfiguration.java | 64 +++++----
.../brave/BraveAutoConfiguration.java | 143 ++++++++-------------
.../otel/OpenTelemetryAutoConfiguration.java | 143 ++++++++-------------
8 files changed, 228 insertions(+), 253 deletions(-)
diff --git
a/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/filter/MetricsClusterFilterTest.java
b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/filter/MetricsClusterFilterTest.java
index fb8e46ed06..604e60b8a0 100644
---
a/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/filter/MetricsClusterFilterTest.java
+++
b/dubbo-cluster/src/test/java/org/apache/dubbo/rpc/cluster/filter/MetricsClusterFilterTest.java
@@ -23,6 +23,7 @@ import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.metrics.collector.DefaultMetricsCollector;
import org.apache.dubbo.metrics.filter.MetricsFilter;
import org.apache.dubbo.metrics.model.MetricsKey;
+import org.apache.dubbo.metrics.model.sample.CounterMetricSample;
import org.apache.dubbo.metrics.model.sample.GaugeMetricSample;
import org.apache.dubbo.metrics.model.sample.MetricSample;
import org.apache.dubbo.rpc.Invocation;
@@ -123,7 +124,7 @@ class MetricsClusterFilterTest {
MetricSample sample = metricsMap.get(name);
- Assertions.assertSame(((GaugeMetricSample) sample).applyAsLong(),
count);
+ Assertions.assertSame(((CounterMetricSample)
sample).getValue().longValue(), count);
teardown();
}
diff --git
a/dubbo-metrics/dubbo-metrics-default/src/main/java/org/apache/dubbo/metrics/collector/sample/MethodMetricsSampler.java
b/dubbo-metrics/dubbo-metrics-default/src/main/java/org/apache/dubbo/metrics/collector/sample/MethodMetricsSampler.java
index 6858410995..b6adaf606e 100644
---
a/dubbo-metrics/dubbo-metrics-default/src/main/java/org/apache/dubbo/metrics/collector/sample/MethodMetricsSampler.java
+++
b/dubbo-metrics/dubbo-metrics-default/src/main/java/org/apache/dubbo/metrics/collector/sample/MethodMetricsSampler.java
@@ -25,6 +25,7 @@ import org.apache.dubbo.metrics.model.MethodMetric;
import org.apache.dubbo.metrics.model.Metric;
import org.apache.dubbo.metrics.model.MetricsCategory;
import org.apache.dubbo.metrics.model.MetricsKey;
+import org.apache.dubbo.metrics.model.sample.CounterMetricSample;
import org.apache.dubbo.metrics.model.sample.GaugeMetricSample;
import org.apache.dubbo.metrics.model.sample.MetricSample;
import org.apache.dubbo.rpc.Invocation;
@@ -36,8 +37,6 @@ import java.util.function.ToDoubleFunction;
import static org.apache.dubbo.common.constants.CommonConstants.CONSUMER_SIDE;
import static org.apache.dubbo.common.constants.CommonConstants.PROVIDER_SIDE;
-import static org.apache.dubbo.metrics.model.MetricsCategory.REQUESTS;
-import static org.apache.dubbo.metrics.model.MetricsCategory.RT;
public class MethodMetricsSampler extends
SimpleMetricsCountSampler<Invocation, String, MethodMetric> {
@@ -59,7 +58,7 @@ public class MethodMetricsSampler extends
SimpleMetricsCountSampler<Invocation,
public void rtConfigure(
MetricsCountSampleConfigurer<Invocation, String, MethodMetric>
sampleConfigure) {
sampleConfigure.configureMetrics(configure -> new
MethodMetric(collector.getApplicationName(), configure.getSource()));
- sampleConfigure.configureEventHandler(configure ->
collector.getEventMulticaster().publishEvent( new
RTEvent(collector.getApplicationModel(),configure.getMetric(),
configure.getRt())));
+ sampleConfigure.configureEventHandler(configure ->
collector.getEventMulticaster().publishEvent(new
RTEvent(collector.getApplicationModel(), configure.getMetric(),
configure.getRt())));
}
@Override
@@ -71,7 +70,7 @@ public class MethodMetricsSampler extends
SimpleMetricsCountSampler<Invocation,
this.collectRT(new MetricSampleFactory<MethodMetric,
GaugeMetricSample<?>>() {
@Override
public <T> GaugeMetricSample<?> newInstance(MetricsKey key,
MethodMetric metric, T value, ToDoubleFunction<T> apply) {
- return getGaugeMetricSample(key, metric, RT, value, apply);
+ return createGaugeMetricSample(key, metric,
MetricsCategory.RT, value, apply);
}
}));
@@ -84,25 +83,25 @@ public class MethodMetricsSampler extends
SimpleMetricsCountSampler<Invocation,
}
private void collectBySide(List<MetricSample> list, String side) {
- count(list, MetricsEvent.Type.TOTAL.getNameByType(side),
MetricsKey.METRIC_REQUESTS);
- count(list, MetricsEvent.Type.SUCCEED.getNameByType(side),
MetricsKey.METRIC_REQUESTS_SUCCEED);
- count(list, MetricsEvent.Type.UNKNOWN_FAILED.getNameByType(side),
MetricsKey.METRIC_REQUESTS_FAILED);
- count(list, MetricsEvent.Type.PROCESSING.getNameByType(side),
MetricsKey.METRIC_REQUESTS_PROCESSING);
- count(list, MetricsEvent.Type.BUSINESS_FAILED.getNameByType(side),
MetricsKey.METRIC_REQUEST_BUSINESS_FAILED);
- count(list, MetricsEvent.Type.REQUEST_TIMEOUT.getNameByType(side),
MetricsKey.METRIC_REQUESTS_TIMEOUT);
- count(list, MetricsEvent.Type.REQUEST_LIMIT.getNameByType(side),
MetricsKey.METRIC_REQUESTS_LIMIT);
- count(list, MetricsEvent.Type.TOTAL_FAILED.getNameByType(side),
MetricsKey.METRIC_REQUESTS_TOTAL_FAILED);
- count(list, MetricsEvent.Type.NETWORK_EXCEPTION.getNameByType(side),
MetricsKey.METRIC_REQUESTS_NETWORK_FAILED);
- count(list, MetricsEvent.Type.SERVICE_UNAVAILABLE.getNameByType(side),
MetricsKey.METRIC_REQUESTS_SERVICE_UNAVAILABLE_FAILED);
- count(list, MetricsEvent.Type.CODEC_EXCEPTION.getNameByType(side),
MetricsKey.METRIC_REQUESTS_CODEC_FAILED);
+ count(list, MetricsEvent.Type.TOTAL.getNameByType(side),
MetricSample.Type.COUNTER, MetricsKey.METRIC_REQUESTS);
+ count(list, MetricsEvent.Type.SUCCEED.getNameByType(side),
MetricSample.Type.COUNTER, MetricsKey.METRIC_REQUESTS_SUCCEED);
+ count(list, MetricsEvent.Type.UNKNOWN_FAILED.getNameByType(side),
MetricSample.Type.COUNTER, MetricsKey.METRIC_REQUESTS_FAILED);
+ count(list, MetricsEvent.Type.PROCESSING.getNameByType(side),
MetricSample.Type.GAUGE, MetricsKey.METRIC_REQUESTS_PROCESSING);
+ count(list, MetricsEvent.Type.BUSINESS_FAILED.getNameByType(side),
MetricSample.Type.COUNTER, MetricsKey.METRIC_REQUEST_BUSINESS_FAILED);
+ count(list, MetricsEvent.Type.REQUEST_TIMEOUT.getNameByType(side),
MetricSample.Type.COUNTER, MetricsKey.METRIC_REQUESTS_TIMEOUT);
+ count(list, MetricsEvent.Type.REQUEST_LIMIT.getNameByType(side),
MetricSample.Type.COUNTER, MetricsKey.METRIC_REQUESTS_LIMIT);
+ count(list, MetricsEvent.Type.TOTAL_FAILED.getNameByType(side),
MetricSample.Type.COUNTER, MetricsKey.METRIC_REQUESTS_TOTAL_FAILED);
+ count(list, MetricsEvent.Type.NETWORK_EXCEPTION.getNameByType(side),
MetricSample.Type.COUNTER, MetricsKey.METRIC_REQUESTS_NETWORK_FAILED);
+ count(list, MetricsEvent.Type.SERVICE_UNAVAILABLE.getNameByType(side),
MetricSample.Type.COUNTER,
MetricsKey.METRIC_REQUESTS_SERVICE_UNAVAILABLE_FAILED);
+ count(list, MetricsEvent.Type.CODEC_EXCEPTION.getNameByType(side),
MetricSample.Type.COUNTER, MetricsKey.METRIC_REQUESTS_CODEC_FAILED);
}
- private <T> GaugeMetricSample<T> getGaugeMetricSample(MetricsKey
metricsKey,
- MethodMetric
methodMetric,
- MetricsCategory
metricsCategory,
- T value,
- ToDoubleFunction<T>
apply) {
+ private <T> GaugeMetricSample<T> createGaugeMetricSample(MetricsKey
metricsKey,
+ MethodMetric
methodMetric,
+ MetricsCategory
metricsCategory,
+ T value,
+
ToDoubleFunction<T> apply) {
return new GaugeMetricSample<>(
metricsKey.getNameByType(methodMetric.getSide()),
metricsKey.getDescription(),
@@ -112,9 +111,23 @@ public class MethodMetricsSampler extends
SimpleMetricsCountSampler<Invocation,
apply);
}
- private <T extends Metric> void count(List<MetricSample> list, String
eventType, MetricsKey metricsKey) {
+ private <T extends Metric> void count(List<MetricSample> list, String
eventType, MetricSample.Type type, MetricsKey metricsKey) {
getCount(eventType).filter(e -> !e.isEmpty())
- .ifPresent(map -> map.forEach((k, v) ->
- list.add(getGaugeMetricSample(metricsKey, k, REQUESTS, v,
AtomicLong::get))));
+ .ifPresent(map -> map.forEach((k, v) -> {
+ if(type == MetricSample.Type.COUNTER){
+ list.add(createCounterMetricSample(metricsKey, k,
MetricsCategory.REQUESTS, v));
+ }else if(type == MetricSample.Type.GAUGE){
+ list.add(createGaugeMetricSample(metricsKey, k,
MetricsCategory.REQUESTS, v, AtomicLong::get));
+ }
+ }
+ ));
+ }
+
+ private MetricSample createCounterMetricSample(MetricsKey metricsKey,
MethodMetric methodMetric, MetricsCategory metricsCategory, AtomicLong value) {
+ return new
CounterMetricSample<>(metricsKey.getNameByType(methodMetric.getSide()),
+ metricsKey.getDescription(),
+ methodMetric.getTags(), metricsCategory, value);
+
+
}
}
diff --git
a/dubbo-metrics/dubbo-metrics-default/src/test/java/org/apache/dubbo/metrics/filter/MetricsFilterTest.java
b/dubbo-metrics/dubbo-metrics-default/src/test/java/org/apache/dubbo/metrics/filter/MetricsFilterTest.java
index c94e8b2af8..d94cbb79e3 100644
---
a/dubbo-metrics/dubbo-metrics-default/src/test/java/org/apache/dubbo/metrics/filter/MetricsFilterTest.java
+++
b/dubbo-metrics/dubbo-metrics-default/src/test/java/org/apache/dubbo/metrics/filter/MetricsFilterTest.java
@@ -23,7 +23,7 @@ import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.metrics.TestMetricsInvoker;
import org.apache.dubbo.metrics.collector.DefaultMetricsCollector;
import org.apache.dubbo.metrics.model.MetricsKey;
-import org.apache.dubbo.metrics.model.sample.GaugeMetricSample;
+import org.apache.dubbo.metrics.model.sample.CounterMetricSample;
import org.apache.dubbo.metrics.model.sample.MetricSample;
import org.apache.dubbo.rpc.AppResponse;
import org.apache.dubbo.rpc.Invoker;
@@ -186,10 +186,10 @@ class MetricsFilterTest {
Assertions.assertTrue(metricsMap.containsKey(MetricsKey.METRIC_REQUESTS_TOTAL_FAILED.getNameByType(side)));
MetricSample timeoutSample =
metricsMap.get(MetricsKey.METRIC_REQUESTS_TIMEOUT.getNameByType(side));
- Assertions.assertSame(((GaugeMetricSample)
timeoutSample).applyAsLong(), count);
+ Assertions.assertSame(((CounterMetricSample)
timeoutSample).getValue().longValue(), count);
- GaugeMetricSample failedSample = (GaugeMetricSample)
metricsMap.get(MetricsKey.METRIC_REQUESTS_TOTAL_FAILED.getNameByType(side));
- Assertions.assertSame(failedSample.applyAsLong(), count);
+ CounterMetricSample failedSample = (CounterMetricSample)
metricsMap.get(MetricsKey.METRIC_REQUESTS_TOTAL_FAILED.getNameByType(side));
+ Assertions.assertSame(failedSample.getValue().longValue(), count);
}
@Test
@@ -214,7 +214,7 @@ class MetricsFilterTest {
MetricSample sample =
metricsMap.get(MetricsKey.METRIC_REQUESTS_LIMIT.getNameByType(side));
- Assertions.assertSame(((GaugeMetricSample) sample).applyAsLong(),
count);
+ Assertions.assertSame(((CounterMetricSample)
sample).getValue().longValue(), count);
}
@Test
@@ -292,7 +292,7 @@ class MetricsFilterTest {
MetricSample sample = metricsMap.get(metricsKey.getName());
- Assertions.assertSame(((GaugeMetricSample) sample).applyAsLong(),
count);
+ Assertions.assertSame(((CounterMetricSample)
sample).getValue().longValue(), count);
Assertions.assertTrue(metricsMap.containsKey(metricsKey.getName()));
diff --git
a/dubbo-metrics/dubbo-metrics-default/src/test/java/org/apache/dubbo/metrics/metrics/collector/DefaultMetricsCollectorTest.java
b/dubbo-metrics/dubbo-metrics-default/src/test/java/org/apache/dubbo/metrics/metrics/collector/DefaultMetricsCollectorTest.java
index 7affb9ae8b..b80db74ee8 100644
---
a/dubbo-metrics/dubbo-metrics-default/src/test/java/org/apache/dubbo/metrics/metrics/collector/DefaultMetricsCollectorTest.java
+++
b/dubbo-metrics/dubbo-metrics-default/src/test/java/org/apache/dubbo/metrics/metrics/collector/DefaultMetricsCollectorTest.java
@@ -28,6 +28,7 @@ import org.apache.dubbo.metrics.event.MetricsEvent;
import org.apache.dubbo.metrics.event.RTEvent;
import org.apache.dubbo.metrics.listener.MetricsListener;
import org.apache.dubbo.metrics.model.MetricsKey;
+import org.apache.dubbo.metrics.model.sample.CounterMetricSample;
import org.apache.dubbo.metrics.model.sample.GaugeMetricSample;
import org.apache.dubbo.metrics.model.sample.MetricSample;
import org.apache.dubbo.rpc.RpcContext;
@@ -107,21 +108,34 @@ class DefaultMetricsCollectorTest {
List<MetricSample> samples = collector.collect();
for (MetricSample sample : samples) {
- Assertions.assertTrue(sample instanceof GaugeMetricSample);
- GaugeMetricSample gaugeSample = (GaugeMetricSample) sample;
- Map<String, String> tags = gaugeSample.getTags();
+ if(sample instanceof GaugeMetricSample) {
+ GaugeMetricSample gaugeSample = (GaugeMetricSample) sample;
+ Assertions.assertEquals(gaugeSample.applyAsLong(), 1);
+ }else if(sample instanceof CounterMetricSample){
+ CounterMetricSample counterMetricSample =
(CounterMetricSample) sample;
+
Assertions.assertEquals(counterMetricSample.getValue().longValue(), 1);
+ }
+ Map<String, String> tags = sample.getTags();
Assertions.assertEquals(tags.get(TAG_INTERFACE_KEY),
interfaceName);
Assertions.assertEquals(tags.get(TAG_METHOD_KEY), methodName);
Assertions.assertEquals(tags.get(TAG_GROUP_KEY), group);
Assertions.assertEquals(tags.get(TAG_VERSION_KEY), version);
- Assertions.assertEquals(gaugeSample.applyAsLong(), 1);
+
}
methodMetricsCountSampler.dec(invocation,
MetricsEvent.Type.PROCESSING.getNameByType(side));
samples = collector.collect();
- Map<String, Long> sampleMap =
samples.stream().collect(Collectors.toMap(MetricSample::getName, k ->
((GaugeMetricSample) k).applyAsLong()));
+ Map<String, Long> sampleMap =
samples.stream().collect(Collectors.toMap(MetricSample::getName, k -> {
+ if(k instanceof GaugeMetricSample){
+ return ((GaugeMetricSample) k).applyAsLong();
+ }else if(k instanceof CounterMetricSample){
+ return ((CounterMetricSample)k).getValue().longValue();
+ }else{
+ throw new RuntimeException("un support sample type");
+ }
+ }));
Assertions.assertEquals(sampleMap.get(MetricsKey.METRIC_REQUESTS_PROCESSING.getNameByType(side)),
0L);
}
diff --git
a/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/DubboMicrometerTracingAutoConfiguration.java
b/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/DubboMicrometerTracingAutoConfiguration.java
index a1f44a1867..ed2553c664 100644
---
a/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/DubboMicrometerTracingAutoConfiguration.java
+++
b/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/DubboMicrometerTracingAutoConfiguration.java
@@ -16,11 +16,6 @@
*/
package org.apache.dubbo.spring.boot.observability.autoconfigure;
-import io.micrometer.tracing.Tracer;
-import io.micrometer.tracing.handler.DefaultTracingObservationHandler;
-import
io.micrometer.tracing.handler.PropagatingReceiverTracingObservationHandler;
-import
io.micrometer.tracing.handler.PropagatingSenderTracingObservationHandler;
-import io.micrometer.tracing.propagation.Propagator;
import
org.apache.dubbo.spring.boot.observability.annotation.ConditionalOnDubboTracingEnable;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
@@ -33,46 +28,46 @@ import org.springframework.core.annotation.Order;
* copy from {@link
org.springframework.boot.actuate.autoconfigure.tracing.MicrometerTracingAutoConfiguration}
* this class is available starting from Boot 3.0. It's not available if
you're using Boot < 3.0
*/
-@ConditionalOnClass(Tracer.class)
@ConditionalOnDubboTracingEnable
+@ConditionalOnClass(name =
{"io.micrometer.observation.Observation","io.micrometer.tracing.Tracer","io.micrometer.tracing.propagation.Propagator"})
@AutoConfigureAfter(name =
"org.springframework.boot.actuate.autoconfigure.tracing.MicrometerTracingAutoConfiguration")
public class DubboMicrometerTracingAutoConfiguration {
/**
* {@code @Order} value of
- * {@link #propagatingReceiverTracingObservationHandler(Tracer,
Propagator)}.
+ * {@link
#propagatingReceiverTracingObservationHandler(io.micrometer.tracing.Tracer,
io.micrometer.tracing.propagation.Propagator )}.
*/
public static final int RECEIVER_TRACING_OBSERVATION_HANDLER_ORDER = 1000;
/**
* {@code @Order} value of
- * {@link #propagatingSenderTracingObservationHandler(Tracer, Propagator)}.
+ * {@link
#propagatingSenderTracingObservationHandler(io.micrometer.tracing.Tracer,
io.micrometer.tracing.propagation.Propagator )}.
*/
public static final int SENDER_TRACING_OBSERVATION_HANDLER_ORDER = 2000;
@Bean
@ConditionalOnMissingBean
- @ConditionalOnBean(Tracer.class)
- public DefaultTracingObservationHandler
defaultTracingObservationHandler(Tracer tracer) {
- return new DefaultTracingObservationHandler(tracer);
+ @ConditionalOnBean(io.micrometer.tracing.Tracer.class)
+ public io.micrometer.tracing.handler.DefaultTracingObservationHandler
defaultTracingObservationHandler(io.micrometer.tracing.Tracer tracer) {
+ return new
io.micrometer.tracing.handler.DefaultTracingObservationHandler(tracer);
}
@Bean
@ConditionalOnMissingBean
- @ConditionalOnBean({Tracer.class, Propagator.class})
+ @ConditionalOnBean({io.micrometer.tracing.Tracer.class,
io.micrometer.tracing.propagation.Propagator.class})
@Order(SENDER_TRACING_OBSERVATION_HANDLER_ORDER)
- public PropagatingSenderTracingObservationHandler<?>
propagatingSenderTracingObservationHandler(Tracer tracer,
-
Propagator propagator) {
- return new PropagatingSenderTracingObservationHandler<>(tracer,
propagator);
+ public
io.micrometer.tracing.handler.PropagatingSenderTracingObservationHandler<?>
propagatingSenderTracingObservationHandler(io.micrometer.tracing.Tracer tracer,
+
io.micrometer.tracing.propagation.Propagator propagator) {
+ return new
io.micrometer.tracing.handler.PropagatingSenderTracingObservationHandler<>(tracer,
propagator);
}
@Bean
@ConditionalOnMissingBean
- @ConditionalOnBean({Tracer.class, Propagator.class})
+ @ConditionalOnBean({io.micrometer.tracing.Tracer.class,
io.micrometer.tracing.propagation.Propagator.class})
@Order(RECEIVER_TRACING_OBSERVATION_HANDLER_ORDER)
- public PropagatingReceiverTracingObservationHandler<?>
propagatingReceiverTracingObservationHandler(Tracer tracer,
-
Propagator propagator) {
- return new PropagatingReceiverTracingObservationHandler<>(tracer,
propagator);
+ public
io.micrometer.tracing.handler.PropagatingReceiverTracingObservationHandler<?>
propagatingReceiverTracingObservationHandler(io.micrometer.tracing.Tracer
tracer,
+
io.micrometer.tracing.propagation.Propagator propagator) {
+ return new
io.micrometer.tracing.handler.PropagatingReceiverTracingObservationHandler<>(tracer,
propagator);
}
}
diff --git
a/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/DubboObservationAutoConfiguration.java
b/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/DubboObservationAutoConfiguration.java
index 6b98ba9090..6b349d23a0 100644
---
a/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/DubboObservationAutoConfiguration.java
+++
b/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/DubboObservationAutoConfiguration.java
@@ -17,23 +17,21 @@
package org.apache.dubbo.spring.boot.observability.autoconfigure;
import io.micrometer.core.instrument.MeterRegistry;
-import
io.micrometer.core.instrument.observation.DefaultMeterObservationHandler;
-import io.micrometer.core.instrument.observation.MeterObservationHandler;
-import io.micrometer.observation.Observation;
-import io.micrometer.observation.ObservationHandler;
-import io.micrometer.observation.ObservationRegistry;
-import io.micrometer.tracing.Tracer;
-import io.micrometer.tracing.handler.TracingAwareMeterObservationHandler;
-import io.micrometer.tracing.handler.TracingObservationHandler;
+import io.micrometer.tracing.Tracer;
+import org.apache.dubbo.common.logger.ErrorTypeAwareLogger;
+import org.apache.dubbo.common.logger.LoggerFactory;
+import org.apache.dubbo.qos.protocol.QosProtocolWrapper;
import org.apache.dubbo.rpc.model.ApplicationModel;
import
org.apache.dubbo.spring.boot.observability.annotation.ConditionalOnDubboTracingEnable;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.SmartInitializingSingleton;
+
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
@@ -50,7 +48,10 @@ import java.util.Arrays;
*/
@AutoConfiguration(after = DubboMicrometerTracingAutoConfiguration.class,
afterName =
"org.springframework.boot.actuate.autoconfigure.observation.ObservationAutoConfiguration")
@ConditionalOnDubboTracingEnable
+@ConditionalOnClass(name = {"io.micrometer.observation.Observation",
"io.micrometer.tracing.Tracer"})
public class DubboObservationAutoConfiguration implements BeanFactoryAware,
SmartInitializingSingleton {
+ private final ErrorTypeAwareLogger logger =
LoggerFactory.getErrorTypeAwareLogger(QosProtocolWrapper.class);
+
public DubboObservationAutoConfiguration(ApplicationModel
applicationModel) {
this.applicationModel = applicationModel;
@@ -62,14 +63,16 @@ public class DubboObservationAutoConfiguration implements
BeanFactoryAware, Smar
@Bean
@ConditionalOnMissingBean
- ObservationRegistry observationRegistry() {
- return ObservationRegistry.create();
+ @ConditionalOnClass(name = "io.micrometer.observation.ObservationRegistry")
+ io.micrometer.observation.ObservationRegistry observationRegistry() {
+ return io.micrometer.observation.ObservationRegistry.create();
}
@Bean
@ConditionalOnMissingBean(type =
"org.springframework.boot.actuate.autoconfigure.observation.ObservationRegistryPostProcessor")
+ @ConditionalOnClass(name = "io.micrometer.observation.ObservationHandler")
public ObservationRegistryPostProcessor
dubboObservationRegistryPostProcessor(ObjectProvider<ObservationHandlerGrouping>
observationHandlerGrouping,
-
ObjectProvider<ObservationHandler<?>> observationHandlers) {
+
ObjectProvider<io.micrometer.observation.ObservationHandler<?>>
observationHandlers) {
return new
ObservationRegistryPostProcessor(observationHandlerGrouping,
observationHandlers);
}
@@ -80,7 +83,13 @@ public class DubboObservationAutoConfiguration implements
BeanFactoryAware, Smar
@Override
public void afterSingletonsInstantiated() {
-
applicationModel.getBeanFactory().registerBean(beanFactory.getBean(ObservationRegistry.class));
+
+ try {
+ Tracer bean = beanFactory.getBean(Tracer.class);
+ applicationModel.getBeanFactory().registerBean(bean);
+ } catch (NoSuchBeanDefinitionException e) {
+ logger.info("Please use a version of micrometer higher than 1.10.0
：{}" + e.getMessage());
+ }
}
@Configuration(proxyBeanMethods = false)
@@ -90,41 +99,44 @@ public class DubboObservationAutoConfiguration implements
BeanFactoryAware, Smar
static class OnlyMetricsConfiguration {
@Bean
+ @ConditionalOnClass(name =
"io.micrometer.core.instrument.observation.MeterObservationHandler")
ObservationHandlerGrouping metricsObservationHandlerGrouping() {
- return new
ObservationHandlerGrouping(MeterObservationHandler.class);
+ return new
ObservationHandlerGrouping(io.micrometer.core.instrument.observation.MeterObservationHandler.class);
}
}
@Configuration(proxyBeanMethods = false)
- @ConditionalOnClass(Tracer.class)
+ @ConditionalOnClass(io.micrometer.tracing.Tracer.class)
@ConditionalOnMissingClass("io.micrometer.core.instrument.MeterRegistry")
@ConditionalOnMissingBean(type =
"org.springframework.boot.actuate.autoconfigure.observation.ObservationRegistryPostProcessor")
static class OnlyTracingConfiguration {
@Bean
+ @ConditionalOnClass(name =
"io.micrometer.tracing.handler.TracingObservationHandler")
ObservationHandlerGrouping tracingObservationHandlerGrouping() {
- return new
ObservationHandlerGrouping(TracingObservationHandler.class);
+ return new
ObservationHandlerGrouping(io.micrometer.tracing.handler.TracingObservationHandler.class);
}
}
@Configuration(proxyBeanMethods = false)
- @ConditionalOnClass({MeterRegistry.class, Tracer.class})
+ @ConditionalOnClass({MeterRegistry.class,
io.micrometer.tracing.Tracer.class})
@ConditionalOnMissingBean(type =
"org.springframework.boot.actuate.autoconfigure.observation.ObservationRegistryPostProcessor")
static class MetricsWithTracingConfiguration {
@Bean
+ @ConditionalOnClass(name =
{"io.micrometer.tracing.handler.TracingObservationHandler",
"io.micrometer.core.instrument.observation.MeterObservationHandler"})
ObservationHandlerGrouping
metricsAndTracingObservationHandlerGrouping() {
return new ObservationHandlerGrouping(
- Arrays.asList(TracingObservationHandler.class,
MeterObservationHandler.class));
+
Arrays.asList(io.micrometer.tracing.handler.TracingObservationHandler.class,
io.micrometer.core.instrument.observation.MeterObservationHandler.class));
}
}
@Configuration(proxyBeanMethods = false)
@ConditionalOnBean(MeterRegistry.class)
- @ConditionalOnMissingBean(MeterObservationHandler.class)
+
@ConditionalOnMissingBean(io.micrometer.core.instrument.observation.MeterObservationHandler.class)
static class MeterObservationHandlerConfiguration {
@ConditionalOnMissingBean(type = "io.micrometer.tracing.Tracer")
@@ -132,21 +144,23 @@ public class DubboObservationAutoConfiguration implements
BeanFactoryAware, Smar
static class OnlyMetricsMeterObservationHandlerConfiguration {
@Bean
- DefaultMeterObservationHandler
defaultMeterObservationHandler(MeterRegistry meterRegistry) {
- return new DefaultMeterObservationHandler(meterRegistry);
+ @ConditionalOnClass(name =
{"io.micrometer.core.instrument.observation.DefaultMeterObservationHandler"})
+
io.micrometer.core.instrument.observation.DefaultMeterObservationHandler
defaultMeterObservationHandler(MeterRegistry meterRegistry) {
+ return new
io.micrometer.core.instrument.observation.DefaultMeterObservationHandler(meterRegistry);
}
}
- @ConditionalOnBean(Tracer.class)
+ @ConditionalOnBean(io.micrometer.tracing.Tracer.class)
@Configuration(proxyBeanMethods = false)
static class TracingAndMetricsObservationHandlerConfiguration {
@Bean
- TracingAwareMeterObservationHandler<Observation.Context>
tracingAwareMeterObservationHandler(
- MeterRegistry meterRegistry, Tracer tracer) {
- DefaultMeterObservationHandler delegate = new
DefaultMeterObservationHandler(meterRegistry);
- return new TracingAwareMeterObservationHandler<>(delegate,
tracer);
+ @ConditionalOnClass(name =
{"io.micrometer.tracing.handler.TracingAwareMeterObservationHandler",
"io.micrometer.tracing.Tracer"})
+
io.micrometer.tracing.handler.TracingAwareMeterObservationHandler<io.micrometer.observation.Observation.Context>
tracingAwareMeterObservationHandler(
+ MeterRegistry meterRegistry, io.micrometer.tracing.Tracer
tracer) {
+
io.micrometer.core.instrument.observation.DefaultMeterObservationHandler
delegate = new
io.micrometer.core.instrument.observation.DefaultMeterObservationHandler(meterRegistry);
+ return new
io.micrometer.tracing.handler.TracingAwareMeterObservationHandler<>(delegate,
tracer);
}
}
diff --git
a/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/brave/BraveAutoConfiguration.java
b/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/brave/BraveAutoConfiguration.java
index bd12e858cb..b3c0bc7f8f 100644
---
a/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/brave/BraveAutoConfiguration.java
+++
b/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/brave/BraveAutoConfiguration.java
@@ -16,41 +16,12 @@
*/
package org.apache.dubbo.spring.boot.observability.autoconfigure.brave;
+
+
import org.apache.dubbo.spring.boot.autoconfigure.DubboConfigurationProperties;
import
org.apache.dubbo.spring.boot.observability.annotation.ConditionalOnDubboTracingEnable;
import
org.apache.dubbo.spring.boot.observability.autoconfigure.DubboMicrometerTracingAutoConfiguration;
import
org.apache.dubbo.spring.boot.observability.autoconfigure.ObservabilityUtils;
-
-import brave.CurrentSpanCustomizer;
-import brave.SpanCustomizer;
-import brave.Tracing;
-import brave.TracingCustomizer;
-import brave.baggage.BaggageField;
-import brave.baggage.BaggagePropagation;
-import brave.baggage.BaggagePropagationConfig;
-import brave.baggage.BaggagePropagationCustomizer;
-import brave.baggage.CorrelationScopeConfig;
-import brave.baggage.CorrelationScopeCustomizer;
-import brave.baggage.CorrelationScopeDecorator;
-import brave.context.slf4j.MDCScopeDecorator;
-import brave.handler.SpanHandler;
-import brave.propagation.B3Propagation;
-import brave.propagation.CurrentTraceContext;
-import brave.propagation.CurrentTraceContextCustomizer;
-import brave.propagation.Propagation;
-import brave.propagation.ThreadLocalCurrentTraceContext;
-import brave.sampler.Sampler;
-import io.micrometer.tracing.Tracer;
-import io.micrometer.tracing.brave.bridge.BraveBaggageManager;
-import io.micrometer.tracing.brave.bridge.BraveCurrentTraceContext;
-import io.micrometer.tracing.brave.bridge.BravePropagator;
-import io.micrometer.tracing.brave.bridge.BraveSpanCustomizer;
-import io.micrometer.tracing.brave.bridge.BraveTracer;
-import io.micrometer.tracing.brave.bridge.CompositeSpanHandler;
-import io.micrometer.tracing.brave.bridge.W3CPropagation;
-import io.micrometer.tracing.exporter.SpanExportingPredicate;
-import io.micrometer.tracing.exporter.SpanFilter;
-import io.micrometer.tracing.exporter.SpanReporter;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
@@ -67,19 +38,17 @@ import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
-import static org.apache.dubbo.config.nested.PropagationConfig.B3;
-import static org.apache.dubbo.config.nested.PropagationConfig.W3C;
/**
* provider Brave when you are using Boot <3.0 or you are not using
spring-boot-starter-actuator
*/
@AutoConfiguration(before = DubboMicrometerTracingAutoConfiguration.class,
afterName =
"org.springframework.boot.actuate.autoconfigure.tracing.BraveAutoConfiguration")
-@ConditionalOnClass({Tracer.class, BraveTracer.class})
+@ConditionalOnClass(name={"io.micrometer.tracing.Tracer",
"io.micrometer.tracing.brave.bridge.BraveTracer","io.micrometer.tracing.brave.bridge.BraveBaggageManager","brave.Tracing"})
@EnableConfigurationProperties(DubboConfigurationProperties.class)
@ConditionalOnDubboTracingEnable
public class BraveAutoConfiguration {
- private static final BraveBaggageManager BRAVE_BAGGAGE_MANAGER = new
BraveBaggageManager();
+ private static final
io.micrometer.tracing.brave.bridge.BraveBaggageManager BRAVE_BAGGAGE_MANAGER =
new io.micrometer.tracing.brave.bridge.BraveBaggageManager();
/**
* Default value for application name if {@code spring.application.name}
is not set.
@@ -89,24 +58,24 @@ public class BraveAutoConfiguration {
@Bean
@ConditionalOnMissingBean
@Order(Ordered.HIGHEST_PRECEDENCE)
- CompositeSpanHandler
compositeSpanHandler(ObjectProvider<SpanExportingPredicate> predicates,
- ObjectProvider<SpanReporter>
reporters, ObjectProvider<SpanFilter> filters) {
- return new
CompositeSpanHandler(predicates.orderedStream().collect(Collectors.toList()),
- reporters.orderedStream().collect(Collectors.toList()),
- filters.orderedStream().collect(Collectors.toList()));
+ io.micrometer.tracing.brave.bridge.CompositeSpanHandler
compositeSpanHandler(ObjectProvider<io.micrometer.tracing.exporter.SpanExportingPredicate>
predicates,
+
ObjectProvider<io.micrometer.tracing.exporter.SpanReporter> reporters,
ObjectProvider<io.micrometer.tracing.exporter.SpanFilter> filters) {
+ return new
io.micrometer.tracing.brave.bridge.CompositeSpanHandler(predicates.orderedStream().collect(Collectors.toList()),
+ reporters.orderedStream().collect(Collectors.toList()),
+ filters.orderedStream().collect(Collectors.toList()));
}
@Bean
@ConditionalOnMissingBean
- public Tracing braveTracing(Environment environment, List<SpanHandler>
spanHandlers,
- List<TracingCustomizer> tracingCustomizers,
CurrentTraceContext currentTraceContext,
- Propagation.Factory propagationFactory,
Sampler sampler) {
+ public brave.Tracing braveTracing(Environment environment,
List<brave.handler.SpanHandler> spanHandlers,
+ List<brave.TracingCustomizer>
tracingCustomizers, brave.propagation.CurrentTraceContext currentTraceContext,
+ brave.propagation.Propagation.Factory
propagationFactory, brave.sampler.Sampler sampler) {
String applicationName =
environment.getProperty("spring.application.name", DEFAULT_APPLICATION_NAME);
- Tracing.Builder builder =
Tracing.newBuilder().currentTraceContext(currentTraceContext).traceId128Bit(true)
-
.supportsJoin(false).propagationFactory(propagationFactory).sampler(sampler)
- .localServiceName(applicationName);
+ brave.Tracing.Builder builder =
brave.Tracing.newBuilder().currentTraceContext(currentTraceContext).traceId128Bit(true)
+
.supportsJoin(false).propagationFactory(propagationFactory).sampler(sampler)
+ .localServiceName(applicationName);
spanHandlers.forEach(builder::addSpanHandler);
- for (TracingCustomizer tracingCustomizer : tracingCustomizers) {
+ for (brave.TracingCustomizer tracingCustomizer : tracingCustomizers) {
tracingCustomizer.customize(builder);
}
return builder.build();
@@ -114,17 +83,17 @@ public class BraveAutoConfiguration {
@Bean
@ConditionalOnMissingBean
- public brave.Tracer braveTracer(Tracing tracing) {
+ public brave.Tracer braveTracer(brave.Tracing tracing) {
return tracing.tracer();
}
@Bean
@ConditionalOnMissingBean
- public CurrentTraceContext
braveCurrentTraceContext(List<CurrentTraceContext.ScopeDecorator>
scopeDecorators,
-
List<CurrentTraceContextCustomizer> currentTraceContextCustomizers) {
- ThreadLocalCurrentTraceContext.Builder builder =
ThreadLocalCurrentTraceContext.newBuilder();
+ public brave.propagation.CurrentTraceContext
braveCurrentTraceContext(List<brave.propagation.CurrentTraceContext.ScopeDecorator>
scopeDecorators,
+
List<brave.propagation.CurrentTraceContextCustomizer>
currentTraceContextCustomizers) {
+ brave.propagation.ThreadLocalCurrentTraceContext.Builder builder =
brave.propagation.ThreadLocalCurrentTraceContext.newBuilder();
scopeDecorators.forEach(builder::addScopeDecorator);
- for (CurrentTraceContextCustomizer currentTraceContextCustomizer :
currentTraceContextCustomizers) {
+ for (brave.propagation.CurrentTraceContextCustomizer
currentTraceContextCustomizer : currentTraceContextCustomizers) {
currentTraceContextCustomizer.customize(builder);
}
return builder.build();
@@ -132,32 +101,32 @@ public class BraveAutoConfiguration {
@Bean
@ConditionalOnMissingBean
- public Sampler braveSampler(DubboConfigurationProperties properties) {
- return
Sampler.create(properties.getTracing().getSampling().getProbability());
+ public brave.sampler.Sampler braveSampler(DubboConfigurationProperties
properties) {
+ return
brave.sampler.Sampler.create(properties.getTracing().getSampling().getProbability());
}
@Bean
@ConditionalOnMissingBean(io.micrometer.tracing.Tracer.class)
- BraveTracer braveTracerBridge(brave.Tracer tracer, CurrentTraceContext
currentTraceContext) {
- return new BraveTracer(tracer, new
BraveCurrentTraceContext(currentTraceContext), BRAVE_BAGGAGE_MANAGER);
+ io.micrometer.tracing.brave.bridge.BraveTracer
braveTracerBridge(brave.Tracer tracer, brave.propagation.CurrentTraceContext
currentTraceContext) {
+ return new io.micrometer.tracing.brave.bridge.BraveTracer(tracer, new
io.micrometer.tracing.brave.bridge.BraveCurrentTraceContext(currentTraceContext),
BRAVE_BAGGAGE_MANAGER);
}
@Bean
@ConditionalOnMissingBean
- BravePropagator bravePropagator(Tracing tracing) {
- return new BravePropagator(tracing);
+ io.micrometer.tracing.brave.bridge.BravePropagator
bravePropagator(brave.Tracing tracing) {
+ return new io.micrometer.tracing.brave.bridge.BravePropagator(tracing);
}
@Bean
- @ConditionalOnMissingBean(SpanCustomizer.class)
- CurrentSpanCustomizer currentSpanCustomizer(Tracing tracing) {
- return CurrentSpanCustomizer.create(tracing);
+ @ConditionalOnMissingBean(brave.SpanCustomizer.class)
+ brave.CurrentSpanCustomizer currentSpanCustomizer(brave.Tracing tracing) {
+ return brave.CurrentSpanCustomizer.create(tracing);
}
@Bean
@ConditionalOnMissingBean(io.micrometer.tracing.SpanCustomizer.class)
- BraveSpanCustomizer braveSpanCustomizer(SpanCustomizer spanCustomizer) {
- return new BraveSpanCustomizer(spanCustomizer);
+ io.micrometer.tracing.brave.bridge.BraveSpanCustomizer
braveSpanCustomizer(brave.SpanCustomizer spanCustomizer) {
+ return new
io.micrometer.tracing.brave.bridge.BraveSpanCustomizer(spanCustomizer);
}
@Configuration(proxyBeanMethods = false)
@@ -166,13 +135,13 @@ public class BraveAutoConfiguration {
@Bean
@ConditionalOnMissingBean
- Propagation.Factory propagationFactory(DubboConfigurationProperties
tracing) {
+ brave.propagation.Propagation.Factory
propagationFactory(DubboConfigurationProperties tracing) {
String type = tracing.getTracing().getPropagation().getType();
switch (type) {
- case B3:
- return
B3Propagation.newFactoryBuilder().injectFormat(B3Propagation.Format.SINGLE_NO_PARENT).build();
- case W3C:
- return new W3CPropagation();
+ case org.apache.dubbo.config.nested.PropagationConfig.B3:
+ return
brave.propagation.B3Propagation.newFactoryBuilder().injectFormat(brave.propagation.B3Propagation.Format.SINGLE_NO_PARENT).build();
+ case org.apache.dubbo.config.nested.PropagationConfig.W3C:
+ return new
io.micrometer.tracing.brave.bridge.W3CPropagation();
default:
throw new IllegalArgumentException("UnSupport propagation
type");
}
@@ -192,12 +161,12 @@ public class BraveAutoConfiguration {
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix =
ObservabilityUtils.DUBBO_TRACING_PROPAGATION, value = "type", havingValue =
"B3")
- BaggagePropagation.FactoryBuilder b3PropagationFactoryBuilder(
- ObjectProvider<BaggagePropagationCustomizer>
baggagePropagationCustomizers) {
- Propagation.Factory delegate =
-
B3Propagation.newFactoryBuilder().injectFormat(B3Propagation.Format.SINGLE_NO_PARENT).build();
+ brave.baggage.BaggagePropagation.FactoryBuilder
b3PropagationFactoryBuilder(
+ ObjectProvider<brave.baggage.BaggagePropagationCustomizer>
baggagePropagationCustomizers) {
+ brave.propagation.Propagation.Factory delegate =
+
brave.propagation.B3Propagation.newFactoryBuilder().injectFormat(brave.propagation.B3Propagation.Format.SINGLE_NO_PARENT).build();
- BaggagePropagation.FactoryBuilder builder =
BaggagePropagation.newFactoryBuilder(delegate);
+ brave.baggage.BaggagePropagation.FactoryBuilder builder =
brave.baggage.BaggagePropagation.newFactoryBuilder(delegate);
baggagePropagationCustomizers.orderedStream().forEach((customizer)
-> customizer.customize(builder));
return builder;
}
@@ -205,11 +174,11 @@ public class BraveAutoConfiguration {
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix =
ObservabilityUtils.DUBBO_TRACING_PROPAGATION, value = "type", havingValue =
"W3C", matchIfMissing = true)
- BaggagePropagation.FactoryBuilder w3cPropagationFactoryBuilder(
- ObjectProvider<BaggagePropagationCustomizer>
baggagePropagationCustomizers) {
- Propagation.Factory delegate = new
W3CPropagation(BRAVE_BAGGAGE_MANAGER, Collections.emptyList());
+ brave.baggage.BaggagePropagation.FactoryBuilder
w3cPropagationFactoryBuilder(
+ ObjectProvider<brave.baggage.BaggagePropagationCustomizer>
baggagePropagationCustomizers) {
+ brave.propagation.Propagation.Factory delegate = new
io.micrometer.tracing.brave.bridge.W3CPropagation(BRAVE_BAGGAGE_MANAGER,
Collections.emptyList());
- BaggagePropagation.FactoryBuilder builder =
BaggagePropagation.newFactoryBuilder(delegate);
+ brave.baggage.BaggagePropagation.FactoryBuilder builder =
brave.baggage.BaggagePropagation.newFactoryBuilder(delegate);
baggagePropagationCustomizers.orderedStream().forEach((customizer)
-> customizer.customize(builder));
return builder;
}
@@ -217,26 +186,26 @@ public class BraveAutoConfiguration {
@Bean
@ConditionalOnMissingBean
@Order(0)
- BaggagePropagationCustomizer
remoteFieldsBaggagePropagationCustomizer() {
+ brave.baggage.BaggagePropagationCustomizer
remoteFieldsBaggagePropagationCustomizer() {
return (builder) -> {
List<String> remoteFields =
dubboConfigProperties.getTracing().getBaggage().getRemoteFields();
for (String fieldName : remoteFields) {
-
builder.add(BaggagePropagationConfig.SingleBaggageField.remote(BaggageField.create(fieldName)));
+
builder.add(brave.baggage.BaggagePropagationConfig.SingleBaggageField.remote(brave.baggage.BaggageField.create(fieldName)));
}
};
}
@Bean
@ConditionalOnMissingBean
- Propagation.Factory
propagationFactory(BaggagePropagation.FactoryBuilder factoryBuilder) {
+ brave.propagation.Propagation.Factory
propagationFactory(brave.baggage.BaggagePropagation.FactoryBuilder
factoryBuilder) {
return factoryBuilder.build();
}
@Bean
@ConditionalOnMissingBean
- CorrelationScopeDecorator.Builder mdcCorrelationScopeDecoratorBuilder(
- ObjectProvider<CorrelationScopeCustomizer>
correlationScopeCustomizers) {
- CorrelationScopeDecorator.Builder builder =
MDCScopeDecorator.newBuilder();
+ brave.baggage.CorrelationScopeDecorator.Builder
mdcCorrelationScopeDecoratorBuilder(
+ ObjectProvider<brave.baggage.CorrelationScopeCustomizer>
correlationScopeCustomizers) {
+ brave.baggage.CorrelationScopeDecorator.Builder builder =
brave.context.slf4j.MDCScopeDecorator.newBuilder();
correlationScopeCustomizers.orderedStream().forEach((customizer)
-> customizer.customize(builder));
return builder;
}
@@ -245,19 +214,19 @@ public class BraveAutoConfiguration {
@Order(0)
@ConditionalOnProperty(prefix =
ObservabilityUtils.DUBBO_TRACING_BAGGAGE_CORRELATION, name = "enabled",
matchIfMissing = true)
- CorrelationScopeCustomizer
correlationFieldsCorrelationScopeCustomizer() {
+ brave.baggage.CorrelationScopeCustomizer
correlationFieldsCorrelationScopeCustomizer() {
return (builder) -> {
List<String> correlationFields =
this.dubboConfigProperties.getTracing().getBaggage().getCorrelation().getFields();
for (String field : correlationFields) {
-
builder.add(CorrelationScopeConfig.SingleCorrelationField.newBuilder(BaggageField.create(field))
+
builder.add(brave.baggage.CorrelationScopeConfig.SingleCorrelationField.newBuilder(brave.baggage.BaggageField.create(field))
.flushOnUpdate().build());
}
};
}
@Bean
- @ConditionalOnMissingBean(CurrentTraceContext.ScopeDecorator.class)
- CurrentTraceContext.ScopeDecorator
correlationScopeDecorator(CorrelationScopeDecorator.Builder builder) {
+
@ConditionalOnMissingBean(brave.propagation.CurrentTraceContext.ScopeDecorator.class)
+ brave.propagation.CurrentTraceContext.ScopeDecorator
correlationScopeDecorator(brave.baggage.CorrelationScopeDecorator.Builder
builder) {
return builder.build();
}
diff --git
a/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/otel/OpenTelemetryAutoConfiguration.java
b/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/otel/OpenTelemetryAutoConfiguration.java
index b0df17980e..4d8d58c81e 100644
---
a/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/otel/OpenTelemetryAutoConfiguration.java
+++
b/dubbo-spring-boot/dubbo-spring-boot-observability-starter/src/main/java/org/apache/dubbo/spring/boot/observability/autoconfigure/otel/OpenTelemetryAutoConfiguration.java
@@ -16,45 +16,12 @@
*/
package org.apache.dubbo.spring.boot.observability.autoconfigure.otel;
+
import org.apache.dubbo.common.Version;
import org.apache.dubbo.spring.boot.autoconfigure.DubboConfigurationProperties;
import
org.apache.dubbo.spring.boot.observability.annotation.ConditionalOnDubboTracingEnable;
import
org.apache.dubbo.spring.boot.observability.autoconfigure.DubboMicrometerTracingAutoConfiguration;
import
org.apache.dubbo.spring.boot.observability.autoconfigure.ObservabilityUtils;
-
-import io.micrometer.tracing.SpanCustomizer;
-import io.micrometer.tracing.exporter.SpanExportingPredicate;
-import io.micrometer.tracing.exporter.SpanFilter;
-import io.micrometer.tracing.exporter.SpanReporter;
-import io.micrometer.tracing.otel.bridge.CompositeSpanExporter;
-import io.micrometer.tracing.otel.bridge.EventListener;
-import io.micrometer.tracing.otel.bridge.EventPublishingContextWrapper;
-import io.micrometer.tracing.otel.bridge.OtelBaggageManager;
-import io.micrometer.tracing.otel.bridge.OtelCurrentTraceContext;
-import io.micrometer.tracing.otel.bridge.OtelPropagator;
-import io.micrometer.tracing.otel.bridge.OtelSpanCustomizer;
-import io.micrometer.tracing.otel.bridge.OtelTracer;
-import io.micrometer.tracing.otel.bridge.Slf4JBaggageEventListener;
-import io.micrometer.tracing.otel.bridge.Slf4JEventListener;
-import io.micrometer.tracing.otel.propagation.BaggageTextMapPropagator;
-import io.opentelemetry.api.OpenTelemetry;
-import io.opentelemetry.api.baggage.propagation.W3CBaggagePropagator;
-import io.opentelemetry.api.common.Attributes;
-import io.opentelemetry.api.trace.Tracer;
-import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
-import io.opentelemetry.context.ContextStorage;
-import io.opentelemetry.context.propagation.ContextPropagators;
-import io.opentelemetry.context.propagation.TextMapPropagator;
-import io.opentelemetry.extension.trace.propagation.B3Propagator;
-import io.opentelemetry.sdk.OpenTelemetrySdk;
-import io.opentelemetry.sdk.resources.Resource;
-import io.opentelemetry.sdk.trace.SdkTracerProvider;
-import io.opentelemetry.sdk.trace.SdkTracerProviderBuilder;
-import io.opentelemetry.sdk.trace.SpanProcessor;
-import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
-import io.opentelemetry.sdk.trace.export.SpanExporter;
-import io.opentelemetry.sdk.trace.samplers.Sampler;
-import io.opentelemetry.semconv.resource.attributes.ResourceAttributes;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
@@ -74,7 +41,9 @@ import java.util.stream.Collectors;
*/
@AutoConfiguration(before = DubboMicrometerTracingAutoConfiguration.class,
afterName =
"org.springframework.boot.actuate.autoconfigure.tracing.OpenTelemetryAutoConfiguration")
@ConditionalOnDubboTracingEnable
-@ConditionalOnClass({OtelTracer.class, SdkTracerProvider.class,
OpenTelemetry.class})
+@ConditionalOnClass(name = {"io.micrometer.tracing.otel.bridge.OtelTracer",
+ "io.opentelemetry.sdk.trace.SdkTracerProvider", "e
io.opentelemetry.api.OpenTelemetry"
+ , "io.micrometer.tracing.SpanCustomizer"})
@EnableConfigurationProperties(DubboConfigurationProperties.class)
public class OpenTelemetryAutoConfiguration {
@@ -91,89 +60,89 @@ public class OpenTelemetryAutoConfiguration {
@Bean
@ConditionalOnMissingBean
- OpenTelemetry openTelemetry(SdkTracerProvider sdkTracerProvider,
ContextPropagators contextPropagators) {
- return
OpenTelemetrySdk.builder().setTracerProvider(sdkTracerProvider).setPropagators(contextPropagators)
- .build();
+ io.opentelemetry.api.OpenTelemetry
openTelemetry(io.opentelemetry.sdk.trace.SdkTracerProvider sdkTracerProvider,
io.opentelemetry.context.propagation.ContextPropagators contextPropagators) {
+ return
io.opentelemetry.sdk.OpenTelemetrySdk.builder().setTracerProvider(sdkTracerProvider).setPropagators(contextPropagators)
+ .build();
}
@Bean
@ConditionalOnMissingBean
- SdkTracerProvider otelSdkTracerProvider(Environment environment,
ObjectProvider<SpanProcessor> spanProcessors,
- Sampler sampler) {
+ io.opentelemetry.sdk.trace.SdkTracerProvider
otelSdkTracerProvider(Environment environment,
ObjectProvider<io.opentelemetry.sdk.trace.SpanProcessor> spanProcessors,
+
io.opentelemetry.sdk.trace.samplers.Sampler sampler) {
String applicationName =
environment.getProperty("spring.application.name", DEFAULT_APPLICATION_NAME);
- SdkTracerProviderBuilder builder =
SdkTracerProvider.builder().setSampler(sampler)
-
.setResource(Resource.create(Attributes.of(ResourceAttributes.SERVICE_NAME,
applicationName)));
+ io.opentelemetry.sdk.trace.SdkTracerProviderBuilder builder =
io.opentelemetry.sdk.trace.SdkTracerProvider.builder().setSampler(sampler)
+
.setResource(io.opentelemetry.sdk.resources.Resource.create(io.opentelemetry.api.common.Attributes.of(io.opentelemetry.semconv.resource.attributes.ResourceAttributes.SERVICE_NAME,
applicationName)));
spanProcessors.orderedStream().forEach(builder::addSpanProcessor);
return builder.build();
}
@Bean
@ConditionalOnMissingBean
- ContextPropagators
otelContextPropagators(ObjectProvider<TextMapPropagator> textMapPropagators) {
- return
ContextPropagators.create(TextMapPropagator.composite(textMapPropagators.orderedStream().collect(Collectors.toList())));
+ io.opentelemetry.context.propagation.ContextPropagators
otelContextPropagators(ObjectProvider<io.opentelemetry.context.propagation.TextMapPropagator>
textMapPropagators) {
+ return
io.opentelemetry.context.propagation.ContextPropagators.create(io.opentelemetry.context.propagation.TextMapPropagator.composite(textMapPropagators.orderedStream().collect(Collectors.toList())));
}
@Bean
@ConditionalOnMissingBean
- Sampler otelSampler() {
- Sampler rootSampler =
Sampler.traceIdRatioBased(this.dubboConfigProperties.getTracing().getSampling().getProbability());
- return Sampler.parentBased(rootSampler);
+ io.opentelemetry.sdk.trace.samplers.Sampler otelSampler() {
+ io.opentelemetry.sdk.trace.samplers.Sampler rootSampler =
io.opentelemetry.sdk.trace.samplers.Sampler.traceIdRatioBased(this.dubboConfigProperties.getTracing().getSampling().getProbability());
+ return
io.opentelemetry.sdk.trace.samplers.Sampler.parentBased(rootSampler);
}
@Bean
@ConditionalOnMissingBean
- SpanProcessor otelSpanProcessor(ObjectProvider<SpanExporter> spanExporters,
- ObjectProvider<SpanExportingPredicate>
spanExportingPredicates, ObjectProvider<SpanReporter> spanReporters,
- ObjectProvider<SpanFilter> spanFilters) {
- return BatchSpanProcessor.builder(new
CompositeSpanExporter(spanExporters.orderedStream().collect(Collectors.toList()),
-
spanExportingPredicates.orderedStream().collect(Collectors.toList()),
spanReporters.orderedStream().collect(Collectors.toList()),
-
spanFilters.orderedStream().collect(Collectors.toList()))).build();
+ io.opentelemetry.sdk.trace.SpanProcessor
otelSpanProcessor(ObjectProvider<io.opentelemetry.sdk.trace.export.SpanExporter>
spanExporters,
+
ObjectProvider<io.micrometer.tracing.exporter.SpanExportingPredicate>
spanExportingPredicates,
ObjectProvider<io.micrometer.tracing.exporter.SpanReporter> spanReporters,
+
ObjectProvider<io.micrometer.tracing.exporter.SpanFilter> spanFilters) {
+ return
io.opentelemetry.sdk.trace.export.BatchSpanProcessor.builder(new
io.micrometer.tracing.otel.bridge.CompositeSpanExporter(spanExporters.orderedStream().collect(Collectors.toList()),
+
spanExportingPredicates.orderedStream().collect(Collectors.toList()),
spanReporters.orderedStream().collect(Collectors.toList()),
+ spanFilters.orderedStream().collect(Collectors.toList()))).build();
}
@Bean
@ConditionalOnMissingBean
- Tracer otelTracer(OpenTelemetry openTelemetry) {
+ io.opentelemetry.api.trace.Tracer
otelTracer(io.opentelemetry.api.OpenTelemetry openTelemetry) {
return openTelemetry.getTracer("org.apache.dubbo",
Version.getVersion());
}
@Bean
@ConditionalOnMissingBean(io.micrometer.tracing.Tracer.class)
- OtelTracer micrometerOtelTracer(Tracer tracer, OtelTracer.EventPublisher
eventPublisher,
- OtelCurrentTraceContext
otelCurrentTraceContext) {
- return new OtelTracer(tracer, otelCurrentTraceContext, eventPublisher,
- new OtelBaggageManager(otelCurrentTraceContext,
this.dubboConfigProperties.getTracing().getBaggage().getRemoteFields(),
+ io.micrometer.tracing.otel.bridge.OtelTracer
micrometerOtelTracer(io.opentelemetry.api.trace.Tracer tracer,
io.micrometer.tracing.otel.bridge.OtelTracer.EventPublisher eventPublisher,
+
io.micrometer.tracing.otel.bridge.OtelCurrentTraceContext
otelCurrentTraceContext) {
+ return new io.micrometer.tracing.otel.bridge.OtelTracer(tracer,
otelCurrentTraceContext, eventPublisher,
+ new
io.micrometer.tracing.otel.bridge.OtelBaggageManager(otelCurrentTraceContext,
this.dubboConfigProperties.getTracing().getBaggage().getRemoteFields(),
Collections.emptyList()));
}
@Bean
@ConditionalOnMissingBean
- OtelPropagator otelPropagator(ContextPropagators contextPropagators,
Tracer tracer) {
- return new OtelPropagator(contextPropagators, tracer);
+ io.micrometer.tracing.otel.bridge.OtelPropagator
otelPropagator(io.opentelemetry.context.propagation.ContextPropagators
contextPropagators, io.opentelemetry.api.trace.Tracer tracer) {
+ return new
io.micrometer.tracing.otel.bridge.OtelPropagator(contextPropagators, tracer);
}
@Bean
@ConditionalOnMissingBean
- OtelTracer.EventPublisher otelTracerEventPublisher(List<EventListener>
eventListeners) {
+ io.micrometer.tracing.otel.bridge.OtelTracer.EventPublisher
otelTracerEventPublisher(List<io.micrometer.tracing.otel.bridge.EventListener>
eventListeners) {
return new OTelEventPublisher(eventListeners);
}
@Bean
@ConditionalOnMissingBean
- OtelCurrentTraceContext otelCurrentTraceContext(OtelTracer.EventPublisher
publisher) {
- ContextStorage.addWrapper(new
EventPublishingContextWrapper(publisher));
- return new OtelCurrentTraceContext();
+ io.micrometer.tracing.otel.bridge.OtelCurrentTraceContext
otelCurrentTraceContext(io.micrometer.tracing.otel.bridge.OtelTracer.EventPublisher
publisher) {
+ io.opentelemetry.context.ContextStorage.addWrapper(new
io.micrometer.tracing.otel.bridge.EventPublishingContextWrapper(publisher));
+ return new io.micrometer.tracing.otel.bridge.OtelCurrentTraceContext();
}
@Bean
@ConditionalOnMissingBean
- Slf4JEventListener otelSlf4JEventListener() {
- return new Slf4JEventListener();
+ io.micrometer.tracing.otel.bridge.Slf4JEventListener
otelSlf4JEventListener() {
+ return new io.micrometer.tracing.otel.bridge.Slf4JEventListener();
}
@Bean
- @ConditionalOnMissingBean(SpanCustomizer.class)
- OtelSpanCustomizer otelSpanCustomizer() {
- return new OtelSpanCustomizer();
+ @ConditionalOnMissingBean(io.micrometer.tracing.SpanCustomizer.class)
+ io.micrometer.tracing.otel.bridge.OtelSpanCustomizer otelSpanCustomizer() {
+ return new io.micrometer.tracing.otel.bridge.OtelSpanCustomizer();
}
@Configuration(proxyBeanMethods = false)
@@ -190,29 +159,29 @@ public class OpenTelemetryAutoConfiguration {
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix =
ObservabilityUtils.DUBBO_TRACING_PROPAGATION, name = "type", havingValue =
"W3C",
matchIfMissing = true)
- TextMapPropagator
w3cTextMapPropagatorWithBaggage(OtelCurrentTraceContext
otelCurrentTraceContext) {
+ io.opentelemetry.context.propagation.TextMapPropagator
w3cTextMapPropagatorWithBaggage(io.micrometer.tracing.otel.bridge.OtelCurrentTraceContext
otelCurrentTraceContext) {
List<String> remoteFields =
this.dubboConfigProperties.getTracing().getBaggage().getRemoteFields();
- return
TextMapPropagator.composite(W3CTraceContextPropagator.getInstance(),
- W3CBaggagePropagator.getInstance(), new
BaggageTextMapPropagator(remoteFields,
- new OtelBaggageManager(otelCurrentTraceContext,
remoteFields, Collections.emptyList())));
+ return
io.opentelemetry.context.propagation.TextMapPropagator.composite(io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator.getInstance(),
+
io.opentelemetry.api.baggage.propagation.W3CBaggagePropagator.getInstance(),
new
io.micrometer.tracing.otel.propagation.BaggageTextMapPropagator(remoteFields,
+ new
io.micrometer.tracing.otel.bridge.OtelBaggageManager(otelCurrentTraceContext,
remoteFields, Collections.emptyList())));
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix =
ObservabilityUtils.DUBBO_TRACING_PROPAGATION, name = "type", havingValue = "B3")
- TextMapPropagator b3BaggageTextMapPropagator(OtelCurrentTraceContext
otelCurrentTraceContext) {
+ io.opentelemetry.context.propagation.TextMapPropagator
b3BaggageTextMapPropagator(io.micrometer.tracing.otel.bridge.OtelCurrentTraceContext
otelCurrentTraceContext) {
List<String> remoteFields =
this.dubboConfigProperties.getTracing().getBaggage().getRemoteFields();
- return
TextMapPropagator.composite(B3Propagator.injectingSingleHeader(),
- new BaggageTextMapPropagator(remoteFields,
- new OtelBaggageManager(otelCurrentTraceContext,
remoteFields, Collections.emptyList())));
+ return
io.opentelemetry.context.propagation.TextMapPropagator.composite(io.opentelemetry.extension.trace.propagation.B3Propagator.injectingSingleHeader(),
+ new
io.micrometer.tracing.otel.propagation.BaggageTextMapPropagator(remoteFields,
+ new
io.micrometer.tracing.otel.bridge.OtelBaggageManager(otelCurrentTraceContext,
remoteFields, Collections.emptyList())));
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix =
ObservabilityUtils.DUBBO_TRACING_BAGGAGE_CORRELATION, name = "enabled",
matchIfMissing = true)
- Slf4JBaggageEventListener otelSlf4JBaggageEventListener() {
- return new
Slf4JBaggageEventListener(this.dubboConfigProperties.getTracing().getBaggage().getCorrelation().getFields());
+ io.micrometer.tracing.otel.bridge.Slf4JBaggageEventListener
otelSlf4JBaggageEventListener() {
+ return new
io.micrometer.tracing.otel.bridge.Slf4JBaggageEventListener(this.dubboConfigProperties.getTracing().getBaggage().getCorrelation().getFields());
}
}
@@ -224,31 +193,31 @@ public class OpenTelemetryAutoConfiguration {
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix =
ObservabilityUtils.DUBBO_TRACING_PROPAGATION, name = "type", havingValue = "B3")
- B3Propagator b3TextMapPropagator() {
- return B3Propagator.injectingSingleHeader();
+ io.opentelemetry.extension.trace.propagation.B3Propagator
b3TextMapPropagator() {
+ return
io.opentelemetry.extension.trace.propagation.B3Propagator.injectingSingleHeader();
}
@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(prefix =
ObservabilityUtils.DUBBO_TRACING_PROPAGATION, name = "type", havingValue =
"W3C",
matchIfMissing = true)
- W3CTraceContextPropagator w3cTextMapPropagatorWithoutBaggage() {
- return W3CTraceContextPropagator.getInstance();
+ io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator
w3cTextMapPropagatorWithoutBaggage() {
+ return
io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator.getInstance();
}
}
- static class OTelEventPublisher implements OtelTracer.EventPublisher {
+ static class OTelEventPublisher implements
io.micrometer.tracing.otel.bridge.OtelTracer.EventPublisher {
- private final List<EventListener> listeners;
+ private final List<io.micrometer.tracing.otel.bridge.EventListener>
listeners;
- OTelEventPublisher(List<EventListener> listeners) {
+
OTelEventPublisher(List<io.micrometer.tracing.otel.bridge.EventListener>
listeners) {
this.listeners = listeners;
}
@Override
public void publishEvent(Object event) {
- for (EventListener listener : this.listeners) {
+ for (io.micrometer.tracing.otel.bridge.EventListener listener :
this.listeners) {
listener.onEvent(event);
}
}
