add TimeWindowQuantile, MetricsFilter, DefaultMetricsService (#10512)
diff --git a/dubbo-common/src/main/java/org/apache/dubbo/common/metrics/model/MetricsKey.java b/dubbo-common/src/main/java/org/apache/dubbo/common/metrics/model/MetricsKey.java
index 3c9ff02..07816a3 100644
--- a/dubbo-common/src/main/java/org/apache/dubbo/common/metrics/model/MetricsKey.java
+++ b/dubbo-common/src/main/java/org/apache/dubbo/common/metrics/model/MetricsKey.java
@@ -26,7 +26,7 @@
METRIC_REQUESTS_TOTAL_AGG("requests.total.aggregate", "Aggregated Total Requests"),
METRIC_REQUESTS_SUCCEED_AGG("requests.succeed.aggregate", "Aggregated Succeed Requests"),
METRIC_REQUESTS_FAILED_AGG("requests.failed.aggregate", "Aggregated Failed Requests"),
- METRIC_QPS_NAME("qps", "Query Per Seconds"),
+ METRIC_QPS("qps", "Query Per Seconds"),
METRIC_RT_LAST("rt.last", "Last Response Time"),
METRIC_RT_MIN("rt.min", "Min Response Time"),
METRIC_RT_MAX("rt.max", "Max Response Time"),
diff --git a/dubbo-dependencies-bom/pom.xml b/dubbo-dependencies-bom/pom.xml
index fb3b390..2070914 100644
--- a/dubbo-dependencies-bom/pom.xml
+++ b/dubbo-dependencies-bom/pom.xml
@@ -130,6 +130,9 @@
<commons_lang3_version>3.8.1</commons_lang3_version>
<protostuff_version>1.5.9</protostuff_version>
<envoy_api_version>0.1.23</envoy_api_version>
+ <micrometer.version>1.7.4</micrometer.version>
+ <t_digest.version>3.3</t_digest.version>
+ <prometheus_client.version>0.10.0</prometheus_client.version>
<rs_api_version>2.0</rs_api_version>
<resteasy_version>3.0.19.Final</resteasy_version>
@@ -773,6 +776,32 @@
<version>${snappy_java_version}</version>
<optional>true</optional>
</dependency>
+ <!-- metrics related dependencies-->
+ <dependency>
+ <groupId>io.micrometer</groupId>
+ <artifactId>micrometer-core</artifactId>
+ <version>${micrometer.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>io.micrometer</groupId>
+ <artifactId>micrometer-registry-prometheus</artifactId>
+ <version>${micrometer.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>com.tdunning</groupId>
+ <artifactId>t-digest</artifactId>
+ <version>${t_digest.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>io.prometheus</groupId>
+ <artifactId>simpleclient</artifactId>
+ <version>${prometheus_client.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>io.prometheus</groupId>
+ <artifactId>simpleclient_pushgateway</artifactId>
+ <version>${prometheus_client.version}</version>
+ </dependency>
</dependencies>
</dependencyManagement>
diff --git a/dubbo-metrics/dubbo-metrics-api/pom.xml b/dubbo-metrics/dubbo-metrics-api/pom.xml
index cb6e664..445787d 100644
--- a/dubbo-metrics/dubbo-metrics-api/pom.xml
+++ b/dubbo-metrics/dubbo-metrics-api/pom.xml
@@ -35,5 +35,18 @@
<artifactId>dubbo-common</artifactId>
<version>${project.parent.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.apache.dubbo</groupId>
+ <artifactId>dubbo-rpc-api</artifactId>
+ <version>${project.parent.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>io.micrometer</groupId>
+ <artifactId>micrometer-core</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.tdunning</groupId>
+ <artifactId>t-digest</artifactId>
+ </dependency>
</dependencies>
</project>
diff --git a/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/AbstractMetricsReporter.java b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/AbstractMetricsReporter.java
new file mode 100644
index 0000000..4e32c7e
--- /dev/null
+++ b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/AbstractMetricsReporter.java
@@ -0,0 +1,169 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ * http://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.apache.dubbo.metrics;
+
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Tag;
+import io.micrometer.core.instrument.binder.jvm.ClassLoaderMetrics;
+import io.micrometer.core.instrument.binder.jvm.JvmGcMetrics;
+import io.micrometer.core.instrument.binder.jvm.JvmMemoryMetrics;
+import io.micrometer.core.instrument.binder.jvm.JvmThreadMetrics;
+import io.micrometer.core.instrument.binder.system.ProcessorMetrics;
+import io.micrometer.core.instrument.composite.CompositeMeterRegistry;
+import org.apache.dubbo.common.URL;
+import org.apache.dubbo.common.lang.ShutdownHookCallbacks;
+import org.apache.dubbo.common.logger.Logger;
+import org.apache.dubbo.common.logger.LoggerFactory;
+import org.apache.dubbo.common.metrics.MetricsReporter;
+import org.apache.dubbo.common.metrics.collector.DefaultMetricsCollector;
+import org.apache.dubbo.common.metrics.collector.MetricsCollector;
+import org.apache.dubbo.common.metrics.model.sample.GaugeMetricSample;
+import org.apache.dubbo.common.metrics.model.sample.MetricSample;
+import org.apache.dubbo.common.utils.NamedThreadFactory;
+import org.apache.dubbo.metrics.collector.AggregateMetricsCollector;
+import org.apache.dubbo.rpc.model.ApplicationModel;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.apache.dubbo.common.constants.MetricsConstants.ENABLE_JVM_METRICS_KEY;
+
+/**
+ * AbstractMetricsReporter.
+ */
+public abstract class AbstractMetricsReporter implements MetricsReporter {
+
+ private final Logger logger = LoggerFactory.getLogger(AbstractMetricsReporter.class);
+
+ private final AtomicBoolean initialized = new AtomicBoolean(false);
+
+ protected final URL url;
+ protected final List<MetricsCollector> collectors = new ArrayList<>();
+ protected final CompositeMeterRegistry compositeRegistry = new CompositeMeterRegistry();
+
+ private final ApplicationModel applicationModel;
+ private ScheduledExecutorService collectorSyncJobExecutor = null;
+
+ private static final int DEFAULT_SCHEDULE_INITIAL_DELAY = 5;
+ private static final int DEFAULT_SCHEDULE_PERIOD = 30;
+
+ protected AbstractMetricsReporter(URL url, ApplicationModel applicationModel) {
+ this.url = url;
+ this.applicationModel = applicationModel;
+ }
+
+ @Override
+ public void init() {
+ if (initialized.compareAndSet(false, true)) {
+ addJvmMetrics();
+ initCollectors();
+ scheduleMetricsCollectorSyncJob();
+
+ doInit();
+
+ registerDubboShutdownHook();
+ }
+ }
+
+ protected void addMeterRegistry(MeterRegistry registry) {
+ compositeRegistry.add(registry);
+ }
+
+ protected ApplicationModel getApplicationModel() {
+ return applicationModel;
+ }
+
+ private void addJvmMetrics() {
+ boolean enableJvmMetrics = url.getParameter(ENABLE_JVM_METRICS_KEY, false);
+ if (enableJvmMetrics) {
+ new ClassLoaderMetrics().bindTo(compositeRegistry);
+ new JvmMemoryMetrics().bindTo(compositeRegistry);
+ new JvmGcMetrics().bindTo(compositeRegistry);
+ new ProcessorMetrics().bindTo(compositeRegistry);
+ new JvmThreadMetrics().bindTo(compositeRegistry);
+ }
+ }
+
+ private void initCollectors() {
+ applicationModel.getBeanFactory().getOrRegisterBean(AggregateMetricsCollector.class);
+
+ collectors.add(applicationModel.getBeanFactory().getBean(DefaultMetricsCollector.class));
+ collectors.add(applicationModel.getBeanFactory().getBean(AggregateMetricsCollector.class));
+ }
+
+ private void scheduleMetricsCollectorSyncJob() {
+ NamedThreadFactory threadFactory = new NamedThreadFactory("metrics-collector-sync-job", true);
+ collectorSyncJobExecutor = Executors.newScheduledThreadPool(1, threadFactory);
+ collectorSyncJobExecutor.scheduleWithFixedDelay(() -> {
+ collectors.forEach(collector -> {
+ List<MetricSample> samples = collector.collect();
+ for (MetricSample sample : samples) {
+ try {
+ switch (sample.getType()) {
+ case GAUGE:
+ GaugeMetricSample gaugeSample = (GaugeMetricSample) sample;
+ List<Tag> tags = new ArrayList<>();
+ gaugeSample.getTags().forEach((k, v) -> {
+ if (v == null) {
+ v = "";
+ }
+
+ tags.add(Tag.of(k, v));
+ });
+
+ Gauge.builder(gaugeSample.getName(), gaugeSample.getSupplier())
+ .description(gaugeSample.getDescription()).tags(tags).register(compositeRegistry);
+ break;
+ case COUNTER:
+ case TIMER:
+ case LONG_TASK_TIMER:
+ case DISTRIBUTION_SUMMARY:
+ // TODO
+ break;
+ default:
+ break;
+ }
+ } catch (Exception e) {
+ logger.error("error occurred when synchronize metrics collector.", e);
+ }
+ }
+ });
+ }, DEFAULT_SCHEDULE_INITIAL_DELAY, DEFAULT_SCHEDULE_PERIOD, TimeUnit.SECONDS);
+ }
+
+ private void registerDubboShutdownHook() {
+ applicationModel.getBeanFactory().getBean(ShutdownHookCallbacks.class).addCallback(this::destroy);
+ }
+
+ public void destroy() {
+ if (collectorSyncJobExecutor != null) {
+ collectorSyncJobExecutor.shutdownNow();
+ }
+
+ doDestroy();
+ }
+
+ protected abstract void doInit();
+
+ protected abstract void doDestroy();
+}
diff --git a/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/AbstractMetricsReporterFactory.java b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/AbstractMetricsReporterFactory.java
new file mode 100644
index 0000000..59763ed
--- /dev/null
+++ b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/AbstractMetricsReporterFactory.java
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ * http://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.apache.dubbo.metrics;
+
+import org.apache.dubbo.common.metrics.MetricsReporterFactory;
+import org.apache.dubbo.rpc.model.ApplicationModel;
+
+/**
+ * AbstractMetricsReporterFactory.
+ */
+public abstract class AbstractMetricsReporterFactory implements MetricsReporterFactory {
+
+ private final ApplicationModel applicationModel;
+
+ public AbstractMetricsReporterFactory(ApplicationModel applicationModel) {
+ this.applicationModel = applicationModel;
+ }
+
+ protected ApplicationModel getApplicationModel() {
+ return applicationModel;
+ }
+}
diff --git a/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/aggregate/TimeWindowQuantile.java b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/aggregate/TimeWindowQuantile.java
new file mode 100644
index 0000000..86249c8
--- /dev/null
+++ b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/aggregate/TimeWindowQuantile.java
@@ -0,0 +1,75 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ * http://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.apache.dubbo.metrics.aggregate;
+
+import com.tdunning.math.stats.TDigest;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Wrapper around TDigest.
+ * <p>
+ * Maintains a ring buffer of TDigest to provide quantiles over a sliding windows of time.
+ */
+public class TimeWindowQuantile {
+ private final double compression;
+ private final TDigest[] ringBuffer;
+ private int currentBucket;
+ private long lastRotateTimestampMillis;
+ private final long durationBetweenRotatesMillis;
+
+ public TimeWindowQuantile(double compression, int bucketNum, int timeWindowSeconds) {
+ this.compression = compression;
+ this.ringBuffer = new TDigest[bucketNum];
+ for (int i = 0; i < bucketNum; i++) {
+ this.ringBuffer[i] = TDigest.createDigest(compression);
+ }
+
+ this.currentBucket = 0;
+ this.lastRotateTimestampMillis = System.currentTimeMillis();
+ this.durationBetweenRotatesMillis = TimeUnit.SECONDS.toMillis(timeWindowSeconds) / bucketNum;
+ }
+
+ public synchronized double quantile(double q) {
+ TDigest currentBucket = rotate();
+
+ // This may return Double.NaN, and it's correct behavior.
+ // see: https://github.com/prometheus/client_golang/issues/85
+ return currentBucket.quantile(q);
+ }
+
+ public synchronized void add(double value) {
+ rotate();
+ for (TDigest bucket : ringBuffer) {
+ bucket.add(value);
+ }
+ }
+
+ private TDigest rotate() {
+ long timeSinceLastRotateMillis = System.currentTimeMillis() - lastRotateTimestampMillis;
+ while (timeSinceLastRotateMillis > durationBetweenRotatesMillis) {
+ ringBuffer[currentBucket] = TDigest.createDigest(compression);
+ if (++currentBucket >= ringBuffer.length) {
+ currentBucket = 0;
+ }
+ timeSinceLastRotateMillis -= durationBetweenRotatesMillis;
+ lastRotateTimestampMillis += durationBetweenRotatesMillis;
+ }
+ return ringBuffer[currentBucket];
+ }
+}
diff --git a/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/collector/AggregateMetricsCollector.java b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/collector/AggregateMetricsCollector.java
new file mode 100644
index 0000000..b473d1f
--- /dev/null
+++ b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/collector/AggregateMetricsCollector.java
@@ -0,0 +1,151 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ * http://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.apache.dubbo.metrics.collector;
+
+import org.apache.dubbo.common.metrics.collector.DefaultMetricsCollector;
+import org.apache.dubbo.common.metrics.collector.MetricsCollector;
+import org.apache.dubbo.common.metrics.event.MetricsEvent;
+import org.apache.dubbo.common.metrics.event.RTEvent;
+import org.apache.dubbo.common.metrics.event.RequestEvent;
+import org.apache.dubbo.common.metrics.listener.MetricsListener;
+import org.apache.dubbo.common.metrics.model.MethodMetric;
+import org.apache.dubbo.common.metrics.model.MetricsKey;
+import org.apache.dubbo.common.metrics.model.sample.GaugeMetricSample;
+import org.apache.dubbo.common.metrics.model.sample.MetricSample;
+import org.apache.dubbo.config.MetricsConfig;
+import org.apache.dubbo.config.context.ConfigManager;
+import org.apache.dubbo.config.nested.AggregationConfig;
+import org.apache.dubbo.metrics.aggregate.TimeWindowCounter;
+import org.apache.dubbo.metrics.aggregate.TimeWindowQuantile;
+import org.apache.dubbo.rpc.model.ApplicationModel;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static org.apache.dubbo.common.metrics.model.MetricsCategory.REQUESTS;
+import static org.apache.dubbo.common.metrics.model.MetricsCategory.QPS;
+import static org.apache.dubbo.common.metrics.model.MetricsCategory.RT;
+
+/**
+ * Aggregation metrics collector implementation of {@link MetricsCollector}.
+ * This collector only enabled when metrics aggregation config is enabled.
+ */
+public class AggregateMetricsCollector implements MetricsCollector, MetricsListener {
+ private int bucketNum;
+ private int timeWindowSeconds;
+
+ private final Map<MethodMetric, TimeWindowCounter> totalRequests = new ConcurrentHashMap<>();
+ private final Map<MethodMetric, TimeWindowCounter> succeedRequests = new ConcurrentHashMap<>();
+ private final Map<MethodMetric, TimeWindowCounter> failedRequests = new ConcurrentHashMap<>();
+ private final Map<MethodMetric, TimeWindowCounter> qps = new ConcurrentHashMap<>();
+ private final Map<MethodMetric, TimeWindowQuantile> rt = new ConcurrentHashMap<>();
+
+ private final ApplicationModel applicationModel;
+
+ private static final Integer DEFAULT_COMPRESSION = 100;
+ private static final Integer DEFAULT_BUCKET_NUM = 10;
+ private static final Integer DEFAULT_TIME_WINDOW_SECONDS = 120;
+
+ public AggregateMetricsCollector(ApplicationModel applicationModel) {
+ this.applicationModel = applicationModel;
+ ConfigManager configManager = applicationModel.getApplicationConfigManager();
+ MetricsConfig config = configManager.getMetrics().orElse(null);
+ if (config != null && config.getAggregation() != null && Boolean.TRUE.equals(config.getAggregation().getEnabled())) {
+ // only registered when aggregation is enabled.
+ registerListener();
+
+ AggregationConfig aggregation = config.getAggregation();
+ this.bucketNum = aggregation.getBucketNum() == null ? DEFAULT_BUCKET_NUM : aggregation.getBucketNum();
+ this.timeWindowSeconds = aggregation.getTimeWindowSeconds() == null ? DEFAULT_TIME_WINDOW_SECONDS : aggregation.getTimeWindowSeconds();
+ }
+ }
+
+ private void registerListener() {
+ applicationModel.getBeanFactory().getBean(DefaultMetricsCollector.class).addListener(this);
+ }
+
+ @Override
+ public void onEvent(MetricsEvent event) {
+ if (event instanceof RTEvent) {
+ onRTEvent((RTEvent) event);
+ } else if (event instanceof RequestEvent) {
+ onRequestEvent((RequestEvent) event);
+ }
+ }
+
+ private void onRTEvent(RTEvent event) {
+ MethodMetric metric = (MethodMetric) event.getSource();
+ Long responseTime = event.getRt();
+ TimeWindowQuantile quantile = rt.computeIfAbsent(metric, k -> new TimeWindowQuantile(DEFAULT_COMPRESSION, bucketNum, timeWindowSeconds));
+ quantile.add(responseTime);
+ }
+
+ private void onRequestEvent(RequestEvent event) {
+ MethodMetric metric = (MethodMetric) event.getSource();
+ RequestEvent.Type type = event.getType();
+ TimeWindowCounter counter = null;
+ switch (type) {
+ case TOTAL:
+ counter = totalRequests.computeIfAbsent(metric, k -> new TimeWindowCounter(bucketNum, timeWindowSeconds));
+ TimeWindowCounter qpsCounter = qps.computeIfAbsent(metric, k -> new TimeWindowCounter(bucketNum, timeWindowSeconds));
+ qpsCounter.increment();
+ break;
+ case SUCCEED:
+ counter = succeedRequests.computeIfAbsent(metric, k -> new TimeWindowCounter(bucketNum, timeWindowSeconds));
+ break;
+ case FAILED:
+ counter = failedRequests.computeIfAbsent(metric, k -> new TimeWindowCounter(bucketNum, timeWindowSeconds));
+ break;
+ default:
+ break;
+ }
+
+ if (counter != null) {
+ counter.increment();
+ }
+ }
+
+ @Override
+ public List<MetricSample> collect() {
+ List<MetricSample> list = new ArrayList<>();
+ collectRequests(list);
+ collectQPS(list);
+ collectRT(list);
+
+ return list;
+ }
+
+ private void collectRequests(List<MetricSample> list) {
+ totalRequests.forEach((k, v) -> list.add(new GaugeMetricSample(MetricsKey.METRIC_REQUESTS_TOTAL_AGG, k.getTags(), REQUESTS, v::get)));
+ succeedRequests.forEach((k, v) -> list.add(new GaugeMetricSample(MetricsKey.METRIC_REQUESTS_SUCCEED_AGG, k.getTags(), REQUESTS, v::get)));
+ failedRequests.forEach((k, v) -> list.add(new GaugeMetricSample(MetricsKey.METRIC_REQUESTS_FAILED_AGG, k.getTags(), REQUESTS, v::get)));
+ }
+
+ private void collectQPS(List<MetricSample> list) {
+ qps.forEach((k, v) -> list.add(new GaugeMetricSample(MetricsKey.METRIC_QPS, k.getTags(), QPS, () -> v.get() / v.bucketLivedSeconds())));
+ }
+
+ private void collectRT(List<MetricSample> list) {
+ rt.forEach((k, v) -> {
+ list.add(new GaugeMetricSample(MetricsKey.METRIC_RT_P99, k.getTags(), RT, () -> v.quantile(0.99)));
+ list.add(new GaugeMetricSample(MetricsKey.METRIC_RT_P95, k.getTags(), RT, () -> v.quantile(0.95)));
+ });
+ }
+}
diff --git a/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/filter/MetricsFilter.java b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/filter/MetricsFilter.java
new file mode 100644
index 0000000..031f8ef
--- /dev/null
+++ b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/filter/MetricsFilter.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ * http://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.apache.dubbo.metrics.filter;
+
+import org.apache.dubbo.common.extension.Activate;
+import org.apache.dubbo.common.metrics.collector.DefaultMetricsCollector;
+import org.apache.dubbo.rpc.Filter;
+import org.apache.dubbo.rpc.Invocation;
+import org.apache.dubbo.rpc.Invoker;
+import org.apache.dubbo.rpc.Result;
+import org.apache.dubbo.rpc.RpcException;
+import org.apache.dubbo.rpc.model.ApplicationModel;
+import org.apache.dubbo.rpc.model.ScopeModelAware;
+
+import static org.apache.dubbo.common.constants.CommonConstants.PROVIDER;
+
+@Activate(group = PROVIDER, order = -1)
+public class MetricsFilter implements Filter, ScopeModelAware {
+
+ private DefaultMetricsCollector collector = null;
+
+ private ApplicationModel applicationModel;
+
+ @Override
+ public void setApplicationModel(ApplicationModel applicationModel) {
+ this.applicationModel = applicationModel;
+
+ collector = applicationModel.getBeanFactory().getBean(DefaultMetricsCollector.class);
+ }
+
+ @Override
+ public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
+ if (collector == null || !collector.isCollectEnabled()) {
+ return invoker.invoke(invocation);
+ }
+
+ String serviceUniqueName = invocation.getTargetServiceUniqueName();
+ String methodName = invocation.getMethodName();
+ String group = null;
+ String interfaceAndVersion;
+ String[] arr = serviceUniqueName.split("/");
+ if (arr.length == 2) {
+ group = arr[0];
+ interfaceAndVersion = arr[1];
+ } else {
+ interfaceAndVersion = arr[0];
+ }
+
+ String[] ivArr = interfaceAndVersion.split(":");
+ String interfaceName = ivArr[0];
+ String version = ivArr.length == 2 ? ivArr[1] : null;
+ collector.increaseTotalRequests(interfaceName, methodName, group, version);
+ collector.increaseProcessingRequests(interfaceName, methodName, group, version);
+
+ Long startTime = System.currentTimeMillis();
+ try {
+ Result invoke = invoker.invoke(invocation);
+ collector.increaseSucceedRequests(interfaceName, methodName, group, version);
+ return invoke;
+ } catch (RpcException e) {
+ collector.increaseFailedRequests(interfaceName, methodName, group, version);
+ throw e;
+ } finally {
+ Long endTime = System.currentTimeMillis();
+ Long rt = endTime - startTime;
+ collector.addRT(interfaceName, methodName, group, version, rt);
+ collector.decreaseProcessingRequests(interfaceName, methodName, group, version);
+ }
+ }
+}
diff --git a/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/service/DefaultMetricsService.java b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/service/DefaultMetricsService.java
new file mode 100644
index 0000000..c91e5f3
--- /dev/null
+++ b/dubbo-metrics/dubbo-metrics-api/src/main/java/org/apache/dubbo/metrics/service/DefaultMetricsService.java
@@ -0,0 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ * http://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.apache.dubbo.metrics.service;
+
+import org.apache.dubbo.common.metrics.collector.DefaultMetricsCollector;
+import org.apache.dubbo.common.metrics.collector.MetricsCollector;
+import org.apache.dubbo.common.metrics.model.MetricsCategory;
+import org.apache.dubbo.common.metrics.model.sample.GaugeMetricSample;
+import org.apache.dubbo.common.metrics.model.sample.MetricSample;
+import org.apache.dubbo.common.metrics.service.MetricsEntity;
+import org.apache.dubbo.common.metrics.service.MetricsService;
+import org.apache.dubbo.metrics.collector.AggregateMetricsCollector;
+import org.apache.dubbo.rpc.model.ApplicationModel;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Default implementation of {@link MetricsService}
+ */
+public class DefaultMetricsService implements MetricsService {
+
+ protected final List<MetricsCollector> collectors = new ArrayList<>();
+
+ private final ApplicationModel applicationModel;
+
+ public DefaultMetricsService(ApplicationModel applicationModel) {
+ this.applicationModel = applicationModel;
+ collectors.add(applicationModel.getBeanFactory().getBean(DefaultMetricsCollector.class));
+ collectors.add(applicationModel.getBeanFactory().getBean(AggregateMetricsCollector.class));
+ }
+
+ @Override
+ public Map<MetricsCategory, List<MetricsEntity>> getMetricsByCategories(List<MetricsCategory> categories) {
+ return getMetricsByCategories(null, categories);
+ }
+
+ @Override
+ public Map<MetricsCategory, List<MetricsEntity>> getMetricsByCategories(String serviceUniqueName, List<MetricsCategory> categories) {
+ return getMetricsByCategories(serviceUniqueName, null, null, categories);
+ }
+
+ @Override
+ public Map<MetricsCategory, List<MetricsEntity>> getMetricsByCategories(String serviceUniqueName, String methodName, Class<?>[] parameterTypes, List<MetricsCategory> categories) {
+ Map<MetricsCategory, List<MetricsEntity>> result = new HashMap<>();
+ for (MetricsCollector collector : collectors) {
+ List<MetricSample> samples = collector.collect();
+ for (MetricSample sample : samples) {
+ if (categories.contains(sample.getCategory())) {
+ List<MetricsEntity> entities = result.computeIfAbsent(sample.getCategory(), k -> new ArrayList<>());
+ entities.add(sampleToEntity(sample));
+ }
+ }
+ }
+
+ return result;
+ }
+
+ private MetricsEntity sampleToEntity(MetricSample sample) {
+ MetricsEntity entity = new MetricsEntity();
+
+ entity.setName(sample.getName());
+ entity.setTags(sample.getTags());
+ entity.setCategory(sample.getCategory());
+ switch (sample.getType()) {
+ case GAUGE:
+ GaugeMetricSample gaugeSample = (GaugeMetricSample) sample;
+ entity.setValue(gaugeSample.getSupplier().get());
+ break;
+ case COUNTER:
+ case LONG_TASK_TIMER:
+ case TIMER:
+ case DISTRIBUTION_SUMMARY:
+ default:
+ break;
+ }
+
+ return entity;
+ }
+}
diff --git a/dubbo-metrics/dubbo-metrics-api/src/test/java/org/apache/dubbo/metrics/aggregate/TimeWindowQuantileTest.java b/dubbo-metrics/dubbo-metrics-api/src/test/java/org/apache/dubbo/metrics/aggregate/TimeWindowQuantileTest.java
new file mode 100644
index 0000000..f3364be
--- /dev/null
+++ b/dubbo-metrics/dubbo-metrics-api/src/test/java/org/apache/dubbo/metrics/aggregate/TimeWindowQuantileTest.java
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ * http://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.apache.dubbo.metrics.aggregate;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class TimeWindowQuantileTest {
+
+ @Test
+ public void test() throws Exception {
+ TimeWindowQuantile quantile = new TimeWindowQuantile(100, 12, 1);
+ for (int i = 1; i <= 100; i++) {
+ quantile.add(i);
+ }
+
+ Assertions.assertEquals(quantile.quantile(0.01), 2);
+ Assertions.assertEquals(quantile.quantile(0.99), 100);
+ Thread.sleep(1000);
+ Assertions.assertEquals(quantile.quantile(0.99), Double.NaN);
+ }
+}
diff --git a/dubbo-metrics/dubbo-metrics-api/src/test/java/org/apache/dubbo/metrics/collector/AggregateMetricsCollectorTest.java b/dubbo-metrics/dubbo-metrics-api/src/test/java/org/apache/dubbo/metrics/collector/AggregateMetricsCollectorTest.java
new file mode 100644
index 0000000..308e238
--- /dev/null
+++ b/dubbo-metrics/dubbo-metrics-api/src/test/java/org/apache/dubbo/metrics/collector/AggregateMetricsCollectorTest.java
@@ -0,0 +1,130 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ * http://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.apache.dubbo.metrics.collector;
+
+import org.apache.dubbo.common.metrics.collector.DefaultMetricsCollector;
+import org.apache.dubbo.common.metrics.model.sample.GaugeMetricSample;
+import org.apache.dubbo.common.metrics.model.sample.MetricSample;
+import org.apache.dubbo.config.ApplicationConfig;
+import org.apache.dubbo.config.MetricsConfig;
+import org.apache.dubbo.config.nested.AggregationConfig;
+import org.apache.dubbo.rpc.model.ApplicationModel;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static org.apache.dubbo.common.constants.MetricsConstants.*;
+
+public class AggregateMetricsCollectorTest {
+
+ private ApplicationModel applicationModel;
+ private DefaultMetricsCollector defaultCollector;
+
+ private String interfaceName;
+ private String methodName;
+ private String group;
+ private String version;
+
+ @BeforeEach
+ public void setup() {
+ ApplicationConfig config = new ApplicationConfig();
+ config.setName("MockMetrics");
+
+ applicationModel = ApplicationModel.defaultModel();
+ applicationModel.getApplicationConfigManager().setApplication(config);
+
+ defaultCollector = new DefaultMetricsCollector(applicationModel);
+ defaultCollector.setCollectEnabled(true);
+ MetricsConfig metricsConfig = new MetricsConfig();
+ AggregationConfig aggregationConfig = new AggregationConfig();
+ aggregationConfig.setEnabled(true);
+ aggregationConfig.setBucketNum(12);
+ aggregationConfig.setTimeWindowSeconds(120);
+ metricsConfig.setAggregation(aggregationConfig);
+ applicationModel.getApplicationConfigManager().setMetrics(metricsConfig);
+ applicationModel.getBeanFactory().registerBean(defaultCollector);
+
+ interfaceName = "org.apache.dubbo.MockInterface";
+ methodName = "mockMethod";
+ group = "mockGroup";
+ version = "1.0.0";
+ }
+
+ @AfterEach
+ public void teardown() {
+ applicationModel.destroy();
+ }
+
+ @Test
+ public void testRequestsMetrics() {
+ AggregateMetricsCollector collector = new AggregateMetricsCollector(applicationModel);
+ defaultCollector.increaseTotalRequests(interfaceName, methodName, group, version);
+ defaultCollector.increaseSucceedRequests(interfaceName, methodName, group, version);
+ defaultCollector.increaseFailedRequests(interfaceName, methodName, group, version);
+
+ List<MetricSample> samples = collector.collect();
+ for (MetricSample sample : samples) {
+ 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);
+ }
+
+ samples = collector.collect();
+ Map<String, Long> sampleMap = samples.stream().collect(Collectors.toMap(MetricSample::getName, k -> {
+ Number number = ((GaugeMetricSample) k).getSupplier().get();
+ return number.longValue();
+ }));
+
+ Assertions.assertEquals(sampleMap.get("requests.total.aggregate"), 1L);
+ Assertions.assertEquals(sampleMap.get("requests.succeed.aggregate"), 1L);
+ Assertions.assertEquals(sampleMap.get("requests.failed.aggregate"), 1L);
+ Assertions.assertTrue(sampleMap.containsKey("qps"));
+ }
+
+ @Test
+ public void testRTMetrics() {
+ AggregateMetricsCollector collector = new AggregateMetricsCollector(applicationModel);
+ defaultCollector.addRT(interfaceName, methodName, group, version, 10L);
+
+ List<MetricSample> samples = collector.collect();
+ for (MetricSample sample : samples) {
+ 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);
+ }
+
+ Map<String, Long> sampleMap = samples.stream().collect(Collectors.toMap(MetricSample::getName, k -> {
+ Number number = ((GaugeMetricSample) k).getSupplier().get();
+ return number.longValue();
+ }));
+
+ Assertions.assertTrue(sampleMap.containsKey("rt.p99"));
+ Assertions.assertTrue(sampleMap.containsKey("rt.p95"));
+ }
+}
diff --git a/dubbo-metrics/dubbo-metrics-api/src/test/java/org/apache/dubbo/metrics/filter/MetricsFilterTest.java b/dubbo-metrics/dubbo-metrics-api/src/test/java/org/apache/dubbo/metrics/filter/MetricsFilterTest.java
new file mode 100644
index 0000000..5e65180
--- /dev/null
+++ b/dubbo-metrics/dubbo-metrics-api/src/test/java/org/apache/dubbo/metrics/filter/MetricsFilterTest.java
@@ -0,0 +1,199 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ * http://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.apache.dubbo.metrics.filter;
+
+import org.apache.dubbo.common.metrics.collector.DefaultMetricsCollector;
+import org.apache.dubbo.common.metrics.model.sample.MetricSample;
+import org.apache.dubbo.config.ApplicationConfig;
+import org.apache.dubbo.rpc.AppResponse;
+import org.apache.dubbo.rpc.Invoker;
+import org.apache.dubbo.rpc.RpcException;
+import org.apache.dubbo.rpc.RpcInvocation;
+import org.apache.dubbo.rpc.model.ApplicationModel;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static org.apache.dubbo.common.constants.MetricsConstants.*;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+
+public class MetricsFilterTest {
+
+ private ApplicationModel applicationModel;
+ private MetricsFilter filter;
+ private DefaultMetricsCollector collector;
+ private RpcInvocation invocation;
+ private final Invoker<?> invoker = mock(Invoker.class);
+
+ private static final String INTERFACE_NAME = "org.apache.dubbo.MockInterface";
+ private static final String METHOD_NAME = "mockMethod";
+ private static final String GROUP = "mockGroup";
+ private static final String VERSION = "1.0.0";
+
+ @BeforeEach
+ public void setup() {
+ ApplicationConfig config = new ApplicationConfig();
+ config.setName("MockMetrics");
+
+ applicationModel = ApplicationModel.defaultModel();
+ applicationModel.getApplicationConfigManager().setApplication(config);
+
+ invocation = new RpcInvocation();
+ filter = new MetricsFilter();
+
+ collector = applicationModel.getBeanFactory().getOrRegisterBean(DefaultMetricsCollector.class);
+ filter.setApplicationModel(applicationModel);
+ }
+
+ @AfterEach
+ public void teardown() {
+ applicationModel.destroy();
+ }
+
+ @Test
+ public void testCollectDisabled() {
+ given(invoker.invoke(invocation)).willReturn(new AppResponse("success"));
+
+ filter.invoke(invoker, invocation);
+ Map<String, MetricSample> metricsMap = getMetricsMap();
+ Assertions.assertTrue(metricsMap.isEmpty());
+ }
+
+ @Test
+ public void testFailedRequests() {
+ collector.setCollectEnabled(true);
+ given(invoker.invoke(invocation)).willThrow(new RpcException("failed"));
+ initParam();
+
+ try {
+ filter.invoke(invoker, invocation);
+ } catch (Exception ignore) {
+
+ }
+
+ Map<String, MetricSample> metricsMap = getMetricsMap();
+ Assertions.assertTrue(metricsMap.containsKey("requests.failed"));
+ Assertions.assertFalse(metricsMap.containsKey("requests.succeed"));
+
+ MetricSample sample = metricsMap.get("requests.failed");
+ Map<String, String> tags = sample.getTags();
+
+ Assertions.assertEquals(tags.get(TAG_INTERFACE_KEY), INTERFACE_NAME);
+ Assertions.assertEquals(tags.get(TAG_METHOD_KEY), METHOD_NAME);
+ Assertions.assertEquals(tags.get(TAG_GROUP_KEY), GROUP);
+ Assertions.assertEquals(tags.get(TAG_VERSION_KEY), VERSION);
+ }
+
+ @Test
+ public void testSucceedRequests() {
+ collector.setCollectEnabled(true);
+ given(invoker.invoke(invocation)).willReturn(new AppResponse("success"));
+ initParam();
+
+ filter.invoke(invoker, invocation);
+ Map<String, MetricSample> metricsMap = getMetricsMap();
+ Assertions.assertFalse(metricsMap.containsKey("requests.failed"));
+ Assertions.assertTrue(metricsMap.containsKey("requests.succeed"));
+
+ MetricSample sample = metricsMap.get("requests.succeed");
+ Map<String, String> tags = sample.getTags();
+
+ Assertions.assertEquals(tags.get(TAG_INTERFACE_KEY), INTERFACE_NAME);
+ Assertions.assertEquals(tags.get(TAG_METHOD_KEY), METHOD_NAME);
+ Assertions.assertEquals(tags.get(TAG_GROUP_KEY), GROUP);
+ Assertions.assertEquals(tags.get(TAG_VERSION_KEY), VERSION);
+ }
+
+ @Test
+ public void testMissingGroup() {
+ collector.setCollectEnabled(true);
+ given(invoker.invoke(invocation)).willReturn(new AppResponse("success"));
+ invocation.setTargetServiceUniqueName(INTERFACE_NAME + ":" + VERSION);
+ invocation.setMethodName(METHOD_NAME);
+ invocation.setParameterTypes(new Class[]{ String.class });
+
+ filter.invoke(invoker, invocation);
+ Map<String, MetricSample> metricsMap = getMetricsMap();
+
+ MetricSample sample = metricsMap.get("requests.succeed");
+ Map<String, String> tags = sample.getTags();
+
+ Assertions.assertEquals(tags.get(TAG_INTERFACE_KEY), INTERFACE_NAME);
+ Assertions.assertEquals(tags.get(TAG_METHOD_KEY), METHOD_NAME);
+ Assertions.assertNull(tags.get(TAG_GROUP_KEY));
+ Assertions.assertEquals(tags.get(TAG_VERSION_KEY), VERSION);
+ }
+
+ @Test
+ public void testMissingVersion() {
+ collector.setCollectEnabled(true);
+ given(invoker.invoke(invocation)).willReturn(new AppResponse("success"));
+ invocation.setTargetServiceUniqueName(GROUP + "/" + INTERFACE_NAME);
+ invocation.setMethodName(METHOD_NAME);
+ invocation.setParameterTypes(new Class[]{ String.class });
+
+ filter.invoke(invoker, invocation);
+ Map<String, MetricSample> metricsMap = getMetricsMap();
+
+ MetricSample sample = metricsMap.get("requests.succeed");
+ Map<String, String> tags = sample.getTags();
+
+ Assertions.assertEquals(tags.get(TAG_INTERFACE_KEY), INTERFACE_NAME);
+ Assertions.assertEquals(tags.get(TAG_METHOD_KEY), METHOD_NAME);
+ Assertions.assertEquals(tags.get(TAG_GROUP_KEY), GROUP);
+ Assertions.assertNull(tags.get(TAG_VERSION_KEY));
+ }
+
+ @Test
+ public void testMissingGroupAndVersion() {
+ collector.setCollectEnabled(true);
+ given(invoker.invoke(invocation)).willReturn(new AppResponse("success"));
+ invocation.setTargetServiceUniqueName(INTERFACE_NAME);
+ invocation.setMethodName(METHOD_NAME);
+ invocation.setParameterTypes(new Class[]{ String.class });
+
+ filter.invoke(invoker, invocation);
+ Map<String, MetricSample> metricsMap = getMetricsMap();
+
+ MetricSample sample = metricsMap.get("requests.succeed");
+ Map<String, String> tags = sample.getTags();
+
+ Assertions.assertEquals(tags.get(TAG_INTERFACE_KEY), INTERFACE_NAME);
+ Assertions.assertEquals(tags.get(TAG_METHOD_KEY), METHOD_NAME);
+ Assertions.assertNull(tags.get(TAG_GROUP_KEY));
+ Assertions.assertNull(tags.get(TAG_VERSION_KEY));
+ }
+
+ private void initParam() {
+ invocation.setTargetServiceUniqueName(GROUP + "/" + INTERFACE_NAME + ":" + VERSION);
+ invocation.setMethodName(METHOD_NAME);
+ invocation.setParameterTypes(new Class[]{ String.class });
+ }
+
+ private Map<String, MetricSample> getMetricsMap() {
+ List<MetricSample> samples = collector.collect();
+ return samples.stream().collect(Collectors.toMap(MetricSample::getName, Function.identity()));
+ }
+}
