From 150d23a41543a5cdc9cafbad651b9ddff9a71c8a Mon Sep 17 00:00:00 2001 From: John Engelman Date: Tue, 5 Nov 2024 08:09:27 -0600 Subject: [PATCH 01/10] Add agent instrumentation for Ratpack 1.7 --- .../client/AbstractRatpackHttpClientTest.java | 28 ++++--- .../ratpack-1.7/javaagent/build.gradle.kts | 53 ++++++++++++ .../ratpack/v1_7/DownstreamWrapper.java | 55 ++++++++++++ .../v1_7/HttpClientInstrumentation.java | 46 ++++++++++ .../v1_7/RatpackInstrumentationModule.java | 44 ++++++++++ .../ratpack/v1_7/RatpackSingletons.java | 54 ++++++++++++ .../RequestActionSupportInstrumentation.java | 84 +++++++++++++++++++ .../v1_7/ServerRegistryInstrumentation.java | 42 ++++++++++ .../server/RatpackAsyncHttpServerTest.groovy | 22 +++++ .../server/RatpackForkedHttpServerTest.groovy | 27 ++++++ .../server/RatpackHttpServerTest.groovy | 22 +++++ .../groovy/server/RatpackRoutesTest.groovy | 21 +++++ .../v1_7/RatpackForkedHttpClientTest.java | 68 +++++++++++++++ .../ratpack/v1_7/RatpackHttpClientTest.java | 68 +++++++++++++++ .../v1_7/RatpackPooledHttpClientTest.java | 68 +++++++++++++++ .../v1_7/OpenTelemetryExecInitializer.java | 2 +- .../v1_7/OpenTelemetryExecInterceptor.java | 4 +- .../ratpack/v1_7/OpenTelemetryHttpClient.java | 26 ++++-- .../ratpack/v1_7/RatpackTelemetryBuilder.java | 8 ++ .../v1_7/AbstractRatpackHttpClientTest.java | 6 +- settings.gradle.kts | 1 + 21 files changed, 724 insertions(+), 25 deletions(-) create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DownstreamWrapper.java create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackAsyncHttpServerTest.groovy create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackForkedHttpServerTest.groovy create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackHttpServerTest.groovy create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackRoutesTest.groovy create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java diff --git a/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/client/AbstractRatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/client/AbstractRatpackHttpClientTest.java index bb6a43e8aa84..f5626cefd2ec 100644 --- a/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/client/AbstractRatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/client/AbstractRatpackHttpClientTest.java @@ -29,13 +29,13 @@ public abstract class AbstractRatpackHttpClientTest extends AbstractHttpClientTest { - private final ExecHarness exec = ExecHarness.harness(); + protected final ExecHarness exec = ExecHarness.harness(); - private HttpClient client; - private HttpClient singleConnectionClient; + protected HttpClient client; + protected HttpClient singleConnectionClient; @BeforeAll - void setUpClient() throws Exception { + protected void setUpClient() throws Exception { exec.run( unused -> { client = buildHttpClient(); @@ -66,7 +66,7 @@ public Void buildRequest(String method, URI uri, Map headers) { @Override public int sendRequest(Void request, String method, URI uri, Map headers) throws Exception { - return exec.yield(unused -> internalSendRequest(client, method, uri, headers)) + return exec.yield(execution -> internalSendRequest(client, method, uri, headers)) .getValueOrThrow(); } @@ -78,13 +78,17 @@ public final void sendRequestWithCallback( Map headers, HttpClientResult httpClientResult) throws Exception { - exec.execute( - Operation.of( - () -> - internalSendRequest(client, method, uri, headers) - .result( - result -> - httpClientResult.complete(result::getValue, result.getThrowable())))); + exec.yield( + (e) -> + Operation.of( + () -> + internalSendRequest(client, method, uri, headers) + .result( + result -> + httpClientResult.complete( + result::getValue, result.getThrowable()))) + .promise()) + .getValueOrThrow(); } // overridden in RatpackForkedHttpClientTest diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts b/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts new file mode 100644 index 000000000000..dbc58cadd42d --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts @@ -0,0 +1,53 @@ +plugins { + id("otel.javaagent-instrumentation") +} + +muzzle { + pass { + group.set("io.ratpack") + module.set("ratpack-core") + versions.set("[1.7.0,)") + } +} + +dependencies { + library("io.ratpack:ratpack-core:1.7.0") + + implementation(project(":instrumentation:netty:netty-4.1:library")) + implementation(project(":instrumentation:ratpack:ratpack-1.4:javaagent")) + implementation(project(":instrumentation:ratpack:ratpack-1.7:library")) + + testImplementation(project(":instrumentation:ratpack:ratpack-1.4:testing")) + + testLibrary("io.ratpack:ratpack-test:1.7.0") + + if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_11)) { + testImplementation("com.sun.activation:jakarta.activation:1.2.2") + } +} + +// to allow all tests to pass we need to choose a specific netty version +if (!(findProperty("testLatestDeps") as Boolean)) { + configurations.configureEach { + if (!name.contains("muzzle")) { + resolutionStrategy { + eachDependency { + // specifying a fixed version for all libraries with io.netty group + if (requested.group == "io.netty" && requested.name != "netty-tcnative") { + useVersion("4.1.37.Final") + } + } + } + } + } +} + +tasks { + withType().configureEach { + systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean) + } +} + +tasks.withType().configureEach { + jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true") +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DownstreamWrapper.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DownstreamWrapper.java new file mode 100644 index 000000000000..5bf5d2454fec --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DownstreamWrapper.java @@ -0,0 +1,55 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; + +import io.opentelemetry.context.Context; +import io.opentelemetry.context.Scope; +import ratpack.exec.Downstream; + +public class DownstreamWrapper implements Downstream { + + private final Downstream delegate; + private final Context parentContext; + + private DownstreamWrapper(Downstream delegate, Context parentContext) { + assert parentContext != null; + this.delegate = delegate; + this.parentContext = parentContext; + } + + @Override + public void success(T value) { + try (Scope ignored = parentContext.makeCurrent()) { + delegate.success(value); + } + } + + @Override + public void error(Throwable throwable) { + try (Scope ignored = parentContext.makeCurrent()) { + delegate.error(throwable); + } + } + + @Override + public void complete() { + try (Scope ignored = parentContext.makeCurrent()) { + delegate.complete(); + } + } + + public static Downstream wrapIfNeeded(Downstream delegate) { + if (delegate instanceof DownstreamWrapper) { + return delegate; + } + Context context = Context.current(); + if (context == Context.root()) { + // Skip wrapping, there is no need to propagate root context. + return delegate; + } + return new DownstreamWrapper<>(delegate, context); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java new file mode 100644 index 000000000000..d14e25458201 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java @@ -0,0 +1,46 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; + +import static net.bytebuddy.matcher.ElementMatchers.isMethod; +import static net.bytebuddy.matcher.ElementMatchers.isStatic; +import static net.bytebuddy.matcher.ElementMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; + +import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; +import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer; +import net.bytebuddy.asm.Advice; +import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.matcher.ElementMatcher; +import ratpack.http.client.HttpClient; + +public class HttpClientInstrumentation implements TypeInstrumentation { + + @Override + public ElementMatcher typeMatcher() { + return named("ratpack.http.client.HttpClient"); + } + + @Override + public void transform(TypeTransformer transformer) { + transformer.applyAdviceToMethod( + isMethod() + .and(isStatic()) + .and(named("of")) + .and(takesArgument(0, named("ratpack.func.Action"))), + HttpClientInstrumentation.class.getName() + "$OfAdvice"); + } + + @SuppressWarnings("unused") + public static class OfAdvice { + + @Advice.OnMethodExit(suppress = Throwable.class) + public static void injectTracing(@Advice.Return(readOnly = false) HttpClient httpClient) + throws Exception { + httpClient = RatpackSingletons.telemetry().instrumentHttpClient(httpClient); + } + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java new file mode 100644 index 000000000000..59232676bc1f --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java @@ -0,0 +1,44 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; + +import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.hasClassesNamed; +import static java.util.Arrays.asList; + +import com.google.auto.service.AutoService; +import io.opentelemetry.javaagent.extension.instrumentation.InstrumentationModule; +import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; +import io.opentelemetry.javaagent.extension.instrumentation.internal.ExperimentalInstrumentationModule; +import java.util.List; +import net.bytebuddy.matcher.ElementMatcher; + +@AutoService(InstrumentationModule.class) +public class RatpackInstrumentationModule extends InstrumentationModule + implements ExperimentalInstrumentationModule { + public RatpackInstrumentationModule() { + super("ratpack", "ratpack-1.7"); + } + + @Override + public String getModuleGroup() { + // relies on netty + return "netty"; + } + + @Override + public ElementMatcher.Junction classLoaderMatcher() { + // Only activate when running ratpack 1.7 or later + return hasClassesNamed("ratpack.exec.util.retry.Delay"); + } + + @Override + public List typeInstrumentations() { + return asList( + new ServerRegistryInstrumentation(), + new HttpClientInstrumentation(), + new RequestActionSupportInstrumentation()); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java new file mode 100644 index 000000000000..a0304c64a0b8 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java @@ -0,0 +1,54 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; + +import io.netty.channel.Channel; +import io.opentelemetry.api.GlobalOpenTelemetry; +import io.opentelemetry.context.Context; +import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; +import io.opentelemetry.instrumentation.netty.v4_1.internal.AttributeKeys; +import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackTelemetry; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.ContextHolder; +import io.opentelemetry.javaagent.bootstrap.internal.AgentCommonConfig; +import io.opentelemetry.javaagent.bootstrap.internal.ExperimentalConfig; +import ratpack.exec.Execution; + +public final class RatpackSingletons { + + static { + TELEMETRY = + RatpackTelemetry.builder(GlobalOpenTelemetry.get()) + .configure(AgentCommonConfig.get()) + .build(); + } + + private static final Instrumenter INSTRUMENTER = + Instrumenter.builder( + GlobalOpenTelemetry.get(), "io.opentelemetry.ratpack-1.7", s -> s) + .setEnabled(ExperimentalConfig.get().controllerTelemetryEnabled()) + .buildInstrumenter(); + + public static Instrumenter instrumenter() { + return INSTRUMENTER; + } + + private static final RatpackTelemetry TELEMETRY; + + public static RatpackTelemetry telemetry() { + return TELEMETRY; + } + + public static void propagateContextToChannel(Execution execution, Channel channel) { + Context parentContext = + execution + .maybeGet(ContextHolder.class) + .map(ContextHolder::context) + .orElse(Context.current()); + channel.attr(AttributeKeys.CLIENT_PARENT_CONTEXT).set(parentContext); + } + + private RatpackSingletons() {} +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java new file mode 100644 index 000000000000..a156ddb638ba --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java @@ -0,0 +1,84 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; + +import static io.opentelemetry.javaagent.extension.matcher.AgentElementMatchers.extendsClass; +import static net.bytebuddy.matcher.ElementMatchers.isMethod; +import static net.bytebuddy.matcher.ElementMatchers.isPrivate; +import static net.bytebuddy.matcher.ElementMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; + +import io.netty.channel.Channel; +import io.opentelemetry.context.Context; +import io.opentelemetry.context.Scope; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.ContextHolder; +import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; +import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer; +import net.bytebuddy.asm.Advice; +import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.matcher.ElementMatcher; +import ratpack.exec.Downstream; +import ratpack.exec.Execution; + +public class RequestActionSupportInstrumentation implements TypeInstrumentation { + + @Override + public ElementMatcher typeMatcher() { + return extendsClass(named("ratpack.http.client.internal.RequestActionSupport")); + } + + @Override + public void transform(TypeTransformer transformer) { + transformer.applyAdviceToMethod( + isMethod() + .and(isPrivate()) + .and(named("send")) + .and(takesArgument(0, named("ratpack.exec.Downstream"))) + .and(takesArgument(1, named("io.netty.channel.Channel"))), + RequestActionSupportInstrumentation.class.getName() + "$SendAdvice"); + transformer.applyAdviceToMethod( + isMethod().and(named("connect")).and(takesArgument(0, named("ratpack.exec.Downstream"))), + RequestActionSupportInstrumentation.class.getName() + "$ConnectAdvice"); + } + + @SuppressWarnings("unused") + public static class SendAdvice { + + @Advice.OnMethodEnter(suppress = Throwable.class) + public static void injectChannelAttribute( + @Advice.FieldValue("execution") Execution execution, + @Advice.Argument(value = 0, readOnly = false) Downstream downstream, + @Advice.Argument(value = 1, readOnly = false) Channel channel) { + RatpackSingletons.propagateContextToChannel(execution, channel); + } + } + + public static class ConnectAdvice { + + @Advice.OnMethodEnter(suppress = Throwable.class) + public static Scope injectChannelAttribute( + @Advice.FieldValue("execution") Execution execution, + @Advice.Argument(value = 0, readOnly = false) Downstream downstream) { + // Propagate the current context to downstream + // since that the is the subsequent + downstream = DownstreamWrapper.wrapIfNeeded(downstream); + + // Capture the CLIENT span and make it current before cally Netty layer + return execution + .maybeGet(ContextHolder.class) + .map(ContextHolder::context) + .map(Context::makeCurrent) + .orElse(null); + } + + @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) + public static void exit(@Advice.Enter Scope scope) { + if (scope != null) { + scope.close(); + } + } + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java new file mode 100644 index 000000000000..657a2e04cd07 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java @@ -0,0 +1,42 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; + +import static net.bytebuddy.matcher.ElementMatchers.isMethod; +import static net.bytebuddy.matcher.ElementMatchers.isStatic; +import static net.bytebuddy.matcher.ElementMatchers.named; + +import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; +import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer; +import net.bytebuddy.asm.Advice; +import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.matcher.ElementMatcher; +import ratpack.registry.Registry; + +public class ServerRegistryInstrumentation implements TypeInstrumentation { + + @Override + public ElementMatcher typeMatcher() { + return named("ratpack.server.internal.ServerRegistry"); + } + + @Override + public void transform(TypeTransformer transformer) { + transformer.applyAdviceToMethod( + isMethod().and(isStatic()).and(named("buildBaseRegistry")), + ServerRegistryInstrumentation.class.getName() + "$BuildAdvice"); + } + + @SuppressWarnings("unused") + public static class BuildAdvice { + + @Advice.OnMethodExit(suppress = Throwable.class) + public static void injectTracing(@Advice.Return(readOnly = false) Registry registry) + throws Exception { + registry = registry.join(Registry.of(RatpackSingletons.telemetry()::configureServerRegistry)); + } + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackAsyncHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackAsyncHttpServerTest.groovy new file mode 100644 index 000000000000..dc1cc42df27f --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackAsyncHttpServerTest.groovy @@ -0,0 +1,22 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package server + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackAsyncHttpServerTest +import io.opentelemetry.instrumentation.test.AgentTestTrait +import io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint +import ratpack.server.RatpackServerSpec + +class RatpackAsyncHttpServerTest extends AbstractRatpackAsyncHttpServerTest implements AgentTestTrait { + @Override + void configure(RatpackServerSpec serverSpec) { + } + + @Override + boolean hasResponseCustomizer(ServerEndpoint endpoint) { + true + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackForkedHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackForkedHttpServerTest.groovy new file mode 100644 index 000000000000..87dc2848b1ff --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackForkedHttpServerTest.groovy @@ -0,0 +1,27 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package server + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackForkedHttpServerTest +import io.opentelemetry.instrumentation.test.AgentTestTrait +import io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint +import ratpack.server.RatpackServerSpec + +class RatpackForkedHttpServerTest extends AbstractRatpackForkedHttpServerTest implements AgentTestTrait { + @Override + void configure(RatpackServerSpec serverSpec) { + } + + @Override + boolean hasResponseCustomizer(ServerEndpoint endpoint) { + true + } + + @Override + boolean testHttpPipelining() { + false + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackHttpServerTest.groovy new file mode 100644 index 000000000000..3fd085dde585 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackHttpServerTest.groovy @@ -0,0 +1,22 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package server + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackHttpServerTest +import io.opentelemetry.instrumentation.test.AgentTestTrait +import io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint +import ratpack.server.RatpackServerSpec + +class RatpackHttpServerTest extends AbstractRatpackHttpServerTest implements AgentTestTrait { + @Override + void configure(RatpackServerSpec serverSpec) { + } + + @Override + boolean hasResponseCustomizer(ServerEndpoint endpoint) { + true + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackRoutesTest.groovy b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackRoutesTest.groovy new file mode 100644 index 000000000000..e52bd4f93c1e --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackRoutesTest.groovy @@ -0,0 +1,21 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package server + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackRoutesTest +import io.opentelemetry.instrumentation.test.AgentTestTrait +import ratpack.server.RatpackServerSpec + +class RatpackRoutesTest extends AbstractRatpackRoutesTest implements AgentTestTrait { + @Override + void configure(RatpackServerSpec serverSpec) { + } + + @Override + boolean hasHandlerSpan() { + return true + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java new file mode 100644 index 000000000000..b9348fd8dcbc --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java @@ -0,0 +1,68 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; + +import com.google.common.collect.ImmutableList; +import io.netty.channel.ConnectTimeoutException; +import io.opentelemetry.api.common.AttributeKey; +import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackForkedHttpClientTest; +import io.opentelemetry.instrumentation.ratpack.v1_7.OpenTelemetryExecInitializer; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; +import io.opentelemetry.semconv.NetworkAttributes; +import java.net.URI; +import java.util.HashSet; +import java.util.Set; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.condition.OS; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.exec.internal.DefaultExecController; +import ratpack.http.client.HttpClientReadTimeoutException; + +class RatpackForkedHttpClientTest extends AbstractRatpackForkedHttpClientTest { + + @RegisterExtension + static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); + + @BeforeAll + @Override + protected void setUpClient() throws Exception { + exec.run( + unused -> { + ((DefaultExecController) exec.getController()) + .setInitializers(ImmutableList.of(OpenTelemetryExecInitializer.INSTANCE)); + client = buildHttpClient(); + singleConnectionClient = buildHttpClient(spec -> spec.poolSize(1)); + }); + } + + @Override + protected Set> computeHttpAttributes(URI uri) { + Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); + attributes.remove(NetworkAttributes.NETWORK_PROTOCOL_VERSION); + return attributes; + } + + @Override + protected void configure(HttpClientTestOptions.Builder optionsBuilder) { + super.configure(optionsBuilder); + optionsBuilder.setExpectedClientSpanNameMapper( + HttpClientTestOptions.DEFAULT_EXPECTED_CLIENT_SPAN_NAME_MAPPER); + optionsBuilder.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; + }); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java new file mode 100644 index 000000000000..02f76cbc04e4 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java @@ -0,0 +1,68 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; + +import com.google.common.collect.ImmutableList; +import io.netty.channel.ConnectTimeoutException; +import io.opentelemetry.api.common.AttributeKey; +import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackHttpClientTest; +import io.opentelemetry.instrumentation.ratpack.v1_7.OpenTelemetryExecInitializer; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; +import io.opentelemetry.semconv.NetworkAttributes; +import java.net.URI; +import java.util.HashSet; +import java.util.Set; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.condition.OS; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.exec.internal.DefaultExecController; +import ratpack.http.client.HttpClientReadTimeoutException; + +class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { + + @RegisterExtension + static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); + + @BeforeAll + @Override + protected void setUpClient() throws Exception { + exec.run( + unused -> { + ((DefaultExecController) exec.getController()) + .setInitializers(ImmutableList.of(OpenTelemetryExecInitializer.INSTANCE)); + client = buildHttpClient(); + singleConnectionClient = buildHttpClient(spec -> spec.poolSize(1)); + }); + } + + @Override + protected Set> computeHttpAttributes(URI uri) { + Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); + attributes.remove(NetworkAttributes.NETWORK_PROTOCOL_VERSION); + return attributes; + } + + @Override + protected void configure(HttpClientTestOptions.Builder optionsBuilder) { + super.configure(optionsBuilder); + optionsBuilder.setExpectedClientSpanNameMapper( + HttpClientTestOptions.DEFAULT_EXPECTED_CLIENT_SPAN_NAME_MAPPER); + optionsBuilder.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; + }); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java new file mode 100644 index 000000000000..80506e4d2fda --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java @@ -0,0 +1,68 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; + +import com.google.common.collect.ImmutableList; +import io.netty.channel.ConnectTimeoutException; +import io.opentelemetry.api.common.AttributeKey; +import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackPooledHttpClientTest; +import io.opentelemetry.instrumentation.ratpack.v1_7.OpenTelemetryExecInitializer; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; +import io.opentelemetry.semconv.NetworkAttributes; +import java.net.URI; +import java.util.HashSet; +import java.util.Set; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.condition.OS; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.exec.internal.DefaultExecController; +import ratpack.http.client.HttpClientReadTimeoutException; + +class RatpackPooledHttpClientTest extends AbstractRatpackPooledHttpClientTest { + + @RegisterExtension + static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); + + @BeforeAll + @Override + protected void setUpClient() throws Exception { + exec.run( + unused -> { + ((DefaultExecController) exec.getController()) + .setInitializers(ImmutableList.of(OpenTelemetryExecInitializer.INSTANCE)); + client = buildHttpClient(); + singleConnectionClient = buildHttpClient(spec -> spec.poolSize(1)); + }); + } + + @Override + protected Set> computeHttpAttributes(URI uri) { + Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); + attributes.remove(NetworkAttributes.NETWORK_PROTOCOL_VERSION); + return attributes; + } + + @Override + protected void configure(HttpClientTestOptions.Builder optionsBuilder) { + super.configure(optionsBuilder); + optionsBuilder.setExpectedClientSpanNameMapper( + HttpClientTestOptions.DEFAULT_EXPECTED_CLIENT_SPAN_NAME_MAPPER); + optionsBuilder.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; + }); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInitializer.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInitializer.java index 5788db8c5655..bbedaee9caca 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInitializer.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInitializer.java @@ -9,7 +9,7 @@ import ratpack.exec.ExecInitializer; import ratpack.exec.Execution; -final class OpenTelemetryExecInitializer implements ExecInitializer { +public 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/v1_7/OpenTelemetryExecInterceptor.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInterceptor.java index f78c0671fe74..07c7a68abc5f 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInterceptor.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInterceptor.java @@ -11,9 +11,9 @@ import ratpack.exec.Execution; import ratpack.func.Block; -final class OpenTelemetryExecInterceptor implements ExecInterceptor { +public final class OpenTelemetryExecInterceptor implements ExecInterceptor { - static final ExecInterceptor INSTANCE = new OpenTelemetryExecInterceptor(); + public static final ExecInterceptor INSTANCE = new OpenTelemetryExecInterceptor(); @Override public void intercept(Execution execution, ExecType type, Block continuation) throws Exception { diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryHttpClient.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryHttpClient.java index aea5fc96faf6..3358f29b8fe9 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryHttpClient.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryHttpClient.java @@ -44,18 +44,30 @@ public HttpClient instrument(HttpClient httpClient) throws Exception { httpClientSpec.responseIntercept( httpResponse -> { Execution execution = Execution.current(); - ContextHolder contextHolder = execution.get(ContextHolder.class); - execution.remove(ContextHolder.class); - instrumenter.end( - contextHolder.context(), contextHolder.requestSpec(), httpResponse, null); + execution + .maybeGet(ContextHolder.class) + .ifPresent( + contextHolder -> { + execution.remove(ContextHolder.class); + instrumenter.end( + contextHolder.context(), + contextHolder.requestSpec(), + httpResponse, + null); + }); }); httpClientSpec.errorIntercept( ex -> { Execution execution = Execution.current(); - ContextHolder contextHolder = execution.get(ContextHolder.class); - execution.remove(ContextHolder.class); - instrumenter.end(contextHolder.context(), contextHolder.requestSpec(), null, ex); + execution + .maybeGet(ContextHolder.class) + .ifPresent( + contextHolder -> { + execution.remove(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/v1_7/RatpackTelemetryBuilder.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackTelemetryBuilder.java index a7e56610913a..b285dbb4bde2 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackTelemetryBuilder.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackTelemetryBuilder.java @@ -9,6 +9,7 @@ import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.instrumentation.api.incubator.builder.internal.DefaultHttpClientInstrumenterBuilder; import io.opentelemetry.instrumentation.api.incubator.builder.internal.DefaultHttpServerInstrumenterBuilder; +import io.opentelemetry.instrumentation.api.incubator.config.internal.CommonConfig; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.SpanNameExtractor; import io.opentelemetry.instrumentation.api.semconv.http.HttpClientAttributesExtractorBuilder; @@ -173,6 +174,13 @@ public RatpackTelemetryBuilder setServerSpanNameExtractor( return this; } + @CanIgnoreReturnValue + public RatpackTelemetryBuilder configure(CommonConfig config) { + clientBuilder.configure(config); + serverBuilder.configure(config); + return this; + } + /** Returns a new {@link RatpackTelemetry} with the configuration of this builder. */ public RatpackTelemetry build() { return new RatpackTelemetry(serverBuilder.build(), clientBuilder.build()); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/AbstractRatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/AbstractRatpackHttpClientTest.java index d13cbcc65932..68057cae039e 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/AbstractRatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/AbstractRatpackHttpClientTest.java @@ -148,16 +148,16 @@ protected void configure(HttpClientTestOptions.Builder optionsBuilder) { } return exception; }); + optionsBuilder.setHttpAttributes(this::computeHttpAttributes); optionsBuilder.disableTestRedirects(); + // these tests will pass, but they don't really test anything since REQUEST is Void optionsBuilder.disableTestReusedRequest(); - optionsBuilder.setHttpAttributes(this::getHttpAttributes); - optionsBuilder.spanEndsAfterBody(); } - protected Set> getHttpAttributes(URI uri) { + protected Set> computeHttpAttributes(URI uri) { Set> attributes = new HashSet<>(HttpClientTestOptions.DEFAULT_HTTP_ATTRIBUTES); attributes.remove(NETWORK_PROTOCOL_VERSION); return attributes; diff --git a/settings.gradle.kts b/settings.gradle.kts index 68cd7bff023f..418f2a101515 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -507,6 +507,7 @@ include(":instrumentation:r2dbc-1.0:testing") include(":instrumentation:rabbitmq-2.7:javaagent") include(":instrumentation:ratpack:ratpack-1.4:javaagent") include(":instrumentation:ratpack:ratpack-1.4:testing") +include(":instrumentation:ratpack:ratpack-1.7:javaagent") include(":instrumentation:ratpack:ratpack-1.7:library") include(":instrumentation:reactor:reactor-3.1:javaagent") include(":instrumentation:reactor:reactor-3.1:library") From ea9c1daf6c42876b70158122644fa5caa9c26c8c Mon Sep 17 00:00:00 2001 From: John Engelman Date: Wed, 6 Nov 2024 10:51:43 -0600 Subject: [PATCH 02/10] (chore) update from review --- .../ratpack-1.7/javaagent/build.gradle.kts | 21 ++----------------- 1 file changed, 2 insertions(+), 19 deletions(-) diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts b/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts index dbc58cadd42d..b3645767cee1 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts @@ -14,34 +14,17 @@ dependencies { library("io.ratpack:ratpack-core:1.7.0") implementation(project(":instrumentation:netty:netty-4.1:library")) - implementation(project(":instrumentation:ratpack:ratpack-1.4:javaagent")) implementation(project(":instrumentation:ratpack:ratpack-1.7:library")) - testImplementation(project(":instrumentation:ratpack:ratpack-1.4:testing")) - testLibrary("io.ratpack:ratpack-test:1.7.0") + testImplementation(project(":instrumentation:ratpack:ratpack-1.4:testing")) + testInstrumentation(project(":instrumentation:ratpack:ratpack-1.4:javaagent")) if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_11)) { testImplementation("com.sun.activation:jakarta.activation:1.2.2") } } -// to allow all tests to pass we need to choose a specific netty version -if (!(findProperty("testLatestDeps") as Boolean)) { - configurations.configureEach { - if (!name.contains("muzzle")) { - resolutionStrategy { - eachDependency { - // specifying a fixed version for all libraries with io.netty group - if (requested.group == "io.netty" && requested.name != "netty-tcnative") { - useVersion("4.1.37.Final") - } - } - } - } - } -} - tasks { withType().configureEach { systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean) From 05a3d0d69ff971ecb701e794643955339ba63789 Mon Sep 17 00:00:00 2001 From: John Engelman Date: Wed, 6 Nov 2024 18:30:12 -0600 Subject: [PATCH 03/10] (bug) apply exec controller classes using instrumentation --- .../DefaultExecControllerInstrumentation.java | 86 +++++++++++++++++++ .../v1_7/RatpackInstrumentationModule.java | 1 + .../v1_7/ServerRegistryInstrumentation.java | 10 ++- .../v1_7/RatpackForkedHttpClientTest.java | 16 ---- .../ratpack/v1_7/RatpackHttpClientTest.java | 16 ---- .../v1_7/RatpackPooledHttpClientTest.java | 16 ---- 6 files changed, 94 insertions(+), 51 deletions(-) create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java new file mode 100644 index 000000000000..7bdef2aaa609 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java @@ -0,0 +1,86 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; + +import static net.bytebuddy.matcher.ElementMatchers.isConstructor; +import static net.bytebuddy.matcher.ElementMatchers.named; +import static net.bytebuddy.matcher.ElementMatchers.takesArgument; + +import com.google.common.collect.ImmutableList; +import io.opentelemetry.instrumentation.ratpack.v1_7.OpenTelemetryExecInitializer; +import io.opentelemetry.instrumentation.ratpack.v1_7.OpenTelemetryExecInterceptor; +import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; +import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer; +import net.bytebuddy.asm.Advice; +import net.bytebuddy.description.type.TypeDescription; +import net.bytebuddy.matcher.ElementMatcher; +import ratpack.exec.ExecInitializer; +import ratpack.exec.ExecInterceptor; + +public class DefaultExecControllerInstrumentation implements TypeInstrumentation { + + @Override + public ElementMatcher typeMatcher() { + return named("ratpack.exec.internal.DefaultExecController"); + } + + @Override + public void transform(TypeTransformer transformer) { + transformer.applyAdviceToMethod( + named("setInitializers") + .and(takesArgument(0, named("com.google.common.collect.ImmutableList"))), + DefaultExecControllerInstrumentation.class.getName() + "$SetInitializersAdvice"); + + transformer.applyAdviceToMethod( + named("setInterceptors") + .and(takesArgument(0, named("com.google.common.collect.ImmutableList"))), + DefaultExecControllerInstrumentation.class.getName() + "$SetInterceptorsAdvice"); + + transformer.applyAdviceToMethod( + isConstructor(), + DefaultExecControllerInstrumentation.class.getName() + "$ConstructorAdvice"); + } + + public static class SetInitializersAdvice { + @Advice.OnMethodEnter(suppress = Throwable.class) + public static void enter( + @Advice.Argument(value = 0, readOnly = false) + ImmutableList initializers) { + initializers = + ImmutableList.builder() + .addAll(initializers) + .add(OpenTelemetryExecInitializer.INSTANCE) + .build(); + } + } + + public static class SetInterceptorsAdvice { + @Advice.OnMethodEnter(suppress = Throwable.class) + public static void enter( + @Advice.Argument(value = 0, readOnly = false) + ImmutableList interceptors) { + interceptors = + ImmutableList.builder() + .addAll(interceptors) + .add(OpenTelemetryExecInterceptor.INSTANCE) + .build(); + } + } + + public static class ConstructorAdvice { + + @SuppressWarnings("UnusedVariable") + @Advice.OnMethodExit(suppress = Throwable.class) + public static void exit( + @Advice.FieldValue(value = "initializers", readOnly = false) + ImmutableList initializers, + @Advice.FieldValue(value = "interceptors", readOnly = false) + ImmutableList interceptors) { + initializers = ImmutableList.of(OpenTelemetryExecInitializer.INSTANCE); + interceptors = ImmutableList.of(OpenTelemetryExecInterceptor.INSTANCE); + } + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java index 59232676bc1f..a98e61d4e0f2 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java @@ -37,6 +37,7 @@ public ElementMatcher.Junction classLoaderMatcher() { @Override public List typeInstrumentations() { return asList( + new DefaultExecControllerInstrumentation(), new ServerRegistryInstrumentation(), new HttpClientInstrumentation(), new RequestActionSupportInstrumentation()); diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java index 657a2e04cd07..df23c3a650e9 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java @@ -14,6 +14,7 @@ import net.bytebuddy.asm.Advice; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; +import ratpack.handling.HandlerDecorator; import ratpack.registry.Registry; public class ServerRegistryInstrumentation implements TypeInstrumentation { @@ -34,9 +35,12 @@ public void transform(TypeTransformer transformer) { public static class BuildAdvice { @Advice.OnMethodExit(suppress = Throwable.class) - public static void injectTracing(@Advice.Return(readOnly = false) Registry registry) - throws Exception { - registry = registry.join(Registry.of(RatpackSingletons.telemetry()::configureServerRegistry)); + public static void injectTracing(@Advice.Return(readOnly = false) Registry registry) { + registry = + registry.join( + Registry.single( + HandlerDecorator.prepend( + RatpackSingletons.telemetry().getOpenTelemetryServerHandler()))); } } } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java index b9348fd8dcbc..36fd784b9242 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java @@ -5,11 +5,9 @@ package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; -import com.google.common.collect.ImmutableList; import io.netty.channel.ConnectTimeoutException; import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackForkedHttpClientTest; -import io.opentelemetry.instrumentation.ratpack.v1_7.OpenTelemetryExecInitializer; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; @@ -17,10 +15,8 @@ import java.net.URI; import java.util.HashSet; import java.util.Set; -import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.condition.OS; import org.junit.jupiter.api.extension.RegisterExtension; -import ratpack.exec.internal.DefaultExecController; import ratpack.http.client.HttpClientReadTimeoutException; class RatpackForkedHttpClientTest extends AbstractRatpackForkedHttpClientTest { @@ -28,18 +24,6 @@ class RatpackForkedHttpClientTest extends AbstractRatpackForkedHttpClientTest { @RegisterExtension static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); - @BeforeAll - @Override - protected void setUpClient() throws Exception { - exec.run( - unused -> { - ((DefaultExecController) exec.getController()) - .setInitializers(ImmutableList.of(OpenTelemetryExecInitializer.INSTANCE)); - client = buildHttpClient(); - singleConnectionClient = buildHttpClient(spec -> spec.poolSize(1)); - }); - } - @Override protected Set> computeHttpAttributes(URI uri) { Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java index 02f76cbc04e4..4955089b76e8 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java @@ -5,11 +5,9 @@ package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; -import com.google.common.collect.ImmutableList; import io.netty.channel.ConnectTimeoutException; import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackHttpClientTest; -import io.opentelemetry.instrumentation.ratpack.v1_7.OpenTelemetryExecInitializer; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; @@ -17,10 +15,8 @@ import java.net.URI; import java.util.HashSet; import java.util.Set; -import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.condition.OS; import org.junit.jupiter.api.extension.RegisterExtension; -import ratpack.exec.internal.DefaultExecController; import ratpack.http.client.HttpClientReadTimeoutException; class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { @@ -28,18 +24,6 @@ class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { @RegisterExtension static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); - @BeforeAll - @Override - protected void setUpClient() throws Exception { - exec.run( - unused -> { - ((DefaultExecController) exec.getController()) - .setInitializers(ImmutableList.of(OpenTelemetryExecInitializer.INSTANCE)); - client = buildHttpClient(); - singleConnectionClient = buildHttpClient(spec -> spec.poolSize(1)); - }); - } - @Override protected Set> computeHttpAttributes(URI uri) { Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java index 80506e4d2fda..6a98d8f0a8d9 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java @@ -5,11 +5,9 @@ package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; -import com.google.common.collect.ImmutableList; import io.netty.channel.ConnectTimeoutException; import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackPooledHttpClientTest; -import io.opentelemetry.instrumentation.ratpack.v1_7.OpenTelemetryExecInitializer; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; @@ -17,10 +15,8 @@ import java.net.URI; import java.util.HashSet; import java.util.Set; -import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.condition.OS; import org.junit.jupiter.api.extension.RegisterExtension; -import ratpack.exec.internal.DefaultExecController; import ratpack.http.client.HttpClientReadTimeoutException; class RatpackPooledHttpClientTest extends AbstractRatpackPooledHttpClientTest { @@ -28,18 +24,6 @@ class RatpackPooledHttpClientTest extends AbstractRatpackPooledHttpClientTest { @RegisterExtension static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); - @BeforeAll - @Override - protected void setUpClient() throws Exception { - exec.run( - unused -> { - ((DefaultExecController) exec.getController()) - .setInitializers(ImmutableList.of(OpenTelemetryExecInitializer.INSTANCE)); - client = buildHttpClient(); - singleConnectionClient = buildHttpClient(spec -> spec.poolSize(1)); - }); - } - @Override protected Set> computeHttpAttributes(URI uri) { Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); From 8fff64a7ecf1d6b61553f46b45486ce85431155a Mon Sep 17 00:00:00 2001 From: John Engelman Date: Wed, 6 Nov 2024 21:20:18 -0600 Subject: [PATCH 04/10] (chore) make indy compatible --- .../DefaultExecControllerInstrumentation.java | 59 +++++++++++-------- .../v1_7/HttpClientInstrumentation.java | 8 +-- .../v1_7/RatpackInstrumentationModule.java | 5 ++ .../RequestActionSupportInstrumentation.java | 35 +++++++---- .../v1_7/ServerRegistryInstrumentation.java | 14 ++--- 5 files changed, 72 insertions(+), 49 deletions(-) diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java index 7bdef2aaa609..3d16352fbe5a 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java @@ -15,6 +15,8 @@ import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer; import net.bytebuddy.asm.Advice; +import net.bytebuddy.asm.Advice.AssignReturned.ToArguments.ToArgument; +import net.bytebuddy.asm.Advice.AssignReturned.ToFields.ToField; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; import ratpack.exec.ExecInitializer; @@ -44,43 +46,48 @@ public void transform(TypeTransformer transformer) { DefaultExecControllerInstrumentation.class.getName() + "$ConstructorAdvice"); } + @SuppressWarnings("unused") public static class SetInitializersAdvice { - @Advice.OnMethodEnter(suppress = Throwable.class) - public static void enter( - @Advice.Argument(value = 0, readOnly = false) - ImmutableList initializers) { - initializers = - ImmutableList.builder() - .addAll(initializers) - .add(OpenTelemetryExecInitializer.INSTANCE) - .build(); + @Advice.OnMethodEnter(suppress = Throwable.class, inline = false) + @Advice.AssignReturned.ToArguments(@ToArgument(0)) + public static ImmutableList enter( + @Advice.Argument(0) ImmutableList initializers) { + return ImmutableList.builder() + .addAll(initializers) + .add(OpenTelemetryExecInitializer.INSTANCE) + .build(); } } + @SuppressWarnings("unused") public static class SetInterceptorsAdvice { - @Advice.OnMethodEnter(suppress = Throwable.class) - public static void enter( - @Advice.Argument(value = 0, readOnly = false) - ImmutableList interceptors) { - interceptors = - ImmutableList.builder() - .addAll(interceptors) - .add(OpenTelemetryExecInterceptor.INSTANCE) - .build(); + @Advice.OnMethodEnter(suppress = Throwable.class, inline = false) + @Advice.AssignReturned.ToArguments(@ToArgument(0)) + public static ImmutableList enter( + @Advice.Argument(0) ImmutableList interceptors) { + return ImmutableList.builder() + .addAll(interceptors) + .add(OpenTelemetryExecInterceptor.INSTANCE) + .build(); } } + @SuppressWarnings("unused") public static class ConstructorAdvice { @SuppressWarnings("UnusedVariable") - @Advice.OnMethodExit(suppress = Throwable.class) - public static void exit( - @Advice.FieldValue(value = "initializers", readOnly = false) - ImmutableList initializers, - @Advice.FieldValue(value = "interceptors", readOnly = false) - ImmutableList interceptors) { - initializers = ImmutableList.of(OpenTelemetryExecInitializer.INSTANCE); - interceptors = ImmutableList.of(OpenTelemetryExecInterceptor.INSTANCE); + @Advice.OnMethodExit(suppress = Throwable.class, inline = false) + @Advice.AssignReturned.ToFields({ + @ToField(value = "initializers", index = 0), + @ToField(value = "interceptors", index = 1) + }) + public static Object[] exit( + @Advice.FieldValue("initializers") ImmutableList initializers, + @Advice.FieldValue("interceptors") ImmutableList interceptors) { + return new Object[] { + ImmutableList.of(OpenTelemetryExecInitializer.INSTANCE), + ImmutableList.of(OpenTelemetryExecInterceptor.INSTANCE) + }; } } } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java index d14e25458201..0fcdef428d80 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java @@ -37,10 +37,10 @@ public void transform(TypeTransformer transformer) { @SuppressWarnings("unused") public static class OfAdvice { - @Advice.OnMethodExit(suppress = Throwable.class) - public static void injectTracing(@Advice.Return(readOnly = false) HttpClient httpClient) - throws Exception { - httpClient = RatpackSingletons.telemetry().instrumentHttpClient(httpClient); + @Advice.OnMethodExit(suppress = Throwable.class, inline = false) + @Advice.AssignReturned.ToReturned + public static HttpClient injectTracing(@Advice.Return HttpClient httpClient) throws Exception { + return RatpackSingletons.telemetry().instrumentHttpClient(httpClient); } } } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java index a98e61d4e0f2..3f00fa32bfc0 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java @@ -28,6 +28,11 @@ public String getModuleGroup() { return "netty"; } + @Override + public boolean isIndyModule() { + return true; + } + @Override public ElementMatcher.Junction classLoaderMatcher() { // Only activate when running ratpack 1.7 or later diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java index a156ddb638ba..e57b93735fd7 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java @@ -18,6 +18,7 @@ import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer; import net.bytebuddy.asm.Advice; +import net.bytebuddy.asm.Advice.AssignReturned.ToArguments.ToArgument; import net.bytebuddy.description.type.TypeDescription; import net.bytebuddy.matcher.ElementMatcher; import ratpack.exec.Downstream; @@ -41,7 +42,10 @@ public void transform(TypeTransformer transformer) { RequestActionSupportInstrumentation.class.getName() + "$SendAdvice"); transformer.applyAdviceToMethod( isMethod().and(named("connect")).and(takesArgument(0, named("ratpack.exec.Downstream"))), - RequestActionSupportInstrumentation.class.getName() + "$ConnectAdvice"); + RequestActionSupportInstrumentation.class.getName() + "$ConnectDownstreamAdvice"); + transformer.applyAdviceToMethod( + isMethod().and(named("connect")).and(takesArgument(0, named("ratpack.exec.Downstream"))), + RequestActionSupportInstrumentation.class.getName() + "$ContextAdvice"); } @SuppressWarnings("unused") @@ -49,22 +53,29 @@ public static class SendAdvice { @Advice.OnMethodEnter(suppress = Throwable.class) public static void injectChannelAttribute( - @Advice.FieldValue("execution") Execution execution, - @Advice.Argument(value = 0, readOnly = false) Downstream downstream, - @Advice.Argument(value = 1, readOnly = false) Channel channel) { + @Advice.FieldValue("execution") Execution execution, @Advice.Argument(1) Channel channel) { RatpackSingletons.propagateContextToChannel(execution, channel); } } - public static class ConnectAdvice { + @SuppressWarnings("unused") + public static class ConnectDownstreamAdvice { - @Advice.OnMethodEnter(suppress = Throwable.class) - public static Scope injectChannelAttribute( - @Advice.FieldValue("execution") Execution execution, - @Advice.Argument(value = 0, readOnly = false) Downstream downstream) { + @Advice.OnMethodEnter(suppress = Throwable.class, inline = false) + @Advice.AssignReturned.ToArguments(@ToArgument(0)) + public static Object wrapDownstream(@Advice.Argument(0) Downstream downstream) { // Propagate the current context to downstream - // since that the is the subsequent - downstream = DownstreamWrapper.wrapIfNeeded(downstream); + // since that is the subsequent code chained to the http client call + return DownstreamWrapper.wrapIfNeeded(downstream); + } + } + + @SuppressWarnings("unused") + public static class ContextAdvice { + + @Advice.OnMethodEnter(suppress = Throwable.class, inline = false) + public static Scope injectChannelAttribute( + @Advice.FieldValue("execution") Execution execution) { // Capture the CLIENT span and make it current before cally Netty layer return execution @@ -74,7 +85,7 @@ public static Scope injectChannelAttribute( .orElse(null); } - @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) + @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class, inline = false) public static void exit(@Advice.Enter Scope scope) { if (scope != null) { scope.close(); diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java index df23c3a650e9..50d055bdb991 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java @@ -34,13 +34,13 @@ public void transform(TypeTransformer transformer) { @SuppressWarnings("unused") public static class BuildAdvice { - @Advice.OnMethodExit(suppress = Throwable.class) - public static void injectTracing(@Advice.Return(readOnly = false) Registry registry) { - registry = - registry.join( - Registry.single( - HandlerDecorator.prepend( - RatpackSingletons.telemetry().getOpenTelemetryServerHandler()))); + @Advice.OnMethodExit(suppress = Throwable.class, inline = false) + @Advice.AssignReturned.ToReturned + public static Registry injectTracing(@Advice.Return Registry registry) { + return registry.join( + Registry.single( + HandlerDecorator.prepend( + RatpackSingletons.telemetry().getOpenTelemetryServerHandler()))); } } } From d72ecda90eb83e3fdf76d9e2ec3cd8560ca28160 Mon Sep 17 00:00:00 2001 From: John Engelman Date: Thu, 14 Nov 2024 10:26:10 -0600 Subject: [PATCH 05/10] (chore) remove indy specific inlining per review --- .../ratpack/v1_7/DefaultExecControllerInstrumentation.java | 6 +++--- .../ratpack/v1_7/HttpClientInstrumentation.java | 2 +- .../ratpack/v1_7/RatpackInstrumentationModule.java | 5 ----- .../ratpack/v1_7/RequestActionSupportInstrumentation.java | 6 +++--- .../ratpack/v1_7/ServerRegistryInstrumentation.java | 2 +- 5 files changed, 8 insertions(+), 13 deletions(-) diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java index 3d16352fbe5a..fb464efece3c 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java @@ -48,7 +48,7 @@ public void transform(TypeTransformer transformer) { @SuppressWarnings("unused") public static class SetInitializersAdvice { - @Advice.OnMethodEnter(suppress = Throwable.class, inline = false) + @Advice.OnMethodEnter(suppress = Throwable.class) @Advice.AssignReturned.ToArguments(@ToArgument(0)) public static ImmutableList enter( @Advice.Argument(0) ImmutableList initializers) { @@ -61,7 +61,7 @@ public static ImmutableList enter( @SuppressWarnings("unused") public static class SetInterceptorsAdvice { - @Advice.OnMethodEnter(suppress = Throwable.class, inline = false) + @Advice.OnMethodEnter(suppress = Throwable.class) @Advice.AssignReturned.ToArguments(@ToArgument(0)) public static ImmutableList enter( @Advice.Argument(0) ImmutableList interceptors) { @@ -76,7 +76,7 @@ public static ImmutableList enter( public static class ConstructorAdvice { @SuppressWarnings("UnusedVariable") - @Advice.OnMethodExit(suppress = Throwable.class, inline = false) + @Advice.OnMethodExit(suppress = Throwable.class) @Advice.AssignReturned.ToFields({ @ToField(value = "initializers", index = 0), @ToField(value = "interceptors", index = 1) diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java index 0fcdef428d80..1c6b34b1ff34 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java @@ -37,7 +37,7 @@ public void transform(TypeTransformer transformer) { @SuppressWarnings("unused") public static class OfAdvice { - @Advice.OnMethodExit(suppress = Throwable.class, inline = false) + @Advice.OnMethodExit(suppress = Throwable.class) @Advice.AssignReturned.ToReturned public static HttpClient injectTracing(@Advice.Return HttpClient httpClient) throws Exception { return RatpackSingletons.telemetry().instrumentHttpClient(httpClient); diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java index 3f00fa32bfc0..a98e61d4e0f2 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java @@ -28,11 +28,6 @@ public String getModuleGroup() { return "netty"; } - @Override - public boolean isIndyModule() { - return true; - } - @Override public ElementMatcher.Junction classLoaderMatcher() { // Only activate when running ratpack 1.7 or later diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java index e57b93735fd7..16952ab1c4d4 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java @@ -61,7 +61,7 @@ public static void injectChannelAttribute( @SuppressWarnings("unused") public static class ConnectDownstreamAdvice { - @Advice.OnMethodEnter(suppress = Throwable.class, inline = false) + @Advice.OnMethodEnter(suppress = Throwable.class) @Advice.AssignReturned.ToArguments(@ToArgument(0)) public static Object wrapDownstream(@Advice.Argument(0) Downstream downstream) { // Propagate the current context to downstream @@ -73,7 +73,7 @@ public static Object wrapDownstream(@Advice.Argument(0) Downstream downstream @SuppressWarnings("unused") public static class ContextAdvice { - @Advice.OnMethodEnter(suppress = Throwable.class, inline = false) + @Advice.OnMethodEnter(suppress = Throwable.class) public static Scope injectChannelAttribute( @Advice.FieldValue("execution") Execution execution) { @@ -85,7 +85,7 @@ public static Scope injectChannelAttribute( .orElse(null); } - @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class, inline = false) + @Advice.OnMethodExit(onThrowable = Throwable.class, suppress = Throwable.class) public static void exit(@Advice.Enter Scope scope) { if (scope != null) { scope.close(); diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java index 50d055bdb991..7484d9637afc 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java @@ -34,7 +34,7 @@ public void transform(TypeTransformer transformer) { @SuppressWarnings("unused") public static class BuildAdvice { - @Advice.OnMethodExit(suppress = Throwable.class, inline = false) + @Advice.OnMethodExit(suppress = Throwable.class) @Advice.AssignReturned.ToReturned public static Registry injectTracing(@Advice.Return Registry registry) { return registry.join( From 65368a3480e29a2caeaaeec3f40b55ce78b32b01 Mon Sep 17 00:00:00 2001 From: John Engelman Date: Thu, 14 Nov 2024 15:16:06 -0600 Subject: [PATCH 06/10] (chore) introduce factories and refactor class access for sharing --- .../DefaultExecControllerInstrumentation.java | 4 +- .../ratpack/v1_7/DownstreamWrapper.java | 2 +- .../v1_7/HttpClientInstrumentation.java | 2 +- .../ratpack/v1_7/RatpackSingletons.java | 40 ++++++++++--------- .../v1_7/ServerRegistryInstrumentation.java | 4 +- .../ratpack/v1_7/RatpackTelemetry.java | 4 ++ .../ratpack/v1_7/RatpackTelemetryBuilder.java | 22 ++-------- .../OpenTelemetryExecInitializer.java | 7 +++- .../OpenTelemetryExecInterceptor.java | 6 ++- .../OpenTelemetryFallbackErrorHandler.java | 6 ++- .../OpenTelemetryHttpClient.java | 11 +++-- .../OpenTelemetryServerErrorHandler.java | 6 ++- .../OpenTelemetryServerHandler.java | 8 +++- ...tpackClientInstrumenterBuilderFactory.java | 29 ++++++++++++++ .../v1_7/{ => internal}/RatpackGetter.java | 8 +++- .../RatpackHttpAttributesGetter.java | 8 +++- .../RatpackHttpClientAttributesGetter.java | 8 +++- ...tpackServerInstrumenterBuilderFactory.java | 30 ++++++++++++++ .../{ => internal}/RequestHeaderSetter.java | 8 +++- .../RatpackServerApplicationTest.groovy | 2 +- .../v1_7/AbstractRatpackHttpClientTest.java | 2 + 21 files changed, 154 insertions(+), 63 deletions(-) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/{ => internal}/OpenTelemetryExecInitializer.java (77%) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/{ => internal}/OpenTelemetryExecInterceptor.java (92%) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/{ => internal}/OpenTelemetryFallbackErrorHandler.java (94%) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/{ => internal}/OpenTelemetryHttpClient.java (88%) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/{ => internal}/OpenTelemetryServerErrorHandler.java (83%) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/{ => internal}/OpenTelemetryServerHandler.java (91%) create mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackClientInstrumenterBuilderFactory.java rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/{ => internal}/RatpackGetter.java (67%) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/{ => internal}/RatpackHttpAttributesGetter.java (88%) rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/{ => internal}/RatpackHttpClientAttributesGetter.java (86%) create mode 100644 instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackServerInstrumenterBuilderFactory.java rename instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/{ => internal}/RequestHeaderSetter.java (61%) diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java index fb464efece3c..27ebfc0bcefb 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DefaultExecControllerInstrumentation.java @@ -10,8 +10,8 @@ import static net.bytebuddy.matcher.ElementMatchers.takesArgument; import com.google.common.collect.ImmutableList; -import io.opentelemetry.instrumentation.ratpack.v1_7.OpenTelemetryExecInitializer; -import io.opentelemetry.instrumentation.ratpack.v1_7.OpenTelemetryExecInterceptor; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryExecInitializer; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryExecInterceptor; import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer; import net.bytebuddy.asm.Advice; diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DownstreamWrapper.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DownstreamWrapper.java index 5bf5d2454fec..e4540162d4e6 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DownstreamWrapper.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/DownstreamWrapper.java @@ -9,7 +9,7 @@ import io.opentelemetry.context.Scope; import ratpack.exec.Downstream; -public class DownstreamWrapper implements Downstream { +public final class DownstreamWrapper implements Downstream { private final Downstream delegate; private final Context parentContext; diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java index 1c6b34b1ff34..866b9c41e4de 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/HttpClientInstrumentation.java @@ -40,7 +40,7 @@ public static class OfAdvice { @Advice.OnMethodExit(suppress = Throwable.class) @Advice.AssignReturned.ToReturned public static HttpClient injectTracing(@Advice.Return HttpClient httpClient) throws Exception { - return RatpackSingletons.telemetry().instrumentHttpClient(httpClient); + return RatpackSingletons.httpClient().instrument(httpClient); } } } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java index a0304c64a0b8..e7672f559706 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java @@ -8,37 +8,41 @@ import io.netty.channel.Channel; import io.opentelemetry.api.GlobalOpenTelemetry; import io.opentelemetry.context.Context; -import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; import io.opentelemetry.instrumentation.netty.v4_1.internal.AttributeKeys; -import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackTelemetry; import io.opentelemetry.instrumentation.ratpack.v1_7.internal.ContextHolder; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryHttpClient; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryServerHandler; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.RatpackClientInstrumenterBuilderFactory; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.RatpackServerInstrumenterBuilderFactory; import io.opentelemetry.javaagent.bootstrap.internal.AgentCommonConfig; -import io.opentelemetry.javaagent.bootstrap.internal.ExperimentalConfig; import ratpack.exec.Execution; public final class RatpackSingletons { static { - TELEMETRY = - RatpackTelemetry.builder(GlobalOpenTelemetry.get()) - .configure(AgentCommonConfig.get()) - .build(); + HTTP_CLIENT = + new OpenTelemetryHttpClient( + RatpackClientInstrumenterBuilderFactory.create( + "io.opentelemetry.ratpack-1.7", GlobalOpenTelemetry.get()) + .configure(AgentCommonConfig.get()) + .build()); + SERVER_HANDLER = + new OpenTelemetryServerHandler( + RatpackServerInstrumenterBuilderFactory.create( + "io.opentelemetry.ratpack-1.7", GlobalOpenTelemetry.get()) + .configure(AgentCommonConfig.get()) + .build()); } - private static final Instrumenter INSTRUMENTER = - Instrumenter.builder( - GlobalOpenTelemetry.get(), "io.opentelemetry.ratpack-1.7", s -> s) - .setEnabled(ExperimentalConfig.get().controllerTelemetryEnabled()) - .buildInstrumenter(); + private static final OpenTelemetryHttpClient HTTP_CLIENT; + private static final OpenTelemetryServerHandler SERVER_HANDLER; - public static Instrumenter instrumenter() { - return INSTRUMENTER; + public static OpenTelemetryHttpClient httpClient() { + return HTTP_CLIENT; } - private static final RatpackTelemetry TELEMETRY; - - public static RatpackTelemetry telemetry() { - return TELEMETRY; + public static OpenTelemetryServerHandler serverHandler() { + return SERVER_HANDLER; } public static void propagateContextToChannel(Execution execution, Channel channel) { diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java index 7484d9637afc..0e7915b0fb01 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java @@ -38,9 +38,7 @@ public static class BuildAdvice { @Advice.AssignReturned.ToReturned public static Registry injectTracing(@Advice.Return Registry registry) { return registry.join( - Registry.single( - HandlerDecorator.prepend( - RatpackSingletons.telemetry().getOpenTelemetryServerHandler()))); + Registry.single(HandlerDecorator.prepend(RatpackSingletons.serverHandler()))); } } } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackTelemetry.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackTelemetry.java index f8468d491908..95ea733c4fe7 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackTelemetry.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackTelemetry.java @@ -7,6 +7,10 @@ import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryExecInitializer; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryExecInterceptor; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryHttpClient; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryServerHandler; import ratpack.exec.ExecInitializer; import ratpack.exec.ExecInterceptor; import ratpack.handling.HandlerDecorator; diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackTelemetryBuilder.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackTelemetryBuilder.java index b285dbb4bde2..1192a8d8d936 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackTelemetryBuilder.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackTelemetryBuilder.java @@ -9,11 +9,12 @@ import io.opentelemetry.api.OpenTelemetry; import io.opentelemetry.instrumentation.api.incubator.builder.internal.DefaultHttpClientInstrumenterBuilder; import io.opentelemetry.instrumentation.api.incubator.builder.internal.DefaultHttpServerInstrumenterBuilder; -import io.opentelemetry.instrumentation.api.incubator.config.internal.CommonConfig; import io.opentelemetry.instrumentation.api.instrumenter.AttributesExtractor; import io.opentelemetry.instrumentation.api.instrumenter.SpanNameExtractor; import io.opentelemetry.instrumentation.api.semconv.http.HttpClientAttributesExtractorBuilder; import io.opentelemetry.instrumentation.api.semconv.http.HttpServerAttributesExtractorBuilder; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.RatpackClientInstrumenterBuilderFactory; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.RatpackServerInstrumenterBuilderFactory; import java.util.List; import java.util.Set; import java.util.function.Function; @@ -32,17 +33,9 @@ public final class RatpackTelemetryBuilder { RatpackTelemetryBuilder(OpenTelemetry openTelemetry) { clientBuilder = - DefaultHttpClientInstrumenterBuilder.create( - INSTRUMENTATION_NAME, - openTelemetry, - RatpackHttpClientAttributesGetter.INSTANCE, - RequestHeaderSetter.INSTANCE); + RatpackClientInstrumenterBuilderFactory.create(INSTRUMENTATION_NAME, openTelemetry); serverBuilder = - DefaultHttpServerInstrumenterBuilder.create( - INSTRUMENTATION_NAME, - openTelemetry, - RatpackHttpAttributesGetter.INSTANCE, - RatpackGetter.INSTANCE); + RatpackServerInstrumenterBuilderFactory.create(INSTRUMENTATION_NAME, openTelemetry); } /** @@ -174,13 +167,6 @@ public RatpackTelemetryBuilder setServerSpanNameExtractor( return this; } - @CanIgnoreReturnValue - public RatpackTelemetryBuilder configure(CommonConfig config) { - clientBuilder.configure(config); - serverBuilder.configure(config); - return this; - } - /** Returns a new {@link RatpackTelemetry} with the configuration of this builder. */ public RatpackTelemetry build() { return new RatpackTelemetry(serverBuilder.build(), clientBuilder.build()); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInitializer.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryExecInitializer.java similarity index 77% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInitializer.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryExecInitializer.java index bbedaee9caca..b192859d8221 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInitializer.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryExecInitializer.java @@ -3,12 +3,15 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.v1_7; +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; -import io.opentelemetry.instrumentation.ratpack.v1_7.internal.ContextHolder; import ratpack.exec.ExecInitializer; import ratpack.exec.Execution; +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ public final class OpenTelemetryExecInitializer implements ExecInitializer { public static final ExecInitializer INSTANCE = new OpenTelemetryExecInitializer(); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInterceptor.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryExecInterceptor.java similarity index 92% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInterceptor.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryExecInterceptor.java index 07c7a68abc5f..b75c801c17fa 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryExecInterceptor.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryExecInterceptor.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.v1_7; +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; import io.opentelemetry.context.Context; import io.opentelemetry.context.Scope; @@ -11,6 +11,10 @@ import ratpack.exec.Execution; import ratpack.func.Block; +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ public final class OpenTelemetryExecInterceptor implements ExecInterceptor { public static final ExecInterceptor INSTANCE = new OpenTelemetryExecInterceptor(); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryFallbackErrorHandler.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryFallbackErrorHandler.java similarity index 94% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryFallbackErrorHandler.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryFallbackErrorHandler.java index f3f2db80c352..4c909be89f8f 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryFallbackErrorHandler.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryFallbackErrorHandler.java @@ -20,7 +20,7 @@ * limitations under the License. */ -package io.opentelemetry.instrumentation.ratpack.v1_7; +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; import static java.util.logging.Level.WARNING; @@ -32,6 +32,10 @@ // Copied from // https://github.com/ratpack/ratpack/blob/master/ratpack-core/src/main/java/ratpack/core/error/internal/DefaultProductionErrorHandler.java // since it is internal and has had breaking changes. +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ final class OpenTelemetryFallbackErrorHandler implements ClientErrorHandler, ServerErrorHandler { static final OpenTelemetryFallbackErrorHandler INSTANCE = new OpenTelemetryFallbackErrorHandler(); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryHttpClient.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryHttpClient.java similarity index 88% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryHttpClient.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryHttpClient.java index 3358f29b8fe9..c657d98bdb9c 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryHttpClient.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryHttpClient.java @@ -3,23 +3,26 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.v1_7; +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; import io.opentelemetry.api.trace.Span; import io.opentelemetry.context.Context; import io.opentelemetry.instrumentation.api.instrumenter.Instrumenter; -import io.opentelemetry.instrumentation.ratpack.v1_7.internal.ContextHolder; import io.opentelemetry.semconv.HttpAttributes; import ratpack.exec.Execution; import ratpack.http.client.HttpClient; import ratpack.http.client.HttpResponse; import ratpack.http.client.RequestSpec; -final class OpenTelemetryHttpClient { +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ +public final class OpenTelemetryHttpClient { private final Instrumenter instrumenter; - OpenTelemetryHttpClient(Instrumenter instrumenter) { + public OpenTelemetryHttpClient(Instrumenter instrumenter) { this.instrumenter = instrumenter; } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryServerErrorHandler.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryServerErrorHandler.java similarity index 83% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryServerErrorHandler.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryServerErrorHandler.java index bc84c476203b..26316c3fe839 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryServerErrorHandler.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryServerErrorHandler.java @@ -3,11 +3,15 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.v1_7; +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; import ratpack.error.ServerErrorHandler; import ratpack.handling.Context; +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ final class OpenTelemetryServerErrorHandler implements ServerErrorHandler { static final ServerErrorHandler INSTANCE = new OpenTelemetryServerErrorHandler(); diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryServerHandler.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryServerHandler.java similarity index 91% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryServerHandler.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryServerHandler.java index 7dedf77ef9ab..2d5f23782066 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/OpenTelemetryServerHandler.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/OpenTelemetryServerHandler.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.v1_7; +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; import static io.opentelemetry.instrumentation.api.semconv.http.HttpServerRouteSource.CONTROLLER; @@ -16,11 +16,15 @@ import ratpack.http.Request; import ratpack.http.Response; +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ public final class OpenTelemetryServerHandler implements Handler { private final Instrumenter instrumenter; - OpenTelemetryServerHandler(Instrumenter instrumenter) { + public OpenTelemetryServerHandler(Instrumenter instrumenter) { this.instrumenter = instrumenter; } diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackClientInstrumenterBuilderFactory.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackClientInstrumenterBuilderFactory.java new file mode 100644 index 000000000000..37d4ea5508b3 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackClientInstrumenterBuilderFactory.java @@ -0,0 +1,29 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; + +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.instrumentation.api.incubator.builder.internal.DefaultHttpClientInstrumenterBuilder; +import ratpack.http.client.HttpResponse; +import ratpack.http.client.RequestSpec; + +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ +public class RatpackClientInstrumenterBuilderFactory { + private RatpackClientInstrumenterBuilderFactory() {} + + public static DefaultHttpClientInstrumenterBuilder create( + String instrumentationName, OpenTelemetry openTelemetry) { + + return DefaultHttpClientInstrumenterBuilder.create( + instrumentationName, + openTelemetry, + RatpackHttpClientAttributesGetter.INSTANCE, + RequestHeaderSetter.INSTANCE); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackGetter.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackGetter.java similarity index 67% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackGetter.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackGetter.java index e9326b12acfc..4c7b4d7ee76a 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackGetter.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackGetter.java @@ -3,13 +3,17 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.v1_7; +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; import io.opentelemetry.context.propagation.TextMapGetter; import javax.annotation.Nullable; import ratpack.http.Request; -enum RatpackGetter implements TextMapGetter { +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ +public enum RatpackGetter implements TextMapGetter { INSTANCE; @Override diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackHttpAttributesGetter.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpAttributesGetter.java similarity index 88% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackHttpAttributesGetter.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpAttributesGetter.java index 95a3d4f888c5..b19210901c70 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackHttpAttributesGetter.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpAttributesGetter.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.v1_7; +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; import io.opentelemetry.instrumentation.api.semconv.http.HttpServerAttributesGetter; import java.util.List; @@ -13,7 +13,11 @@ import ratpack.http.Response; import ratpack.server.PublicAddress; -enum RatpackHttpAttributesGetter implements HttpServerAttributesGetter { +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ +public enum RatpackHttpAttributesGetter implements HttpServerAttributesGetter { INSTANCE; @Override diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackHttpClientAttributesGetter.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpClientAttributesGetter.java similarity index 86% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackHttpClientAttributesGetter.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpClientAttributesGetter.java index 6aa8f0227fa5..89615fe523b7 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RatpackHttpClientAttributesGetter.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpClientAttributesGetter.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.v1_7; +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; import io.opentelemetry.instrumentation.api.semconv.http.HttpClientAttributesGetter; import java.util.List; @@ -11,7 +11,11 @@ import ratpack.http.client.HttpResponse; import ratpack.http.client.RequestSpec; -enum RatpackHttpClientAttributesGetter +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ +public enum RatpackHttpClientAttributesGetter implements HttpClientAttributesGetter { INSTANCE; diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackServerInstrumenterBuilderFactory.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackServerInstrumenterBuilderFactory.java new file mode 100644 index 000000000000..8cce9e84928a --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackServerInstrumenterBuilderFactory.java @@ -0,0 +1,30 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; + +import io.opentelemetry.api.OpenTelemetry; +import io.opentelemetry.instrumentation.api.incubator.builder.internal.DefaultHttpServerInstrumenterBuilder; +import ratpack.http.Request; +import ratpack.http.Response; + +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ +public class RatpackServerInstrumenterBuilderFactory { + + private RatpackServerInstrumenterBuilderFactory() {} + + public static DefaultHttpServerInstrumenterBuilder create( + String instrumentationName, OpenTelemetry openTelemetry) { + + return DefaultHttpServerInstrumenterBuilder.create( + instrumentationName, + openTelemetry, + RatpackHttpAttributesGetter.INSTANCE, + RatpackGetter.INSTANCE); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RequestHeaderSetter.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RequestHeaderSetter.java similarity index 61% rename from instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RequestHeaderSetter.java rename to instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RequestHeaderSetter.java index d6da0e36d752..9eb9b837f092 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/RequestHeaderSetter.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RequestHeaderSetter.java @@ -3,13 +3,17 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.instrumentation.ratpack.v1_7; +package io.opentelemetry.instrumentation.ratpack.v1_7.internal; import io.opentelemetry.context.propagation.TextMapSetter; import ratpack.api.Nullable; import ratpack.http.client.RequestSpec; -enum RequestHeaderSetter implements TextMapSetter { +/** + * This class is internal and is hence not for public use. Its APIs are unstable and can change at + * any time. + */ +public enum RequestHeaderSetter implements TextMapSetter { INSTANCE; @Override diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackServerApplicationTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackServerApplicationTest.groovy index ced2052acce7..3e0ed088f401 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackServerApplicationTest.groovy +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackServerApplicationTest.groovy @@ -10,7 +10,7 @@ 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.v1_7.OpenTelemetryServerHandler +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryServerHandler import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackFunctionalTest import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackTelemetry import io.opentelemetry.sdk.OpenTelemetrySdk diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/AbstractRatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/AbstractRatpackHttpClientTest.java index 68057cae039e..2704b1ad6ba5 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/AbstractRatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/AbstractRatpackHttpClientTest.java @@ -11,6 +11,8 @@ import io.netty.channel.ConnectTimeoutException; import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.context.Context; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryExecInitializer; +import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryExecInterceptor; import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientResult; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; From 14272dec0983c4f885aa6f788cf4eef5f48855ce Mon Sep 17 00:00:00 2001 From: John Engelman Date: Fri, 15 Nov 2024 10:23:47 -0600 Subject: [PATCH 07/10] (chore) class access cleanup from review --- .../ratpack-1.7/javaagent/build.gradle.kts | 14 +++--- .../v1_7/RatpackInstrumentationModule.java | 1 - .../v1_7/ServerRegistryInstrumentation.java | 44 ------------------- .../v1_7/RatpackPooledHttpClientTest.java | 5 +-- .../ratpack/v1_7/internal/RatpackGetter.java | 2 +- .../internal/RatpackHttpAttributesGetter.java | 2 +- .../RatpackHttpClientAttributesGetter.java | 2 +- .../v1_7/internal/RequestHeaderSetter.java | 2 +- 8 files changed, 12 insertions(+), 60 deletions(-) delete mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts b/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts index b3645767cee1..e699d41c1934 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts @@ -8,6 +8,11 @@ muzzle { module.set("ratpack-core") versions.set("[1.7.0,)") } + fail { + group.set("io.ratpack") + module.set("ratpack-core") + versions.set("[1.0,1.7)") + } } dependencies { @@ -19,18 +24,11 @@ dependencies { testLibrary("io.ratpack:ratpack-test:1.7.0") testImplementation(project(":instrumentation:ratpack:ratpack-1.4:testing")) testInstrumentation(project(":instrumentation:ratpack:ratpack-1.4:javaagent")) - - if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_11)) { - testImplementation("com.sun.activation:jakarta.activation:1.2.2") - } } tasks { withType().configureEach { systemProperty("testLatestDeps", findProperty("testLatestDeps") as Boolean) + jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true") } } - -tasks.withType().configureEach { - jvmArgs("-Dotel.instrumentation.common.experimental.controller-telemetry.enabled=true") -} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java index a98e61d4e0f2..992e9583c652 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackInstrumentationModule.java @@ -38,7 +38,6 @@ public ElementMatcher.Junction classLoaderMatcher() { public List typeInstrumentations() { return asList( new DefaultExecControllerInstrumentation(), - new ServerRegistryInstrumentation(), new HttpClientInstrumentation(), new RequestActionSupportInstrumentation()); } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java deleted file mode 100644 index 0e7915b0fb01..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/ServerRegistryInstrumentation.java +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; - -import static net.bytebuddy.matcher.ElementMatchers.isMethod; -import static net.bytebuddy.matcher.ElementMatchers.isStatic; -import static net.bytebuddy.matcher.ElementMatchers.named; - -import io.opentelemetry.javaagent.extension.instrumentation.TypeInstrumentation; -import io.opentelemetry.javaagent.extension.instrumentation.TypeTransformer; -import net.bytebuddy.asm.Advice; -import net.bytebuddy.description.type.TypeDescription; -import net.bytebuddy.matcher.ElementMatcher; -import ratpack.handling.HandlerDecorator; -import ratpack.registry.Registry; - -public class ServerRegistryInstrumentation implements TypeInstrumentation { - - @Override - public ElementMatcher typeMatcher() { - return named("ratpack.server.internal.ServerRegistry"); - } - - @Override - public void transform(TypeTransformer transformer) { - transformer.applyAdviceToMethod( - isMethod().and(isStatic()).and(named("buildBaseRegistry")), - ServerRegistryInstrumentation.class.getName() + "$BuildAdvice"); - } - - @SuppressWarnings("unused") - public static class BuildAdvice { - - @Advice.OnMethodExit(suppress = Throwable.class) - @Advice.AssignReturned.ToReturned - public static Registry injectTracing(@Advice.Return Registry registry) { - return registry.join( - Registry.single(HandlerDecorator.prepend(RatpackSingletons.serverHandler()))); - } - } -} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java index 6a98d8f0a8d9..665f157953a7 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java @@ -38,9 +38,8 @@ protected void configure(HttpClientTestOptions.Builder optionsBuilder) { HttpClientTestOptions.DEFAULT_EXPECTED_CLIENT_SPAN_NAME_MAPPER); optionsBuilder.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/")) { + if (uri.toString().equals("https://192.0.2.1/") + || (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( diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackGetter.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackGetter.java index 4c7b4d7ee76a..b50e28244418 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackGetter.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackGetter.java @@ -13,7 +13,7 @@ * This class is internal and is hence not for public use. Its APIs are unstable and can change at * any time. */ -public enum RatpackGetter implements TextMapGetter { +enum RatpackGetter implements TextMapGetter { INSTANCE; @Override diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpAttributesGetter.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpAttributesGetter.java index b19210901c70..fcf38f576e9f 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpAttributesGetter.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpAttributesGetter.java @@ -17,7 +17,7 @@ * This class is internal and is hence not for public use. Its APIs are unstable and can change at * any time. */ -public enum RatpackHttpAttributesGetter implements HttpServerAttributesGetter { +enum RatpackHttpAttributesGetter implements HttpServerAttributesGetter { INSTANCE; @Override diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpClientAttributesGetter.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpClientAttributesGetter.java index 89615fe523b7..fbf8059096c5 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpClientAttributesGetter.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackHttpClientAttributesGetter.java @@ -15,7 +15,7 @@ * This class is internal and is hence not for public use. Its APIs are unstable and can change at * any time. */ -public enum RatpackHttpClientAttributesGetter +enum RatpackHttpClientAttributesGetter implements HttpClientAttributesGetter { INSTANCE; diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RequestHeaderSetter.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RequestHeaderSetter.java index 9eb9b837f092..f847e7e8271e 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RequestHeaderSetter.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RequestHeaderSetter.java @@ -13,7 +13,7 @@ * This class is internal and is hence not for public use. Its APIs are unstable and can change at * any time. */ -public enum RequestHeaderSetter implements TextMapSetter { +enum RequestHeaderSetter implements TextMapSetter { INSTANCE; @Override From 948e5ba9f5196cb0289f24fe678b53cab22058fc Mon Sep 17 00:00:00 2001 From: John Engelman Date: Fri, 15 Nov 2024 12:11:51 -0600 Subject: [PATCH 08/10] (chore) remove extraneous test dependency --- instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts | 1 - 1 file changed, 1 deletion(-) diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts b/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts index e699d41c1934..eaebce6016a6 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/build.gradle.kts @@ -21,7 +21,6 @@ dependencies { implementation(project(":instrumentation:netty:netty-4.1:library")) implementation(project(":instrumentation:ratpack:ratpack-1.7:library")) - testLibrary("io.ratpack:ratpack-test:1.7.0") testImplementation(project(":instrumentation:ratpack:ratpack-1.4:testing")) testInstrumentation(project(":instrumentation:ratpack:ratpack-1.4:javaagent")) } From 6ad7e61b7b9c7db01a5e6d85dc68c35418de6511 Mon Sep 17 00:00:00 2001 From: John Engelman Date: Mon, 18 Nov 2024 20:23:23 -0600 Subject: [PATCH 09/10] (chore) cleanup from review --- .../ratpack/RatpackForkedHttpClientTest.java | 16 ---- .../ratpack/RatpackHttpClientTest.java | 16 ---- .../ratpack/RatpackPooledHttpClientTest.java | 16 ---- .../client/AbstractRatpackHttpClientTest.java | 74 ++++++++++++------- .../ratpack/v1_7/RatpackSingletons.java | 13 ---- .../RequestActionSupportInstrumentation.java | 2 +- .../v1_7/RatpackForkedHttpClientTest.java | 29 +------- .../ratpack/v1_7/RatpackHttpClientTest.java | 29 +------- .../v1_7/RatpackPooledHttpClientTest.java | 28 +------ .../ratpack/v1_7/RatpackTestSingletons.java | 27 +++++++ ...tpackClientInstrumenterBuilderFactory.java | 2 +- ...tpackServerInstrumenterBuilderFactory.java | 2 +- 12 files changed, 88 insertions(+), 166 deletions(-) create mode 100644 instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestSingletons.java diff --git a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackForkedHttpClientTest.java b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackForkedHttpClientTest.java index bb5e2be158d7..ed453607a20d 100644 --- a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackForkedHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackForkedHttpClientTest.java @@ -5,29 +5,13 @@ package io.opentelemetry.javaagent.instrumentation.ratpack; -import static io.opentelemetry.semconv.ServerAttributes.SERVER_ADDRESS; -import static io.opentelemetry.semconv.ServerAttributes.SERVER_PORT; - -import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackForkedHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; -import java.net.URI; -import java.util.HashSet; -import java.util.Set; import org.junit.jupiter.api.extension.RegisterExtension; class RatpackForkedHttpClientTest extends AbstractRatpackForkedHttpClientTest { @RegisterExtension static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); - - @Override - protected Set> computeHttpAttributes(URI uri) { - Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); - // underlying netty instrumentation does not provide these - attributes.remove(SERVER_ADDRESS); - attributes.remove(SERVER_PORT); - return attributes; - } } 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 972b2f6676fe..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 @@ -5,29 +5,13 @@ package io.opentelemetry.javaagent.instrumentation.ratpack; -import static io.opentelemetry.semconv.ServerAttributes.SERVER_ADDRESS; -import static io.opentelemetry.semconv.ServerAttributes.SERVER_PORT; - -import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; -import java.net.URI; -import java.util.HashSet; -import java.util.Set; import org.junit.jupiter.api.extension.RegisterExtension; class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { @RegisterExtension static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); - - @Override - protected Set> computeHttpAttributes(URI uri) { - Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); - // underlying netty instrumentation does not provide these - attributes.remove(SERVER_ADDRESS); - attributes.remove(SERVER_PORT); - return attributes; - } } diff --git a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackPooledHttpClientTest.java b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackPooledHttpClientTest.java index 6a5c668b7037..1b5863d5b0b1 100644 --- a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackPooledHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackPooledHttpClientTest.java @@ -5,29 +5,13 @@ package io.opentelemetry.javaagent.instrumentation.ratpack; -import static io.opentelemetry.semconv.ServerAttributes.SERVER_ADDRESS; -import static io.opentelemetry.semconv.ServerAttributes.SERVER_PORT; - -import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackPooledHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; -import java.net.URI; -import java.util.HashSet; -import java.util.Set; import org.junit.jupiter.api.extension.RegisterExtension; class RatpackPooledHttpClientTest extends AbstractRatpackPooledHttpClientTest { @RegisterExtension static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); - - @Override - protected Set> computeHttpAttributes(URI uri) { - Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); - // underlying netty instrumentation does not provide these - attributes.remove(SERVER_ADDRESS); - attributes.remove(SERVER_PORT); - return attributes; - } } diff --git a/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/client/AbstractRatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/client/AbstractRatpackHttpClientTest.java index f5626cefd2ec..3e3ed9a1f6f1 100644 --- a/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/client/AbstractRatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/client/AbstractRatpackHttpClientTest.java @@ -5,15 +5,20 @@ package io.opentelemetry.instrumentation.ratpack.client; +import static io.opentelemetry.semconv.ServerAttributes.SERVER_ADDRESS; +import static io.opentelemetry.semconv.ServerAttributes.SERVER_PORT; + import io.netty.channel.ConnectTimeoutException; import io.netty.handler.timeout.ReadTimeoutException; import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientResult; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; +import io.opentelemetry.semconv.NetworkAttributes; import java.net.URI; import java.time.Duration; import java.util.Collections; +import java.util.HashSet; import java.util.Map; import java.util.Set; import org.junit.jupiter.api.AfterAll; @@ -122,32 +127,13 @@ protected void configure(HttpClientTestOptions.Builder optionsBuilder) { .getValueOrThrow(); }); - optionsBuilder.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); - } - }); + if (useNettyClientAttributes()) { + optionsBuilder.setExpectedClientSpanNameMapper( + AbstractRatpackHttpClientTest::nettyExpectedClientSpanNameMapper); + } optionsBuilder.setClientSpanErrorMapper( - (uri, exception) -> { - if (uri.toString().equals("https://192.0.2.1/")) { - return new ConnectTimeoutException( - "connection timed out" - + (Boolean.getBoolean("testLatestDeps") ? " after 2000 ms" : "") - + ": /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; - }); + AbstractRatpackHttpClientTest::nettyClientSpanErrorMapper); optionsBuilder.setHttpAttributes(this::computeHttpAttributes); @@ -164,7 +150,45 @@ protected Set> computeHttpAttributes(URI uri) { case "https://192.0.2.1/": // non routable address return Collections.emptySet(); default: - return HttpClientTestOptions.DEFAULT_HTTP_ATTRIBUTES; + HashSet> attributes = + new HashSet<>(HttpClientTestOptions.DEFAULT_HTTP_ATTRIBUTES); + if (useNettyClientAttributes()) { + // underlying netty instrumentation does not provide these + attributes.remove(SERVER_ADDRESS); + attributes.remove(SERVER_PORT); + } else { + // ratpack client instrumentation does not provide this + attributes.remove(NetworkAttributes.NETWORK_PROTOCOL_VERSION); + } + return attributes; + } + } + + protected boolean useNettyClientAttributes() { + return true; + } + + private static Throwable nettyClientSpanErrorMapper(URI uri, Throwable exception) { + if (uri.toString().equals("https://192.0.2.1/")) { + return new ConnectTimeoutException( + "connection timed out" + + (Boolean.getBoolean("testLatestDeps") ? " after 2000 ms" : "") + + ": /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; + } + + private static String nettyExpectedClientSpanNameMapper(URI uri, String 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); } } } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java index e7672f559706..8c0adac4ba75 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackSingletons.java @@ -11,9 +11,7 @@ import io.opentelemetry.instrumentation.netty.v4_1.internal.AttributeKeys; import io.opentelemetry.instrumentation.ratpack.v1_7.internal.ContextHolder; import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryHttpClient; -import io.opentelemetry.instrumentation.ratpack.v1_7.internal.OpenTelemetryServerHandler; import io.opentelemetry.instrumentation.ratpack.v1_7.internal.RatpackClientInstrumenterBuilderFactory; -import io.opentelemetry.instrumentation.ratpack.v1_7.internal.RatpackServerInstrumenterBuilderFactory; import io.opentelemetry.javaagent.bootstrap.internal.AgentCommonConfig; import ratpack.exec.Execution; @@ -26,25 +24,14 @@ public final class RatpackSingletons { "io.opentelemetry.ratpack-1.7", GlobalOpenTelemetry.get()) .configure(AgentCommonConfig.get()) .build()); - SERVER_HANDLER = - new OpenTelemetryServerHandler( - RatpackServerInstrumenterBuilderFactory.create( - "io.opentelemetry.ratpack-1.7", GlobalOpenTelemetry.get()) - .configure(AgentCommonConfig.get()) - .build()); } private static final OpenTelemetryHttpClient HTTP_CLIENT; - private static final OpenTelemetryServerHandler SERVER_HANDLER; public static OpenTelemetryHttpClient httpClient() { return HTTP_CLIENT; } - public static OpenTelemetryServerHandler serverHandler() { - return SERVER_HANDLER; - } - public static void propagateContextToChannel(Execution execution, Channel channel) { Context parentContext = execution diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java index 16952ab1c4d4..10be05690e86 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RequestActionSupportInstrumentation.java @@ -77,7 +77,7 @@ public static class ContextAdvice { public static Scope injectChannelAttribute( @Advice.FieldValue("execution") Execution execution) { - // Capture the CLIENT span and make it current before cally Netty layer + // Capture the CLIENT span and make it current before calling Netty layer return execution .maybeGet(ContextHolder.class) .map(ContextHolder::context) diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java index 36fd784b9242..4e2e6f0a7881 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java @@ -5,19 +5,11 @@ package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; -import io.netty.channel.ConnectTimeoutException; -import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackForkedHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; -import io.opentelemetry.semconv.NetworkAttributes; -import java.net.URI; -import java.util.HashSet; -import java.util.Set; -import org.junit.jupiter.api.condition.OS; import org.junit.jupiter.api.extension.RegisterExtension; -import ratpack.http.client.HttpClientReadTimeoutException; class RatpackForkedHttpClientTest extends AbstractRatpackForkedHttpClientTest { @@ -25,28 +17,13 @@ class RatpackForkedHttpClientTest extends AbstractRatpackForkedHttpClientTest { static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); @Override - protected Set> computeHttpAttributes(URI uri) { - Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); - attributes.remove(NetworkAttributes.NETWORK_PROTOCOL_VERSION); - return attributes; + protected boolean useNettyClientAttributes() { + return false; } @Override protected void configure(HttpClientTestOptions.Builder optionsBuilder) { super.configure(optionsBuilder); - optionsBuilder.setExpectedClientSpanNameMapper( - HttpClientTestOptions.DEFAULT_EXPECTED_CLIENT_SPAN_NAME_MAPPER); - optionsBuilder.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; - }); + optionsBuilder.setClientSpanErrorMapper(RatpackTestSingletons::ratpackClientSpanErrorMapper); } } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java index 4955089b76e8..43185c2d1cde 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java @@ -5,19 +5,11 @@ package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; -import io.netty.channel.ConnectTimeoutException; -import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; -import io.opentelemetry.semconv.NetworkAttributes; -import java.net.URI; -import java.util.HashSet; -import java.util.Set; -import org.junit.jupiter.api.condition.OS; import org.junit.jupiter.api.extension.RegisterExtension; -import ratpack.http.client.HttpClientReadTimeoutException; class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { @@ -25,28 +17,13 @@ class RatpackHttpClientTest extends AbstractRatpackHttpClientTest { static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); @Override - protected Set> computeHttpAttributes(URI uri) { - Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); - attributes.remove(NetworkAttributes.NETWORK_PROTOCOL_VERSION); - return attributes; + protected boolean useNettyClientAttributes() { + return false; } @Override protected void configure(HttpClientTestOptions.Builder optionsBuilder) { super.configure(optionsBuilder); - optionsBuilder.setExpectedClientSpanNameMapper( - HttpClientTestOptions.DEFAULT_EXPECTED_CLIENT_SPAN_NAME_MAPPER); - optionsBuilder.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; - }); + optionsBuilder.setClientSpanErrorMapper(RatpackTestSingletons::ratpackClientSpanErrorMapper); } } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java index 665f157953a7..5c5d68a6438f 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java @@ -5,19 +5,11 @@ package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; -import io.netty.channel.ConnectTimeoutException; -import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackPooledHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientInstrumentationExtension; import io.opentelemetry.instrumentation.testing.junit.http.HttpClientTestOptions; -import io.opentelemetry.semconv.NetworkAttributes; -import java.net.URI; -import java.util.HashSet; -import java.util.Set; -import org.junit.jupiter.api.condition.OS; import org.junit.jupiter.api.extension.RegisterExtension; -import ratpack.http.client.HttpClientReadTimeoutException; class RatpackPooledHttpClientTest extends AbstractRatpackPooledHttpClientTest { @@ -25,27 +17,13 @@ class RatpackPooledHttpClientTest extends AbstractRatpackPooledHttpClientTest { static final InstrumentationExtension testing = HttpClientInstrumentationExtension.forAgent(); @Override - protected Set> computeHttpAttributes(URI uri) { - Set> attributes = new HashSet<>(super.computeHttpAttributes(uri)); - attributes.remove(NetworkAttributes.NETWORK_PROTOCOL_VERSION); - return attributes; + protected boolean useNettyClientAttributes() { + return false; } @Override protected void configure(HttpClientTestOptions.Builder optionsBuilder) { super.configure(optionsBuilder); - optionsBuilder.setExpectedClientSpanNameMapper( - HttpClientTestOptions.DEFAULT_EXPECTED_CLIENT_SPAN_NAME_MAPPER); - optionsBuilder.setClientSpanErrorMapper( - (uri, exception) -> { - if (uri.toString().equals("https://192.0.2.1/") - || (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; - }); + optionsBuilder.setClientSpanErrorMapper(RatpackTestSingletons::ratpackClientSpanErrorMapper); } } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestSingletons.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestSingletons.java new file mode 100644 index 000000000000..63a103a93b63 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestSingletons.java @@ -0,0 +1,27 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; + +import io.netty.channel.ConnectTimeoutException; +import java.net.URI; +import org.junit.jupiter.api.condition.OS; +import ratpack.http.client.HttpClientReadTimeoutException; + +public final class RatpackTestSingletons { + + private RatpackTestSingletons() {} + + public static Throwable ratpackClientSpanErrorMapper(URI uri, Throwable exception) { + if (uri.toString().equals("https://192.0.2.1/") + || (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; + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackClientInstrumenterBuilderFactory.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackClientInstrumenterBuilderFactory.java index 37d4ea5508b3..c5a0999dea35 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackClientInstrumenterBuilderFactory.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackClientInstrumenterBuilderFactory.java @@ -14,7 +14,7 @@ * This class is internal and is hence not for public use. Its APIs are unstable and can change at * any time. */ -public class RatpackClientInstrumenterBuilderFactory { +public final class RatpackClientInstrumenterBuilderFactory { private RatpackClientInstrumenterBuilderFactory() {} public static DefaultHttpClientInstrumenterBuilder create( diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackServerInstrumenterBuilderFactory.java b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackServerInstrumenterBuilderFactory.java index 8cce9e84928a..c0539634ab8f 100644 --- a/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackServerInstrumenterBuilderFactory.java +++ b/instrumentation/ratpack/ratpack-1.7/library/src/main/java/io/opentelemetry/instrumentation/ratpack/v1_7/internal/RatpackServerInstrumenterBuilderFactory.java @@ -14,7 +14,7 @@ * This class is internal and is hence not for public use. Its APIs are unstable and can change at * any time. */ -public class RatpackServerInstrumenterBuilderFactory { +public final class RatpackServerInstrumenterBuilderFactory { private RatpackServerInstrumenterBuilderFactory() {} From f28eb5a90e704e48ef5e6eaea2a3a75b3448f74d Mon Sep 17 00:00:00 2001 From: John Engelman Date: Wed, 20 Nov 2024 09:07:34 -0600 Subject: [PATCH 10/10] (chore) rename class for clarity --- .../ratpack/v1_7/RatpackForkedHttpClientTest.java | 2 +- .../instrumentation/ratpack/v1_7/RatpackHttpClientTest.java | 2 +- .../ratpack/v1_7/RatpackPooledHttpClientTest.java | 2 +- .../{RatpackTestSingletons.java => RatpackTestUtils.java} | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) rename instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/{RatpackTestSingletons.java => RatpackTestUtils.java} (91%) diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java index 4e2e6f0a7881..509d08576c80 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java @@ -24,6 +24,6 @@ protected boolean useNettyClientAttributes() { @Override protected void configure(HttpClientTestOptions.Builder optionsBuilder) { super.configure(optionsBuilder); - optionsBuilder.setClientSpanErrorMapper(RatpackTestSingletons::ratpackClientSpanErrorMapper); + optionsBuilder.setClientSpanErrorMapper(RatpackTestUtils::ratpackClientSpanErrorMapper); } } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java index 43185c2d1cde..53e6e22734d5 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java @@ -24,6 +24,6 @@ protected boolean useNettyClientAttributes() { @Override protected void configure(HttpClientTestOptions.Builder optionsBuilder) { super.configure(optionsBuilder); - optionsBuilder.setClientSpanErrorMapper(RatpackTestSingletons::ratpackClientSpanErrorMapper); + optionsBuilder.setClientSpanErrorMapper(RatpackTestUtils::ratpackClientSpanErrorMapper); } } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java index 5c5d68a6438f..396b4db4da64 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java @@ -24,6 +24,6 @@ protected boolean useNettyClientAttributes() { @Override protected void configure(HttpClientTestOptions.Builder optionsBuilder) { super.configure(optionsBuilder); - optionsBuilder.setClientSpanErrorMapper(RatpackTestSingletons::ratpackClientSpanErrorMapper); + optionsBuilder.setClientSpanErrorMapper(RatpackTestUtils::ratpackClientSpanErrorMapper); } } diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestSingletons.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestUtils.java similarity index 91% rename from instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestSingletons.java rename to instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestUtils.java index 63a103a93b63..4c4a9418f507 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestSingletons.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestUtils.java @@ -10,9 +10,9 @@ import org.junit.jupiter.api.condition.OS; import ratpack.http.client.HttpClientReadTimeoutException; -public final class RatpackTestSingletons { +public final class RatpackTestUtils { - private RatpackTestSingletons() {} + private RatpackTestUtils() {} public static Throwable ratpackClientSpanErrorMapper(URI uri, Throwable exception) { if (uri.toString().equals("https://192.0.2.1/")