diff --git a/bom/application/pom.xml b/bom/application/pom.xml index 8bd533cab08e4..5a0c92d197ea0 100644 --- a/bom/application/pom.xml +++ b/bom/application/pom.xml @@ -460,6 +460,16 @@ + + + + io.opentelemetry + opentelemetry-bom-alpha + 1.56.0-alpha-SNAPSHOT + pom + import + + io.opentelemetry.instrumentation opentelemetry-instrumentation-bom-alpha diff --git a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/OTelExporterRecorder.java b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/OTelExporterRecorder.java index f2e637ce3b46d..14c4ad57379fa 100644 --- a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/OTelExporterRecorder.java +++ b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/OTelExporterRecorder.java @@ -22,9 +22,6 @@ import io.opentelemetry.exporter.internal.ExporterBuilderUtil; import io.opentelemetry.exporter.internal.grpc.GrpcExporter; import io.opentelemetry.exporter.internal.http.HttpExporter; -import io.opentelemetry.exporter.internal.otlp.logs.LogsRequestMarshaler; -import io.opentelemetry.exporter.internal.otlp.metrics.MetricsRequestMarshaler; -import io.opentelemetry.exporter.internal.otlp.traces.TraceRequestMarshaler; import io.opentelemetry.exporter.otlp.internal.OtlpUserAgent; import io.opentelemetry.sdk.autoconfigure.spi.ConfigurationException; import io.opentelemetry.sdk.common.InternalTelemetryVersion; @@ -166,7 +163,7 @@ private SpanExporter createOtlpGrpcSpanExporter(OtlpExporterRuntimeConfig export OtlpExporterTracesConfig tracesConfig = exporterRuntimeConfig.traces(); - return new VertxGrpcSpanExporter(new GrpcExporter( + return new VertxGrpcSpanExporter(new GrpcExporter( new VertxGrpcSender( baseUri, VertxGrpcSender.GRPC_TRACE_SERVICE_NAME, @@ -178,7 +175,7 @@ private SpanExporter createOtlpGrpcSpanExporter(OtlpExporterRuntimeConfig export InternalTelemetryVersion.LATEST, ComponentId.generateLazy(StandardComponentId.ExporterType.OTLP_GRPC_SPAN_EXPORTER), // use the same as OTel does MeterProvider::noop, - baseUri.toASCIIString())); + baseUri)); } private SpanExporter createHttpSpanExporter(OtlpExporterRuntimeConfig exporterRuntimeConfig, Vertx vertx, @@ -189,7 +186,7 @@ private SpanExporter createHttpSpanExporter(OtlpExporterRuntimeConfig exporterRu boolean exportAsJson = false; //TODO: this will be enhanced in the future - return new VertxHttpSpanExporter(new HttpExporter( + return new VertxHttpSpanExporter(new HttpExporter( ComponentId.generateLazy(StandardComponentId.ExporterType.OTLP_HTTP_SPAN_EXPORTER), new VertxHttpSender( baseUri, @@ -202,7 +199,8 @@ private SpanExporter createHttpSpanExporter(OtlpExporterRuntimeConfig exporterRu vertx), MeterProvider::noop, InternalTelemetryVersion.LATEST, - baseUri.toASCIIString())); + baseUri, + false)); } }; } @@ -233,7 +231,7 @@ public MetricExporter apply(SyntheticCreationalContext context) String protocol = metricsConfig.protocol().get(); if (GRPC.equals(protocol)) { metricExporter = new VertxGrpcMetricExporter( - new GrpcExporter( + new GrpcExporter( new VertxGrpcSender( baseUri, VertxGrpcSender.GRPC_METRIC_SERVICE_NAME, @@ -245,13 +243,13 @@ public MetricExporter apply(SyntheticCreationalContext context) InternalTelemetryVersion.LATEST, ComponentId.generateLazy(OTLP_GRPC_METRIC_EXPORTER), // use the same as OTel does MeterProvider::noop, - baseUri.toASCIIString()), + baseUri), aggregationTemporalityResolver(metricsConfig), aggregationResolver(metricsConfig)); } else if (HTTP_PROTOBUF.equals(protocol)) { boolean exportAsJson = false; //TODO: this will be enhanced in the future metricExporter = new VertxHttpMetricsExporter( - new HttpExporter( + new HttpExporter( ComponentId.generateLazy( StandardComponentId.ExporterType.OTLP_HTTP_METRIC_EXPORTER), new VertxHttpSender( @@ -265,7 +263,8 @@ public MetricExporter apply(SyntheticCreationalContext context) vertx.get()), MeterProvider::noop, InternalTelemetryVersion.LATEST, - baseUri.toASCIIString()), + baseUri, + false), aggregationTemporalityResolver(metricsConfig), aggregationResolver(metricsConfig)); } else { @@ -307,7 +306,7 @@ public LogRecordExporter apply(SyntheticCreationalContext con String protocol = logsConfig.protocol().get(); if (GRPC.equals(protocol)) { logRecordExporter = new VertxGrpcLogRecordExporter( - new GrpcExporter( + new GrpcExporter( new VertxGrpcSender( baseUri, VertxGrpcSender.GRPC_LOG_SERVICE_NAME, @@ -320,11 +319,11 @@ public LogRecordExporter apply(SyntheticCreationalContext con ComponentId.generateLazy( StandardComponentId.ExporterType.OTLP_GRPC_LOG_EXPORTER), // use the same as OTel does MeterProvider::noop, - baseUri.toASCIIString())); + baseUri)); } else if (HTTP_PROTOBUF.equals(protocol)) { boolean exportAsJson = false; //TODO: this will be enhanced in the future logRecordExporter = new VertxHttpLogRecordExporter( - new HttpExporter( + new HttpExporter( ComponentId.generateLazy( StandardComponentId.ExporterType.OTLP_HTTP_LOG_EXPORTER), new VertxHttpSender( @@ -338,7 +337,8 @@ public LogRecordExporter apply(SyntheticCreationalContext con vertx.get()), MeterProvider::noop, InternalTelemetryVersion.LATEST, - baseUri.toASCIIString())); + baseUri, + false)); } else { throw new IllegalArgumentException(String.format("Unsupported OTLP protocol %s specified. " + "Please check `quarkus.otel.exporter.otlp.logs.protocol` property", protocol)); diff --git a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/logs/VertxGrpcLogRecordExporter.java b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/logs/VertxGrpcLogRecordExporter.java index dd7e5b245cf65..25028421e91ee 100644 --- a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/logs/VertxGrpcLogRecordExporter.java +++ b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/logs/VertxGrpcLogRecordExporter.java @@ -9,9 +9,9 @@ import io.opentelemetry.sdk.logs.export.LogRecordExporter; public class VertxGrpcLogRecordExporter implements LogRecordExporter { - private final GrpcExporter delegate; + private final GrpcExporter delegate; - public VertxGrpcLogRecordExporter(GrpcExporter delegate) { + public VertxGrpcLogRecordExporter(GrpcExporter delegate) { this.delegate = delegate; } diff --git a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/logs/VertxHttpLogRecordExporter.java b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/logs/VertxHttpLogRecordExporter.java index 9d23d65ec7c77..3ebfaf5292ff0 100644 --- a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/logs/VertxHttpLogRecordExporter.java +++ b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/logs/VertxHttpLogRecordExporter.java @@ -9,9 +9,9 @@ import io.opentelemetry.sdk.logs.export.LogRecordExporter; public class VertxHttpLogRecordExporter implements LogRecordExporter { - private final HttpExporter delegate; + private final HttpExporter delegate; - public VertxHttpLogRecordExporter(HttpExporter delegate) { + public VertxHttpLogRecordExporter(HttpExporter delegate) { this.delegate = delegate; } diff --git a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/metrics/VertxGrpcMetricExporter.java b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/metrics/VertxGrpcMetricExporter.java index 61eeb1d1390ee..3c2e54355f6ea 100644 --- a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/metrics/VertxGrpcMetricExporter.java +++ b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/metrics/VertxGrpcMetricExporter.java @@ -16,11 +16,11 @@ public class VertxGrpcMetricExporter implements MetricExporter { - private final GrpcExporter delegate; + private final GrpcExporter delegate; private final AggregationTemporalitySelector aggregationTemporalitySelector; private final DefaultAggregationSelector defaultAggregationSelector; - public VertxGrpcMetricExporter(GrpcExporter grpcExporter, + public VertxGrpcMetricExporter(GrpcExporter grpcExporter, AggregationTemporalitySelector aggregationTemporalitySelector, DefaultAggregationSelector defaultAggregationSelector) { this.delegate = grpcExporter; diff --git a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/metrics/VertxHttpMetricsExporter.java b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/metrics/VertxHttpMetricsExporter.java index bf4afaede728b..afbc0fde3bbbd 100644 --- a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/metrics/VertxHttpMetricsExporter.java +++ b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/metrics/VertxHttpMetricsExporter.java @@ -16,11 +16,11 @@ public class VertxHttpMetricsExporter implements MetricExporter { - private final HttpExporter delegate; + private final HttpExporter delegate; private final AggregationTemporalitySelector aggregationTemporalitySelector; private final DefaultAggregationSelector defaultAggregationSelector; - public VertxHttpMetricsExporter(HttpExporter delegate, + public VertxHttpMetricsExporter(HttpExporter delegate, AggregationTemporalitySelector aggregationTemporalitySelector, DefaultAggregationSelector defaultAggregationSelector) { this.delegate = delegate; diff --git a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/sender/VertxGrpcSender.java b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/sender/VertxGrpcSender.java index a8761d70cf161..450d9da94f76f 100644 --- a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/sender/VertxGrpcSender.java +++ b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/sender/VertxGrpcSender.java @@ -7,6 +7,7 @@ import java.nio.charset.StandardCharsets; import java.time.Duration; import java.util.Map; +import java.util.Optional; import java.util.concurrent.CompletionStage; import java.util.concurrent.RejectedExecutionException; import java.util.concurrent.atomic.AtomicBoolean; @@ -17,16 +18,19 @@ import java.util.logging.Logger; import io.netty.handler.codec.http.QueryStringDecoder; -import io.opentelemetry.exporter.internal.grpc.GrpcResponse; -import io.opentelemetry.exporter.internal.grpc.GrpcSender; -import io.opentelemetry.exporter.internal.marshal.Marshaler; +import io.opentelemetry.exporter.grpc.GrpcMessageWriter; +import io.opentelemetry.exporter.grpc.GrpcResponse; +import io.opentelemetry.exporter.grpc.GrpcSender; +import io.opentelemetry.exporter.grpc.GrpcStatusCode; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.internal.ThrottlingLogger; import io.quarkus.opentelemetry.runtime.exporter.otlp.OTelExporterUtil; import io.quarkus.vertx.core.runtime.BufferOutputStream; import io.smallrye.common.annotation.SuppressForbidden; import io.smallrye.mutiny.Uni; +import io.vertx.core.Future; import io.vertx.core.Handler; +import io.vertx.core.Promise; import io.vertx.core.Vertx; import io.vertx.core.buffer.Buffer; import io.vertx.core.http.HttpClientOptions; @@ -88,15 +92,17 @@ public VertxGrpcSender( } @Override - public void send(Marshaler request, Consumer onSuccess, Consumer onError) { + public void send(GrpcMessageWriter messageWriter, + Consumer onResponse, + Consumer onError) { if (isShutdown.get()) { return; } - final String marshalerType = request.getClass().getSimpleName(); + final String marshalerType = messageWriter.getClass().getSimpleName(); var onSuccessHandler = new ClientRequestOnSuccessHandler(client, server, headers, compressionEnabled, - request, - loggedUnimplemented, logger, marshalerType, onSuccess, onError, 1, grpcEndpointPath, + messageWriter, + loggedUnimplemented, logger, marshalerType, onResponse, onError, 1, grpcEndpointPath, isShutdown::get, exportTimeout); initiateSend(client, server, MAX_ATTEMPTS, onSuccessHandler, exportTimeout, new Consumer<>() { @@ -195,11 +201,11 @@ private static final class ClientRequestOnSuccessHandler implements Handler headers; private final boolean compressionEnabled; - private final Marshaler marshaler; + private final GrpcMessageWriter messageWriter; private final AtomicBoolean loggedUnimplemented; private final ThrottlingLogger logger; private final String type; - private final Consumer onSuccess; + private final Consumer onResponse; private final Consumer onError; private final String grpcEndpointPath; @@ -211,11 +217,11 @@ public ClientRequestOnSuccessHandler(GrpcClient client, SocketAddress server, Map headers, boolean compressionEnabled, - Marshaler marshaler, + GrpcMessageWriter messageWriter, AtomicBoolean loggedUnimplemented, ThrottlingLogger logger, String type, - Consumer onSuccess, + Consumer onResponse, Consumer onError, int attemptNumber, String grpcEndpointPath, @@ -226,11 +232,11 @@ public ClientRequestOnSuccessHandler(GrpcClient client, this.grpcEndpointPath = grpcEndpointPath; this.headers = headers; this.compressionEnabled = compressionEnabled; - this.marshaler = marshaler; + this.messageWriter = messageWriter; this.loggedUnimplemented = loggedUnimplemented; this.logger = logger; this.type = type; - this.onSuccess = onSuccess; + this.onResponse = onResponse; this.onError = onError; this.attemptNumber = attemptNumber; this.isShutdown = isShutdown; @@ -255,10 +261,10 @@ public void handle(GrpcClientRequest request) { } try { - int messageSize = marshaler.getBinarySerializedSize(); + int messageSize = messageWriter.contentLength(); Buffer buffer = Buffer.buffer(messageSize); var os = new BufferOutputStream(buffer); - marshaler.writeBinaryTo(os); + messageWriter.writeMessage(os); request.send(buffer).onSuccess(new Handler<>() { @Override public void handle(GrpcClientResponse response) { @@ -291,7 +297,44 @@ public void handle(GrpcError error) { public void handle(Void ignored) { GrpcStatus status = getStatus(response); if (status == GrpcStatus.OK) { - onSuccess.accept(GrpcResponse.create(status.code, status.toString())); + // onResponse.accept(GrpcResponse.create(status.code, status.toString())); + onResponse.accept(new GrpcResponse() { + @Override + public GrpcStatusCode getStatusCode() { + return GrpcStatusCode.fromValue(status.code); + } + + @Override + public String getStatusDescription() { + return status.name(); + } + + @Override + public byte[] getResponseMessage() { + if (response == null) { + return null; + } + Promise promise = Promise.promise(); + StringBuilder sb = new StringBuilder(); + response.handler(msg -> { + sb.append(msg.toString()); + }); + response.endHandler(v -> { + // Done reading stream + promise.complete(sb.toString()); + }); + response.exceptionHandler(promise::fail); + String result = promise.future() + .timeout(exportTimeout.toMillis(), MILLISECONDS) + .recover(throwable -> Future.succeededFuture( + "Response error: " + throwable.getMessage())) + .result(); + if (result == null || result.isEmpty()) { + return null; + } + return result.getBytes(StandardCharsets.UTF_8); + } + }); } else { handleError(status, response); } @@ -447,8 +490,8 @@ private void failOnClientRequest(Throwable t, Consumer onError, int a } public ClientRequestOnSuccessHandler newAttempt() { - return new ClientRequestOnSuccessHandler(client, server, headers, compressionEnabled, marshaler, - loggedUnimplemented, logger, type, onSuccess, onError, attemptNumber + 1, + return new ClientRequestOnSuccessHandler(client, server, headers, compressionEnabled, messageWriter, + loggedUnimplemented, logger, type, onResponse, onError, attemptNumber + 1, grpcEndpointPath, isShutdown, exportTimeout); } } diff --git a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/sender/VertxHttpSender.java b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/sender/VertxHttpSender.java index f2bdec9b9fc84..7608dacd3de37 100644 --- a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/sender/VertxHttpSender.java +++ b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/sender/VertxHttpSender.java @@ -17,8 +17,9 @@ import java.util.logging.Logger; import java.util.zip.GZIPOutputStream; -import io.opentelemetry.exporter.internal.http.HttpSender; -import io.opentelemetry.exporter.internal.marshal.Marshaler; +import io.opentelemetry.exporter.http.HttpRequestBodyWriter; +import io.opentelemetry.exporter.http.HttpResponse; +import io.opentelemetry.exporter.http.HttpSender; import io.opentelemetry.sdk.common.CompletableResultCode; import io.opentelemetry.sdk.internal.ThrottlingLogger; import io.quarkus.vertx.core.runtime.BufferOutputStream; @@ -94,24 +95,23 @@ private static String determineBasePath(URI baseUri) { } @Override - public void send(Marshaler marshaler, - int contentLength, - Consumer onHttpResponseRead, + public void send(HttpRequestBodyWriter requestBodyWriter, + Consumer onHttpResponseRead, Consumer onError) { if (isShutdown.get()) { return; } - String marshalerType = marshaler.getClass().getSimpleName(); + String writerType = requestBodyWriter.getClass().getSimpleName(); String requestURI = basePath + signalPath; var clientRequestSuccessHandler = new ClientRequestSuccessHandler(client, requestURI, headers, compressionEnabled, contentType, - contentLength, onHttpResponseRead, - onError, marshaler, 1, isShutdown::get); + onHttpResponseRead, + onError, requestBodyWriter, 1, isShutdown::get); initiateSend(client, requestURI, MAX_ATTEMPTS, clientRequestSuccessHandler, new Consumer<>() { @Override public void accept(Throwable throwable) { - failOnClientRequest(marshalerType, throwable, onError); + failOnClientRequest(writerType, throwable, onError); } }); } @@ -201,10 +201,9 @@ private static class ClientRequestSuccessHandler implements Handler headers; private final boolean compressionEnabled; private final String contentType; - private final int contentLength; - private final Consumer onHttpResponseRead; + private final Consumer onHttpResponseRead; private final Consumer onError; - private final Marshaler marshaler; + private final HttpRequestBodyWriter requestBodyWriter; private final int attemptNumber; private final Supplier isShutdown; @@ -213,10 +212,9 @@ public ClientRequestSuccessHandler(HttpClient client, String requestURI, Map headers, boolean compressionEnabled, String contentType, - int contentLength, - Consumer onHttpResponseRead, + Consumer onHttpResponseRead, Consumer onError, - Marshaler marshaler, + HttpRequestBodyWriter requestBodyWriter, int attemptNumber, Supplier isShutdown) { this.client = client; @@ -224,10 +222,9 @@ public ClientRequestSuccessHandler(HttpClient client, this.headers = headers; this.compressionEnabled = compressionEnabled; this.contentType = contentType; - this.contentLength = contentLength; this.onHttpResponseRead = onHttpResponseRead; this.onError = onError; - this.marshaler = marshaler; + this.requestBodyWriter = requestBodyWriter; this.attemptNumber = attemptNumber; this.isShutdown = isShutdown; } @@ -255,19 +252,19 @@ public void handle(AsyncResult bodyResult) { return; } } - onHttpResponseRead.accept(new Response() { + onHttpResponseRead.accept(new HttpResponse() { @Override - public int statusCode() { + public int getStatusCode() { return clientResponse.statusCode(); } @Override - public String statusMessage() { + public String getStatusMessage() { return clientResponse.statusMessage(); } @Override - public byte[] responseBody() { + public byte[] getResponseBody() { return bodyResult.result().getBytes(); } }); @@ -299,18 +296,18 @@ public byte[] responseBody() { }) .putHeader("Content-Type", contentType); - Buffer buffer = Buffer.buffer(contentLength); + Buffer buffer = Buffer.buffer(requestBodyWriter.contentLength()); OutputStream os = new BufferOutputStream(buffer); if (compressionEnabled) { clientRequest.putHeader("Content-Encoding", "gzip"); try (var gzos = new GZIPOutputStream(os)) { - marshaler.writeBinaryTo(gzos); + requestBodyWriter.writeRequestBody(gzos); } catch (IOException e) { throw new IllegalStateException(e); } } else { try { - marshaler.writeBinaryTo(os); + requestBodyWriter.writeRequestBody(os); } catch (IOException e) { throw new IllegalStateException(e); } @@ -327,8 +324,8 @@ public byte[] responseBody() { public ClientRequestSuccessHandler newAttempt() { return new ClientRequestSuccessHandler(client, requestURI, headers, compressionEnabled, - contentType, contentLength, onHttpResponseRead, - onError, marshaler, attemptNumber + 1, isShutdown); + contentType, onHttpResponseRead, + onError, requestBodyWriter, attemptNumber + 1, isShutdown); } } } diff --git a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/tracing/VertxGrpcSpanExporter.java b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/tracing/VertxGrpcSpanExporter.java index 58e03f24a4e45..1a2282437108c 100644 --- a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/tracing/VertxGrpcSpanExporter.java +++ b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/tracing/VertxGrpcSpanExporter.java @@ -10,9 +10,9 @@ public final class VertxGrpcSpanExporter implements SpanExporter { - private final GrpcExporter delegate; + private final GrpcExporter delegate; - public VertxGrpcSpanExporter(GrpcExporter delegate) { + public VertxGrpcSpanExporter(GrpcExporter delegate) { this.delegate = delegate; } diff --git a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/tracing/VertxHttpSpanExporter.java b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/tracing/VertxHttpSpanExporter.java index dedba95064e45..aca54327ae0aa 100644 --- a/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/tracing/VertxHttpSpanExporter.java +++ b/extensions/opentelemetry/runtime/src/main/java/io/quarkus/opentelemetry/runtime/exporter/otlp/tracing/VertxHttpSpanExporter.java @@ -10,9 +10,9 @@ public final class VertxHttpSpanExporter implements SpanExporter { - private final HttpExporter delegate; + private final HttpExporter delegate; - public VertxHttpSpanExporter(HttpExporter delegate) { + public VertxHttpSpanExporter(HttpExporter delegate) { this.delegate = delegate; }