From f8b3870ed503fb30bcca93c1ab24a13f71916d68 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Tue, 7 Dec 2021 16:53:25 +0100 Subject: [PATCH 01/15] Add Ratpack HttpClient instrumentation --- .../ratpack/OpenTelemetryExecInitializer.java | 40 ++++ .../client/OpenTelemetryHttpClient.java | 56 +++++ .../RatpackHttpClientAttributesExtractor.java | 83 +++++++ .../ratpack/client/RatpackHttpTracing.java | 39 +++ .../client/RatpackHttpTracingBuilder.java | 78 ++++++ .../RatpackHttpNetAttributesExtractor.java | 37 +++ .../client/InstrumentedHttpClientTest.groovy | 224 ++++++++++++++++++ .../RatpackServerApplicationTest.groovy | 54 ++++- 8 files changed, 610 insertions(+), 1 deletion(-) create mode 100644 instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java create mode 100644 instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java create mode 100644 instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java create mode 100644 instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java create mode 100644 instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java create mode 100644 instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java create mode 100644 instrumentation/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java new file mode 100644 index 000000000000..fd3993c81040 --- /dev/null +++ b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java @@ -0,0 +1,40 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack; + +import io.opentelemetry.context.Context; +import ratpack.exec.ExecInitializer; +import ratpack.exec.Execution; +import ratpack.http.client.RequestSpec; + +public final class OpenTelemetryExecInitializer implements ExecInitializer { + + @Override + public void init(Execution execution) { + execution + .maybeParent() + .flatMap(parent -> parent.maybeGet(ContextHolder.class)) + .ifPresent(execution::add); + } + + public static final class ContextHolder { + private final Context context; + private final RequestSpec requestSpec; + + public ContextHolder(Context context, RequestSpec requestSpec) { + this.context = context; + this.requestSpec = requestSpec; + } + + public Context context() { + return context; + } + + public RequestSpec requestSpec() { + return requestSpec; + } + } +} diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java new file mode 100644 index 000000000000..056fc05d50d1 --- /dev/null +++ b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java @@ -0,0 +1,56 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.client; + +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.context.Context; +import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; +import io.opentelemetry.instrumentation.ratpack.OpenTelemetryExecInitializer; +import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; +import ratpack.exec.Execution; +import ratpack.http.client.HttpClient; +import ratpack.http.client.HttpResponse; +import ratpack.http.client.RequestSpec; + +final class OpenTelemetryHttpClient { + + private final Instrumenter instrumenter; + + OpenTelemetryHttpClient(Instrumenter instrumenter) { + this.instrumenter = instrumenter; + } + + public HttpClient instrument(HttpClient httpClient) throws Exception { + return httpClient.copyWith( + httpClientSpec -> { + httpClientSpec.requestIntercept( + requestSpec -> { + Context otelCtx = instrumenter.start(Context.current(), requestSpec); + Span span = Span.fromContext(otelCtx); + String path = requestSpec.getUri().getPath(); + span.updateName(path); + span.setAttribute(SemanticAttributes.HTTP_ROUTE, path); + Execution.current() + .add(new OpenTelemetryExecInitializer.ContextHolder(otelCtx, requestSpec)); + }); + + httpClientSpec.responseIntercept( + httpResponse -> { + OpenTelemetryExecInitializer.ContextHolder contextHolder = + Execution.current().get(OpenTelemetryExecInitializer.ContextHolder.class); + instrumenter.end( + contextHolder.context(), contextHolder.requestSpec(), httpResponse, null); + }); + + httpClientSpec.errorIntercept( + ex -> { + OpenTelemetryExecInitializer.ContextHolder contextHolder = + Execution.current().get(OpenTelemetryExecInitializer.ContextHolder.class); + instrumenter.end(contextHolder.context(), contextHolder.requestSpec(), null, ex); + }); + }); + } +} diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java new file mode 100644 index 000000000000..444f4dd4326d --- /dev/null +++ b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java @@ -0,0 +1,83 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.client; + +import io.opentelemetry.instrumentation.api.instrumenter.http.CapturedHttpHeaders; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; +import java.util.List; +import javax.annotation.Nullable; +import ratpack.http.client.HttpResponse; +import ratpack.http.client.RequestSpec; + +final class RatpackHttpClientAttributesExtractor + extends HttpClientAttributesExtractor { + + RatpackHttpClientAttributesExtractor(CapturedHttpHeaders capturedHttpHeaders) { + super(capturedHttpHeaders); + } + + @Nullable + @Override + protected String url(RequestSpec requestSpec) { + return requestSpec.getUri().toString(); + } + + @Nullable + @Override + protected String flavor(RequestSpec requestSpec, @Nullable HttpResponse httpResponse) { + return null; + } + + @Nullable + @Override + protected String method(RequestSpec requestSpec) { + return requestSpec.getMethod().getName(); + } + + @Override + protected List requestHeader(RequestSpec requestSpec, String name) { + return requestSpec.getHeaders().getAll(name); + } + + @Nullable + @Override + protected Long requestContentLength( + RequestSpec requestSpec, @Nullable HttpResponse httpResponse) { + return null; + } + + @Nullable + @Override + protected Long requestContentLengthUncompressed( + RequestSpec requestSpec, @Nullable HttpResponse httpResponse) { + return null; + } + + @Nullable + @Override + protected Integer statusCode(RequestSpec requestSpec, HttpResponse httpResponse) { + return httpResponse.getStatusCode(); + } + + @Nullable + @Override + protected Long responseContentLength(RequestSpec requestSpec, HttpResponse httpResponse) { + return null; + } + + @Nullable + @Override + protected Long responseContentLengthUncompressed( + RequestSpec requestSpec, HttpResponse httpResponse) { + return null; + } + + @Override + protected List responseHeader( + RequestSpec requestSpec, HttpResponse httpResponse, String name) { + return httpResponse.getHeaders().getAll(name); + } +} diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java new file mode 100644 index 000000000000..a03be65ec29e --- /dev/null +++ b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java @@ -0,0 +1,39 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.client; + +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; +import ratpack.http.client.HttpClient; +import ratpack.http.client.HttpResponse; +import ratpack.http.client.RequestSpec; + +/** Entrypoint for tracing OkHttp clients. */ +public final class RatpackHttpTracing { + + /** Returns a new {@link RatpackHttpTracing} configured with the given {@link OpenTelemetry}. */ + public static RatpackHttpTracing create(OpenTelemetry openTelemetry) { + return builder(openTelemetry).build(); + } + + /** + * Returns a new {@link RatpackHttpTracingBuilder} configured with the given {@link + * OpenTelemetry}. + */ + public static RatpackHttpTracingBuilder builder(OpenTelemetry openTelemetry) { + return new RatpackHttpTracingBuilder(openTelemetry); + } + + private final Instrumenter instrumenter; + + RatpackHttpTracing(Instrumenter instrumenter) { + this.instrumenter = instrumenter; + } + + public HttpClient instrumentedHttpClient(HttpClient httpClient) throws Exception { + return new OpenTelemetryHttpClient(instrumenter).instrument(httpClient); + } +} diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java new file mode 100644 index 000000000000..b0be3fddd2c7 --- /dev/null +++ b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java @@ -0,0 +1,78 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.client; + +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.instrumentation.api.config.Config; +import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; +import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; +import io.opentelemetry.instrumentation.api.instrumenter.SpanKindExtractor; +import io.opentelemetry.instrumentation.api.instrumenter.http.CapturedHttpHeaders; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpServerMetrics; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; +import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; +import io.opentelemetry.instrumentation.ratpack.client.internal.RatpackHttpNetAttributesExtractor; +import java.util.ArrayList; +import java.util.List; +import ratpack.http.client.HttpResponse; +import ratpack.http.client.RequestSpec; + +/** A builder for {@link RatpackHttpTracing}. */ +public final class RatpackHttpTracingBuilder { + + private static final String INSTRUMENTATION_NAME = "io.opentelemetry.ratpack-1.4"; + + private final OpenTelemetry openTelemetry; + + private final List> + additionalExtractors = new ArrayList<>(); + private CapturedHttpHeaders capturedHttpHeaders = CapturedHttpHeaders.client(Config.get()); + + RatpackHttpTracingBuilder(OpenTelemetry openTelemetry) { + this.openTelemetry = openTelemetry; + } + + /** + * Adds an additional {@link AttributesExtractor} to invoke to set attributes to instrumented + * items. The {@link AttributesExtractor} will be executed after all default extractors. + */ + public RatpackHttpTracingBuilder addAttributeExtractor( + AttributesExtractor attributesExtractor) { + additionalExtractors.add(attributesExtractor); + return this; + } + + /** + * Configure the instrumentation to capture chosen HTTP request and response headers as span + * attributes. + * + * @param capturedHttpHeaders An instance of {@link CapturedHttpHeaders} containing the configured + * HTTP request and response names. + */ + public RatpackHttpTracingBuilder captureHttpHeaders(CapturedHttpHeaders capturedHttpHeaders) { + this.capturedHttpHeaders = capturedHttpHeaders; + return this; + } + + /** Returns a new {@link RatpackHttpTracing} with the configuration of this builder. */ + public RatpackHttpTracing build() { + RatpackHttpNetAttributesExtractor netAttributes = new RatpackHttpNetAttributesExtractor(); + RatpackHttpClientAttributesExtractor httpAttributes = + new RatpackHttpClientAttributesExtractor(capturedHttpHeaders); + + Instrumenter instrumenter = + Instrumenter.builder( + openTelemetry, INSTRUMENTATION_NAME, HttpSpanNameExtractor.create(httpAttributes)) + .setSpanStatusExtractor(HttpSpanStatusExtractor.create(httpAttributes)) + .addAttributesExtractor(netAttributes) + .addAttributesExtractor(httpAttributes) + .addAttributesExtractors(additionalExtractors) + .addRequestMetrics(HttpServerMetrics.get()) + .newInstrumenter(SpanKindExtractor.alwaysClient()); + + return new RatpackHttpTracing(instrumenter); + } +} diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java new file mode 100644 index 000000000000..6452cb9d7da3 --- /dev/null +++ b/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java @@ -0,0 +1,37 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.client.internal; + +import io.opentelemetry.instrumentation.api.instrumenter.net.NetClientAttributesExtractor; +import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; +import javax.annotation.Nullable; +import ratpack.http.client.HttpResponse; +import ratpack.http.client.RequestSpec; + +public final class RatpackHttpNetAttributesExtractor + extends NetClientAttributesExtractor { + @Override + public String transport(RequestSpec request, @Nullable HttpResponse response) { + return SemanticAttributes.NetTransportValues.IP_TCP; + } + + @Override + @Nullable + public String peerName(RequestSpec request, @Nullable HttpResponse response) { + return request.getUri().getHost(); + } + + @Override + public Integer peerPort(RequestSpec request, @Nullable HttpResponse response) { + return request.getUri().getPort(); + } + + @Override + @Nullable + public String peerIp(RequestSpec request, @Nullable HttpResponse response) { + return null; + } +} diff --git a/instrumentation/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy b/instrumentation/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy new file mode 100644 index 000000000000..8264e08e7bbe --- /dev/null +++ b/instrumentation/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy @@ -0,0 +1,224 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.client + +import io.opentelemetry.api.trace.SpanKind +import io.opentelemetry.api.trace.StatusCode +import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator +import io.opentelemetry.context.propagation.ContextPropagators +import io.opentelemetry.instrumentation.ratpack.OpenTelemetryExecInitializer +import io.opentelemetry.instrumentation.ratpack.RatpackTracing +import io.opentelemetry.sdk.OpenTelemetrySdk +import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter +import io.opentelemetry.sdk.trace.SdkTracerProvider +import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor +import io.opentelemetry.semconv.trace.attributes.SemanticAttributes +import ratpack.exec.Promise +import ratpack.func.Action +import ratpack.guice.Guice +import ratpack.http.client.HttpClient +import ratpack.test.embed.EmbeddedApp +import spock.lang.Specification +import spock.util.concurrent.PollingConditions + +import java.time.Duration +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit + +class InstrumentedHttpClientTest extends Specification { + + def spanExporter = InMemorySpanExporter.create() + def tracerProvider = SdkTracerProvider.builder() + .addSpanProcessor(SimpleSpanProcessor.create(spanExporter)) + .build() + + def openTelemetry = OpenTelemetrySdk.builder() + .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) + .setTracerProvider(tracerProvider).build() + + def ratpackTracing = RatpackTracing.create(openTelemetry) + def ratpackHttpTracing = RatpackHttpTracing.create(openTelemetry) + + def cleanup() { + spanExporter.reset() + } + + def "propagate trace with http calls"() { + expect: + def otherApp = EmbeddedApp.of { spec -> + spec.handlers { + it.get("bar") { ctx -> ctx.render("foo") } + } + } + + def app = EmbeddedApp.of { spec -> + spec.registry( + Guice.registry { bindings -> + bindings.bind(OpenTelemetryExecInitializer) + ratpackTracing.configureServerRegistry(bindings) + bindings.bindInstance(HttpClient, ratpackHttpTracing.instrumentedHttpClient(HttpClient.of(Action.noop()))) + } + ) + + spec.handlers { chain -> + chain.get("foo") { ctx -> + HttpClient instrumentedHttpClient = ctx.get(HttpClient) + instrumentedHttpClient.get(new URI("${otherApp.address}bar")) + .then { ctx.render("bar") } + } + } + } + + app.test { httpClient -> + "bar" == httpClient.get("foo").body.text + } + + new PollingConditions().eventually { + def spanData = spanExporter.finishedSpanItems.find { it.name == "/foo" } + def spanClientData = spanExporter.finishedSpanItems.find { it.name == "/bar" } + + spanData.traceId == spanClientData.traceId + + spanData.kind == SpanKind.SERVER + spanClientData.kind == SpanKind.CLIENT + def atts = spanClientData.attributes.asMap() + atts[SemanticAttributes.HTTP_ROUTE] == "/bar" + atts[SemanticAttributes.HTTP_METHOD] == "GET" + atts[SemanticAttributes.HTTP_STATUS_CODE] == 200L + + def attributes = spanData.attributes.asMap() + attributes[SemanticAttributes.HTTP_ROUTE] == "/foo" + attributes[SemanticAttributes.HTTP_TARGET] == "/foo" + attributes[SemanticAttributes.HTTP_METHOD] == "GET" + attributes[SemanticAttributes.HTTP_STATUS_CODE] == 200L + } + } + + def "add spans for multiple concurrent client calls"() { + expect: + def latch = new CountDownLatch(2) + + def otherApp = EmbeddedApp.of { spec -> + spec.handlers { chain -> + chain.get("foo") { ctx -> ctx.render("bar") } + chain.get("bar") { ctx -> ctx.render("foo") } + } + } + + def app = EmbeddedApp.of { spec -> + spec.registry( + Guice.registry { bindings -> + bindings.bind(OpenTelemetryExecInitializer) + ratpackTracing.configureServerRegistry(bindings) + bindings.bindInstance(HttpClient, ratpackHttpTracing.instrumentedHttpClient(HttpClient.of(Action.noop()))) + } + ) + + spec.handlers { chain -> + chain.get("path-name") { ctx -> + ctx.render("hello") + def instrumentedHttpClient = ctx.get(HttpClient) + instrumentedHttpClient.get(new URI("${otherApp.address}foo")).then { latch.countDown() } + instrumentedHttpClient.get(new URI("${otherApp.address}bar")).then { latch.countDown() } + } + } + } + + app.test { httpClient -> + "hello" == httpClient.get("path-name").body.text + latch.await(1, TimeUnit.SECONDS) + } + + new PollingConditions().eventually { + spanExporter.finishedSpanItems.size() == 3 + def spanData = spanExporter.finishedSpanItems.find { spanData -> spanData.name == "/path-name" } + def spanClientData1 = spanExporter.finishedSpanItems.find { s -> s.name == "/foo" } + def spanClientData2 = spanExporter.finishedSpanItems.find { s -> s.name == "/bar" } + + spanData.traceId == spanClientData1.traceId + spanData.traceId == spanClientData2.traceId + + spanData.kind == SpanKind.SERVER + + spanClientData1.kind == SpanKind.CLIENT + def atts = spanClientData1.attributes.asMap() + atts[SemanticAttributes.HTTP_ROUTE] == "/foo" + atts[SemanticAttributes.HTTP_METHOD] == "GET" + atts[SemanticAttributes.HTTP_STATUS_CODE] == 200L + + spanClientData2.kind == SpanKind.CLIENT + def atts2 = spanClientData2.attributes.asMap() + atts2[SemanticAttributes.HTTP_ROUTE] == "/bar" + atts2[SemanticAttributes.HTTP_METHOD] == "GET" + atts2[SemanticAttributes.HTTP_STATUS_CODE] == 200L + + def attributes = spanData.attributes.asMap() + attributes[SemanticAttributes.HTTP_ROUTE] == "/path-name" + attributes[SemanticAttributes.HTTP_TARGET] == "/path-name" + attributes[SemanticAttributes.HTTP_METHOD] == "GET" + attributes[SemanticAttributes.HTTP_STATUS_CODE] == 200L + } + } + + def "handling exception errors in http client"() { + expect: + def otherApp = EmbeddedApp.of { spec -> + spec.handlers { + it.get("foo") { ctx -> + Promise.value("bar").defer(Duration.ofSeconds(1L)) + .then { ctx.render("bar") } + } + } + } + + def app = EmbeddedApp.of { spec -> + spec.registry( + Guice.registry { bindings -> + bindings.bind(OpenTelemetryExecInitializer) + ratpackTracing.configureServerRegistry(bindings) + bindings.bindInstance(HttpClient, ratpackHttpTracing.instrumentedHttpClient( + HttpClient.of { s -> s.readTimeout(Duration.ofMillis(10)) }) + ) + } + ) + + spec.handlers { chain -> + chain.get("path-name") { ctx -> + def instrumentedHttpClient = ctx.get(HttpClient) + instrumentedHttpClient.get(new URI("${otherApp.address}foo")) + .onError { ctx.render("error") } + .then { ctx.render("hello") } + } + } + } + + app.test { httpClient -> + "error" == httpClient.get("path-name").body.text + } + + new PollingConditions().eventually { + def spanData = spanExporter.finishedSpanItems.find { it.name == "/path-name" } + def spanClientData = spanExporter.finishedSpanItems.find { it.name == "/foo" } + + spanData.traceId == spanClientData.traceId + + spanData.kind == SpanKind.SERVER + spanClientData.kind == SpanKind.CLIENT + def atts = spanClientData.attributes.asMap() + atts[SemanticAttributes.HTTP_ROUTE] == "/foo" + atts[SemanticAttributes.HTTP_METHOD] == "GET" + atts[SemanticAttributes.HTTP_STATUS_CODE] == null + spanClientData.status.statusCode == StatusCode.ERROR + spanClientData.events.first().name == "exception" + + def attributes = spanData.attributes.asMap() + attributes[SemanticAttributes.HTTP_ROUTE] == "/path-name" + attributes[SemanticAttributes.HTTP_TARGET] == "/path-name" + attributes[SemanticAttributes.HTTP_METHOD] == "GET" + attributes[SemanticAttributes.HTTP_STATUS_CODE] == 200L + } + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy index a867322a2599..9acd1a8a8a1b 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy @@ -10,9 +10,11 @@ import com.google.inject.Provides import groovy.transform.CompileStatic import io.opentelemetry.api.OpenTelemetry import io.opentelemetry.api.trace.SpanKind +import io.opentelemetry.instrumentation.ratpack.OpenTelemetryExecInitializer import io.opentelemetry.instrumentation.ratpack.OpenTelemetryServerHandler import io.opentelemetry.instrumentation.ratpack.RatpackFunctionalTest import io.opentelemetry.instrumentation.ratpack.RatpackTracing +import io.opentelemetry.instrumentation.ratpack.client.RatpackHttpTracing import io.opentelemetry.sdk.OpenTelemetrySdk import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter import io.opentelemetry.sdk.trace.SdkTracerProvider @@ -21,6 +23,7 @@ import io.opentelemetry.sdk.trace.export.SpanExporter import io.opentelemetry.semconv.trace.attributes.SemanticAttributes import ratpack.exec.ExecInterceptor import ratpack.guice.Guice +import ratpack.http.client.HttpClient import ratpack.server.RatpackServer import spock.lang.Specification import spock.util.concurrent.PollingConditions @@ -47,6 +50,32 @@ class RatpackServerApplicationTest extends Specification { } } + def "propagate trace to http calls"() { + expect: + app.test { httpClient -> "hi-bar" == httpClient.get("bar").body.text } + + new PollingConditions().eventually { + def spanData = app.spanExporter.finishedSpanItems.find { it.name == "/bar" } + def spanDataClient = app.spanExporter.finishedSpanItems.find { it.name == "/other" } + def attributes = spanData.attributes.asMap() + + spanData.traceId == spanDataClient.traceId + + spanData.kind == SpanKind.SERVER + attributes[SemanticAttributes.HTTP_ROUTE] == "/bar" + attributes[SemanticAttributes.HTTP_TARGET] == "/bar" + attributes[SemanticAttributes.HTTP_METHOD] == "GET" + attributes[SemanticAttributes.HTTP_STATUS_CODE] == 200L + + spanDataClient.kind == SpanKind.CLIENT + def attributesClient = spanDataClient.attributes.asMap() + attributesClient[SemanticAttributes.HTTP_ROUTE] == "/other" + attributesClient[SemanticAttributes.HTTP_METHOD] == "GET" + attributesClient[SemanticAttributes.HTTP_STATUS_CODE] == 200L + + } + } + def "ignore handlers before OpenTelemetryServerHandler"() { expect: app.test { httpClient -> "ignored" == httpClient.get("ignore").body.text } @@ -91,18 +120,36 @@ class OpenTelemetryModule extends AbstractModule { .build() return OpenTelemetrySdk.builder().setTracerProvider(tracerProvider).build() } + + @Singleton + @Provides + RatpackHttpTracing ratpackHttpTracing(OpenTelemetry openTelemetry) { + return RatpackHttpTracing.create(openTelemetry) + } + + @Singleton + @Provides + HttpClient instrumentedHttpClient(RatpackHttpTracing ratpackHttpTracing) { + return ratpackHttpTracing.instrumentedHttpClient(HttpClient.of { it.poolQueueSize(10) }) + } } -@CompileStatic class RatpackApp { static void main(String... args) { + def other = RatpackServer.start { server -> + server.handlers { chain -> + chain.get("other") { ctx -> ctx.render("hi-other") } + } + } + RatpackServer.start { server -> server .registry( Guice.registry { bindings -> bindings .module(OpenTelemetryModule) + .bind(OpenTelemetryExecInitializer) } ) .handlers { chain -> @@ -110,6 +157,11 @@ class RatpackApp { .get("ignore") { ctx -> ctx.render("ignored") } .all(OpenTelemetryServerHandler) .get("foo") { ctx -> ctx.render("hi-foo") } + .get("bar") { ctx -> + def instrumentedHttpClient = ctx.get(HttpClient) + instrumentedHttpClient.get(new URI("http://${other.bindHost}:${other.bindPort}/other")) + .then { ctx.render("hi-bar") } + } } } } From 10affd8b1c30ba9f582a2ff0cb79767142ff8651 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Thu, 30 Dec 2021 00:00:39 +0100 Subject: [PATCH 02/15] Propagate trace through Ratpack HttpClient --- .../ratpack/RatpackHttpClientTest.java | 2 +- .../ratpack/OpenTelemetryExecInitializer.java | 0 .../client/OpenTelemetryHttpClient.java | 10 +- .../RatpackHttpClientAttributesExtractor.java | 3 +- .../ratpack/client/RatpackHttpTracing.java | 0 .../client/RatpackHttpTracingBuilder.java | 3 +- .../ratpack/client/RequestHeaderSetter.java | 16 ++ .../RatpackHttpNetAttributesExtractor.java | 0 .../AbstractRatpackHttpClientTest.groovy | 168 ++++++++++++++++++ .../ratpack/RatpackHttpClientTest.java | 32 ++++ .../client/InstrumentedHttpClientTest.groovy | 0 11 files changed, 228 insertions(+), 6 deletions(-) rename instrumentation/{ => ratpack}/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java (100%) rename instrumentation/{ => ratpack}/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java (84%) rename instrumentation/{ => ratpack}/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java (94%) rename instrumentation/{ => ratpack}/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java (100%) rename instrumentation/{ => ratpack}/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java (95%) create mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RequestHeaderSetter.java rename instrumentation/{ => ratpack}/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java (100%) create mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy create mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java rename instrumentation/{ => ratpack}/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy (100%) diff --git a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackHttpClientTest.java index 13b941a21879..c3151e7e8d7c 100644 --- a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackHttpClientTest.java @@ -13,5 +13,5 @@ class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { @RegisterExtension - static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); + static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forLibrary(); } diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java similarity index 100% rename from instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java similarity index 84% rename from instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java index 056fc05d50d1..c7e672eac9aa 100644 --- a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java @@ -28,10 +28,16 @@ public HttpClient instrument(HttpClient httpClient) throws Exception { httpClientSpec -> { httpClientSpec.requestIntercept( requestSpec -> { - Context otelCtx = instrumenter.start(Context.current(), requestSpec); + Context parentOtelCtx = Context.current(); + if (!instrumenter.shouldStart(parentOtelCtx, requestSpec)) { + return; + } + + Context otelCtx = instrumenter.start(parentOtelCtx, requestSpec); Span span = Span.fromContext(otelCtx); String path = requestSpec.getUri().getPath(); - span.updateName(path); +// span.updateName(path); + span.updateName("HTTP " + requestSpec.getMethod().getName()); span.setAttribute(SemanticAttributes.HTTP_ROUTE, path); Execution.current() .add(new OpenTelemetryExecInitializer.ContextHolder(otelCtx, requestSpec)); diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java similarity index 94% rename from instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java index 444f4dd4326d..92f6b60ee8e0 100644 --- a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java @@ -9,6 +9,7 @@ import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; import java.util.List; import javax.annotation.Nullable; +import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; import ratpack.http.client.HttpResponse; import ratpack.http.client.RequestSpec; @@ -28,7 +29,7 @@ protected String url(RequestSpec requestSpec) { @Nullable @Override protected String flavor(RequestSpec requestSpec, @Nullable HttpResponse httpResponse) { - return null; + return SemanticAttributes.HttpFlavorValues.HTTP_1_1; } @Nullable diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java similarity index 100% rename from instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java similarity index 95% rename from instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java index b0be3fddd2c7..a8a2b269e11f 100644 --- a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java @@ -9,7 +9,6 @@ import io.opentelemetry.instrumentation.api.config.Config; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; -import io.opentelemetry.instrumentation.api.instrumenter.SpanKindExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.CapturedHttpHeaders; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpServerMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; @@ -71,7 +70,7 @@ public RatpackHttpTracing build() { .addAttributesExtractor(httpAttributes) .addAttributesExtractors(additionalExtractors) .addRequestMetrics(HttpServerMetrics.get()) - .newInstrumenter(SpanKindExtractor.alwaysClient()); + .newClientInstrumenter(RequestHeaderSetter.INSTANCE); return new RatpackHttpTracing(instrumenter); } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RequestHeaderSetter.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RequestHeaderSetter.java new file mode 100644 index 000000000000..91dab0ddb51c --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RequestHeaderSetter.java @@ -0,0 +1,16 @@ +package io.opentelemetry.instrumentation.ratpack.client; + +import io.opentelemetry.context.propagation.TextMapSetter; +import ratpack.api.Nullable; +import ratpack.http.client.RequestSpec; + +enum RequestHeaderSetter implements TextMapSetter { + INSTANCE; + + @Override + public void set(@Nullable RequestSpec carrier, String key, String value) { + if (carrier != null) { + carrier.getHeaders().set(key, value); + } + } +} diff --git a/instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java similarity index 100% rename from instrumentation/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy new file mode 100644 index 000000000000..61f715203856 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy @@ -0,0 +1,168 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack + +import com.google.common.collect.ImmutableList +import io.netty.channel.ConnectTimeoutException +import io.netty.handler.timeout.ReadTimeoutException +import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest +import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions +import org.junit.jupiter.api.AfterAll +import org.junit.jupiter.api.BeforeAll +import org.junit.jupiter.api.condition.OS +import ratpack.exec.Operation +import ratpack.exec.Promise +import ratpack.exec.internal.DefaultExecController +import ratpack.func.Action +import ratpack.http.client.HttpClient +import ratpack.http.client.HttpClientSpec +import ratpack.http.client.ReceivedResponse +import ratpack.test.exec.ExecHarness + +import java.time.Duration + +abstract class AbstractRatpackHttpClientTest extends AbstractHttpClientTest { + + final ExecHarness exec = ExecHarness.harness() + + HttpClient client + HttpClient singleConnectionClient + + @BeforeAll + void setUpClient() throws Exception { + exec.run { + (exec.controller as DefaultExecController).setInitializers(ImmutableList.of(new OpenTelemetryExecInitializer())) + client = buildHttpClient() + singleConnectionClient = buildHttpClient(spec -> spec.poolSize(1)) + } + } + + @AfterAll + void cleanUpClient() { + client.close() + singleConnectionClient.close() + exec.close() + } + + protected HttpClient buildHttpClient() throws Exception { + return buildHttpClient(Action.noop()) + } + + protected HttpClient buildHttpClient(Action action) throws Exception { + return HttpClient.of(action) + } + + @Override + protected final Void buildRequest(String method, URI uri, Map headers) { + return null + } + + @Override + protected final int sendRequest(Void request, String method, URI uri, Map headers) + throws Exception { + return exec.yield { internalSendRequest(client, method, uri, headers) } + .getValueOrThrow() + } + + @Override + protected final void sendRequestWithCallback( + Void request, + String method, + URI uri, + Map headers, + RequestResult requestResult) + throws Exception { + exec.execute( + Operation.of( + () -> + internalSendRequest(client, method, uri, headers) + .result( + result -> + requestResult.complete(result::getValue, result.getThrowable())))) + } + + // overridden in RatpackForkedHttpClientTest + protected Promise internalSendRequest( + HttpClient client, String method, URI uri, Map headers) { + Promise resp = + client.request( + uri, + spec -> { + // Connect timeout for the whole client was added in 1.5 so we need to add timeout for + // each request + spec.connectTimeout(Duration.ofSeconds(2)) + if (uri.getPath().equals("/read-timeout")) { + spec.readTimeout(readTimeout()) + } + spec.method(method) + spec.headers(headersSpec -> headers.forEach(headersSpec::add)) + }) + + return resp.map(ReceivedResponse::getStatusCode) + } + + @Override + protected void configure(HttpClientTestOptions options) { + options.setSingleConnectionFactory( + (host, port) -> + (path, headers) -> { + URI uri = resolveAddress(path) + return exec.yield( + unused -> internalSendRequest(singleConnectionClient, "GET", uri, headers)) + .getValueOrThrow() + }) + + options.setExpectedClientSpanNameMapper( + (uri, method) -> { + switch (uri.toString()) { + case "http://localhost:61/": // unopened port + case "https://192.0.2.1/": // non routable address + return "CONNECT" + default: + return HttpClientTestOptions.DEFAULT_EXPECTED_CLIENT_SPAN_NAME_MAPPER.apply( + uri, method) + } + }) + + options.setClientSpanErrorMapper( + (uri, exception) -> { + if (uri.toString() == "https://192.0.2.1/") { + return new ConnectTimeoutException("connection timed out: /192.0.2.1:443") + } else if (OS.WINDOWS.isCurrentOs() && uri.toString().equals("http://localhost:61/")) { + return new ConnectTimeoutException("connection timed out: localhost/127.0.0.1:61") + } else if (uri.getPath().equals("/read-timeout")) { + return ReadTimeoutException.INSTANCE + } + return exception + }) + + options.setHttpAttributes( + uri -> { + switch (uri.toString()) { + case "http://localhost:61/": // unopened port + case "https://192.0.2.1/": // non routable address + return Collections.emptySet() + default: + return HttpClientTestOptions.DEFAULT_HTTP_ATTRIBUTES + } + }) + + options.disableTestRedirects() + + // these tests will pass, but they don't really test anything since REQUEST is Void + options.disableTestReusedRequest() + + options.enableTestReadTimeout() + + + // library instrumentation doesn't have a good way of suppressing nested CLIENT spans yet + options.disableTestWithClientParent() + // Agent users have automatic propagation through executor instrumentation, but library users + // should do manually using Armeria patterns. +// options.disableTestCallbackWithParent() +// options.disableTestErrorWithCallback() + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java new file mode 100644 index 000000000000..7e6cff954ce1 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java @@ -0,0 +1,32 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack; + +import io.opentelemetry.instrumentation.ratpack.client.RatpackHttpTracing; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.func.Action; +import ratpack.http.client.HttpClient; +import ratpack.http.client.HttpClientSpec; + +class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { + + @RegisterExtension + static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forLibrary(); + + @Override + protected HttpClient buildHttpClient() throws Exception { + return RatpackHttpTracing.create(testing.getOpenTelemetry()) + .instrumentedHttpClient(HttpClient.of(Action.noop())); + } + + @Override + protected HttpClient buildHttpClient(Action action) throws Exception { + return RatpackHttpTracing.create(testing.getOpenTelemetry()) + .instrumentedHttpClient(HttpClient.of(action)); + } +} diff --git a/instrumentation/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy similarity index 100% rename from instrumentation/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy rename to instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy From 22fab497bbdd965b9f727df3d942382c2b503b39 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Thu, 30 Dec 2021 00:17:26 +0100 Subject: [PATCH 03/15] Add test to verify trace propagation --- .../ratpack/RatpackHttpClientTest.java | 2 +- .../ratpack/client/OpenTelemetryHttpClient.java | 4 ++-- .../client/InstrumentedHttpClientTest.groovy | 15 ++++++++++++++- 3 files changed, 17 insertions(+), 4 deletions(-) diff --git a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackHttpClientTest.java index c3151e7e8d7c..13b941a21879 100644 --- a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackHttpClientTest.java @@ -13,5 +13,5 @@ class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { @RegisterExtension - static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forLibrary(); + static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java index c7e672eac9aa..936e4630f226 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java @@ -36,8 +36,8 @@ public HttpClient instrument(HttpClient httpClient) throws Exception { Context otelCtx = instrumenter.start(parentOtelCtx, requestSpec); Span span = Span.fromContext(otelCtx); String path = requestSpec.getUri().getPath(); -// span.updateName(path); - span.updateName("HTTP " + requestSpec.getMethod().getName()); + span.updateName(path); +// span.updateName("HTTP " + requestSpec.getMethod().getName()); // TODO use path instead of [HTTP method] span.setAttribute(SemanticAttributes.HTTP_ROUTE, path); Execution.current() .add(new OpenTelemetryExecInitializer.ContextHolder(otelCtx, requestSpec)); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy index 8264e08e7bbe..0d7d94aaa733 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy @@ -49,6 +49,11 @@ class InstrumentedHttpClientTest extends Specification { def "propagate trace with http calls"() { expect: def otherApp = EmbeddedApp.of { spec -> + spec.registry( + Guice.registry { bindings -> + ratpackTracing.configureServerRegistry(bindings) + } + ) spec.handlers { it.get("bar") { ctx -> ctx.render("foo") } } @@ -78,9 +83,11 @@ class InstrumentedHttpClientTest extends Specification { new PollingConditions().eventually { def spanData = spanExporter.finishedSpanItems.find { it.name == "/foo" } - def spanClientData = spanExporter.finishedSpanItems.find { it.name == "/bar" } + def spanClientData = spanExporter.finishedSpanItems.find { it.name == "/bar" && it.kind == SpanKind.CLIENT } + def spanDataApi = spanExporter.finishedSpanItems.find { it.name == "/bar" && it.kind == SpanKind.SERVER } spanData.traceId == spanClientData.traceId + spanData.traceId == spanDataApi.traceId spanData.kind == SpanKind.SERVER spanClientData.kind == SpanKind.CLIENT @@ -94,6 +101,12 @@ class InstrumentedHttpClientTest extends Specification { attributes[SemanticAttributes.HTTP_TARGET] == "/foo" attributes[SemanticAttributes.HTTP_METHOD] == "GET" attributes[SemanticAttributes.HTTP_STATUS_CODE] == 200L + + def attsApi = spanDataApi.attributes.asMap() + attsApi[SemanticAttributes.HTTP_ROUTE] == "/bar" + attsApi[SemanticAttributes.HTTP_TARGET] == "/bar" + attsApi[SemanticAttributes.HTTP_METHOD] == "GET" + attsApi[SemanticAttributes.HTTP_STATUS_CODE] == 200L } } From 55a6cafd8123e766b61a0fecc12c706caddbd892 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Thu, 30 Dec 2021 00:23:32 +0100 Subject: [PATCH 04/15] Fix spotlessApply --- .../ratpack/client/OpenTelemetryHttpClient.java | 3 ++- .../ratpack/client/RatpackHttpClientAttributesExtractor.java | 2 +- .../instrumentation/ratpack/client/RequestHeaderSetter.java | 5 +++++ 3 files changed, 8 insertions(+), 2 deletions(-) diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java index 936e4630f226..4ea72d0183b4 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java @@ -37,7 +37,8 @@ public HttpClient instrument(HttpClient httpClient) throws Exception { Span span = Span.fromContext(otelCtx); String path = requestSpec.getUri().getPath(); span.updateName(path); -// span.updateName("HTTP " + requestSpec.getMethod().getName()); // TODO use path instead of [HTTP method] + // span.updateName("HTTP " + requestSpec.getMethod().getName()); // + // TODO use path instead of [HTTP method] span.setAttribute(SemanticAttributes.HTTP_ROUTE, path); Execution.current() .add(new OpenTelemetryExecInitializer.ContextHolder(otelCtx, requestSpec)); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java index 92f6b60ee8e0..8155a5167e0f 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java @@ -7,9 +7,9 @@ import io.opentelemetry.instrumentation.api.instrumenter.http.CapturedHttpHeaders; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; +import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; import java.util.List; import javax.annotation.Nullable; -import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; import ratpack.http.client.HttpResponse; import ratpack.http.client.RequestSpec; diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RequestHeaderSetter.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RequestHeaderSetter.java index 91dab0ddb51c..e36e89aedaff 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RequestHeaderSetter.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RequestHeaderSetter.java @@ -1,3 +1,8 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + package io.opentelemetry.instrumentation.ratpack.client; import io.opentelemetry.context.propagation.TextMapSetter; From 8f6bc1a546a252a954642afdf5f6c9d3d797fd12 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Fri, 7 Jan 2022 09:31:48 +0100 Subject: [PATCH 05/15] Use HTTP method as name for ratpack http client --- .../client/OpenTelemetryHttpClient.java | 3 - .../AbstractRatpackHttpClientTest.groovy | 1 + .../client/InstrumentedHttpClientTest.groovy | 60 ++++++++++--------- 3 files changed, 33 insertions(+), 31 deletions(-) diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java index 4ea72d0183b4..24e87388260c 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java @@ -36,9 +36,6 @@ public HttpClient instrument(HttpClient httpClient) throws Exception { Context otelCtx = instrumenter.start(parentOtelCtx, requestSpec); Span span = Span.fromContext(otelCtx); String path = requestSpec.getUri().getPath(); - span.updateName(path); - // span.updateName("HTTP " + requestSpec.getMethod().getName()); // - // TODO use path instead of [HTTP method] span.setAttribute(SemanticAttributes.HTTP_ROUTE, path); Execution.current() .add(new OpenTelemetryExecInitializer.ContextHolder(otelCtx, requestSpec)); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy index 61f715203856..08d6fd4508f7 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy @@ -35,6 +35,7 @@ abstract class AbstractRatpackHttpClientTest extends AbstractHttpClientTest spec.poolSize(1)) } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy index 0d7d94aaa733..d2d7977fd1a6 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy @@ -28,6 +28,10 @@ import java.time.Duration import java.util.concurrent.CountDownLatch import java.util.concurrent.TimeUnit +import static io.opentelemetry.semconv.trace.attributes.SemanticAttributes.HTTP_METHOD +import static io.opentelemetry.semconv.trace.attributes.SemanticAttributes.HTTP_ROUTE +import static io.opentelemetry.semconv.trace.attributes.SemanticAttributes.HTTP_STATUS_CODE + class InstrumentedHttpClientTest extends Specification { def spanExporter = InMemorySpanExporter.create() @@ -83,7 +87,7 @@ class InstrumentedHttpClientTest extends Specification { new PollingConditions().eventually { def spanData = spanExporter.finishedSpanItems.find { it.name == "/foo" } - def spanClientData = spanExporter.finishedSpanItems.find { it.name == "/bar" && it.kind == SpanKind.CLIENT } + def spanClientData = spanExporter.finishedSpanItems.find { it.name == "HTTP GET" && it.kind == SpanKind.CLIENT } def spanDataApi = spanExporter.finishedSpanItems.find { it.name == "/bar" && it.kind == SpanKind.SERVER } spanData.traceId == spanClientData.traceId @@ -92,21 +96,21 @@ class InstrumentedHttpClientTest extends Specification { spanData.kind == SpanKind.SERVER spanClientData.kind == SpanKind.CLIENT def atts = spanClientData.attributes.asMap() - atts[SemanticAttributes.HTTP_ROUTE] == "/bar" - atts[SemanticAttributes.HTTP_METHOD] == "GET" - atts[SemanticAttributes.HTTP_STATUS_CODE] == 200L + atts[HTTP_ROUTE] == "/bar" + atts[HTTP_METHOD] == "GET" + atts[HTTP_STATUS_CODE] == 200L def attributes = spanData.attributes.asMap() - attributes[SemanticAttributes.HTTP_ROUTE] == "/foo" + attributes[HTTP_ROUTE] == "/foo" attributes[SemanticAttributes.HTTP_TARGET] == "/foo" - attributes[SemanticAttributes.HTTP_METHOD] == "GET" - attributes[SemanticAttributes.HTTP_STATUS_CODE] == 200L + attributes[HTTP_METHOD] == "GET" + attributes[HTTP_STATUS_CODE] == 200L def attsApi = spanDataApi.attributes.asMap() - attsApi[SemanticAttributes.HTTP_ROUTE] == "/bar" + attsApi[HTTP_ROUTE] == "/bar" attsApi[SemanticAttributes.HTTP_TARGET] == "/bar" - attsApi[SemanticAttributes.HTTP_METHOD] == "GET" - attsApi[SemanticAttributes.HTTP_STATUS_CODE] == 200L + attsApi[HTTP_METHOD] == "GET" + attsApi[HTTP_STATUS_CODE] == 200L } } @@ -148,8 +152,8 @@ class InstrumentedHttpClientTest extends Specification { new PollingConditions().eventually { spanExporter.finishedSpanItems.size() == 3 def spanData = spanExporter.finishedSpanItems.find { spanData -> spanData.name == "/path-name" } - def spanClientData1 = spanExporter.finishedSpanItems.find { s -> s.name == "/foo" } - def spanClientData2 = spanExporter.finishedSpanItems.find { s -> s.name == "/bar" } + def spanClientData1 = spanExporter.finishedSpanItems.find { s -> s.name == "HTTP GET" && s.attributes.asMap()[HTTP_ROUTE] == "/foo" } + def spanClientData2 = spanExporter.finishedSpanItems.find { s -> s.name == "HTTP GET" && s.attributes.asMap()[HTTP_ROUTE] == "/bar" } spanData.traceId == spanClientData1.traceId spanData.traceId == spanClientData2.traceId @@ -158,21 +162,21 @@ class InstrumentedHttpClientTest extends Specification { spanClientData1.kind == SpanKind.CLIENT def atts = spanClientData1.attributes.asMap() - atts[SemanticAttributes.HTTP_ROUTE] == "/foo" - atts[SemanticAttributes.HTTP_METHOD] == "GET" - atts[SemanticAttributes.HTTP_STATUS_CODE] == 200L + atts[HTTP_ROUTE] == "/foo" + atts[HTTP_METHOD] == "GET" + atts[HTTP_STATUS_CODE] == 200L spanClientData2.kind == SpanKind.CLIENT def atts2 = spanClientData2.attributes.asMap() - atts2[SemanticAttributes.HTTP_ROUTE] == "/bar" - atts2[SemanticAttributes.HTTP_METHOD] == "GET" - atts2[SemanticAttributes.HTTP_STATUS_CODE] == 200L + atts2[HTTP_ROUTE] == "/bar" + atts2[HTTP_METHOD] == "GET" + atts2[HTTP_STATUS_CODE] == 200L def attributes = spanData.attributes.asMap() - attributes[SemanticAttributes.HTTP_ROUTE] == "/path-name" + attributes[HTTP_ROUTE] == "/path-name" attributes[SemanticAttributes.HTTP_TARGET] == "/path-name" - attributes[SemanticAttributes.HTTP_METHOD] == "GET" - attributes[SemanticAttributes.HTTP_STATUS_CODE] == 200L + attributes[HTTP_METHOD] == "GET" + attributes[HTTP_STATUS_CODE] == 200L } } @@ -214,24 +218,24 @@ class InstrumentedHttpClientTest extends Specification { new PollingConditions().eventually { def spanData = spanExporter.finishedSpanItems.find { it.name == "/path-name" } - def spanClientData = spanExporter.finishedSpanItems.find { it.name == "/foo" } + def spanClientData = spanExporter.finishedSpanItems.find { it.name == "HTTP GET" } spanData.traceId == spanClientData.traceId spanData.kind == SpanKind.SERVER spanClientData.kind == SpanKind.CLIENT def atts = spanClientData.attributes.asMap() - atts[SemanticAttributes.HTTP_ROUTE] == "/foo" - atts[SemanticAttributes.HTTP_METHOD] == "GET" - atts[SemanticAttributes.HTTP_STATUS_CODE] == null + atts[HTTP_ROUTE] == "/foo" + atts[HTTP_METHOD] == "GET" + atts[HTTP_STATUS_CODE] == null spanClientData.status.statusCode == StatusCode.ERROR spanClientData.events.first().name == "exception" def attributes = spanData.attributes.asMap() - attributes[SemanticAttributes.HTTP_ROUTE] == "/path-name" + attributes[HTTP_ROUTE] == "/path-name" attributes[SemanticAttributes.HTTP_TARGET] == "/path-name" - attributes[SemanticAttributes.HTTP_METHOD] == "GET" - attributes[SemanticAttributes.HTTP_STATUS_CODE] == 200L + attributes[HTTP_METHOD] == "GET" + attributes[HTTP_STATUS_CODE] == 200L } } } From 60770c545dbd201192f8426378038bd3a5cdf6c1 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Fri, 7 Jan 2022 21:51:05 +0100 Subject: [PATCH 06/15] Add current Context to the execution --- .../instrumentation/ratpack/OpenTelemetryExecInitializer.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java index fd3993c81040..f5e32586fc56 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java @@ -14,6 +14,10 @@ public final class OpenTelemetryExecInitializer implements ExecInitializer { @Override public void init(Execution execution) { + // Adds current Context to Execution + execution.add(Context.current()); + + // Propagates ContextHolder to child execution because response interceptor are triggered in different execution execution .maybeParent() .flatMap(parent -> parent.maybeGet(ContextHolder.class)) From a4d1dddcfedf4654f3404b32772b105c922b4829 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Sat, 8 Jan 2022 00:12:49 +0100 Subject: [PATCH 07/15] Fix HttpClient tests --- .../ratpack/OpenTelemetryExecInitializer.java | 3 +- .../AbstractRatpackHttpClientSpec.java | 140 +++++++++++++++ .../AbstractRatpackHttpClientTest.groovy | 169 ------------------ .../ratpack/RatpackHttpClientTest.java | 2 +- .../RatpackServerApplicationTest.groovy | 43 +++-- 5 files changed, 163 insertions(+), 194 deletions(-) create mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientSpec.java delete mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java index f5e32586fc56..20733e17718b 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java @@ -17,7 +17,8 @@ public void init(Execution execution) { // Adds current Context to Execution execution.add(Context.current()); - // Propagates ContextHolder to child execution because response interceptor are triggered in different execution + // Propagates ContextHolder to child execution because response interceptor are triggered in + // different execution execution .maybeParent() .flatMap(parent -> parent.maybeGet(ContextHolder.class)) diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientSpec.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientSpec.java new file mode 100644 index 000000000000..2550d3d7f903 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientSpec.java @@ -0,0 +1,140 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack; + +import com.google.common.collect.ImmutableList; +import io.netty.channel.ConnectTimeoutException; +import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest; +import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; +import java.net.URI; +import java.time.Duration; +import java.util.Map; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.condition.OS; +import ratpack.exec.Operation; +import ratpack.exec.Promise; +import ratpack.exec.internal.DefaultExecController; +import ratpack.func.Action; +import ratpack.http.client.HttpClient; +import ratpack.http.client.HttpClientReadTimeoutException; +import ratpack.http.client.HttpClientSpec; +import ratpack.http.client.ReceivedResponse; +import ratpack.test.exec.ExecHarness; + +abstract class AbstractRatpackHttpClientSpec extends AbstractHttpClientTest { + + final ExecHarness exec = ExecHarness.harness(); + + HttpClient client; + HttpClient singleConnectionClient; + + @BeforeAll + void setUpClient() throws Exception { + exec.run( + unused -> { + ((DefaultExecController) exec.getController()) + .setInitializers(ImmutableList.of(new OpenTelemetryExecInitializer())); + ((DefaultExecController) exec.getController()) + .setInterceptors(ImmutableList.of(OpenTelemetryExecInterceptor.INSTANCE)); + client = buildHttpClient(); + singleConnectionClient = buildHttpClient(spec -> spec.poolSize(1)); + }); + } + + @AfterAll + void cleanUpClient() { + client.close(); + singleConnectionClient.close(); + exec.close(); + } + + protected HttpClient buildHttpClient() throws Exception { + return buildHttpClient(Action.noop()); + } + + protected HttpClient buildHttpClient(Action action) throws Exception { + return HttpClient.of(action); + } + + @Override + protected final Void buildRequest(String method, URI uri, Map headers) { + return null; + } + + @Override + protected final int sendRequest(Void request, String method, URI uri, Map headers) + throws Exception { + return exec.yield(unused -> internalSendRequest(client, method, uri, headers)) + .getValueOrThrow(); + } + + @Override + protected final void sendRequestWithCallback( + Void request, + String method, + URI uri, + Map headers, + RequestResult requestResult) + throws Exception { + exec.execute( + Operation.of( + () -> + internalSendRequest(client, method, uri, headers) + .result( + result -> + requestResult.complete(result::getValue, result.getThrowable())))); + } + + // overridden in RatpackForkedHttpClientTest + protected Promise internalSendRequest( + HttpClient client, String method, URI uri, Map headers) { + Promise resp = + client.request( + uri, + spec -> { + // Connect timeout for the whole client was added in 1.5 so we need to add timeout for + // each request + spec.connectTimeout(Duration.ofSeconds(2)); + if (uri.getPath().equals("/read-timeout")) { + spec.readTimeout(readTimeout()); + } + spec.method(method); + spec.headers(headersSpec -> headers.forEach(headersSpec::add)); + }); + + return resp.map(ReceivedResponse::getStatusCode); + } + + @Override + protected void configure(HttpClientTestOptions options) { + options.setSingleConnectionFactory( + (host, port) -> + (path, headers) -> { + URI uri = resolveAddress(path); + return exec.yield( + unused -> internalSendRequest(singleConnectionClient, "GET", uri, headers)) + .getValueOrThrow(); + }); + + options.setClientSpanErrorMapper( + (uri, exception) -> { + if (uri.toString().equals("https://192.0.2.1/")) { + return new ConnectTimeoutException("Connect timeout (PT2S) connecting to " + uri); + } else if (OS.WINDOWS.isCurrentOs() && uri.toString().equals("http://localhost:61/")) { + return new ConnectTimeoutException("Connect timeout (PT2S) connecting to " + uri); + } else if (uri.getPath().equals("/read-timeout")) { + return new HttpClientReadTimeoutException( + "Read timeout (PT2S) waiting on HTTP server at " + uri); + } + return exception; + }); + + options.disableTestRedirects(); + options.disableTestReusedRequest(); + options.enableTestReadTimeout(); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy deleted file mode 100644 index 08d6fd4508f7..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.groovy +++ /dev/null @@ -1,169 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack - -import com.google.common.collect.ImmutableList -import io.netty.channel.ConnectTimeoutException -import io.netty.handler.timeout.ReadTimeoutException -import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest -import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions -import org.junit.jupiter.api.AfterAll -import org.junit.jupiter.api.BeforeAll -import org.junit.jupiter.api.condition.OS -import ratpack.exec.Operation -import ratpack.exec.Promise -import ratpack.exec.internal.DefaultExecController -import ratpack.func.Action -import ratpack.http.client.HttpClient -import ratpack.http.client.HttpClientSpec -import ratpack.http.client.ReceivedResponse -import ratpack.test.exec.ExecHarness - -import java.time.Duration - -abstract class AbstractRatpackHttpClientTest extends AbstractHttpClientTest { - - final ExecHarness exec = ExecHarness.harness() - - HttpClient client - HttpClient singleConnectionClient - - @BeforeAll - void setUpClient() throws Exception { - exec.run { - (exec.controller as DefaultExecController).setInitializers(ImmutableList.of(new OpenTelemetryExecInitializer())) - (exec.controller as DefaultExecController).setInterceptors(ImmutableList.of(OpenTelemetryExecInterceptor.INSTANCE)) - client = buildHttpClient() - singleConnectionClient = buildHttpClient(spec -> spec.poolSize(1)) - } - } - - @AfterAll - void cleanUpClient() { - client.close() - singleConnectionClient.close() - exec.close() - } - - protected HttpClient buildHttpClient() throws Exception { - return buildHttpClient(Action.noop()) - } - - protected HttpClient buildHttpClient(Action action) throws Exception { - return HttpClient.of(action) - } - - @Override - protected final Void buildRequest(String method, URI uri, Map headers) { - return null - } - - @Override - protected final int sendRequest(Void request, String method, URI uri, Map headers) - throws Exception { - return exec.yield { internalSendRequest(client, method, uri, headers) } - .getValueOrThrow() - } - - @Override - protected final void sendRequestWithCallback( - Void request, - String method, - URI uri, - Map headers, - RequestResult requestResult) - throws Exception { - exec.execute( - Operation.of( - () -> - internalSendRequest(client, method, uri, headers) - .result( - result -> - requestResult.complete(result::getValue, result.getThrowable())))) - } - - // overridden in RatpackForkedHttpClientTest - protected Promise internalSendRequest( - HttpClient client, String method, URI uri, Map headers) { - Promise resp = - client.request( - uri, - spec -> { - // Connect timeout for the whole client was added in 1.5 so we need to add timeout for - // each request - spec.connectTimeout(Duration.ofSeconds(2)) - if (uri.getPath().equals("/read-timeout")) { - spec.readTimeout(readTimeout()) - } - spec.method(method) - spec.headers(headersSpec -> headers.forEach(headersSpec::add)) - }) - - return resp.map(ReceivedResponse::getStatusCode) - } - - @Override - protected void configure(HttpClientTestOptions options) { - options.setSingleConnectionFactory( - (host, port) -> - (path, headers) -> { - URI uri = resolveAddress(path) - return exec.yield( - unused -> internalSendRequest(singleConnectionClient, "GET", uri, headers)) - .getValueOrThrow() - }) - - options.setExpectedClientSpanNameMapper( - (uri, method) -> { - switch (uri.toString()) { - case "http://localhost:61/": // unopened port - case "https://192.0.2.1/": // non routable address - return "CONNECT" - default: - return HttpClientTestOptions.DEFAULT_EXPECTED_CLIENT_SPAN_NAME_MAPPER.apply( - uri, method) - } - }) - - options.setClientSpanErrorMapper( - (uri, exception) -> { - if (uri.toString() == "https://192.0.2.1/") { - return new ConnectTimeoutException("connection timed out: /192.0.2.1:443") - } else if (OS.WINDOWS.isCurrentOs() && uri.toString().equals("http://localhost:61/")) { - return new ConnectTimeoutException("connection timed out: localhost/127.0.0.1:61") - } else if (uri.getPath().equals("/read-timeout")) { - return ReadTimeoutException.INSTANCE - } - return exception - }) - - options.setHttpAttributes( - uri -> { - switch (uri.toString()) { - case "http://localhost:61/": // unopened port - case "https://192.0.2.1/": // non routable address - return Collections.emptySet() - default: - return HttpClientTestOptions.DEFAULT_HTTP_ATTRIBUTES - } - }) - - options.disableTestRedirects() - - // these tests will pass, but they don't really test anything since REQUEST is Void - options.disableTestReusedRequest() - - options.enableTestReadTimeout() - - - // library instrumentation doesn't have a good way of suppressing nested CLIENT spans yet - options.disableTestWithClientParent() - // Agent users have automatic propagation through executor instrumentation, but library users - // should do manually using Armeria patterns. -// options.disableTestCallbackWithParent() -// options.disableTestErrorWithCallback() - } -} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java index 7e6cff954ce1..8a9b0233cceb 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java @@ -13,7 +13,7 @@ import ratpack.http.client.HttpClient; import ratpack.http.client.HttpClientSpec; -class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { +class RatpackHttpClientTest extends AbstractRatpackHttpClientSpec { @RegisterExtension static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forLibrary(); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy index 9acd1a8a8a1b..a76255c38c84 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy @@ -20,7 +20,6 @@ import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter import io.opentelemetry.sdk.trace.SdkTracerProvider import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor import io.opentelemetry.sdk.trace.export.SpanExporter -import io.opentelemetry.semconv.trace.attributes.SemanticAttributes import ratpack.exec.ExecInterceptor import ratpack.guice.Guice import ratpack.http.client.HttpClient @@ -30,6 +29,11 @@ import spock.util.concurrent.PollingConditions import javax.inject.Singleton +import static io.opentelemetry.semconv.trace.attributes.SemanticAttributes.HTTP_METHOD +import static io.opentelemetry.semconv.trace.attributes.SemanticAttributes.HTTP_ROUTE +import static io.opentelemetry.semconv.trace.attributes.SemanticAttributes.HTTP_STATUS_CODE +import static io.opentelemetry.semconv.trace.attributes.SemanticAttributes.HTTP_TARGET + class RatpackServerApplicationTest extends Specification { def app = new RatpackFunctionalTest(RatpackApp) @@ -43,10 +47,10 @@ class RatpackServerApplicationTest extends Specification { def attributes = spanData.attributes.asMap() spanData.kind == SpanKind.SERVER - attributes[SemanticAttributes.HTTP_ROUTE] == "/foo" - attributes[SemanticAttributes.HTTP_TARGET] == "/foo" - attributes[SemanticAttributes.HTTP_METHOD] == "GET" - attributes[SemanticAttributes.HTTP_STATUS_CODE] == 200L + attributes[HTTP_ROUTE] == "/foo" + attributes[HTTP_TARGET] == "/foo" + attributes[HTTP_METHOD] == "GET" + attributes[HTTP_STATUS_CODE] == 200L } } @@ -56,23 +60,22 @@ class RatpackServerApplicationTest extends Specification { new PollingConditions().eventually { def spanData = app.spanExporter.finishedSpanItems.find { it.name == "/bar" } - def spanDataClient = app.spanExporter.finishedSpanItems.find { it.name == "/other" } + def spanDataClient = app.spanExporter.finishedSpanItems.find { it.name == "HTTP GET" } def attributes = spanData.attributes.asMap() spanData.traceId == spanDataClient.traceId spanData.kind == SpanKind.SERVER - attributes[SemanticAttributes.HTTP_ROUTE] == "/bar" - attributes[SemanticAttributes.HTTP_TARGET] == "/bar" - attributes[SemanticAttributes.HTTP_METHOD] == "GET" - attributes[SemanticAttributes.HTTP_STATUS_CODE] == 200L + attributes[HTTP_ROUTE] == "/bar" + attributes[HTTP_TARGET] == "/bar" + attributes[HTTP_METHOD] == "GET" + attributes[HTTP_STATUS_CODE] == 200L spanDataClient.kind == SpanKind.CLIENT def attributesClient = spanDataClient.attributes.asMap() - attributesClient[SemanticAttributes.HTTP_ROUTE] == "/other" - attributesClient[SemanticAttributes.HTTP_METHOD] == "GET" - attributesClient[SemanticAttributes.HTTP_STATUS_CODE] == 200L - + attributesClient[HTTP_ROUTE] == "/other" + attributesClient[HTTP_METHOD] == "GET" + attributesClient[HTTP_STATUS_CODE] == 200L } } @@ -92,6 +95,7 @@ class OpenTelemetryModule extends AbstractModule { @Override protected void configure() { bind(SpanExporter).toInstance(InMemorySpanExporter.create()) + bind(OpenTelemetryExecInitializer) } @Singleton @@ -130,7 +134,7 @@ class OpenTelemetryModule extends AbstractModule { @Singleton @Provides HttpClient instrumentedHttpClient(RatpackHttpTracing ratpackHttpTracing) { - return ratpackHttpTracing.instrumentedHttpClient(HttpClient.of { it.poolQueueSize(10) }) + return ratpackHttpTracing.instrumentedHttpClient(HttpClient.of {}) } } @@ -145,13 +149,7 @@ class RatpackApp { RatpackServer.start { server -> server - .registry( - Guice.registry { bindings -> - bindings - .module(OpenTelemetryModule) - .bind(OpenTelemetryExecInitializer) - } - ) + .registry(Guice.registry { b -> b.module(OpenTelemetryModule) }) .handlers { chain -> chain .get("ignore") { ctx -> ctx.render("ignored") } @@ -166,4 +164,3 @@ class RatpackApp { } } } - From d08277c7b7871a72493556683805b386bf73e1cb Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Sat, 8 Jan 2022 00:46:22 +0100 Subject: [PATCH 08/15] Move Ratpack HttpClient tests to java package --- .../instrumentation/ratpack/AbstractRatpackHttpClientTest.java} | 2 +- .../instrumentation/ratpack/RatpackHttpClientTest.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) rename instrumentation/ratpack/ratpack-1.7/library/src/test/{groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientSpec.java => java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java} (98%) rename instrumentation/ratpack/ratpack-1.7/library/src/test/{groovy => java}/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java (94%) diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientSpec.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java similarity index 98% rename from instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientSpec.java rename to instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java index 2550d3d7f903..1c22078cc6b5 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientSpec.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java @@ -25,7 +25,7 @@ import ratpack.http.client.ReceivedResponse; import ratpack.test.exec.ExecHarness; -abstract class AbstractRatpackHttpClientSpec extends AbstractHttpClientTest { +abstract class AbstractRatpackHttpClientTest extends AbstractHttpClientTest { final ExecHarness exec = ExecHarness.harness(); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java similarity index 94% rename from instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java rename to instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java index 8a9b0233cceb..7e6cff954ce1 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java @@ -13,7 +13,7 @@ import ratpack.http.client.HttpClient; import ratpack.http.client.HttpClientSpec; -class RatpackHttpClientTest extends AbstractRatpackHttpClientSpec { +class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { @RegisterExtension static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forLibrary(); From 6d8770e07ac531a0e50cdc40963c1351d4dba6b9 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Sat, 8 Jan 2022 01:06:48 +0100 Subject: [PATCH 09/15] Remove nullaway conventions from library --- instrumentation/ratpack/ratpack-1.7/library/build.gradle.kts | 1 - 1 file changed, 1 deletion(-) diff --git a/instrumentation/ratpack/ratpack-1.7/library/build.gradle.kts b/instrumentation/ratpack/ratpack-1.7/library/build.gradle.kts index 2643318cb984..7386823c002e 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/build.gradle.kts +++ b/instrumentation/ratpack/ratpack-1.7/library/build.gradle.kts @@ -1,6 +1,5 @@ plugins { id("otel.library-instrumentation") - id("otel.nullaway-conventions") } dependencies { From b25303fd522e715b3ca9e777d1bc2e458ac13d70 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Sun, 9 Jan 2022 23:57:20 +0100 Subject: [PATCH 10/15] Add Context to ExecHarness executions --- .../ratpack/OpenTelemetryExecInitializer.java | 45 ------------------- .../client/OpenTelemetryExecInitializer.java | 24 ++++++++++ .../client/OpenTelemetryHttpClient.java | 11 ++--- .../ratpack/client/RatpackHttpTracing.java | 6 +++ .../client/internal/ContextHolder.java | 27 +++++++++++ .../client/InstrumentedHttpClientTest.groovy | 10 ++--- .../RatpackServerApplicationTest.groovy | 10 ++++- .../AbstractRatpackHttpClientTest.java | 29 ++++++++---- 8 files changed, 93 insertions(+), 69 deletions(-) delete mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java create mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryExecInitializer.java create mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/ContextHolder.java diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java deleted file mode 100644 index 20733e17718b..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack; - -import io.opentelemetry.context.Context; -import ratpack.exec.ExecInitializer; -import ratpack.exec.Execution; -import ratpack.http.client.RequestSpec; - -public final class OpenTelemetryExecInitializer implements ExecInitializer { - - @Override - public void init(Execution execution) { - // Adds current Context to Execution - execution.add(Context.current()); - - // Propagates ContextHolder to child execution because response interceptor are triggered in - // different execution - execution - .maybeParent() - .flatMap(parent -> parent.maybeGet(ContextHolder.class)) - .ifPresent(execution::add); - } - - public static final class ContextHolder { - private final Context context; - private final RequestSpec requestSpec; - - public ContextHolder(Context context, RequestSpec requestSpec) { - this.context = context; - this.requestSpec = requestSpec; - } - - public Context context() { - return context; - } - - public RequestSpec requestSpec() { - return requestSpec; - } - } -} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryExecInitializer.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryExecInitializer.java new file mode 100644 index 000000000000..c570ff393400 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryExecInitializer.java @@ -0,0 +1,24 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.client; + +import io.opentelemetry.instrumentation.ratpack.client.internal.ContextHolder; +import ratpack.exec.ExecInitializer; +import ratpack.exec.Execution; + +public final class OpenTelemetryExecInitializer implements ExecInitializer { + public static final ExecInitializer INSTANCE = new OpenTelemetryExecInitializer(); + + @Override + public void init(Execution execution) { + // Propagates ContextHolder to child execution because the response interceptor is triggered in + // another execution segment + execution + .maybeParent() + .flatMap(parent -> parent.maybeGet(ContextHolder.class)) + .ifPresent(execution::add); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java index 24e87388260c..c3c616aed40b 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java @@ -8,7 +8,7 @@ import io.opentelemetry.api.trace.Span; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; -import io.opentelemetry.instrumentation.ratpack.OpenTelemetryExecInitializer; +import io.opentelemetry.instrumentation.ratpack.client.internal.ContextHolder; import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; import ratpack.exec.Execution; import ratpack.http.client.HttpClient; @@ -37,22 +37,19 @@ public HttpClient instrument(HttpClient httpClient) throws Exception { Span span = Span.fromContext(otelCtx); String path = requestSpec.getUri().getPath(); span.setAttribute(SemanticAttributes.HTTP_ROUTE, path); - Execution.current() - .add(new OpenTelemetryExecInitializer.ContextHolder(otelCtx, requestSpec)); + Execution.current().add(new ContextHolder(otelCtx, requestSpec)); }); httpClientSpec.responseIntercept( httpResponse -> { - OpenTelemetryExecInitializer.ContextHolder contextHolder = - Execution.current().get(OpenTelemetryExecInitializer.ContextHolder.class); + ContextHolder contextHolder = Execution.current().get(ContextHolder.class); instrumenter.end( contextHolder.context(), contextHolder.requestSpec(), httpResponse, null); }); httpClientSpec.errorIntercept( ex -> { - OpenTelemetryExecInitializer.ContextHolder contextHolder = - Execution.current().get(OpenTelemetryExecInitializer.ContextHolder.class); + ContextHolder contextHolder = Execution.current().get(ContextHolder.class); instrumenter.end(contextHolder.context(), contextHolder.requestSpec(), null, ex); }); }); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java index a03be65ec29e..91c0de1b6889 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java @@ -7,6 +7,7 @@ import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; +import ratpack.exec.ExecInitializer; import ratpack.http.client.HttpClient; import ratpack.http.client.HttpResponse; import ratpack.http.client.RequestSpec; @@ -36,4 +37,9 @@ public static RatpackHttpTracingBuilder builder(OpenTelemetry openTelemetry) { public HttpClient instrumentedHttpClient(HttpClient httpClient) throws Exception { return new OpenTelemetryHttpClient(instrumenter).instrument(httpClient); } + + /** Returns instance of {@link ExecInitializer} to support Ratpack Registry binding. */ + public ExecInitializer getOpenTelemetryExecInitializer() { + return OpenTelemetryExecInitializer.INSTANCE; + } } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/ContextHolder.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/ContextHolder.java new file mode 100644 index 000000000000..6ffbcdf847a5 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/ContextHolder.java @@ -0,0 +1,27 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.client.internal; + +import io.opentelemetry.context.Context; +import ratpack.http.client.RequestSpec; + +public final class ContextHolder { + private final Context context; + private final RequestSpec requestSpec; + + public ContextHolder(Context context, RequestSpec requestSpec) { + this.context = context; + this.requestSpec = requestSpec; + } + + public Context context() { + return context; + } + + public RequestSpec requestSpec() { + return requestSpec; + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy index d2d7977fd1a6..0a63bae14664 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy @@ -9,7 +9,6 @@ import io.opentelemetry.api.trace.SpanKind import io.opentelemetry.api.trace.StatusCode import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator import io.opentelemetry.context.propagation.ContextPropagators -import io.opentelemetry.instrumentation.ratpack.OpenTelemetryExecInitializer import io.opentelemetry.instrumentation.ratpack.RatpackTracing import io.opentelemetry.sdk.OpenTelemetrySdk import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter @@ -66,8 +65,8 @@ class InstrumentedHttpClientTest extends Specification { def app = EmbeddedApp.of { spec -> spec.registry( Guice.registry { bindings -> - bindings.bind(OpenTelemetryExecInitializer) ratpackTracing.configureServerRegistry(bindings) + bindings.bindInstance(ratpackHttpTracing.getOpenTelemetryExecInitializer()) bindings.bindInstance(HttpClient, ratpackHttpTracing.instrumentedHttpClient(HttpClient.of(Action.noop()))) } ) @@ -128,8 +127,8 @@ class InstrumentedHttpClientTest extends Specification { def app = EmbeddedApp.of { spec -> spec.registry( Guice.registry { bindings -> - bindings.bind(OpenTelemetryExecInitializer) ratpackTracing.configureServerRegistry(bindings) + bindings.bindInstance(ratpackHttpTracing.getOpenTelemetryExecInitializer()) bindings.bindInstance(HttpClient, ratpackHttpTracing.instrumentedHttpClient(HttpClient.of(Action.noop()))) } ) @@ -194,8 +193,8 @@ class InstrumentedHttpClientTest extends Specification { def app = EmbeddedApp.of { spec -> spec.registry( Guice.registry { bindings -> - bindings.bind(OpenTelemetryExecInitializer) ratpackTracing.configureServerRegistry(bindings) + bindings.bindInstance(ratpackHttpTracing.getOpenTelemetryExecInitializer()) bindings.bindInstance(HttpClient, ratpackHttpTracing.instrumentedHttpClient( HttpClient.of { s -> s.readTimeout(Duration.ofMillis(10)) }) ) @@ -212,8 +211,7 @@ class InstrumentedHttpClientTest extends Specification { } } - app.test { httpClient -> - "error" == httpClient.get("path-name").body.text + app.test { httpClient -> "error" == httpClient.get("path-name").body.text } new PollingConditions().eventually { diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy index a76255c38c84..dc6c0649b94b 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy @@ -10,7 +10,6 @@ import com.google.inject.Provides import groovy.transform.CompileStatic import io.opentelemetry.api.OpenTelemetry import io.opentelemetry.api.trace.SpanKind -import io.opentelemetry.instrumentation.ratpack.OpenTelemetryExecInitializer import io.opentelemetry.instrumentation.ratpack.OpenTelemetryServerHandler import io.opentelemetry.instrumentation.ratpack.RatpackFunctionalTest import io.opentelemetry.instrumentation.ratpack.RatpackTracing @@ -20,6 +19,7 @@ import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter import io.opentelemetry.sdk.trace.SdkTracerProvider import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor import io.opentelemetry.sdk.trace.export.SpanExporter +import ratpack.exec.ExecInitializer import ratpack.exec.ExecInterceptor import ratpack.guice.Guice import ratpack.http.client.HttpClient @@ -95,7 +95,6 @@ class OpenTelemetryModule extends AbstractModule { @Override protected void configure() { bind(SpanExporter).toInstance(InMemorySpanExporter.create()) - bind(OpenTelemetryExecInitializer) } @Singleton @@ -136,6 +135,13 @@ class OpenTelemetryModule extends AbstractModule { HttpClient instrumentedHttpClient(RatpackHttpTracing ratpackHttpTracing) { return ratpackHttpTracing.instrumentedHttpClient(HttpClient.of {}) } + + @Singleton + @Provides + ExecInitializer ratpackExecInitializer(RatpackHttpTracing ratpackTracing) { + return ratpackTracing.getOpenTelemetryExecInitializer() + } + } class RatpackApp { diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java index 1c22078cc6b5..c1ebdb301d19 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java @@ -7,6 +7,8 @@ import com.google.common.collect.ImmutableList; import io.netty.channel.ConnectTimeoutException; +import io.opentelemetry.context.Context; +import io.opentelemetry.instrumentation.ratpack.client.OpenTelemetryExecInitializer; import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; import java.net.URI; @@ -37,7 +39,7 @@ void setUpClient() throws Exception { exec.run( unused -> { ((DefaultExecController) exec.getController()) - .setInitializers(ImmutableList.of(new OpenTelemetryExecInitializer())); + .setInitializers(ImmutableList.of(OpenTelemetryExecInitializer.INSTANCE)); ((DefaultExecController) exec.getController()) .setInterceptors(ImmutableList.of(OpenTelemetryExecInterceptor.INSTANCE)); client = buildHttpClient(); @@ -68,7 +70,9 @@ protected final Void buildRequest(String method, URI uri, Map he @Override protected final int sendRequest(Void request, String method, URI uri, Map headers) throws Exception { - return exec.yield(unused -> internalSendRequest(client, method, uri, headers)) + return exec.yield( + r -> r.add(Context.class, Context.current()), + execution -> internalSendRequest(client, method, uri, headers)) .getValueOrThrow(); } @@ -80,13 +84,19 @@ protected final void sendRequestWithCallback( Map headers, RequestResult requestResult) throws Exception { - exec.execute( - Operation.of( - () -> - internalSendRequest(client, method, uri, headers) - .result( - result -> - requestResult.complete(result::getValue, result.getThrowable())))); + // ratpack-test 1.8 supports execute with an Action of registrySpec + exec.yield( + r -> r.add(Context.class, Context.current()), + (e) -> + Operation.of( + () -> + internalSendRequest(client, method, uri, headers) + .result( + result -> + requestResult.complete( + result::getValue, result.getThrowable()))) + .promise()) + .getValueOrThrow(); } // overridden in RatpackForkedHttpClientTest @@ -116,6 +126,7 @@ protected void configure(HttpClientTestOptions options) { (path, headers) -> { URI uri = resolveAddress(path); return exec.yield( + r -> r.add(Context.class, Context.current()), unused -> internalSendRequest(singleConnectionClient, "GET", uri, headers)) .getValueOrThrow(); }); From 0600b5b8df1ea92a3934378b314545ea88bc296e Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Mon, 10 Jan 2022 09:10:27 +0100 Subject: [PATCH 11/15] Remove ContextHolder from execution --- .../ratpack/client/OpenTelemetryHttpClient.java | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java index c3c616aed40b..43916e865db9 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java @@ -42,14 +42,18 @@ public HttpClient instrument(HttpClient httpClient) throws Exception { httpClientSpec.responseIntercept( httpResponse -> { - ContextHolder contextHolder = Execution.current().get(ContextHolder.class); + Execution execution = Execution.current(); + ContextHolder contextHolder = execution.get(ContextHolder.class); + execution.remove(ContextHolder.class); instrumenter.end( contextHolder.context(), contextHolder.requestSpec(), httpResponse, null); }); httpClientSpec.errorIntercept( ex -> { - ContextHolder contextHolder = Execution.current().get(ContextHolder.class); + Execution execution = Execution.current(); + ContextHolder contextHolder = execution.get(ContextHolder.class); + execution.remove(ContextHolder.class); instrumenter.end(contextHolder.context(), contextHolder.requestSpec(), null, ex); }); }); From 10f404e5bc679edf57a176ae26865bf04dbeafc1 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Tue, 11 Jan 2022 12:59:08 +0100 Subject: [PATCH 12/15] Fix function test using other server stub --- .../ratpack/RatpackFunctionalTest.groovy | 10 ++++++++++ .../server/RatpackServerApplicationTest.groovy | 15 ++++----------- 2 files changed, 14 insertions(+), 11 deletions(-) diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackFunctionalTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackFunctionalTest.groovy index 6d4bf8fc834c..396ed15173e1 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackFunctionalTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackFunctionalTest.groovy @@ -8,16 +8,23 @@ package io.opentelemetry.instrumentation.ratpack import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter import io.opentelemetry.sdk.trace.export.SpanExporter +import ratpack.guice.BindingsImposition import ratpack.impose.ForceDevelopmentImposition import ratpack.impose.ImpositionsSpec import ratpack.impose.UserRegistryImposition import ratpack.registry.Registry import ratpack.test.MainClassApplicationUnderTest +import ratpack.test.embed.EmbeddedApp class RatpackFunctionalTest extends MainClassApplicationUnderTest { Registry registry @Lazy InMemorySpanExporter spanExporter = registry.get(SpanExporter) as InMemorySpanExporter + @Lazy EmbeddedApp app = EmbeddedApp.of { server -> + server.handlers { chain -> + chain.get("other") { ctx -> ctx.render("hi-other") } + } + } RatpackFunctionalTest(Class mainClass) { super(mainClass) @@ -31,5 +38,8 @@ class RatpackFunctionalTest extends MainClassApplicationUnderTest { registry = r registry }) + impositions.add(BindingsImposition.of { + it.bindInstance(URI, app.address.resolve("other")) + }) } } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy index dc6c0649b94b..80e1696c3502 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy @@ -138,21 +138,15 @@ class OpenTelemetryModule extends AbstractModule { @Singleton @Provides - ExecInitializer ratpackExecInitializer(RatpackHttpTracing ratpackTracing) { - return ratpackTracing.getOpenTelemetryExecInitializer() + ExecInitializer ratpackExecInitializer(RatpackHttpTracing ratpackHttpTracing) { + return ratpackHttpTracing.getOpenTelemetryExecInitializer() } - } +@CompileStatic class RatpackApp { static void main(String... args) { - def other = RatpackServer.start { server -> - server.handlers { chain -> - chain.get("other") { ctx -> ctx.render("hi-other") } - } - } - RatpackServer.start { server -> server .registry(Guice.registry { b -> b.module(OpenTelemetryModule) }) @@ -162,8 +156,7 @@ class RatpackApp { .all(OpenTelemetryServerHandler) .get("foo") { ctx -> ctx.render("hi-foo") } .get("bar") { ctx -> - def instrumentedHttpClient = ctx.get(HttpClient) - instrumentedHttpClient.get(new URI("http://${other.bindHost}:${other.bindPort}/other")) + ctx.get(HttpClient).get(ctx.get(URI)) .then { ctx.render("hi-bar") } } } From 19e1b1a769fb056609c1077e54d5fbff6342e772 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Tue, 11 Jan 2022 13:12:46 +0100 Subject: [PATCH 13/15] Fix lazy other app --- .../instrumentation/ratpack/RatpackFunctionalTest.groovy | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackFunctionalTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackFunctionalTest.groovy index 396ed15173e1..91c61c983632 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackFunctionalTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/RatpackFunctionalTest.groovy @@ -5,7 +5,6 @@ package io.opentelemetry.instrumentation.ratpack - import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter import io.opentelemetry.sdk.trace.export.SpanExporter import ratpack.guice.BindingsImposition @@ -20,7 +19,7 @@ class RatpackFunctionalTest extends MainClassApplicationUnderTest { Registry registry @Lazy InMemorySpanExporter spanExporter = registry.get(SpanExporter) as InMemorySpanExporter - @Lazy EmbeddedApp app = EmbeddedApp.of { server -> + EmbeddedApp app = EmbeddedApp.of { server -> server.handlers { chain -> chain.get("other") { ctx -> ctx.render("hi-other") } } From ff0b01362284f48f97305420e3ef688737edbaab Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Sat, 15 Jan 2022 22:17:09 +0100 Subject: [PATCH 14/15] Refactor ratpack client packages --- .../OpenTelemetryExecInitializer.java | 6 +- .../{client => }/OpenTelemetryHttpClient.java | 4 +- .../RatpackHttpClientAttributesExtractor.java | 2 +- .../ratpack/RatpackTracing.java | 21 ++++- .../ratpack/RatpackTracingBuilder.java | 29 ++++++- .../{client => }/RequestHeaderSetter.java | 2 +- .../ratpack/client/RatpackHttpTracing.java | 45 ----------- .../client/RatpackHttpTracingBuilder.java | 77 ------------------- .../{client => }/internal/ContextHolder.java | 2 +- .../RatpackHttpNetAttributesExtractor.java | 2 +- .../client/InstrumentedHttpClientTest.groovy | 12 +-- .../RatpackServerApplicationTest.groovy | 15 +--- .../AbstractRatpackHttpClientTest.java | 1 - .../ratpack/RatpackHttpClientTest.java | 5 +- 14 files changed, 67 insertions(+), 156 deletions(-) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/{client => }/OpenTelemetryExecInitializer.java (72%) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/{client => }/OpenTelemetryHttpClient.java (94%) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/{client => }/RatpackHttpClientAttributesExtractor.java (97%) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/{client => }/RequestHeaderSetter.java (89%) delete mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java delete mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/{client => }/internal/ContextHolder.java (89%) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/{client => }/internal/RatpackHttpNetAttributesExtractor.java (94%) diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryExecInitializer.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java similarity index 72% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryExecInitializer.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java index c570ff393400..5ae07f75b8ad 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryExecInitializer.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryExecInitializer.java @@ -3,13 +3,13 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.client; +package io.opentelemetry.instrumentation.ratpack; -import io.opentelemetry.instrumentation.ratpack.client.internal.ContextHolder; +import io.opentelemetry.instrumentation.ratpack.internal.ContextHolder; import ratpack.exec.ExecInitializer; import ratpack.exec.Execution; -public final class OpenTelemetryExecInitializer implements ExecInitializer { +final class OpenTelemetryExecInitializer implements ExecInitializer { public static final ExecInitializer INSTANCE = new OpenTelemetryExecInitializer(); @Override diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryHttpClient.java similarity index 94% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryHttpClient.java index 43916e865db9..a221d6160cdc 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/OpenTelemetryHttpClient.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/OpenTelemetryHttpClient.java @@ -3,12 +3,12 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.client; +package io.opentelemetry.instrumentation.ratpack; import io.opentelemetry.api.trace.Span; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; -import io.opentelemetry.instrumentation.ratpack.client.internal.ContextHolder; +import io.opentelemetry.instrumentation.ratpack.internal.ContextHolder; import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; import ratpack.exec.Execution; import ratpack.http.client.HttpClient; diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientAttributesExtractor.java similarity index 97% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientAttributesExtractor.java index 8155a5167e0f..9b34b3014846 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpClientAttributesExtractor.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientAttributesExtractor.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.client; +package io.opentelemetry.instrumentation.ratpack; import io.opentelemetry.instrumentation.api.instrumenter.http.CapturedHttpHeaders; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpClientAttributesExtractor; diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracing.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracing.java index 2b9de88c31b2..7f207bd65d59 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracing.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracing.java @@ -7,10 +7,14 @@ import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; +import ratpack.exec.ExecInitializer; import ratpack.exec.ExecInterceptor; import ratpack.handling.HandlerDecorator; import ratpack.http.Request; import ratpack.http.Response; +import ratpack.http.client.HttpClient; +import ratpack.http.client.HttpResponse; +import ratpack.http.client.RequestSpec; import ratpack.registry.RegistrySpec; /** @@ -42,9 +46,13 @@ public static RatpackTracingBuilder builder(OpenTelemetry openTelemetry) { } private final OpenTelemetryServerHandler serverHandler; + private final OpenTelemetryHttpClient httpClientInstrumenter; - RatpackTracing(Instrumenter serverInstrumenter) { + RatpackTracing( + Instrumenter serverInstrumenter, + Instrumenter clientInstrumenter) { serverHandler = new OpenTelemetryServerHandler(serverInstrumenter); + httpClientInstrumenter = new OpenTelemetryHttpClient(clientInstrumenter); } /** Returns instance of {@link OpenTelemetryServerHandler} to support Ratpack Registry binding. */ @@ -57,9 +65,20 @@ public ExecInterceptor getOpenTelemetryExecInterceptor() { return OpenTelemetryExecInterceptor.INSTANCE; } + /** Returns instance of {@link ExecInitializer} to support Ratpack Registry binding. */ + public ExecInitializer getOpenTelemetryExecInitializer() { + return OpenTelemetryExecInitializer.INSTANCE; + } + /** Configures the {@link RegistrySpec} with OpenTelemetry. */ public void configureServerRegistry(RegistrySpec registry) { registry.add(HandlerDecorator.prepend(serverHandler)); registry.add(OpenTelemetryExecInterceptor.INSTANCE); + registry.add(OpenTelemetryExecInitializer.INSTANCE); + } + + /** Returns instrumented instance of {@link HttpClient} with OpenTelemetry. */ + public HttpClient instrumentedHttpClient(HttpClient httpClient) throws Exception { + return httpClientInstrumenter.instrument(httpClient); } } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracingBuilder.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracingBuilder.java index c0a350a8c6da..74b7bacdf58a 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracingBuilder.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracingBuilder.java @@ -13,11 +13,14 @@ import io.opentelemetry.instrumentation.api.instrumenter.http.HttpServerMetrics; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; +import io.opentelemetry.instrumentation.ratpack.internal.RatpackHttpNetAttributesExtractor; import io.opentelemetry.instrumentation.ratpack.internal.RatpackNetAttributesExtractor; import java.util.ArrayList; import java.util.List; import ratpack.http.Request; import ratpack.http.Response; +import ratpack.http.client.HttpResponse; +import ratpack.http.client.RequestSpec; /** A builder for {@link RatpackTracing}. */ public final class RatpackTracingBuilder { @@ -30,6 +33,9 @@ public final class RatpackTracingBuilder { new ArrayList<>(); private CapturedHttpHeaders capturedHttpHeaders = CapturedHttpHeaders.server(Config.get()); + private final List> + additionalHttpClientExtractors = new ArrayList<>(); + RatpackTracingBuilder(OpenTelemetry openTelemetry) { this.openTelemetry = openTelemetry; } @@ -44,6 +50,12 @@ public RatpackTracingBuilder addAttributeExtractor( return this; } + public RatpackTracingBuilder addClientAttributeExtractor( + AttributesExtractor attributesExtractor) { + additionalHttpClientExtractors.add(attributesExtractor); + return this; + } + /** * Configure the instrumentation to capture chosen HTTP request and response headers as span * attributes. @@ -72,6 +84,21 @@ public RatpackTracing build() { .addRequestMetrics(HttpServerMetrics.get()) .newServerInstrumenter(RatpackGetter.INSTANCE); - return new RatpackTracing(instrumenter); + return new RatpackTracing(instrumenter, httpClientInstrumenter()); + } + + private Instrumenter httpClientInstrumenter() { + RatpackHttpNetAttributesExtractor netAttributes = new RatpackHttpNetAttributesExtractor(); + RatpackHttpClientAttributesExtractor httpAttributes = + new RatpackHttpClientAttributesExtractor(capturedHttpHeaders); + + return Instrumenter.builder( + openTelemetry, INSTRUMENTATION_NAME, HttpSpanNameExtractor.create(httpAttributes)) + .setSpanStatusExtractor(HttpSpanStatusExtractor.create(httpAttributes)) + .addAttributesExtractor(netAttributes) + .addAttributesExtractor(httpAttributes) + .addAttributesExtractors(additionalHttpClientExtractors) + .addRequestMetrics(HttpServerMetrics.get()) + .newClientInstrumenter(RequestHeaderSetter.INSTANCE); } } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RequestHeaderSetter.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RequestHeaderSetter.java similarity index 89% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RequestHeaderSetter.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RequestHeaderSetter.java index e36e89aedaff..9ff9c2a23f8b 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RequestHeaderSetter.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RequestHeaderSetter.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.client; +package io.opentelemetry.instrumentation.ratpack; import io.opentelemetry.context.propagation.TextMapSetter; import ratpack.api.Nullable; diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java deleted file mode 100644 index 91c0de1b6889..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracing.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack.client; - -import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; -import ratpack.exec.ExecInitializer; -import ratpack.http.client.HttpClient; -import ratpack.http.client.HttpResponse; -import ratpack.http.client.RequestSpec; - -/** Entrypoint for tracing OkHttp clients. */ -public final class RatpackHttpTracing { - - /** Returns a new {@link RatpackHttpTracing} configured with the given {@link OpenTelemetry}. */ - public static RatpackHttpTracing create(OpenTelemetry openTelemetry) { - return builder(openTelemetry).build(); - } - - /** - * Returns a new {@link RatpackHttpTracingBuilder} configured with the given {@link - * OpenTelemetry}. - */ - public static RatpackHttpTracingBuilder builder(OpenTelemetry openTelemetry) { - return new RatpackHttpTracingBuilder(openTelemetry); - } - - private final Instrumenter instrumenter; - - RatpackHttpTracing(Instrumenter instrumenter) { - this.instrumenter = instrumenter; - } - - public HttpClient instrumentedHttpClient(HttpClient httpClient) throws Exception { - return new OpenTelemetryHttpClient(instrumenter).instrument(httpClient); - } - - /** Returns instance of {@link ExecInitializer} to support Ratpack Registry binding. */ - public ExecInitializer getOpenTelemetryExecInitializer() { - return OpenTelemetryExecInitializer.INSTANCE; - } -} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java deleted file mode 100644 index a8a2b269e11f..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/RatpackHttpTracingBuilder.java +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack.client; - -import io.opentelemetry.api.OpenTelemetry; -import io.opentelemetry.instrumentation.api.config.Config; -import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; -import io.opentelemetry.instrumentation.api.instrumenter.http.CapturedHttpHeaders; -import io.opentelemetry.instrumentation.api.instrumenter.http.HttpServerMetrics; -import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanNameExtractor; -import io.opentelemetry.instrumentation.api.instrumenter.http.HttpSpanStatusExtractor; -import io.opentelemetry.instrumentation.ratpack.client.internal.RatpackHttpNetAttributesExtractor; -import java.util.ArrayList; -import java.util.List; -import ratpack.http.client.HttpResponse; -import ratpack.http.client.RequestSpec; - -/** A builder for {@link RatpackHttpTracing}. */ -public final class RatpackHttpTracingBuilder { - - private static final String INSTRUMENTATION_NAME = "io.opentelemetry.ratpack-1.4"; - - private final OpenTelemetry openTelemetry; - - private final List> - additionalExtractors = new ArrayList<>(); - private CapturedHttpHeaders capturedHttpHeaders = CapturedHttpHeaders.client(Config.get()); - - RatpackHttpTracingBuilder(OpenTelemetry openTelemetry) { - this.openTelemetry = openTelemetry; - } - - /** - * Adds an additional {@link AttributesExtractor} to invoke to set attributes to instrumented - * items. The {@link AttributesExtractor} will be executed after all default extractors. - */ - public RatpackHttpTracingBuilder addAttributeExtractor( - AttributesExtractor attributesExtractor) { - additionalExtractors.add(attributesExtractor); - return this; - } - - /** - * Configure the instrumentation to capture chosen HTTP request and response headers as span - * attributes. - * - * @param capturedHttpHeaders An instance of {@link CapturedHttpHeaders} containing the configured - * HTTP request and response names. - */ - public RatpackHttpTracingBuilder captureHttpHeaders(CapturedHttpHeaders capturedHttpHeaders) { - this.capturedHttpHeaders = capturedHttpHeaders; - return this; - } - - /** Returns a new {@link RatpackHttpTracing} with the configuration of this builder. */ - public RatpackHttpTracing build() { - RatpackHttpNetAttributesExtractor netAttributes = new RatpackHttpNetAttributesExtractor(); - RatpackHttpClientAttributesExtractor httpAttributes = - new RatpackHttpClientAttributesExtractor(capturedHttpHeaders); - - Instrumenter instrumenter = - Instrumenter.builder( - openTelemetry, INSTRUMENTATION_NAME, HttpSpanNameExtractor.create(httpAttributes)) - .setSpanStatusExtractor(HttpSpanStatusExtractor.create(httpAttributes)) - .addAttributesExtractor(netAttributes) - .addAttributesExtractor(httpAttributes) - .addAttributesExtractors(additionalExtractors) - .addRequestMetrics(HttpServerMetrics.get()) - .newClientInstrumenter(RequestHeaderSetter.INSTANCE); - - return new RatpackHttpTracing(instrumenter); - } -} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/ContextHolder.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/internal/ContextHolder.java similarity index 89% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/ContextHolder.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/internal/ContextHolder.java index 6ffbcdf847a5..c1839e091ac5 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/ContextHolder.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/internal/ContextHolder.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.client.internal; +package io.opentelemetry.instrumentation.ratpack.internal; import io.opentelemetry.context.Context; import ratpack.http.client.RequestSpec; diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/internal/RatpackHttpNetAttributesExtractor.java similarity index 94% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/internal/RatpackHttpNetAttributesExtractor.java index 6452cb9d7da3..b2da2ff9a5b9 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/client/internal/RatpackHttpNetAttributesExtractor.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/internal/RatpackHttpNetAttributesExtractor.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.client.internal; +package io.opentelemetry.instrumentation.ratpack.internal; import io.opentelemetry.instrumentation.api.instrumenter.net.NetClientAttributesExtractor; import io.opentelemetry.semconv.trace.attributes.SemanticAttributes; diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy index 0a63bae14664..2d20e614b61d 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy @@ -42,8 +42,7 @@ class InstrumentedHttpClientTest extends Specification { .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) .setTracerProvider(tracerProvider).build() - def ratpackTracing = RatpackTracing.create(openTelemetry) - def ratpackHttpTracing = RatpackHttpTracing.create(openTelemetry) + RatpackTracing ratpackTracing = RatpackTracing.create(openTelemetry) def cleanup() { spanExporter.reset() @@ -66,8 +65,7 @@ class InstrumentedHttpClientTest extends Specification { spec.registry( Guice.registry { bindings -> ratpackTracing.configureServerRegistry(bindings) - bindings.bindInstance(ratpackHttpTracing.getOpenTelemetryExecInitializer()) - bindings.bindInstance(HttpClient, ratpackHttpTracing.instrumentedHttpClient(HttpClient.of(Action.noop()))) + bindings.bindInstance(HttpClient, ratpackTracing.instrumentedHttpClient(HttpClient.of(Action.noop()))) } ) @@ -128,8 +126,7 @@ class InstrumentedHttpClientTest extends Specification { spec.registry( Guice.registry { bindings -> ratpackTracing.configureServerRegistry(bindings) - bindings.bindInstance(ratpackHttpTracing.getOpenTelemetryExecInitializer()) - bindings.bindInstance(HttpClient, ratpackHttpTracing.instrumentedHttpClient(HttpClient.of(Action.noop()))) + bindings.bindInstance(HttpClient, ratpackTracing.instrumentedHttpClient(HttpClient.of(Action.noop()))) } ) @@ -194,8 +191,7 @@ class InstrumentedHttpClientTest extends Specification { spec.registry( Guice.registry { bindings -> ratpackTracing.configureServerRegistry(bindings) - bindings.bindInstance(ratpackHttpTracing.getOpenTelemetryExecInitializer()) - bindings.bindInstance(HttpClient, ratpackHttpTracing.instrumentedHttpClient( + bindings.bindInstance(HttpClient, ratpackTracing.instrumentedHttpClient( HttpClient.of { s -> s.readTimeout(Duration.ofMillis(10)) }) ) } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy index 80e1696c3502..944a7207fefe 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy @@ -13,7 +13,6 @@ import io.opentelemetry.api.trace.SpanKind import io.opentelemetry.instrumentation.ratpack.OpenTelemetryServerHandler import io.opentelemetry.instrumentation.ratpack.RatpackFunctionalTest import io.opentelemetry.instrumentation.ratpack.RatpackTracing -import io.opentelemetry.instrumentation.ratpack.client.RatpackHttpTracing import io.opentelemetry.sdk.OpenTelemetrySdk import io.opentelemetry.sdk.testing.exporter.InMemorySpanExporter import io.opentelemetry.sdk.trace.SdkTracerProvider @@ -126,20 +125,14 @@ class OpenTelemetryModule extends AbstractModule { @Singleton @Provides - RatpackHttpTracing ratpackHttpTracing(OpenTelemetry openTelemetry) { - return RatpackHttpTracing.create(openTelemetry) + HttpClient instrumentedHttpClient(RatpackTracing ratpackTracing) { + return ratpackTracing.instrumentedHttpClient(HttpClient.of {}) } @Singleton @Provides - HttpClient instrumentedHttpClient(RatpackHttpTracing ratpackHttpTracing) { - return ratpackHttpTracing.instrumentedHttpClient(HttpClient.of {}) - } - - @Singleton - @Provides - ExecInitializer ratpackExecInitializer(RatpackHttpTracing ratpackHttpTracing) { - return ratpackHttpTracing.getOpenTelemetryExecInitializer() + ExecInitializer ratpackExecInitializer(RatpackTracing ratpackTracing) { + return ratpackTracing.getOpenTelemetryExecInitializer() } } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java index c1ebdb301d19..4353940edae1 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/AbstractRatpackHttpClientTest.java @@ -8,7 +8,6 @@ import com.google.common.collect.ImmutableList; import io.netty.channel.ConnectTimeoutException; import io.opentelemetry.context.Context; -import io.opentelemetry.instrumentation.ratpack.client.OpenTelemetryExecInitializer; import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; import java.net.URI; diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java index 7e6cff954ce1..3c90ac050989 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java @@ -5,7 +5,6 @@ package io.opentelemetry.instrumentation.ratpack; -import io.opentelemetry.instrumentation.ratpack.client.RatpackHttpTracing; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; import org.junit.jupiter.api.extension.RegisterExtension; @@ -20,13 +19,13 @@ class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { @Override protected HttpClient buildHttpClient() throws Exception { - return RatpackHttpTracing.create(testing.getOpenTelemetry()) + return RatpackTracing.create(testing.getOpenTelemetry()) .instrumentedHttpClient(HttpClient.of(Action.noop())); } @Override protected HttpClient buildHttpClient(Action action) throws Exception { - return RatpackHttpTracing.create(testing.getOpenTelemetry()) + return RatpackTracing.create(testing.getOpenTelemetry()) .instrumentedHttpClient(HttpClient.of(action)); } } From ccaad32d63dbbc3d81dace3ffaf2221f3d1b5c84 Mon Sep 17 00:00:00 2001 From: Javier Salinas Date: Tue, 18 Jan 2022 14:15:58 +0100 Subject: [PATCH 15/15] Rename getter method --- .../instrumentation/ratpack/RatpackTracing.java | 2 +- .../ratpack/client/InstrumentedHttpClientTest.groovy | 6 +++--- .../ratpack/server/RatpackServerApplicationTest.groovy | 2 +- .../instrumentation/ratpack/RatpackHttpClientTest.java | 4 ++-- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracing.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracing.java index 7f207bd65d59..9f7f3f1ce2b9 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracing.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/RatpackTracing.java @@ -78,7 +78,7 @@ public void configureServerRegistry(RegistrySpec registry) { } /** Returns instrumented instance of {@link HttpClient} with OpenTelemetry. */ - public HttpClient instrumentedHttpClient(HttpClient httpClient) throws Exception { + public HttpClient instrumentHttpClient(HttpClient httpClient) throws Exception { return httpClientInstrumenter.instrument(httpClient); } } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy index 2d20e614b61d..1cda8adaf70d 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/client/InstrumentedHttpClientTest.groovy @@ -65,7 +65,7 @@ class InstrumentedHttpClientTest extends Specification { spec.registry( Guice.registry { bindings -> ratpackTracing.configureServerRegistry(bindings) - bindings.bindInstance(HttpClient, ratpackTracing.instrumentedHttpClient(HttpClient.of(Action.noop()))) + bindings.bindInstance(HttpClient, ratpackTracing.instrumentHttpClient(HttpClient.of(Action.noop()))) } ) @@ -126,7 +126,7 @@ class InstrumentedHttpClientTest extends Specification { spec.registry( Guice.registry { bindings -> ratpackTracing.configureServerRegistry(bindings) - bindings.bindInstance(HttpClient, ratpackTracing.instrumentedHttpClient(HttpClient.of(Action.noop()))) + bindings.bindInstance(HttpClient, ratpackTracing.instrumentHttpClient(HttpClient.of(Action.noop()))) } ) @@ -191,7 +191,7 @@ class InstrumentedHttpClientTest extends Specification { spec.registry( Guice.registry { bindings -> ratpackTracing.configureServerRegistry(bindings) - bindings.bindInstance(HttpClient, ratpackTracing.instrumentedHttpClient( + bindings.bindInstance(HttpClient, ratpackTracing.instrumentHttpClient( HttpClient.of { s -> s.readTimeout(Duration.ofMillis(10)) }) ) } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy index 944a7207fefe..95222d77155a 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/server/RatpackServerApplicationTest.groovy @@ -126,7 +126,7 @@ class OpenTelemetryModule extends AbstractModule { @Singleton @Provides HttpClient instrumentedHttpClient(RatpackTracing ratpackTracing) { - return ratpackTracing.instrumentedHttpClient(HttpClient.of {}) + return ratpackTracing.instrumentHttpClient(HttpClient.of {}) } @Singleton diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java index 3c90ac050989..a0ea3d12cade 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/RatpackHttpClientTest.java @@ -20,12 +20,12 @@ class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { @Override protected HttpClient buildHttpClient() throws Exception { return RatpackTracing.create(testing.getOpenTelemetry()) - .instrumentedHttpClient(HttpClient.of(Action.noop())); + .instrumentHttpClient(HttpClient.of(Action.noop())); } @Override protected HttpClient buildHttpClient(Action action) throws Exception { return RatpackTracing.create(testing.getOpenTelemetry()) - .instrumentedHttpClient(HttpClient.of(action)); + .instrumentHttpClient(HttpClient.of(action)); } }