From 65297f98b8bcf9f9585ed6479c74cabcdd1b0edd Mon Sep 17 00:00:00 2001 From: David Sondermann Date: Fri, 23 Sep 2022 05:01:27 +0200 Subject: [PATCH 1/6] Fix handling of compressionMethod `none` in GrpcExporterBuilder --- .../internal/grpc/GrpcExporterBuilder.java | 2 +- .../grpc/GrpcExporterBuilderTest.java | 183 ++++++++++++++++++ 2 files changed, 184 insertions(+), 1 deletion(-) create mode 100644 exporters/common/src/test/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilderTest.java diff --git a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java index 316266dfd4b..48fcbe470f1 100644 --- a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java +++ b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java @@ -98,7 +98,7 @@ public GrpcExporterBuilder setEndpoint(String endpoint) { } public GrpcExporterBuilder setCompression(String compressionMethod) { - this.compressionEnabled = true; + this.compressionEnabled = compressionMethod.equals("gzip"); return this; } diff --git a/exporters/common/src/test/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilderTest.java b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilderTest.java new file mode 100644 index 00000000000..9bdf242cf6d --- /dev/null +++ b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilderTest.java @@ -0,0 +1,183 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.exporter.internal.grpc; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import com.google.common.util.concurrent.Futures; +import com.google.common.util.concurrent.ListenableFuture; +import io.grpc.CallOptions; +import io.grpc.Channel; +import io.grpc.Codec; +import io.grpc.ManagedChannel; +import io.opentelemetry.exporter.internal.marshal.Marshaler; +import java.net.URI; +import java.util.function.BiFunction; +import java.util.function.Supplier; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +class GrpcExporterBuilderTest { + + private final ManagedChannel channel = mock(ManagedChannel.class); + + private GrpcExporterBuilder builder; + + @BeforeEach + @SuppressWarnings("unchecked") + void setUp() { + Supplier>> grpcStubFactory = + mock(Supplier.class); + when(grpcStubFactory.get()) + .thenReturn((c, s) -> new TestMarshalerServiceStub(c, CallOptions.DEFAULT)); + + builder = + GrpcExporter.builder( + "otlp", "span", 0, URI.create("http://localhost:4317"), grpcStubFactory, "/test"); + } + + @Test + void compressionDefault() { + GrpcExporter exporter = builder.build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + OkHttpGrpcExporter.class, + otlp -> assertThat(otlp).extracting("compressionEnabled").isEqualTo(false)); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionNone() { + GrpcExporter exporter = builder.setCompression("none").build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + OkHttpGrpcExporter.class, + otlp -> assertThat(otlp).extracting("compressionEnabled").isEqualTo(false)); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionGzip() { + GrpcExporter exporter = builder.setCompression("gzip").build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + OkHttpGrpcExporter.class, + otlp -> assertThat(otlp).extracting("compressionEnabled").isEqualTo(true)); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionEnabledAndDisabled() { + GrpcExporter exporter = + builder.setCompression("gzip").setCompression("none").build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + OkHttpGrpcExporter.class, + otlp -> assertThat(otlp).extracting("compressionEnabled").isEqualTo(false)); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionDefaultWithChannel() { + GrpcExporter exporter = builder.setChannel(channel).build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + UpstreamGrpcExporter.class, + otlp -> + assertThat(otlp) + .extracting("stub") + .extracting("callOptions.compressorName") + .isEqualTo(Codec.Identity.NONE.getMessageEncoding())); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionNoneWithChannel() { + GrpcExporter exporter = builder.setChannel(channel).setCompression("none").build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + UpstreamGrpcExporter.class, + otlp -> + assertThat(otlp) + .extracting("stub") + .extracting("callOptions.compressorName") + .isEqualTo(Codec.Identity.NONE.getMessageEncoding())); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionGzipWithChannel() { + GrpcExporter exporter = builder.setChannel(channel).setCompression("gzip").build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + UpstreamGrpcExporter.class, + otlp -> + assertThat(otlp) + .extracting("stub") + .extracting("callOptions.compressorName") + .isEqualTo(new Codec.Gzip().getMessageEncoding())); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionEnabledAndDisabledWithChannel() { + GrpcExporter exporter = + builder.setChannel(channel).setCompression("gzip").setCompression("none").build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + UpstreamGrpcExporter.class, + otlp -> + assertThat(otlp) + .extracting("stub") + .extracting("callOptions.compressorName") + .isEqualTo(Codec.Identity.NONE.getMessageEncoding())); + } finally { + exporter.shutdown(); + } + } + + private final class TestMarshalerServiceStub + extends MarshalerServiceStub { + + private TestMarshalerServiceStub(Channel channel, CallOptions callOptions) { + super(channel, callOptions); + } + + @Override + protected TestMarshalerServiceStub build(Channel channel, CallOptions callOptions) { + return new TestMarshalerServiceStub(channel, callOptions); + } + + @Override + public ListenableFuture export(Marshaler request) { + return Futures.immediateVoidFuture(); + } + } +} From f30b8338dd2d7531fb4fa627557334c057bfba74 Mon Sep 17 00:00:00 2001 From: David Sondermann Date: Fri, 23 Sep 2022 05:02:19 +0200 Subject: [PATCH 2/6] Fix handling of compressionMethod `none` in OkHttpExporterBuilder --- .../okhttp/OkHttpExporterBuilder.java | 4 +- .../okhttp/OkHttpExporterBuilderTest.java | 70 +++++++++++++++++++ 2 files changed, 71 insertions(+), 3 deletions(-) create mode 100644 exporters/common/src/test/java/io/opentelemetry/exporter/internal/okhttp/OkHttpExporterBuilderTest.java diff --git a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/okhttp/OkHttpExporterBuilder.java b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/okhttp/OkHttpExporterBuilder.java index c1a4c4e1033..f1fa38b4391 100644 --- a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/okhttp/OkHttpExporterBuilder.java +++ b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/okhttp/OkHttpExporterBuilder.java @@ -72,9 +72,7 @@ public OkHttpExporterBuilder setEndpoint(String endpoint) { } public OkHttpExporterBuilder setCompression(String compressionMethod) { - if (compressionMethod.equals("gzip")) { - this.compressionEnabled = true; - } + this.compressionEnabled = compressionMethod.equals("gzip"); return this; } diff --git a/exporters/common/src/test/java/io/opentelemetry/exporter/internal/okhttp/OkHttpExporterBuilderTest.java b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/okhttp/OkHttpExporterBuilderTest.java new file mode 100644 index 00000000000..d6cd07b5d90 --- /dev/null +++ b/exporters/common/src/test/java/io/opentelemetry/exporter/internal/okhttp/OkHttpExporterBuilderTest.java @@ -0,0 +1,70 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.exporter.internal.okhttp; + +import static org.assertj.core.api.Assertions.assertThat; + +import io.opentelemetry.exporter.internal.marshal.Marshaler; +import org.junit.jupiter.api.Test; + +class OkHttpExporterBuilderTest { + + private final OkHttpExporterBuilder builder = + new OkHttpExporterBuilder<>("otlp", "span", "http://localhost:4318/v1/traces"); + + @Test + void compressionDefault() { + OkHttpExporter exporter = builder.build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + OkHttpExporter.class, + otlp -> assertThat(otlp).extracting("compressionEnabled").isEqualTo(false)); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionNone() { + OkHttpExporter exporter = builder.setCompression("none").build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + OkHttpExporter.class, + otlp -> assertThat(otlp).extracting("compressionEnabled").isEqualTo(false)); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionGzip() { + OkHttpExporter exporter = builder.setCompression("gzip").build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + OkHttpExporter.class, + otlp -> assertThat(otlp).extracting("compressionEnabled").isEqualTo(true)); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionEnabledAndDisabled() { + OkHttpExporter exporter = + builder.setCompression("gzip").setCompression("none").build(); + try { + assertThat(exporter) + .isInstanceOfSatisfying( + OkHttpExporter.class, + otlp -> assertThat(otlp).extracting("compressionEnabled").isEqualTo(false)); + } finally { + exporter.shutdown(); + } + } +} From 88f114cc763d2d63241804a9823e00594262dbeb Mon Sep 17 00:00:00 2001 From: David Sondermann Date: Tue, 4 Oct 2022 18:03:20 +0200 Subject: [PATCH 3/6] Add compression configuration assertions to AbstractGrpcTelemetryExporterTest --- .../AbstractGrpcTelemetryExporterTest.java | 23 +++++++++++++++++++ ...anagedChannelTelemetryExporterBuilder.java | 5 ++++ .../testing/internal/TelemetryExporter.java | 17 ++++++++++++++ 3 files changed, 45 insertions(+) diff --git a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/AbstractGrpcTelemetryExporterTest.java b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/AbstractGrpcTelemetryExporterTest.java index a775bf77f4a..24ae1fb7c4e 100644 --- a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/AbstractGrpcTelemetryExporterTest.java +++ b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/AbstractGrpcTelemetryExporterTest.java @@ -8,6 +8,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatCode; import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Assumptions.assumeThat; import static org.junit.jupiter.api.Named.named; import static org.junit.jupiter.params.provider.Arguments.arguments; @@ -229,6 +230,28 @@ void multipleItems() { assertThat(exportedResourceTelemetry).containsExactlyElementsOf(expectedResourceTelemetry); } + @Test + void compressionWithNone() { + TelemetryExporter exporter = + exporterBuilder().setEndpoint(server.httpUri().toString()).setCompression("none").build(); + // UpstreamGrpcExporter doesn't support compression, so we skip the assertion + assumeThat(exporter.unwrap()) + .extracting("delegate") + .isNotInstanceOf(UpstreamGrpcExporter.class); + assertThat(exporter.unwrap()).extracting("delegate.compressionEnabled").isEqualTo(false); + } + + @Test + void compressionWithGzip() { + TelemetryExporter exporter = + exporterBuilder().setEndpoint(server.httpUri().toString()).setCompression("gzip").build(); + // UpstreamGrpcExporter doesn't support compression, so we skip the assertion + assumeThat(exporter.unwrap()) + .extracting("delegate") + .isNotInstanceOf(UpstreamGrpcExporter.class); + assertThat(exporter.unwrap()).extracting("delegate.compressionEnabled").isEqualTo(true); + } + @Test void authorityWithAuth() { TelemetryExporter exporter = diff --git a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/ManagedChannelTelemetryExporterBuilder.java b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/ManagedChannelTelemetryExporterBuilder.java index 1402819ca7c..5866bc6f2f8 100644 --- a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/ManagedChannelTelemetryExporterBuilder.java +++ b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/ManagedChannelTelemetryExporterBuilder.java @@ -134,6 +134,11 @@ public TelemetryExporter build() { delegate.setChannel(channel); TelemetryExporter delegateExporter = delegate.build(); return new TelemetryExporter() { + @Override + public Object unwrap() { + return delegateExporter.unwrap(); + } + @Override public CompletableResultCode export(Collection items) { return delegateExporter.export(items); diff --git a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporter.java b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporter.java index a44ec5dd036..23af19dcefd 100644 --- a/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporter.java +++ b/exporters/otlp/testing-internal/src/main/java/io/opentelemetry/exporter/otlp/testing/internal/TelemetryExporter.java @@ -19,6 +19,11 @@ public interface TelemetryExporter { /** Wraps a SpanExporter. */ static TelemetryExporter wrap(SpanExporter exporter) { return new TelemetryExporter() { + @Override + public Object unwrap() { + return exporter; + } + @Override public CompletableResultCode export(Collection items) { return exporter.export(items); @@ -34,6 +39,11 @@ public CompletableResultCode shutdown() { /** Wraps a MetricExporter. */ static TelemetryExporter wrap(MetricExporter exporter) { return new TelemetryExporter() { + @Override + public Object unwrap() { + return exporter; + } + @Override public CompletableResultCode export(Collection items) { return exporter.export(items); @@ -49,6 +59,11 @@ public CompletableResultCode shutdown() { /** Wraps a LogRecordExporter. */ static TelemetryExporter wrap(LogRecordExporter exporter) { return new TelemetryExporter() { + @Override + public Object unwrap() { + return exporter; + } + @Override public CompletableResultCode export(Collection items) { return exporter.export(items); @@ -61,6 +76,8 @@ public CompletableResultCode shutdown() { }; } + Object unwrap(); + CompletableResultCode export(Collection items); CompletableResultCode shutdown(); From d5ec7736cccd5bbed738a29c86e4c38f6177dbb3 Mon Sep 17 00:00:00 2001 From: David Sondermann Date: Fri, 23 Sep 2022 05:03:08 +0200 Subject: [PATCH 4/6] Add compression configuration to JaegerGrpcSpanExporterBuilder --- .../opentelemetry-exporter-jaeger.txt | 4 +- .../jaeger/JaegerGrpcSpanExporterBuilder.java | 13 +++++ .../jaeger/JaegerGrpcSpanExporterTest.java | 51 +++++++++++++++++++ 3 files changed, 67 insertions(+), 1 deletion(-) diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-jaeger.txt b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-jaeger.txt index df26146497b..f2e115c71f2 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-jaeger.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-jaeger.txt @@ -1,2 +1,4 @@ Comparing source compatibility of against -No changes. \ No newline at end of file +*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.exporter.jaeger.JaegerGrpcSpanExporterBuilder (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.jaeger.JaegerGrpcSpanExporterBuilder setCompression(java.lang.String) diff --git a/exporters/jaeger/src/main/java/io/opentelemetry/exporter/jaeger/JaegerGrpcSpanExporterBuilder.java b/exporters/jaeger/src/main/java/io/opentelemetry/exporter/jaeger/JaegerGrpcSpanExporterBuilder.java index 78ec92c9e26..6c0efeaeea3 100644 --- a/exporters/jaeger/src/main/java/io/opentelemetry/exporter/jaeger/JaegerGrpcSpanExporterBuilder.java +++ b/exporters/jaeger/src/main/java/io/opentelemetry/exporter/jaeger/JaegerGrpcSpanExporterBuilder.java @@ -66,6 +66,19 @@ public JaegerGrpcSpanExporterBuilder setEndpoint(String endpoint) { return this; } + /** + * Sets the method used to compress payloads. If unset, compression is disabled. Currently + * supported compression methods include "gzip" and "none". + */ + public JaegerGrpcSpanExporterBuilder setCompression(String compressionMethod) { + requireNonNull(compressionMethod, "compressionMethod"); + checkArgument( + compressionMethod.equals("gzip") || compressionMethod.equals("none"), + "Unsupported compression method. Supported compression methods include: gzip, none."); + delegate.setCompression(compressionMethod); + return this; + } + /** * Sets the maximum time to wait for the collector to process an exported batch of spans. If * unset, defaults to {@value DEFAULT_TIMEOUT_SECS}s. diff --git a/exporters/jaeger/src/test/java/io/opentelemetry/exporter/jaeger/JaegerGrpcSpanExporterTest.java b/exporters/jaeger/src/test/java/io/opentelemetry/exporter/jaeger/JaegerGrpcSpanExporterTest.java index ceebf069008..0dbdb2691fa 100644 --- a/exporters/jaeger/src/test/java/io/opentelemetry/exporter/jaeger/JaegerGrpcSpanExporterTest.java +++ b/exporters/jaeger/src/test/java/io/opentelemetry/exporter/jaeger/JaegerGrpcSpanExporterTest.java @@ -357,6 +357,57 @@ void invalidConfig() { assertThatThrownBy(() -> JaegerGrpcSpanExporter.builder().setEndpoint("gopher://localhost")) .isInstanceOf(IllegalArgumentException.class) .hasMessage("Invalid endpoint, must start with http:// or https://: gopher://localhost"); + + assertThatThrownBy(() -> JaegerGrpcSpanExporter.builder().setCompression(null)) + .isInstanceOf(NullPointerException.class) + .hasMessage("compressionMethod"); + assertThatThrownBy(() -> JaegerGrpcSpanExporter.builder().setCompression("foo")) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage( + "Unsupported compression method. Supported compression methods include: gzip, none."); + } + + @Test + void compressionDefault() { + JaegerGrpcSpanExporter exporter = JaegerGrpcSpanExporter.builder().build(); + try { + assertThat(exporter).extracting("delegate.compressionEnabled").isEqualTo(false); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionNone() { + JaegerGrpcSpanExporter exporter = + JaegerGrpcSpanExporter.builder().setCompression("none").build(); + try { + assertThat(exporter).extracting("delegate.compressionEnabled").isEqualTo(false); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionGzip() { + JaegerGrpcSpanExporter exporter = + JaegerGrpcSpanExporter.builder().setCompression("gzip").build(); + try { + assertThat(exporter).extracting("delegate.compressionEnabled").isEqualTo(true); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionEnabledAndDisabled() { + JaegerGrpcSpanExporter exporter = + JaegerGrpcSpanExporter.builder().setCompression("gzip").setCompression("none").build(); + try { + assertThat(exporter).extracting("delegate.compressionEnabled").isEqualTo(false); + } finally { + exporter.shutdown(); + } } @Test From c46b1770d0794144e7bd0549f0b666c5ce9ecdf7 Mon Sep 17 00:00:00 2001 From: David Sondermann Date: Fri, 23 Sep 2022 05:03:26 +0200 Subject: [PATCH 5/6] Add compression configuration to ZipkinSpanExporterBuilder --- .../opentelemetry-exporter-zipkin.txt | 4 +- .../zipkin/ZipkinSpanExporterBuilder.java | 33 ++++++++++++-- .../zipkin/ZipkinSpanExporterTest.java | 45 +++++++++++++++++++ 3 files changed, 78 insertions(+), 4 deletions(-) diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-zipkin.txt b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-zipkin.txt index df26146497b..535314c07b1 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-zipkin.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-zipkin.txt @@ -1,2 +1,4 @@ Comparing source compatibility of against -No changes. \ No newline at end of file +*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.exporter.zipkin.ZipkinSpanExporterBuilder (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.zipkin.ZipkinSpanExporterBuilder setCompression(java.lang.String) diff --git a/exporters/zipkin/src/main/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterBuilder.java b/exporters/zipkin/src/main/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterBuilder.java index 9e3731aff76..ba896ad1bdd 100644 --- a/exporters/zipkin/src/main/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterBuilder.java +++ b/exporters/zipkin/src/main/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterBuilder.java @@ -26,11 +26,14 @@ public final class ZipkinSpanExporterBuilder { private Supplier localIpAddressSupplier = LocalInetAddressSupplier.getInstance(); @Nullable private Sender sender; private String endpoint = ZipkinSpanExporter.DEFAULT_ENDPOINT; + // compression is enabled by default, because this is the default of OkHttpSender, + // which is created when no custom sender is set (see OkHttpSender.Builder) + private boolean compressionEnabled = true; private long readTimeoutMillis = TimeUnit.SECONDS.toMillis(10); private MeterProvider meterProvider = MeterProvider.noop(); /** - * Sets the Zipkin sender. Implements the client side of the span transport. A {@link + * Sets the Zipkin sender. Implements the client side of the span transport. An {@link * OkHttpSender} is a good default. * *

The {@link Sender#close()} method will be called when the exporter is shut down. @@ -75,7 +78,7 @@ public ZipkinSpanExporterBuilder setLocalIpAddressSupplier(Supplier } /** - * Sets the zipkin endpoint. This will use the endpoint to assign a {@link OkHttpSender} instance + * Sets the zipkin endpoint. This will use the endpoint to assign an {@link OkHttpSender} instance * to this builder. * * @param endpoint The Zipkin endpoint URL, ex. "http://zipkinhost:9411/api/v2/spans". @@ -88,6 +91,26 @@ public ZipkinSpanExporterBuilder setEndpoint(String endpoint) { return this; } + /** + * Sets the method used to compress payloads. If unset, compression is enabled. Currently + * supported compression methods include "gzip" and "none". + * + *

The compression method is ignored when a custom Zipkin sender is set via {@link + * #setSender(Sender)}. + * + * @param compressionMethod The compression method, ex. "gzip". + * @return this. + * @see OkHttpSender + */ + public ZipkinSpanExporterBuilder setCompression(String compressionMethod) { + requireNonNull(compressionMethod, "compressionMethod"); + checkArgument( + compressionMethod.equals("gzip") || compressionMethod.equals("none"), + "Unsupported compression method. Supported compression methods include: gzip, none."); + this.compressionEnabled = compressionMethod.equals("gzip"); + return this; + } + /** * Sets the maximum time to wait for the export of a batch of spans. If unset, defaults to 10s. * @@ -135,7 +158,11 @@ public ZipkinSpanExporter build() { Sender sender = this.sender; if (sender == null) { sender = - OkHttpSender.newBuilder().endpoint(endpoint).readTimeout((int) readTimeoutMillis).build(); + OkHttpSender.newBuilder() + .endpoint(endpoint) + .compressionEnabled(compressionEnabled) + .readTimeout((int) readTimeoutMillis) + .build(); } OtelToZipkinSpanTransformer transformer = OtelToZipkinSpanTransformer.create(localIpAddressSupplier); diff --git a/exporters/zipkin/src/test/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterTest.java b/exporters/zipkin/src/test/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterTest.java index 7fab654b511..56ad4ff81cc 100644 --- a/exporters/zipkin/src/test/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterTest.java +++ b/exporters/zipkin/src/test/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterTest.java @@ -136,6 +136,10 @@ void invalidConfig() { .isInstanceOf(NullPointerException.class) .hasMessage("endpoint"); + assertThatThrownBy(() -> ZipkinSpanExporter.builder().setCompression(null)) + .isInstanceOf(NullPointerException.class) + .hasMessage("compressionMethod"); + assertThatThrownBy(() -> ZipkinSpanExporter.builder().setSender(null)) .isInstanceOf(NullPointerException.class) .hasMessage("sender"); @@ -144,4 +148,45 @@ void invalidConfig() { .isInstanceOf(NullPointerException.class) .hasMessage("encoder"); } + + @Test + void compressionDefault() { + ZipkinSpanExporter exporter = ZipkinSpanExporter.builder().build(); + try { + assertThat(exporter).extracting("sender.compressionEnabled").isEqualTo(true); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionNone() { + ZipkinSpanExporter exporter = ZipkinSpanExporter.builder().setCompression("none").build(); + try { + assertThat(exporter).extracting("sender.compressionEnabled").isEqualTo(false); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionGzip() { + ZipkinSpanExporter exporter = ZipkinSpanExporter.builder().setCompression("gzip").build(); + try { + assertThat(exporter).extracting("sender.compressionEnabled").isEqualTo(true); + } finally { + exporter.shutdown(); + } + } + + @Test + void compressionEnabledAndDisabled() { + ZipkinSpanExporter exporter = + ZipkinSpanExporter.builder().setCompression("gzip").setCompression("none").build(); + try { + assertThat(exporter).extracting("sender.compressionEnabled").isEqualTo(false); + } finally { + exporter.shutdown(); + } + } } From 1457bee495b365735f608620191fdd603cd74100 Mon Sep 17 00:00:00 2001 From: Jack Berg Date: Tue, 1 Nov 2022 11:05:26 -0500 Subject: [PATCH 6/6] Specify that zipkin default compression is gzip --- .../exporter/zipkin/ZipkinSpanExporterBuilder.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/exporters/zipkin/src/main/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterBuilder.java b/exporters/zipkin/src/main/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterBuilder.java index ba896ad1bdd..3467202b31e 100644 --- a/exporters/zipkin/src/main/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterBuilder.java +++ b/exporters/zipkin/src/main/java/io/opentelemetry/exporter/zipkin/ZipkinSpanExporterBuilder.java @@ -92,7 +92,7 @@ public ZipkinSpanExporterBuilder setEndpoint(String endpoint) { } /** - * Sets the method used to compress payloads. If unset, compression is enabled. Currently + * Sets the method used to compress payloads. If unset, gzip compression is enabled. Currently * supported compression methods include "gzip" and "none". * *

The compression method is ignored when a custom Zipkin sender is set via {@link