From 91f804c32f9946e931f027bfa65e9b7b2adcd7a0 Mon Sep 17 00:00:00 2001 From: Stephan Schroevers Date: Thu, 3 Oct 2024 22:57:35 +0200 Subject: [PATCH] Skip redundant tag deduplication Both `KeyValues` and `Tags` unconditionally maintain the invariant that they wrap distinct key-value pairs. --- benchmarks/build.gradle | 3 ++ ...enerConfigurationResolveTagsBenchmark.java | 53 +++++++++++++++++++ gradle/libs.versions.toml | 2 + .../MicrometerMeterListenerConfiguration.java | 7 ++- ...meterObservationListenerConfiguration.java | 7 ++- .../reactor/core/publisher/FluxMetrics.java | 7 ++- 6 files changed, 67 insertions(+), 12 deletions(-) create mode 100644 benchmarks/src/main/java/reactor/core/observability/micrometer/MicrometerMeterListenerConfigurationResolveTagsBenchmark.java diff --git a/benchmarks/build.gradle b/benchmarks/build.gradle index 3307226a59..0ab48e6491 100644 --- a/benchmarks/build.gradle +++ b/benchmarks/build.gradle @@ -13,15 +13,18 @@ configurations { dependencies { // Use the baseline to avoid using new APIs in the benchmarks compileOnly libs.reactor.perfBaseline.core + compileOnly libs.reactor.perfBaseline.coreMicrometer compileOnly libs.jsr305 implementation "org.openjdk.jmh:jmh-core:$jmhVersion" implementation libs.reactor.perfBaseline.extra, { exclude group: 'io.projectreactor', module: 'reactor-core' } + implementation platform(libs.micrometer.bom) annotationProcessor "org.openjdk.jmh:jmh-generator-annprocess:$jmhVersion" current project(':reactor-core') + current project(':reactor-core-micrometer') baseline libs.reactor.perfBaseline.core, { changing = true } diff --git a/benchmarks/src/main/java/reactor/core/observability/micrometer/MicrometerMeterListenerConfigurationResolveTagsBenchmark.java b/benchmarks/src/main/java/reactor/core/observability/micrometer/MicrometerMeterListenerConfigurationResolveTagsBenchmark.java new file mode 100644 index 0000000000..a52d840d1a --- /dev/null +++ b/benchmarks/src/main/java/reactor/core/observability/micrometer/MicrometerMeterListenerConfigurationResolveTagsBenchmark.java @@ -0,0 +1,53 @@ +package reactor.core.observability.micrometer; + +import io.micrometer.core.instrument.Tags; +import java.util.concurrent.TimeUnit; +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Param; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.Warmup; +import org.reactivestreams.Publisher; +import reactor.core.publisher.Mono; + +@BenchmarkMode({Mode.AverageTime}) +@Warmup(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) +@Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) +@Fork(value = 1) +@OutputTimeUnit(TimeUnit.NANOSECONDS) +@State(Scope.Benchmark) +public class MicrometerMeterListenerConfigurationResolveTagsBenchmark { + @Param({"1", "2", "5", "10"}) + private int distinctTagCount; + + @Param({"1", "2", "5", "10"}) + private int totalTagCount; + + private Publisher publisher; + + @Setup(Level.Iteration) + public void setup() { + publisher = addTags(Mono.empty(), distinctTagCount, totalTagCount); + } + + @SuppressWarnings("unused") + @Benchmark + public Tags measureThroughput() { + return MicrometerMeterListenerConfiguration.resolveTags(publisher, Tags.of("k", "v")); + } + + private static Mono addTags(Mono source, int distinct, int total) { + if (total == 0) { + return source; + } + + return addTags(source.tag("k-" + total % distinct, "v-" + total), distinct, total - 1); + } +} diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 6072728f50..9f58f3b261 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -9,6 +9,7 @@ # Baselines, should be updated on every release baseline-core-api = "3.6.10" baselinePerfCore = "3.6.10" +baselinePerfCoreMicrometer = "1.1.9" baselinePerfExtra = "3.5.2" # Other shared versions @@ -46,6 +47,7 @@ kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = " reactiveStreams = { module = "org.reactivestreams:reactive-streams", version.ref = "reactiveStreams" } reactiveStreams-tck = { module = "org.reactivestreams:reactive-streams-tck", version.ref = "reactiveStreams" } reactor-perfBaseline-core = { module = "io.projectreactor:reactor-core", version.ref = "baselinePerfCore" } +reactor-perfBaseline-coreMicrometer = { module = "io.projectreactor:reactor-core-micrometer", version.ref = "baselinePerfCoreMicrometer" } reactor-perfBaseline-extra = { module = "io.projectreactor.addons:reactor-extra", version.ref = "baselinePerfExtra" } [plugins] diff --git a/reactor-core-micrometer/src/main/java/reactor/core/observability/micrometer/MicrometerMeterListenerConfiguration.java b/reactor-core-micrometer/src/main/java/reactor/core/observability/micrometer/MicrometerMeterListenerConfiguration.java index 6699700306..9de3f7f8fe 100644 --- a/reactor-core-micrometer/src/main/java/reactor/core/observability/micrometer/MicrometerMeterListenerConfiguration.java +++ b/reactor-core-micrometer/src/main/java/reactor/core/observability/micrometer/MicrometerMeterListenerConfiguration.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 VMware Inc. or its affiliates, All Rights Reserved. + * Copyright (c) 2022-2024 VMware Inc. or its affiliates, All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -93,9 +93,8 @@ static Tags resolveTags(Publisher source, Tags tags) { Scannable scannable = Scannable.from(source); if (scannable.isScanAvailable()) { - List discoveredTags = scannable.tagsDeduplicated() - .entrySet().stream() - .map(e -> Tag.of(e.getKey(), e.getValue())) + List discoveredTags = scannable.tags() + .map(t -> Tag.of(t.getT1(), t.getT2())) .collect(Collectors.toList()); return tags.and(discoveredTags); } diff --git a/reactor-core-micrometer/src/main/java/reactor/core/observability/micrometer/MicrometerObservationListenerConfiguration.java b/reactor-core-micrometer/src/main/java/reactor/core/observability/micrometer/MicrometerObservationListenerConfiguration.java index 0b87e210a9..337cbefd14 100644 --- a/reactor-core-micrometer/src/main/java/reactor/core/observability/micrometer/MicrometerObservationListenerConfiguration.java +++ b/reactor-core-micrometer/src/main/java/reactor/core/observability/micrometer/MicrometerObservationListenerConfiguration.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 VMware Inc. or its affiliates, All Rights Reserved. + * Copyright (c) 2022-2024 VMware Inc. or its affiliates, All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -70,9 +70,8 @@ static KeyValues resolveKeyValues(Publisher source, KeyValues tags) { Scannable scannable = Scannable.from(source); if (scannable.isScanAvailable()) { - List discoveredTags = scannable.tagsDeduplicated() - .entrySet().stream() - .map(e -> KeyValue.of(e.getKey(), e.getValue())) + List discoveredTags = scannable.tags() + .map(e -> KeyValue.of(e.getT1(), e.getT2())) .collect(Collectors.toList()); return tags.and(discoveredTags); } diff --git a/reactor-core/src/main/java/reactor/core/publisher/FluxMetrics.java b/reactor-core/src/main/java/reactor/core/publisher/FluxMetrics.java index 64704cc26c..395eb3001a 100644 --- a/reactor-core/src/main/java/reactor/core/publisher/FluxMetrics.java +++ b/reactor-core/src/main/java/reactor/core/publisher/FluxMetrics.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018-2022 VMware Inc. or its affiliates, All Rights Reserved. + * Copyright (c) 2018-2024 VMware Inc. or its affiliates, All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -295,9 +295,8 @@ static Tags resolveTags(Publisher source, Tags tags) { Scannable scannable = Scannable.from(source); if (scannable.isScanAvailable()) { - List discoveredTags = scannable.tagsDeduplicated() - .entrySet().stream() - .map(e -> Tag.of(e.getKey(), e.getValue())) + List discoveredTags = scannable.tags() + .map(t -> Tag.of(t.getT1(), t.getT2())) .collect(Collectors.toList()); return tags.and(discoveredTags); }