From 9a712829fa8853c9d09370ca209436084295b73b Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Tue, 4 Feb 2020 14:56:39 +0300 Subject: [PATCH 01/14] test: add benchmarks for http trace context extract and inject --- .../HtpTraceContextExtractBenchmark.java | 58 ++++++++++++++++ .../HttpTraceContextInjectBenchmark.java | 68 +++++++++++++++++++ jmh.gradle | 52 +++++++------- 3 files changed, 152 insertions(+), 26 deletions(-) create mode 100644 api/src/jmh/java/io/opentelemetry/trace/propagation/HtpTraceContextExtractBenchmark.java create mode 100644 api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HtpTraceContextExtractBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HtpTraceContextExtractBenchmark.java new file mode 100644 index 00000000000..383a7fa7426 --- /dev/null +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HtpTraceContextExtractBenchmark.java @@ -0,0 +1,58 @@ +package io.opentelemetry.trace.propagation; + +import io.opentelemetry.context.propagation.HttpTextFormat.Getter; +import io.opentelemetry.trace.SpanContext; +import java.util.LinkedHashMap; +import java.util.Map; +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.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.annotations.Warmup; + +@State(Scope.Thread) +public class HtpTraceContextExtractBenchmark { + + private String traceIdBase16 = "ff000000000000000000000000000041"; + private String spanIdBase16 = "ff00000000000041"; + private String traceparent = "traceparent"; + private String traceparentHeaderSampled = "00-" + traceIdBase16 + "-" + spanIdBase16 + "-01"; + private HttpTraceContext httpTraceContext; + private Map carrier; + private Getter> getter = + new Getter>() { + @Override + public String get(Map carrier, String key) { + return carrier.get(key); + } + }; + + @Setup + public void setup() { + this.httpTraceContext = new HttpTraceContext(); + this.carrier = new LinkedHashMap<>(); + this.carrier.put(traceparent, traceparentHeaderSampled); + } + + @Benchmark + @BenchmarkMode({Mode.Throughput, Mode.AverageTime}) + @Fork(1) + @Warmup(iterations = 5, time = 1) + @Measurement(iterations = 20, time = 100, timeUnit = TimeUnit.MILLISECONDS) + public SpanContext measureExtract() { + return httpTraceContext.extract(carrier, getter); + } + + @TearDown(Level.Iteration) + public void refreshCarrier() { + this.carrier = new LinkedHashMap<>(); + this.carrier.put(traceparent, traceparentHeaderSampled); + } +} diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java new file mode 100644 index 00000000000..b098dea3887 --- /dev/null +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java @@ -0,0 +1,68 @@ +package io.opentelemetry.trace.propagation; + +import io.opentelemetry.context.propagation.HttpTextFormat.Setter; +import io.opentelemetry.trace.SpanContext; +import io.opentelemetry.trace.SpanId; +import io.opentelemetry.trace.TraceFlags; +import io.opentelemetry.trace.TraceId; +import io.opentelemetry.trace.Tracestate; +import java.util.LinkedHashMap; +import java.util.Map; +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.Scope; +import org.openjdk.jmh.annotations.Setup; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.annotations.Warmup; + +@State(Scope.Thread) +public class HttpTraceContextInjectBenchmark { + + private String traceIdBase16 = "ff000000000000000000000000000041"; + private TraceId traceId = TraceId.fromLowerBase16(traceIdBase16, 0); + private String spanIdBase16 = "ff00000000000041"; + private SpanId spanId = SpanId.fromLowerBase16(spanIdBase16, 0); + private byte sampledTraceOptionsBytes = 1; + private TraceFlags sampledTraceOptions = TraceFlags.fromByte(sampledTraceOptionsBytes); + private Tracestate traceStateDefault = Tracestate.builder().build(); + + private HttpTraceContext httpTraceContext; + private Map carrier; + private Setter> setter = + new Setter>() { + @Override + public void set(Map carrier, String key, String value) { + carrier.put(key, value); + } + }; + + @Setup + public void setup() { + this.httpTraceContext = new HttpTraceContext(); + this.carrier = new LinkedHashMap<>(); + } + + @Benchmark + @BenchmarkMode({Mode.Throughput, Mode.AverageTime}) + @Fork(1) + @Warmup(iterations = 5, time = 1) + @Measurement(iterations = 20, time = 100, timeUnit = TimeUnit.MILLISECONDS) + public Map measureInject() { + httpTraceContext.inject( + SpanContext.create(traceId, spanId, sampledTraceOptions, traceStateDefault), + carrier, + setter); + return carrier; + } + + @TearDown(Level.Iteration) + public void refreshCarrier() { + this.carrier = new LinkedHashMap<>(); + } +} diff --git a/jmh.gradle b/jmh.gradle index 365d3c829fc..38dd55ddcef 100644 --- a/jmh.gradle +++ b/jmh.gradle @@ -52,10 +52,10 @@ sourceSets { jmh { - java.srcDir 'src/jmh/java' - resources.srcDir 'src/jmh/resources' - compileClasspath += main.output - runtimeClasspath += main.output + java.srcDir 'src/jmh/java' + resources.srcDir 'src/jmh/resources' + compileClasspath += main.output + runtimeClasspath += main.output } } @@ -68,17 +68,17 @@ dependencies { configurations { jmhCompile { - extendsFrom compile + extendsFrom compile } jmhImplementation { - extendsFrom implementation - extendsFrom jmhCompile + extendsFrom implementation + extendsFrom jmhCompile } jmh { - extendsFrom runtime - extendsFrom jmhCompile + extendsFrom runtime + extendsFrom jmhCompile } } @@ -107,36 +107,36 @@ task jmhJar(type: Jar) { group 'Build' classifier "jmh" doFirst { - manifest { - attributes('Main-Class': 'org.openjdk.jmh.Main', 'Class-Path': ([jar.archiveName] + configurations.runtimeClasspath.files.collect { it.getName() }).join(' ')) - } + manifest { + attributes('Main-Class': 'org.openjdk.jmh.Main', 'Class-Path': ([jar.archiveFileName] + configurations.runtimeClasspath.files.collect { it.getName() }).join(' ')) + } } from { - // Only include JMH benchmarks and JMH in Jar file - (configurations.jmhRuntimeClasspath.files - configurations.runtimeClasspath.files).collect { it.isDirectory() ? it : zipTree(it) } + // Only include JMH benchmarks and JMH in Jar file + (configurations.jmhRuntimeClasspath.files - configurations.runtimeClasspath.files).collect { it.isDirectory() ? it : zipTree(it) } } { - exclude 'META-INF/*.SF' - exclude 'META-INF/*.DSA' - exclude 'META-INF/*.RSA' - exclude 'log4j.properties' + exclude 'META-INF/*.SF' + exclude 'META-INF/*.DSA' + exclude 'META-INF/*.RSA' + exclude 'log4j.properties' } from sourceSets.jmh.output } artifacts { if (benchmarksAvailable) { - archives jmhJar + archives jmhJar } } publishing { publications { - mavenJava(MavenPublication) { - if (benchmarksAvailable) { - artifact jmhJar { - classifier "jmh" - } - } - } + mavenJava(MavenPublication) { + if (benchmarksAvailable) { + artifact jmhJar { + classifier "jmh" + } + } + } } } From fd256fded0a934912dc00654a1752589737a2e84 Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Tue, 4 Feb 2020 15:08:51 +0300 Subject: [PATCH 02/14] test: add benchmarks for http trace context extract and inject --- ...ractBenchmark.java => HttpTraceContextExtractBenchmark.java} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename api/src/jmh/java/io/opentelemetry/trace/propagation/{HtpTraceContextExtractBenchmark.java => HttpTraceContextExtractBenchmark.java} (97%) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HtpTraceContextExtractBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java similarity index 97% rename from api/src/jmh/java/io/opentelemetry/trace/propagation/HtpTraceContextExtractBenchmark.java rename to api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java index 383a7fa7426..0bc52a8f1a4 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HtpTraceContextExtractBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java @@ -18,7 +18,7 @@ import org.openjdk.jmh.annotations.Warmup; @State(Scope.Thread) -public class HtpTraceContextExtractBenchmark { +public class HttpTraceContextExtractBenchmark { private String traceIdBase16 = "ff000000000000000000000000000041"; private String spanIdBase16 = "ff00000000000041"; From 22d1601be038e1269d4fb015df999269e5a051ae Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Tue, 4 Feb 2020 15:33:39 +0300 Subject: [PATCH 03/14] docs: add docs --- .../HttpTraceContextExtractBenchmark.java | 16 ++++++++++++++++ .../HttpTraceContextInjectBenchmark.java | 19 +++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java index 0bc52a8f1a4..fa65ffb1ce4 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java @@ -1,3 +1,19 @@ +/* + * Copyright 2020, OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * 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 io.opentelemetry.trace.propagation; import io.opentelemetry.context.propagation.HttpTextFormat.Getter; diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java index b098dea3887..1995a732ba2 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java @@ -1,3 +1,19 @@ +/* + * Copyright 2020, OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * 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 io.opentelemetry.trace.propagation; import io.opentelemetry.context.propagation.HttpTextFormat.Setter; @@ -48,6 +64,9 @@ public void setup() { this.carrier = new LinkedHashMap<>(); } + /** + * Benchmark for measuring inject with default trace state and sampled trace options. + */ @Benchmark @BenchmarkMode({Mode.Throughput, Mode.AverageTime}) @Fork(1) From ad5de141cba53cb97161c1fa7e5573d165cc12ef Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Tue, 4 Feb 2020 15:37:36 +0300 Subject: [PATCH 04/14] style: apply google code style --- .../trace/propagation/HttpTraceContextInjectBenchmark.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java index 1995a732ba2..9324f4bb3ba 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java @@ -64,9 +64,7 @@ public void setup() { this.carrier = new LinkedHashMap<>(); } - /** - * Benchmark for measuring inject with default trace state and sampled trace options. - */ + /** Benchmark for measuring inject with default trace state and sampled trace options. */ @Benchmark @BenchmarkMode({Mode.Throughput, Mode.AverageTime}) @Fork(1) From 47da1efd8546d8032b0ff1fd1f24726939afe8a3 Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Wed, 5 Feb 2020 22:27:11 +0300 Subject: [PATCH 05/14] style: format jmh.gradle, use not deprecated archiveFileName --- jmh.gradle | 52 ++++++++++++++++++++++++++-------------------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/jmh.gradle b/jmh.gradle index 365d3c829fc..38dd55ddcef 100644 --- a/jmh.gradle +++ b/jmh.gradle @@ -52,10 +52,10 @@ sourceSets { jmh { - java.srcDir 'src/jmh/java' - resources.srcDir 'src/jmh/resources' - compileClasspath += main.output - runtimeClasspath += main.output + java.srcDir 'src/jmh/java' + resources.srcDir 'src/jmh/resources' + compileClasspath += main.output + runtimeClasspath += main.output } } @@ -68,17 +68,17 @@ dependencies { configurations { jmhCompile { - extendsFrom compile + extendsFrom compile } jmhImplementation { - extendsFrom implementation - extendsFrom jmhCompile + extendsFrom implementation + extendsFrom jmhCompile } jmh { - extendsFrom runtime - extendsFrom jmhCompile + extendsFrom runtime + extendsFrom jmhCompile } } @@ -107,36 +107,36 @@ task jmhJar(type: Jar) { group 'Build' classifier "jmh" doFirst { - manifest { - attributes('Main-Class': 'org.openjdk.jmh.Main', 'Class-Path': ([jar.archiveName] + configurations.runtimeClasspath.files.collect { it.getName() }).join(' ')) - } + manifest { + attributes('Main-Class': 'org.openjdk.jmh.Main', 'Class-Path': ([jar.archiveFileName] + configurations.runtimeClasspath.files.collect { it.getName() }).join(' ')) + } } from { - // Only include JMH benchmarks and JMH in Jar file - (configurations.jmhRuntimeClasspath.files - configurations.runtimeClasspath.files).collect { it.isDirectory() ? it : zipTree(it) } + // Only include JMH benchmarks and JMH in Jar file + (configurations.jmhRuntimeClasspath.files - configurations.runtimeClasspath.files).collect { it.isDirectory() ? it : zipTree(it) } } { - exclude 'META-INF/*.SF' - exclude 'META-INF/*.DSA' - exclude 'META-INF/*.RSA' - exclude 'log4j.properties' + exclude 'META-INF/*.SF' + exclude 'META-INF/*.DSA' + exclude 'META-INF/*.RSA' + exclude 'log4j.properties' } from sourceSets.jmh.output } artifacts { if (benchmarksAvailable) { - archives jmhJar + archives jmhJar } } publishing { publications { - mavenJava(MavenPublication) { - if (benchmarksAvailable) { - artifact jmhJar { - classifier "jmh" - } - } - } + mavenJava(MavenPublication) { + if (benchmarksAvailable) { + artifact jmhJar { + classifier "jmh" + } + } + } } } From f1177d260b884bfe229400ad3ff136c73bd885a0 Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Fri, 7 Feb 2020 23:07:16 +0300 Subject: [PATCH 06/14] test: add params for trace id and span id --- .../HttpTraceContextExtractBenchmark.java | 41 +++++++++++++++---- .../HttpTraceContextInjectBenchmark.java | 40 +++++++++++++++--- 2 files changed, 68 insertions(+), 13 deletions(-) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java index fa65ffb1ce4..77e1329c937 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java @@ -27,6 +27,7 @@ import org.openjdk.jmh.annotations.Level; import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Scope; import org.openjdk.jmh.annotations.Setup; import org.openjdk.jmh.annotations.State; @@ -36,10 +37,25 @@ @State(Scope.Thread) public class HttpTraceContextExtractBenchmark { - private String traceIdBase16 = "ff000000000000000000000000000041"; - private String spanIdBase16 = "ff00000000000041"; + @Param({ + "905734c59b913b4a905734c59b913b4a", + "21196a77f299580e21196a77f299580e", + "2e7d0ad2390617702e7d0ad239061770", + "905734c59b913b4a905734c59b913b4a", + "68ec932c33b3f2ee68ec932c33b3f2ee" + }) + public static String traceIdBase16; + + @Param({ + "9909983295041501", + "993a97ee3691eb26", + "d49582a2de984b86", + "776ff807b787538a", + "68ec932c33b3f2ee" + }) + public static String spanIdBase16; + private String traceparent = "traceparent"; - private String traceparentHeaderSampled = "00-" + traceIdBase16 + "-" + spanIdBase16 + "-01"; private HttpTraceContext httpTraceContext; private Map carrier; private Getter> getter = @@ -50,11 +66,22 @@ public String get(Map carrier, String key) { } }; + @State(Scope.Thread) + public static class HttpTraceContextExtractState { + + public String traceparentHeaderSampled; + + @Setup + public void setup() { + this.traceparentHeaderSampled = "00-" + traceIdBase16 + "-" + spanIdBase16 + "-01"; + } + } + @Setup - public void setup() { + public void setup(HttpTraceContextExtractState state) { this.httpTraceContext = new HttpTraceContext(); this.carrier = new LinkedHashMap<>(); - this.carrier.put(traceparent, traceparentHeaderSampled); + this.carrier.put(traceparent, state.traceparentHeaderSampled); } @Benchmark @@ -67,8 +94,8 @@ public SpanContext measureExtract() { } @TearDown(Level.Iteration) - public void refreshCarrier() { + public void refreshCarrier(HttpTraceContextExtractState state) { this.carrier = new LinkedHashMap<>(); - this.carrier.put(traceparent, traceparentHeaderSampled); + this.carrier.put(traceparent, state.traceparentHeaderSampled); } } diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java index 9324f4bb3ba..6886d25d0d6 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java @@ -31,6 +31,7 @@ import org.openjdk.jmh.annotations.Level; import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Scope; import org.openjdk.jmh.annotations.Setup; import org.openjdk.jmh.annotations.State; @@ -40,10 +41,24 @@ @State(Scope.Thread) public class HttpTraceContextInjectBenchmark { - private String traceIdBase16 = "ff000000000000000000000000000041"; - private TraceId traceId = TraceId.fromLowerBase16(traceIdBase16, 0); - private String spanIdBase16 = "ff00000000000041"; - private SpanId spanId = SpanId.fromLowerBase16(spanIdBase16, 0); + @Param({ + "905734c59b913b4a905734c59b913b4a", + "21196a77f299580e21196a77f299580e", + "2e7d0ad2390617702e7d0ad239061770", + "905734c59b913b4a905734c59b913b4a", + "68ec932c33b3f2ee68ec932c33b3f2ee" + }) + public static String traceIdBase16; + + @Param({ + "9909983295041501", + "993a97ee3691eb26", + "d49582a2de984b86", + "776ff807b787538a", + "68ec932c33b3f2ee" + }) + public static String spanIdBase16; + private byte sampledTraceOptionsBytes = 1; private TraceFlags sampledTraceOptions = TraceFlags.fromByte(sampledTraceOptionsBytes); private Tracestate traceStateDefault = Tracestate.builder().build(); @@ -58,6 +73,19 @@ public void set(Map carrier, String key, String value) { } }; + @State(Scope.Thread) + public static class HttpTraceContextInjectState { + + public TraceId traceId; + public SpanId spanId; + + @Setup + public void setup() { + this.traceId = TraceId.fromLowerBase16(traceIdBase16, 0); + this.spanId = SpanId.fromLowerBase16(spanIdBase16, 0); + } + } + @Setup public void setup() { this.httpTraceContext = new HttpTraceContext(); @@ -70,9 +98,9 @@ public void setup() { @Fork(1) @Warmup(iterations = 5, time = 1) @Measurement(iterations = 20, time = 100, timeUnit = TimeUnit.MILLISECONDS) - public Map measureInject() { + public Map measureInject(HttpTraceContextInjectState state) { httpTraceContext.inject( - SpanContext.create(traceId, spanId, sampledTraceOptions, traceStateDefault), + SpanContext.create(state.traceId, state.spanId, sampledTraceOptions, traceStateDefault), carrier, setter); return carrier; From fb518d0f5bb285fcd4bc185cd9f2d14b60c4afd9 Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Fri, 7 Feb 2020 23:42:19 +0300 Subject: [PATCH 07/14] fix: fix merge conflicts --- .../trace/propagation/HttpTraceContextInjectBenchmark.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java index 6886d25d0d6..1b7a076e74c 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java @@ -21,7 +21,7 @@ import io.opentelemetry.trace.SpanId; import io.opentelemetry.trace.TraceFlags; import io.opentelemetry.trace.TraceId; -import io.opentelemetry.trace.Tracestate; +import io.opentelemetry.trace.TraceState; import java.util.LinkedHashMap; import java.util.Map; import java.util.concurrent.TimeUnit; @@ -61,7 +61,7 @@ public class HttpTraceContextInjectBenchmark { private byte sampledTraceOptionsBytes = 1; private TraceFlags sampledTraceOptions = TraceFlags.fromByte(sampledTraceOptionsBytes); - private Tracestate traceStateDefault = Tracestate.builder().build(); + private TraceState traceStateDefault = TraceState.builder().build(); private HttpTraceContext httpTraceContext; private Map carrier; From fbeb6bfbcc2f15d7f952159dcb090582713c1962 Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Sat, 8 Feb 2020 00:47:55 +0300 Subject: [PATCH 08/14] feat: use HashMap move params to inner state --- .../HttpTraceContextExtractBenchmark.java | 39 ++++++++++--------- .../HttpTraceContextInjectBenchmark.java | 39 ++++++++++--------- 2 files changed, 40 insertions(+), 38 deletions(-) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java index 77e1329c937..98ebe4c676c 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java @@ -18,6 +18,7 @@ import io.opentelemetry.context.propagation.HttpTextFormat.Getter; import io.opentelemetry.trace.SpanContext; +import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.concurrent.TimeUnit; @@ -37,24 +38,6 @@ @State(Scope.Thread) public class HttpTraceContextExtractBenchmark { - @Param({ - "905734c59b913b4a905734c59b913b4a", - "21196a77f299580e21196a77f299580e", - "2e7d0ad2390617702e7d0ad239061770", - "905734c59b913b4a905734c59b913b4a", - "68ec932c33b3f2ee68ec932c33b3f2ee" - }) - public static String traceIdBase16; - - @Param({ - "9909983295041501", - "993a97ee3691eb26", - "d49582a2de984b86", - "776ff807b787538a", - "68ec932c33b3f2ee" - }) - public static String spanIdBase16; - private String traceparent = "traceparent"; private HttpTraceContext httpTraceContext; private Map carrier; @@ -69,6 +52,24 @@ public String get(Map carrier, String key) { @State(Scope.Thread) public static class HttpTraceContextExtractState { + @Param({ + "905734c59b913b4a905734c59b913b4a", + "21196a77f299580e21196a77f299580e", + "2e7d0ad2390617702e7d0ad239061770", + "905734c59b913b4a905734c59b913b4a", + "68ec932c33b3f2ee68ec932c33b3f2ee" + }) + public String traceIdBase16; + + @Param({ + "9909983295041501", + "993a97ee3691eb26", + "d49582a2de984b86", + "776ff807b787538a", + "68ec932c33b3f2ee" + }) + public String spanIdBase16; + public String traceparentHeaderSampled; @Setup @@ -95,7 +96,7 @@ public SpanContext measureExtract() { @TearDown(Level.Iteration) public void refreshCarrier(HttpTraceContextExtractState state) { - this.carrier = new LinkedHashMap<>(); + this.carrier = new HashMap<>(); this.carrier.put(traceparent, state.traceparentHeaderSampled); } } diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java index 1b7a076e74c..b7ada554b9a 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java @@ -22,6 +22,7 @@ import io.opentelemetry.trace.TraceFlags; import io.opentelemetry.trace.TraceId; import io.opentelemetry.trace.TraceState; +import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; import java.util.concurrent.TimeUnit; @@ -41,24 +42,6 @@ @State(Scope.Thread) public class HttpTraceContextInjectBenchmark { - @Param({ - "905734c59b913b4a905734c59b913b4a", - "21196a77f299580e21196a77f299580e", - "2e7d0ad2390617702e7d0ad239061770", - "905734c59b913b4a905734c59b913b4a", - "68ec932c33b3f2ee68ec932c33b3f2ee" - }) - public static String traceIdBase16; - - @Param({ - "9909983295041501", - "993a97ee3691eb26", - "d49582a2de984b86", - "776ff807b787538a", - "68ec932c33b3f2ee" - }) - public static String spanIdBase16; - private byte sampledTraceOptionsBytes = 1; private TraceFlags sampledTraceOptions = TraceFlags.fromByte(sampledTraceOptionsBytes); private TraceState traceStateDefault = TraceState.builder().build(); @@ -76,6 +59,24 @@ public void set(Map carrier, String key, String value) { @State(Scope.Thread) public static class HttpTraceContextInjectState { + @Param({ + "905734c59b913b4a905734c59b913b4a", + "21196a77f299580e21196a77f299580e", + "2e7d0ad2390617702e7d0ad239061770", + "905734c59b913b4a905734c59b913b4a", + "68ec932c33b3f2ee68ec932c33b3f2ee" + }) + public String traceIdBase16; + + @Param({ + "9909983295041501", + "993a97ee3691eb26", + "d49582a2de984b86", + "776ff807b787538a", + "68ec932c33b3f2ee" + }) + public String spanIdBase16; + public TraceId traceId; public SpanId spanId; @@ -108,6 +109,6 @@ public Map measureInject(HttpTraceContextInjectState state) { @TearDown(Level.Iteration) public void refreshCarrier() { - this.carrier = new LinkedHashMap<>(); + this.carrier = new HashMap<>(); } } From 4ace58035ae8cc784ea6034346e2986d27d2d2d2 Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Sat, 8 Feb 2020 00:56:24 +0300 Subject: [PATCH 09/14] feat: use same measurement params --- .../HttpTraceContextExtractBenchmark.java | 22 +++++++++---------- .../HttpTraceContextInjectBenchmark.java | 2 +- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java index 98ebe4c676c..86e87a122fc 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java @@ -53,20 +53,20 @@ public String get(Map carrier, String key) { public static class HttpTraceContextExtractState { @Param({ - "905734c59b913b4a905734c59b913b4a", - "21196a77f299580e21196a77f299580e", - "2e7d0ad2390617702e7d0ad239061770", - "905734c59b913b4a905734c59b913b4a", - "68ec932c33b3f2ee68ec932c33b3f2ee" + "905734c59b913b4a905734c59b913b4a", + "21196a77f299580e21196a77f299580e", + "2e7d0ad2390617702e7d0ad239061770", + "905734c59b913b4a905734c59b913b4a", + "68ec932c33b3f2ee68ec932c33b3f2ee" }) public String traceIdBase16; @Param({ - "9909983295041501", - "993a97ee3691eb26", - "d49582a2de984b86", - "776ff807b787538a", - "68ec932c33b3f2ee" + "9909983295041501", + "993a97ee3691eb26", + "d49582a2de984b86", + "776ff807b787538a", + "68ec932c33b3f2ee" }) public String spanIdBase16; @@ -89,7 +89,7 @@ public void setup(HttpTraceContextExtractState state) { @BenchmarkMode({Mode.Throughput, Mode.AverageTime}) @Fork(1) @Warmup(iterations = 5, time = 1) - @Measurement(iterations = 20, time = 100, timeUnit = TimeUnit.MILLISECONDS) + @Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.MILLISECONDS) public SpanContext measureExtract() { return httpTraceContext.extract(carrier, getter); } diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java index b7ada554b9a..75291f52f1d 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java @@ -98,7 +98,7 @@ public void setup() { @BenchmarkMode({Mode.Throughput, Mode.AverageTime}) @Fork(1) @Warmup(iterations = 5, time = 1) - @Measurement(iterations = 20, time = 100, timeUnit = TimeUnit.MILLISECONDS) + @Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.MILLISECONDS) public Map measureInject(HttpTraceContextInjectState state) { httpTraceContext.inject( SpanContext.create(state.traceId, state.spanId, sampledTraceOptions, traceStateDefault), From 76b3f5d65eba6e1ec66dfa3eb591d8e3aa192b23 Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Sat, 8 Feb 2020 01:01:48 +0300 Subject: [PATCH 10/14] fix: apply google code style --- .../HttpTraceContextInjectBenchmark.java | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java index 75291f52f1d..73a096f682e 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java @@ -60,20 +60,20 @@ public void set(Map carrier, String key, String value) { public static class HttpTraceContextInjectState { @Param({ - "905734c59b913b4a905734c59b913b4a", - "21196a77f299580e21196a77f299580e", - "2e7d0ad2390617702e7d0ad239061770", - "905734c59b913b4a905734c59b913b4a", - "68ec932c33b3f2ee68ec932c33b3f2ee" + "905734c59b913b4a905734c59b913b4a", + "21196a77f299580e21196a77f299580e", + "2e7d0ad2390617702e7d0ad239061770", + "905734c59b913b4a905734c59b913b4a", + "68ec932c33b3f2ee68ec932c33b3f2ee" }) public String traceIdBase16; @Param({ - "9909983295041501", - "993a97ee3691eb26", - "d49582a2de984b86", - "776ff807b787538a", - "68ec932c33b3f2ee" + "9909983295041501", + "993a97ee3691eb26", + "d49582a2de984b86", + "776ff807b787538a", + "68ec932c33b3f2ee" }) public String spanIdBase16; From 6294048e91653ee5df33d470e4c63a447c90b3d0 Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Sat, 8 Feb 2020 21:49:29 +0300 Subject: [PATCH 11/14] fix: extract span creation for more clear benchmark --- .../HttpTraceContextInjectBenchmark.java | 23 +++++++++---------- 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java index 73a096f682e..7e341a0e42d 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java @@ -42,10 +42,6 @@ @State(Scope.Thread) public class HttpTraceContextInjectBenchmark { - private byte sampledTraceOptionsBytes = 1; - private TraceFlags sampledTraceOptions = TraceFlags.fromByte(sampledTraceOptionsBytes); - private TraceState traceStateDefault = TraceState.builder().build(); - private HttpTraceContext httpTraceContext; private Map carrier; private Setter> setter = @@ -77,13 +73,19 @@ public static class HttpTraceContextInjectState { }) public String spanIdBase16; - public TraceId traceId; - public SpanId spanId; + public SpanContext spanContext; + private byte sampledTraceOptionsBytes = 1; + private TraceFlags sampledTraceOptions = TraceFlags.fromByte(sampledTraceOptionsBytes); + private TraceState traceStateDefault = TraceState.builder().build(); @Setup public void setup() { - this.traceId = TraceId.fromLowerBase16(traceIdBase16, 0); - this.spanId = SpanId.fromLowerBase16(spanIdBase16, 0); + this.spanContext = + SpanContext.create( + TraceId.fromLowerBase16(traceIdBase16, 0), + SpanId.fromLowerBase16(spanIdBase16, 0), + sampledTraceOptions, + traceStateDefault); } } @@ -100,10 +102,7 @@ public void setup() { @Warmup(iterations = 5, time = 1) @Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.MILLISECONDS) public Map measureInject(HttpTraceContextInjectState state) { - httpTraceContext.inject( - SpanContext.create(state.traceId, state.spanId, sampledTraceOptions, traceStateDefault), - carrier, - setter); + httpTraceContext.inject(state.spanContext, carrier, setter); return carrier; } From 74b1734d356267eb2e6137086499531aa7704fc1 Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Fri, 14 Feb 2020 19:20:52 +0300 Subject: [PATCH 12/14] test: use vector of traceparents, increase iterations to 50k --- .../HttpTraceContextExtractBenchmark.java | 56 ++++++------------- .../HttpTraceContextInjectBenchmark.java | 2 +- 2 files changed, 18 insertions(+), 40 deletions(-) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java index 86e87a122fc..459c2993ffa 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java @@ -18,8 +18,10 @@ import io.opentelemetry.context.propagation.HttpTextFormat.Getter; import io.opentelemetry.trace.SpanContext; +import java.util.Arrays; import java.util.HashMap; import java.util.LinkedHashMap; +import java.util.List; import java.util.Map; import java.util.concurrent.TimeUnit; import org.openjdk.jmh.annotations.Benchmark; @@ -28,7 +30,6 @@ import org.openjdk.jmh.annotations.Level; import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; -import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Scope; import org.openjdk.jmh.annotations.Setup; import org.openjdk.jmh.annotations.State; @@ -39,8 +40,8 @@ public class HttpTraceContextExtractBenchmark { private String traceparent = "traceparent"; - private HttpTraceContext httpTraceContext; - private Map carrier; + private HttpTraceContext httpTraceContext = new HttpTraceContext(); + private Map carrier = new LinkedHashMap<>(); private Getter> getter = new Getter>() { @Override @@ -48,55 +49,32 @@ public String get(Map carrier, String key) { return carrier.get(key); } }; - - @State(Scope.Thread) - public static class HttpTraceContextExtractState { - - @Param({ - "905734c59b913b4a905734c59b913b4a", - "21196a77f299580e21196a77f299580e", - "2e7d0ad2390617702e7d0ad239061770", - "905734c59b913b4a905734c59b913b4a", - "68ec932c33b3f2ee68ec932c33b3f2ee" - }) - public String traceIdBase16; - - @Param({ - "9909983295041501", - "993a97ee3691eb26", - "d49582a2de984b86", - "776ff807b787538a", - "68ec932c33b3f2ee" - }) - public String spanIdBase16; - - public String traceparentHeaderSampled; - - @Setup - public void setup() { - this.traceparentHeaderSampled = "00-" + traceIdBase16 + "-" + spanIdBase16 + "-01"; - } - } + private List traceparentsHeaders = + Arrays.asList( + "00-905734c59b913b4a905734c59b913b4a-9909983295041501-01", + "00-21196a77f299580e21196a77f299580e-993a97ee3691eb26-00", + "00-2e7d0ad2390617702e7d0ad239061770-d49582a2de984b86-01", + "00-905734c59b913b4a905734c59b913b4a-776ff807b787538a-00", + "00-68ec932c33b3f2ee68ec932c33b3f2ee-68ec932c33b3f2ee-00"); + private Integer iteration = 0; @Setup - public void setup(HttpTraceContextExtractState state) { - this.httpTraceContext = new HttpTraceContext(); - this.carrier = new LinkedHashMap<>(); - this.carrier.put(traceparent, state.traceparentHeaderSampled); + public void setup() { + carrier.put(traceparent, traceparentsHeaders.get(0)); } @Benchmark @BenchmarkMode({Mode.Throughput, Mode.AverageTime}) @Fork(1) @Warmup(iterations = 5, time = 1) - @Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.MILLISECONDS) + @Measurement(iterations = 50_000, time = 1, timeUnit = TimeUnit.MILLISECONDS) public SpanContext measureExtract() { return httpTraceContext.extract(carrier, getter); } @TearDown(Level.Iteration) - public void refreshCarrier(HttpTraceContextExtractState state) { + public void tearDown() { this.carrier = new HashMap<>(); - this.carrier.put(traceparent, state.traceparentHeaderSampled); + this.carrier.put(traceparent, traceparentsHeaders.get(++iteration % traceparentsHeaders.size())); } } diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java index 7e341a0e42d..1629c9da840 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java @@ -100,7 +100,7 @@ public void setup() { @BenchmarkMode({Mode.Throughput, Mode.AverageTime}) @Fork(1) @Warmup(iterations = 5, time = 1) - @Measurement(iterations = 10, time = 1, timeUnit = TimeUnit.MILLISECONDS) + @Measurement(iterations = 50_000, time = 1, timeUnit = TimeUnit.MILLISECONDS) public Map measureInject(HttpTraceContextInjectState state) { httpTraceContext.inject(state.spanContext, carrier, setter); return carrier; From c9f61a674642e2a140e049e23052e1908d120b9b Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Fri, 14 Feb 2020 19:23:34 +0300 Subject: [PATCH 13/14] style: apply google code style --- .../trace/propagation/HttpTraceContextExtractBenchmark.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java index 459c2993ffa..ecc89f14ebb 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextExtractBenchmark.java @@ -75,6 +75,7 @@ public SpanContext measureExtract() { @TearDown(Level.Iteration) public void tearDown() { this.carrier = new HashMap<>(); - this.carrier.put(traceparent, traceparentsHeaders.get(++iteration % traceparentsHeaders.size())); + this.carrier.put( + traceparent, traceparentsHeaders.get(++iteration % traceparentsHeaders.size())); } } From da76a061df6bc2de15c4524af89b3daa11cb2e3c Mon Sep 17 00:00:00 2001 From: Uladzislau Kiva Date: Fri, 14 Feb 2020 20:50:10 +0300 Subject: [PATCH 14/14] feat: use vector of traceparents in inject benchmark --- .../HttpTraceContextInjectBenchmark.java | 69 +++++++------------ 1 file changed, 26 insertions(+), 43 deletions(-) diff --git a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java index 1629c9da840..926886a1765 100644 --- a/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java +++ b/api/src/jmh/java/io/opentelemetry/trace/propagation/HttpTraceContextInjectBenchmark.java @@ -22,8 +22,9 @@ import io.opentelemetry.trace.TraceFlags; import io.opentelemetry.trace.TraceId; import io.opentelemetry.trace.TraceState; -import java.util.HashMap; +import java.util.Arrays; import java.util.LinkedHashMap; +import java.util.List; import java.util.Map; import java.util.concurrent.TimeUnit; import org.openjdk.jmh.annotations.Benchmark; @@ -32,7 +33,6 @@ import org.openjdk.jmh.annotations.Level; import org.openjdk.jmh.annotations.Measurement; import org.openjdk.jmh.annotations.Mode; -import org.openjdk.jmh.annotations.Param; import org.openjdk.jmh.annotations.Scope; import org.openjdk.jmh.annotations.Setup; import org.openjdk.jmh.annotations.State; @@ -51,43 +51,15 @@ public void set(Map carrier, String key, String value) { carrier.put(key, value); } }; - - @State(Scope.Thread) - public static class HttpTraceContextInjectState { - - @Param({ - "905734c59b913b4a905734c59b913b4a", - "21196a77f299580e21196a77f299580e", - "2e7d0ad2390617702e7d0ad239061770", - "905734c59b913b4a905734c59b913b4a", - "68ec932c33b3f2ee68ec932c33b3f2ee" - }) - public String traceIdBase16; - - @Param({ - "9909983295041501", - "993a97ee3691eb26", - "d49582a2de984b86", - "776ff807b787538a", - "68ec932c33b3f2ee" - }) - public String spanIdBase16; - - public SpanContext spanContext; - private byte sampledTraceOptionsBytes = 1; - private TraceFlags sampledTraceOptions = TraceFlags.fromByte(sampledTraceOptionsBytes); - private TraceState traceStateDefault = TraceState.builder().build(); - - @Setup - public void setup() { - this.spanContext = - SpanContext.create( - TraceId.fromLowerBase16(traceIdBase16, 0), - SpanId.fromLowerBase16(spanIdBase16, 0), - sampledTraceOptions, - traceStateDefault); - } - } + private List spanContexts = + Arrays.asList( + createTestSpanContext("905734c59b913b4a905734c59b913b4a", "9909983295041501"), + createTestSpanContext("21196a77f299580e21196a77f299580e", "993a97ee3691eb26"), + createTestSpanContext("2e7d0ad2390617702e7d0ad239061770", "d49582a2de984b86"), + createTestSpanContext("905734c59b913b4a905734c59b913b4a", "776ff807b787538a"), + createTestSpanContext("68ec932c33b3f2ee68ec932c33b3f2ee", "68ec932c33b3f2ee")); + private Integer iteration = 0; + private SpanContext contextToTest = spanContexts.get(iteration); @Setup public void setup() { @@ -101,13 +73,24 @@ public void setup() { @Fork(1) @Warmup(iterations = 5, time = 1) @Measurement(iterations = 50_000, time = 1, timeUnit = TimeUnit.MILLISECONDS) - public Map measureInject(HttpTraceContextInjectState state) { - httpTraceContext.inject(state.spanContext, carrier, setter); + public Map measureInject() { + httpTraceContext.inject(contextToTest, carrier, setter); return carrier; } @TearDown(Level.Iteration) - public void refreshCarrier() { - this.carrier = new HashMap<>(); + public void tearDown() { + this.contextToTest = spanContexts.get(++iteration % spanContexts.size()); + } + + private SpanContext createTestSpanContext(String traceId, String spanId) { + byte sampledTraceOptionsBytes = 1; + TraceFlags sampledTraceOptions = TraceFlags.fromByte(sampledTraceOptionsBytes); + TraceState traceStateDefault = TraceState.builder().build(); + return SpanContext.create( + TraceId.fromLowerBase16(traceId, 0), + SpanId.fromLowerBase16(spanId, 0), + sampledTraceOptions, + traceStateDefault); } }