diff --git a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/groovy/server/RatpackAsyncHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/groovy/server/RatpackAsyncHttpServerTest.groovy deleted file mode 100644 index dc1cc42df27f..000000000000 --- a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/groovy/server/RatpackAsyncHttpServerTest.groovy +++ /dev/null @@ -1,22 +0,0 @@ -/* - * 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.4/javaagent/src/test/groovy/server/RatpackForkedHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/groovy/server/RatpackForkedHttpServerTest.groovy deleted file mode 100644 index 87dc2848b1ff..000000000000 --- a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/groovy/server/RatpackForkedHttpServerTest.groovy +++ /dev/null @@ -1,27 +0,0 @@ -/* - * 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.4/javaagent/src/test/groovy/server/RatpackHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/groovy/server/RatpackHttpServerTest.groovy deleted file mode 100644 index e21d36c4dc7b..000000000000 --- a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/groovy/server/RatpackHttpServerTest.groovy +++ /dev/null @@ -1,23 +0,0 @@ -/* - * 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.4/javaagent/src/test/groovy/server/RatpackRoutesTest.groovy b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/groovy/server/RatpackRoutesTest.groovy deleted file mode 100644 index e52bd4f93c1e..000000000000 --- a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/groovy/server/RatpackRoutesTest.groovy +++ /dev/null @@ -1,21 +0,0 @@ -/* - * 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.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/client/RatpackForkedHttpClientTest.java similarity index 90% rename from instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackForkedHttpClientTest.java rename to instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/client/RatpackForkedHttpClientTest.java index ed453607a20d..cf0e73b15044 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/client/RatpackForkedHttpClientTest.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.javaagent.instrumentation.ratpack; +package io.opentelemetry.javaagent.instrumentation.ratpack.client; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackForkedHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; 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/client/RatpackHttpClientTest.java similarity index 89% rename from instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackHttpClientTest.java rename to instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/client/RatpackHttpClientTest.java index 13b941a21879..837fcf39b57a 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/client/RatpackHttpClientTest.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.javaagent.instrumentation.ratpack; +package io.opentelemetry.javaagent.instrumentation.ratpack.client; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; 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/client/RatpackPooledHttpClientTest.java similarity index 90% rename from instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/RatpackPooledHttpClientTest.java rename to instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/client/RatpackPooledHttpClientTest.java index 1b5863d5b0b1..fb8eca4f3dbf 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/client/RatpackPooledHttpClientTest.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.javaagent.instrumentation.ratpack; +package io.opentelemetry.javaagent.instrumentation.ratpack.client; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackPooledHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; diff --git a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackAsyncHttpServerTest.java b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackAsyncHttpServerTest.java new file mode 100644 index 000000000000..7ee79d7dfbdd --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackAsyncHttpServerTest.java @@ -0,0 +1,30 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.server; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackAsyncHttpServerTest; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackAsyncHttpServerTest extends AbstractRatpackAsyncHttpServerTest { + + @RegisterExtension + public static final InstrumentationExtension testing = + HttpServerInstrumentationExtension.forAgent(); + + @Override + protected void configure(RatpackServerSpec serverSpec) {} + + @Override + protected void configure(HttpServerTestOptions options) { + super.configure(options); + + options.setHasResponseCustomizer(endpoint -> true); + } +} diff --git a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackForkedHttpServerTest.java b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackForkedHttpServerTest.java new file mode 100644 index 000000000000..ccc0f634f5fa --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackForkedHttpServerTest.java @@ -0,0 +1,31 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.server; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackForkedHttpServerTest; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackForkedHttpServerTest extends AbstractRatpackForkedHttpServerTest { + + @RegisterExtension + public static final InstrumentationExtension testing = + HttpServerInstrumentationExtension.forAgent(); + + @Override + protected void configure(RatpackServerSpec serverSpec) {} + + @Override + protected void configure(HttpServerTestOptions options) { + super.configure(options); + + options.setHasResponseCustomizer(endpoint -> true); + options.setTestHttpPipelining(false); + } +} diff --git a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackHttpServerTest.java b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackHttpServerTest.java new file mode 100644 index 000000000000..278704d4e8d3 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackHttpServerTest.java @@ -0,0 +1,30 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.server; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackHttpServerTest; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackHttpServerTest extends AbstractRatpackHttpServerTest { + + @RegisterExtension + public static final InstrumentationExtension testing = + HttpServerInstrumentationExtension.forAgent(); + + @Override + protected void configure(RatpackServerSpec serverSpec) {} + + @Override + protected void configure(HttpServerTestOptions options) { + super.configure(options); + + options.setHasResponseCustomizer(endpoint -> true); + } +} diff --git a/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackRoutesTest.java b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackRoutesTest.java new file mode 100644 index 000000000000..84492a179693 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.4/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/server/RatpackRoutesTest.java @@ -0,0 +1,31 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.server; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackRoutesTest; +import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackRoutesTest extends AbstractRatpackRoutesTest { + + @RegisterExtension + static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); + + @Override + protected InstrumentationExtension testing() { + return testing; + } + + @Override + protected void configure(RatpackServerSpec serverSpec) {} + + @Override + protected boolean hasHandlerSpan() { + return true; + } +} diff --git a/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackAsyncHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackAsyncHttpServerTest.groovy deleted file mode 100644 index 4a207b4c3cf7..000000000000 --- a/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackAsyncHttpServerTest.groovy +++ /dev/null @@ -1,142 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack.server - -import ratpack.error.ServerErrorHandler -import ratpack.exec.Promise -import ratpack.server.RatpackServer - -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_HEADERS -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.ERROR -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.INDEXED_CHILD -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.PATH_PARAM -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.QUERY_PARAM -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.SUCCESS - -abstract class AbstractRatpackAsyncHttpServerTest extends AbstractRatpackHttpServerTest { - - @Override - RatpackServer startServer(int bindPort) { - def ratpack = RatpackServer.start { - it.serverConfig { - it.port(bindPort) - it.address(InetAddress.getByName("localhost")) - } - it.handlers { - it.register { - it.add(ServerErrorHandler, new TestErrorHandler()) - } - it.prefix(SUCCESS.rawPath()) { - it.all { context -> - Promise.sync { - SUCCESS - } then { endpoint -> - controller(endpoint) { - context.response.status(endpoint.status).send(endpoint.body) - } - } - } - } - it.prefix(INDEXED_CHILD.rawPath()) { - it.all { context -> - Promise.sync { - INDEXED_CHILD - } then { - controller(INDEXED_CHILD) { - INDEXED_CHILD.collectSpanAttributes { context.request.queryParams.get(it) } - context.response.status(INDEXED_CHILD.status).send() - } - } - } - } - it.prefix(QUERY_PARAM.rawPath()) { - it.all { context -> - Promise.sync { - QUERY_PARAM - } then { endpoint -> - controller(endpoint) { - context.response.status(endpoint.status).send(context.request.query) - } - } - } - } - it.prefix(REDIRECT.rawPath()) { - it.all { context -> - Promise.sync { - REDIRECT - } then { endpoint -> - controller(endpoint) { - context.redirect(endpoint.body) - } - } - } - } - it.prefix(ERROR.rawPath()) { - it.all { context -> - Promise.sync { - ERROR - } then { endpoint -> - controller(endpoint) { - context.response.status(endpoint.status).send(endpoint.body) - } - } - } - } - it.prefix(EXCEPTION.rawPath()) { - it.all { - Promise.sync { - EXCEPTION - } then { endpoint -> - controller(endpoint) { - throw new Exception(endpoint.body) - } - } - } - } - it.prefix("path/:id/param") { - it.all { context -> - Promise.sync { - PATH_PARAM - } then { endpoint -> - controller(endpoint) { - context.response.status(endpoint.status).send(context.pathTokens.id) - } - } - } - } - it.prefix(CAPTURE_HEADERS.rawPath()) { - it.all { context -> - Promise.sync { - CAPTURE_HEADERS - } then { endpoint -> - controller(endpoint) { - context.response.status(endpoint.status) - context.response.headers.set("X-Test-Response", context.request.headers.get("X-Test-Request")) - context.response.send(endpoint.body) - } - } - } - } - it.prefix(POST_STREAM.rawPath()) { - it.all { context -> - Promise.sync { - POST_STREAM - } then { - handlePostStream(context) - } - } - } - } - configure(it) - } - - assert ratpack.bindPort == bindPort - assert ratpack.bindHost == 'localhost' - return ratpack - } -} diff --git a/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackForkedHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackForkedHttpServerTest.groovy deleted file mode 100644 index 925e409769e1..000000000000 --- a/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackForkedHttpServerTest.groovy +++ /dev/null @@ -1,206 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack.server - -import io.opentelemetry.api.trace.SpanKind -import io.opentelemetry.testing.internal.armeria.common.AggregatedHttpRequest -import io.opentelemetry.testing.internal.armeria.common.AggregatedHttpResponse -import io.opentelemetry.testing.internal.armeria.common.HttpMethod -import ratpack.error.ServerErrorHandler -import ratpack.exec.Execution -import ratpack.exec.Promise -import ratpack.exec.Result -import ratpack.exec.util.ParallelBatch -import ratpack.server.RatpackServer - -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_HEADERS -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.ERROR -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.INDEXED_CHILD -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.PATH_PARAM -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.QUERY_PARAM -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.SUCCESS - -abstract class AbstractRatpackForkedHttpServerTest extends AbstractRatpackHttpServerTest { - - @Override - RatpackServer startServer(int bindPort) { - - def ratpack = RatpackServer.start { - it.serverConfig { - it.port(bindPort) - it.address(InetAddress.getByName("localhost")) - } - it.handlers { - it.register { - it.add(ServerErrorHandler, new TestErrorHandler()) - } - it.prefix(SUCCESS.rawPath()) { - it.all { context -> - Promise.sync { - SUCCESS - }.fork().then { endpoint -> - controller(endpoint) { - context.response.status(endpoint.status).send(endpoint.body) - } - } - } - } - it.prefix(INDEXED_CHILD.rawPath()) { - it.all { context -> - Promise.sync { - INDEXED_CHILD - }.fork().then { - controller(INDEXED_CHILD) { - INDEXED_CHILD.collectSpanAttributes { context.request.queryParams.get(it) } - context.response.status(INDEXED_CHILD.status).send() - } - } - } - } - it.prefix(QUERY_PARAM.rawPath()) { - it.all { context -> - Promise.sync { - QUERY_PARAM - }.fork().then { endpoint -> - controller(endpoint) { - context.response.status(endpoint.status).send(context.request.query) - } - } - } - } - it.prefix(REDIRECT.rawPath()) { - it.all { context -> - Promise.sync { - REDIRECT - }.fork().then { endpoint -> - controller(endpoint) { - context.redirect(endpoint.body) - } - } - } - } - it.prefix(ERROR.rawPath()) { - it.all { context -> - Promise.sync { - ERROR - }.fork().then { endpoint -> - controller(endpoint) { - context.response.status(endpoint.status).send(endpoint.body) - } - } - } - } - it.prefix(EXCEPTION.rawPath()) { - it.all { - Promise.sync { - EXCEPTION - }.fork().then { endpoint -> - controller(endpoint) { - throw new Exception(endpoint.body) - } - } - } - } - it.prefix("path/:id/param") { - it.all { context -> - Promise.sync { - PATH_PARAM - }.fork().then { endpoint -> - controller(endpoint) { - context.response.status(endpoint.status).send(context.pathTokens.id) - } - } - } - } - it.prefix(CAPTURE_HEADERS.rawPath()) { - it.all { context -> - Promise.sync { - CAPTURE_HEADERS - }.fork().then { endpoint -> - controller(endpoint) { - context.response.status(endpoint.status) - context.response.headers.set("X-Test-Response", context.request.headers.get("X-Test-Request")) - context.response.send(endpoint.body) - } - } - } - } - it.prefix(POST_STREAM.rawPath()) { - it.all { context -> - Promise.sync { - POST_STREAM - }.fork().then { - handlePostStream(context) - } - } - } - it.prefix("fork_and_yieldAll") { - it.all { context -> - def promise = Promise.async { upstream -> - Execution.fork().start({ - upstream.accept(Result.success(SUCCESS)) - }) - } - ParallelBatch.of(promise).yieldAll().flatMap { list -> - Promise.sync { list.get(0).value } - } then { endpoint -> - controller(endpoint) { - context.response.status(endpoint.status).send(endpoint.body) - } - } - } - } - } - configure(it) - } - - assert ratpack.bindPort == bindPort - assert ratpack.bindHost == 'localhost' - return ratpack - } - - def "test fork and yieldAll"() { - setup: - def url = address.resolve("fork_and_yieldAll").toString() - url = url.replace("http://", "h1c://") - def request = AggregatedHttpRequest.of(HttpMethod.GET, url) - AggregatedHttpResponse response = client.execute(request).aggregate().join() - - expect: - response.status().code() == SUCCESS.status - response.contentUtf8() == SUCCESS.body - - assertTraces(1) { - trace(0, 2 + (hasHandlerSpan(SUCCESS) ? 1 : 0)) { - span(0) { - name "GET /fork_and_yieldAll" - kind SpanKind.SERVER - hasNoParent() - } - if (hasHandlerSpan(SUCCESS)) { - span(1) { - name "/fork_and_yieldAll" - kind SpanKind.INTERNAL - childOf span(0) - } - span(2) { - name "controller" - kind SpanKind.INTERNAL - childOf span(1) - } - } else { - span(1) { - name "controller" - kind SpanKind.INTERNAL - childOf span(0) - } - } - } - } - } -} diff --git a/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackHttpServerTest.groovy deleted file mode 100644 index d147b637cca2..000000000000 --- a/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackHttpServerTest.groovy +++ /dev/null @@ -1,274 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack.server - -import io.netty.buffer.ByteBuf -import io.opentelemetry.api.trace.Span -import io.opentelemetry.api.trace.StatusCode -import io.opentelemetry.instrumentation.test.asserts.TraceAssert -import io.opentelemetry.instrumentation.test.base.HttpServerTest -import io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint -import io.opentelemetry.sdk.trace.data.SpanData -import org.junit.Assume -import org.reactivestreams.Subscriber -import org.reactivestreams.Subscription -import ratpack.error.ServerErrorHandler -import ratpack.handling.Context -import ratpack.server.RatpackServer -import ratpack.server.RatpackServerSpec - -import static io.opentelemetry.api.trace.SpanKind.INTERNAL -import static io.opentelemetry.api.trace.SpanKind.SERVER -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_HEADERS -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.ERROR -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.INDEXED_CHILD -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.PATH_PARAM -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.QUERY_PARAM -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT -import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.SUCCESS - -abstract class AbstractRatpackHttpServerTest extends HttpServerTest { - - protected static final ServerEndpoint POST_STREAM = - new ServerEndpoint( - "POST_STREAM", - "post-stream", - SUCCESS.getStatus(), - SUCCESS.getBody(), - false) - - abstract void configure(RatpackServerSpec serverSpec) - - @Override - RatpackServer startServer(int bindPort) { - def ratpack = RatpackServer.start { - it.serverConfig { - it.port(bindPort) - it.address(InetAddress.getByName("localhost")) - } - it.handlers { - it.register { - it.add(ServerErrorHandler, new TestErrorHandler()) - } - it.prefix(SUCCESS.rawPath()) { - it.all { context -> - controller(SUCCESS) { - context.response.status(SUCCESS.status).send(SUCCESS.body) - } - } - } - it.prefix(INDEXED_CHILD.rawPath()) { - it.all { context -> - controller(INDEXED_CHILD) { - INDEXED_CHILD.collectSpanAttributes { context.request.queryParams.get(it) } - context.response.status(INDEXED_CHILD.status).send() - } - } - } - it.prefix(QUERY_PARAM.rawPath()) { - it.all { context -> - controller(QUERY_PARAM) { - context.response.status(QUERY_PARAM.status).send(context.request.query) - } - } - } - it.prefix(REDIRECT.rawPath()) { - it.all { context -> - controller(REDIRECT) { - context.redirect(REDIRECT.body) - } - } - } - it.prefix(ERROR.rawPath()) { - it.all { context -> - controller(ERROR) { - context.response.status(ERROR.status).send(ERROR.body) - } - } - } - it.prefix(EXCEPTION.rawPath()) { - it.all { - controller(EXCEPTION) { - throw new Exception(EXCEPTION.body) - } - } - } - it.prefix("path/:id/param") { - it.all { context -> - controller(PATH_PARAM) { - context.response.status(PATH_PARAM.status).send(context.pathTokens.id) - } - } - } - it.prefix(CAPTURE_HEADERS.rawPath()) { - it.all { context -> - controller(CAPTURE_HEADERS) { - context.response.status(CAPTURE_HEADERS.status) - context.response.headers.set("X-Test-Response", context.request.headers.get("X-Test-Request")) - context.response.send(CAPTURE_HEADERS.body) - } - } - } - it.prefix(POST_STREAM.rawPath()) { - it.all { context -> - handlePostStream(context) - } - } - } - configure(it) - } - - assert ratpack.bindPort == bindPort - return ratpack - } - - def handlePostStream(context) { - controller(POST_STREAM) { - context.request.bodyStream.subscribe(new Subscriber() { - private Subscription subscription - private int count - private String traceId - - @Override - void onSubscribe(Subscription subscription) { - this.subscription = subscription - traceId = Span.current().getSpanContext().getTraceId() - subscription.request(1) - } - - @Override - void onNext(ByteBuf byteBuf) { - assert traceId == Span.current().getSpanContext().getTraceId() - if (count < 2) { - runWithSpan("onNext") { - count++ - } - } - byteBuf.release() - subscription.request(1) - } - - @Override - void onError(Throwable throwable) { - // prints the assertion error from onNext - throwable.printStackTrace() - context.response.status(500).send(throwable.message) - } - - @Override - void onComplete() { - runWithSpan("onComplete") { - context.response.status(200).send(POST_STREAM.body) - } - } - }) - } - } - - // TODO(anuraaga): The default Ratpack error handler also returns a 500 which is all we test, so - // we don't actually have test coverage ensuring our instrumentation correctly delegates to this - // user registered handler. - static class TestErrorHandler implements ServerErrorHandler { - @Override - void error(Context context, Throwable throwable) throws Exception { - context.response.status(500).send(throwable.message) - } - } - - @Override - void stopServer(RatpackServer server) { - server.stop() - } - - @Override - boolean hasHandlerSpan(ServerEndpoint endpoint) { - true - } - - @Override - boolean testPathParam() { - true - } - - @Override - boolean verifyServerSpanEndTime() { - // server spans are ended inside of the controller spans - return false - } - - @Override - void handlerSpan(TraceAssert trace, int index, Object parent, String method = "GET", ServerEndpoint endpoint = SUCCESS) { - trace.span(index) { - name endpoint.status == 404 ? "/" : endpoint == PATH_PARAM ? "/path/:id/param" : endpoint.path - kind INTERNAL - childOf((SpanData) parent) - if (endpoint == EXCEPTION) { - status StatusCode.ERROR - errorEvent(Exception, EXCEPTION.body) - } - } - } - - @Override - String expectedHttpRoute(ServerEndpoint endpoint, String method) { - return endpoint.status == 404 ? "/" : endpoint == PATH_PARAM ? "/path/:id/param" : endpoint.path - } - - boolean testPostStream() { - true - } - - def "test post stream"() { - Assume.assumeTrue(testPostStream()) - - when: - // body should be large enough to trigger multiple calls to onNext - def body = "foobar" * 10000 - def response = client.post(resolveAddress(POST_STREAM), body).aggregate().join() - - then: - response.status().code() == POST_STREAM.status - response.contentUtf8() == POST_STREAM.body - - def hasHandlerSpan = hasHandlerSpan(POST_STREAM) - // when using javaagent instrumentation the parent of reactive callbacks is the controller span - // where subscribe was called, for library instrumentation server span is the parent - def reactiveCallbackParent = hasHandlerSpan ? 2 : 0 - assertTraces(1) { - trace(0, 5 + (hasHandlerSpan ? 1 : 0)) { - span(0) { - name "POST /post-stream" - kind SERVER - hasNoParent() - } - if (hasHandlerSpan) { - span(1) { - name "/post-stream" - childOf span(0) - } - } - def offset = hasHandlerSpan ? 1 : 0 - span(1 + offset) { - name "controller" - childOf span(offset) - } - span(2 + offset) { - name "onNext" - childOf span(reactiveCallbackParent) - } - span(3 + offset) { - name "onNext" - childOf span(reactiveCallbackParent) - } - span(4 + offset) { - name "onComplete" - childOf span(reactiveCallbackParent) - } - } - } - } -} diff --git a/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackRoutesTest.groovy b/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackRoutesTest.groovy deleted file mode 100644 index cbe8b560fd4a..000000000000 --- a/instrumentation/ratpack/ratpack-1.4/testing/src/main/groovy/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackRoutesTest.groovy +++ /dev/null @@ -1,143 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack.server - -import io.opentelemetry.instrumentation.test.InstrumentationSpecification -import io.opentelemetry.instrumentation.test.utils.PortUtils -import io.opentelemetry.semconv.ServerAttributes -import io.opentelemetry.semconv.ClientAttributes -import io.opentelemetry.semconv.UserAgentAttributes -import io.opentelemetry.semconv.HttpAttributes -import io.opentelemetry.semconv.NetworkAttributes -import io.opentelemetry.semconv.UrlAttributes -import io.opentelemetry.testing.internal.armeria.client.WebClient -import ratpack.path.PathBinding -import ratpack.server.RatpackServer -import ratpack.server.RatpackServerSpec -import spock.lang.Shared -import spock.lang.Unroll - -import static io.opentelemetry.api.trace.SpanKind.INTERNAL -import static io.opentelemetry.api.trace.SpanKind.SERVER - -@Unroll -abstract class AbstractRatpackRoutesTest extends InstrumentationSpecification { - - abstract void configure(RatpackServerSpec serverSpec) - - @Shared - RatpackServer app - - // Force HTTP/1 with h1c to prevent tracing of upgrade request. - @Shared - WebClient client - - def setupSpec() { - app = RatpackServer.start { - it.serverConfig { - it.port(PortUtils.findOpenPort()) - it.address(InetAddress.getByName("localhost")) - } - it.handlers { - it.prefix("a") { - it.all { context -> - context.render(context.get(PathBinding).description) - } - } - it.prefix("b/::\\d+") { - it.all { context -> - context.render(context.get(PathBinding).description) - } - } - it.prefix("c/:val?") { - it.all { context -> - context.render(context.get(PathBinding).description) - } - } - it.prefix("d/:val") { - it.all { context -> - context.render(context.get(PathBinding).description) - } - } - it.prefix("e/:val?:\\d+") { - it.all { context -> - context.render(context.get(PathBinding).description) - } - } - it.prefix("f/:val:\\d+") { - it.all { context -> - context.render(context.get(PathBinding).description) - } - } - } - configure(it) - } - client = WebClient.of("h1c://localhost:${app.bindPort}") - } - - def cleanupSpec() { - app.stop() - } - - abstract boolean hasHandlerSpan() - - def "test bindings for #path"() { - when: - def resp = client.get(path).aggregate().join() - - then: - resp.status().code() == 200 - resp.contentUtf8() == route - - assertTraces(1) { - trace(0, 1 + (hasHandlerSpan() ? 1 : 0)) { - span(0) { - name "GET /$route" - kind SERVER - hasNoParent() - attributes { - "$NetworkAttributes.NETWORK_PROTOCOL_VERSION" "1.1" - "$ServerAttributes.SERVER_ADDRESS" { it == "localhost" || it == null } - "$ServerAttributes.SERVER_PORT" { it == app.bindPort || it == null } - "$ClientAttributes.CLIENT_ADDRESS" { it == "127.0.0.1" || it == null } - "$NetworkAttributes.NETWORK_PEER_ADDRESS" { it == "127.0.0.1" || it == null } - "$NetworkAttributes.NETWORK_PEER_PORT" { it instanceof Long || it == null } - "$HttpAttributes.HTTP_REQUEST_METHOD" "GET" - "$HttpAttributes.HTTP_RESPONSE_STATUS_CODE" 200 - "$UserAgentAttributes.USER_AGENT_ORIGINAL" String - "$UrlAttributes.URL_SCHEME" "http" - "$UrlAttributes.URL_PATH" "/$path" - "$UrlAttributes.URL_QUERY" { it == "" || it == null } - "$HttpAttributes.HTTP_ROUTE" "/$route" - } - } - if (hasHandlerSpan()) { - span(1) { - name "/$route" - kind INTERNAL - childOf span(0) - attributes { - } - } - } - } - } - - where: - path | route - "a" | "a" - "b/123" | "b/::\\d+" - "c" | "c/:val?" - "c/123" | "c/:val?" - "c/foo" | "c/:val?" - "d/123" | "d/:val" - "d/foo" | "d/:val" - "e" | "e/:val?:\\d+" - "e/123" | "e/:val?:\\d+" - "e/foo" | "e/:val?:\\d+" - "f/123" | "f/:val:\\d+" - } -} diff --git a/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackAsyncHttpServerTest.java b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackAsyncHttpServerTest.java new file mode 100644 index 000000000000..b347fa91ac62 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackAsyncHttpServerTest.java @@ -0,0 +1,18 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.server; + +import io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint; +import java.util.function.Consumer; +import ratpack.exec.Promise; + +public abstract class AbstractRatpackAsyncHttpServerTest extends AbstractRatpackHttpServerTest { + + @Override + protected void process(ServerEndpoint endpoint, Consumer consumer) { + Promise.sync(() -> endpoint).then(consumer::accept); + } +} diff --git a/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackForkedHttpServerTest.java b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackForkedHttpServerTest.java new file mode 100644 index 000000000000..023fc92ce01c --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackForkedHttpServerTest.java @@ -0,0 +1,101 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.server; + +import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.SUCCESS; +import static org.assertj.core.api.Assertions.assertThat; + +import io.opentelemetry.api.trace.SpanKind; +import io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint; +import io.opentelemetry.sdk.testing.assertj.SpanDataAssert; +import io.opentelemetry.testing.internal.armeria.common.AggregatedHttpRequest; +import io.opentelemetry.testing.internal.armeria.common.AggregatedHttpResponse; +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import org.junit.jupiter.api.Test; +import ratpack.exec.Execution; +import ratpack.exec.Operation; +import ratpack.exec.Promise; +import ratpack.exec.Result; +import ratpack.exec.util.ParallelBatch; +import ratpack.handling.Chain; + +public abstract class AbstractRatpackForkedHttpServerTest extends AbstractRatpackHttpServerTest { + + private static final ServerEndpoint FORK_AND_YIELD_ALL = + new ServerEndpoint( + "FORK_AND_YIELD_ALL", "fork_and_yieldAll", SUCCESS.getStatus(), SUCCESS.getBody(), false); + + @Override + protected void process(ServerEndpoint endpoint, Consumer consumer) { + Promise.sync(() -> endpoint).fork().then(consumer::accept); + } + + @Override + protected void registerHandlers(Chain chain) throws Exception { + chain.prefix( + FORK_AND_YIELD_ALL.rawPath(), + chain1 -> + chain1.all( + context -> { + Promise promise = + Promise.async( + upstream -> + Execution.fork() + .start( + Operation.of( + () -> upstream.accept(Result.success(SUCCESS))))); + ParallelBatch.of(promise) + .yieldAll() + .flatMap(list -> Promise.sync(() -> list.get(0).getValue())) + .then( + endpoint -> + controller( + endpoint, + () -> + context + .getResponse() + .status(endpoint.getStatus()) + .send(endpoint.getBody()))); + })); + } + + @Test + void forkAndYieldAll() { + AggregatedHttpRequest request = request(FORK_AND_YIELD_ALL, "GET"); + AggregatedHttpResponse response = client.execute(request).aggregate().join(); + + assertThat(response.status().code()).isEqualTo(SUCCESS.getStatus()); + assertThat(response.contentUtf8()).isEqualTo(SUCCESS.getBody()); + + testing() + .waitAndAssertTraces( + trace -> { + List> assertions = new ArrayList<>(); + assertions.add( + span -> + span.hasName("GET /fork_and_yieldAll") + .hasKind(SpanKind.SERVER) + .hasNoParent()); + boolean hasHandlerSpan = hasHandlerSpan(FORK_AND_YIELD_ALL); + if (hasHandlerSpan) { + assertions.add( + span -> + span.hasName("/fork_and_yieldAll") + .hasKind(SpanKind.INTERNAL) + .hasParent(trace.getSpan(0))); + } + assertions.add( + span -> + span.hasName("controller") + .hasKind(SpanKind.INTERNAL) + .hasParent(trace.getSpan(hasHandlerSpan ? 1 : 0))); + + trace.hasSpansSatisfyingExactly(assertions); + }); + } +} diff --git a/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackHttpServerTest.java b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackHttpServerTest.java new file mode 100644 index 000000000000..c3fbe44074d8 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackHttpServerTest.java @@ -0,0 +1,383 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.server; + +import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.CAPTURE_HEADERS; +import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.ERROR; +import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.EXCEPTION; +import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.INDEXED_CHILD; +import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.PATH_PARAM; +import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.QUERY_PARAM; +import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.REDIRECT; +import static io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint.SUCCESS; +import static org.assertj.core.api.Assertions.assertThat; + +import io.netty.buffer.ByteBuf; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.SpanKind; +import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpServerTest; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions; +import io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint; +import io.opentelemetry.sdk.testing.assertj.SpanDataAssert; +import io.opentelemetry.sdk.trace.data.StatusData; +import io.opentelemetry.testing.internal.armeria.common.AggregatedHttpResponse; +import java.net.InetAddress; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.function.Consumer; +import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.Test; +import org.reactivestreams.Subscriber; +import org.reactivestreams.Subscription; +import ratpack.error.ServerErrorHandler; +import ratpack.handling.Chain; +import ratpack.handling.Context; +import ratpack.server.RatpackServer; +import ratpack.server.RatpackServerSpec; + +public abstract class AbstractRatpackHttpServerTest extends AbstractHttpServerTest { + + protected static final ServerEndpoint POST_STREAM = + new ServerEndpoint( + "POST_STREAM", "post-stream", SUCCESS.getStatus(), SUCCESS.getBody(), false); + + @SuppressWarnings("CheckedExceptionNotThrown") + @Override + protected RatpackServer setupServer() throws Exception { + return RatpackServer.start( + ratpackServerSpec -> { + ratpackServerSpec.serverConfig( + serverConfigBuilder -> { + serverConfigBuilder.port(port); + serverConfigBuilder.address(InetAddress.getByName("localhost")); + }); + ratpackServerSpec.handlers( + handlerChain -> { + handlerChain.register( + registrySpec -> + registrySpec.add(ServerErrorHandler.class, new TestErrorHandler())); + handlerChain.prefix( + SUCCESS.rawPath(), + chain -> + chain.all( + context -> + process( + SUCCESS, + endpoint -> + controller( + endpoint, + () -> + context + .getResponse() + .status(endpoint.getStatus()) + .send(endpoint.getBody()))))); + + handlerChain.prefix( + INDEXED_CHILD.rawPath(), + chain -> + chain.all( + context -> + process( + INDEXED_CHILD, + endpoint -> + controller( + endpoint, + () -> { + endpoint.collectSpanAttributes( + name -> + context + .getRequest() + .getQueryParams() + .get(name)); + context + .getResponse() + .status(endpoint.getStatus()) + .send(); + })))); + + handlerChain.prefix( + QUERY_PARAM.rawPath(), + chain -> + chain.all( + context -> + process( + QUERY_PARAM, + endpoint -> + controller( + endpoint, + () -> + context + .getResponse() + .status(endpoint.getStatus()) + .send(context.getRequest().getQuery()))))); + + handlerChain.prefix( + REDIRECT.rawPath(), + chain -> + chain.all( + context -> + process( + REDIRECT, + endpoint -> + controller( + endpoint, + () -> context.redirect(endpoint.getBody()))))); + + handlerChain.prefix( + ERROR.rawPath(), + chain -> + chain.all( + context -> + process( + ERROR, + endpoint -> + controller( + endpoint, + () -> + context + .getResponse() + .status(endpoint.getStatus()) + .send(endpoint.getBody()))))); + + handlerChain.prefix( + EXCEPTION.rawPath(), + chain -> + chain.all( + context -> + process( + EXCEPTION, + endpoint -> + controller( + endpoint, + () -> { + throw new IllegalStateException(endpoint.getBody()); + })))); + + handlerChain.prefix( + "path/:id/param", + chain -> + chain.all( + context -> + process( + PATH_PARAM, + endpoint -> + controller( + endpoint, + () -> + context + .getResponse() + .status(endpoint.getStatus()) + .send(context.getPathTokens().get("id")))))); + + handlerChain.prefix( + CAPTURE_HEADERS.rawPath(), + chain -> + chain.all( + context -> + process( + CAPTURE_HEADERS, + endpoint -> + controller( + endpoint, + () -> { + context.getResponse().status(endpoint.getStatus()); + context + .getResponse() + .getHeaders() + .set( + "X-Test-Response", + context + .getRequest() + .getHeaders() + .get("X-Test-Request")); + context.getResponse().send(endpoint.getBody()); + })))); + + handlerChain.prefix( + POST_STREAM.rawPath(), + chain -> + chain.all( + context -> + process(POST_STREAM, endpoint -> handlePostStream(context)))); + + registerHandlers(handlerChain); + }); + + configure(ratpackServerSpec); + }); + } + + protected void registerHandlers(Chain chain) throws Exception {} + + protected void process(ServerEndpoint endpoint, Consumer consumer) { + consumer.accept(endpoint); + } + + private void handlePostStream(Context context) { + controller( + POST_STREAM, + () -> { + context + .getRequest() + .getBodyStream() + .subscribe( + new Subscriber() { + private Subscription subscription; + private int count; + private String traceId; + + @Override + public void onSubscribe(Subscription subscription) { + this.subscription = subscription; + traceId = Span.current().getSpanContext().getTraceId(); + subscription.request(1); + } + + @Override + public void onNext(ByteBuf byteBuf) { + assertThat(Span.current().getSpanContext().getTraceId()).isEqualTo(traceId); + if (count < 2) { + testing().runWithSpan("onNext", () -> count++); + } + byteBuf.release(); + subscription.request(1); + } + + @SuppressWarnings("SystemOut") + @Override + public void onError(Throwable throwable) { + // prints the assertion error from onNext + throwable.printStackTrace(); + context.getResponse().status(500).send(throwable.getMessage()); + } + + @Override + public void onComplete() { + testing() + .runWithSpan( + "onComplete", + () -> context.getResponse().status(200).send(POST_STREAM.getBody())); + } + }); + }); + } + + // TODO(anuraaga): The default Ratpack error handler also returns a 500 which is all we test, so + // we don't actually have test coverage ensuring our instrumentation correctly delegates to this + // user registered handler. + private static class TestErrorHandler implements ServerErrorHandler { + @Override + public void error(Context context, Throwable throwable) { + context.getResponse().status(500).send(throwable.getMessage()); + } + } + + @Override + protected void stopServer(RatpackServer server) throws Exception { + server.stop(); + } + + protected abstract void configure(RatpackServerSpec serverSpec) throws Exception; + + @Override + protected void configure(HttpServerTestOptions options) { + super.configure(options); + + options.setHasHandlerSpan(endpoint -> true); + options.setTestPathParam(true); + // server spans are ended inside the controller spans + options.setVerifyServerSpanEndTime(false); + + options.setExpectedHttpRoute( + (endpoint, method) -> { + if (endpoint.getStatus() == 404) { + return "/"; + } else if (endpoint == PATH_PARAM) { + return "/path/:id/param"; + } else { + return endpoint.getPath(); + } + }); + } + + @Override + protected SpanDataAssert assertHandlerSpan( + SpanDataAssert span, String method, ServerEndpoint endpoint) { + String spanName; + if (endpoint.getStatus() == 404) { + spanName = "/"; + } else if (endpoint == PATH_PARAM) { + spanName = "/path/:id/param"; + } else { + spanName = endpoint.getPath(); + } + span.hasName(spanName).hasKind(SpanKind.INTERNAL); + if (endpoint == EXCEPTION) { + span.hasStatus(StatusData.error()) + .hasException(new IllegalStateException(EXCEPTION.getBody())); + } + return span; + } + + protected boolean testPostStream() { + return true; + } + + @Test + void postStream() { + Assumptions.assumeTrue(testPostStream()); + + // body should be large enough to trigger multiple calls to onNext + String body = String.join("", Collections.nCopies(10000, "foobar")); + AggregatedHttpResponse response = + client.post(resolveAddress(POST_STREAM), body).aggregate().join(); + + assertThat(response.status().code()).isEqualTo(POST_STREAM.getStatus()); + assertThat(response.contentUtf8()).isEqualTo(POST_STREAM.getBody()); + + boolean hasHandlerSpan = hasHandlerSpan(POST_STREAM); + // when using javaagent instrumentation the parent of reactive callbacks is the controller span + // where subscribe was called, for library instrumentation server span is the parent + int reactiveCallbackParent = hasHandlerSpan ? 2 : 0; + + testing() + .waitAndAssertTraces( + trace -> { + List> assertions = new ArrayList<>(); + assertions.add( + span -> span.hasName("POST /post-stream").hasKind(SpanKind.SERVER).hasNoParent()); + if (hasHandlerSpan) { + assertions.add( + span -> + span.hasName("/post-stream") + .hasKind(SpanKind.INTERNAL) + .hasParent(trace.getSpan(0))); + } + assertions.add( + span -> + span.hasName("controller") + .hasKind(SpanKind.INTERNAL) + .hasParent(trace.getSpan(hasHandlerSpan ? 1 : 0))); + assertions.add( + span -> + span.hasName("onNext") + .hasKind(SpanKind.INTERNAL) + .hasParent(trace.getSpan(reactiveCallbackParent))); + assertions.add( + span -> + span.hasName("onNext") + .hasKind(SpanKind.INTERNAL) + .hasParent(trace.getSpan(reactiveCallbackParent))); + assertions.add( + span -> + span.hasName("onComplete") + .hasKind(SpanKind.INTERNAL) + .hasParent(trace.getSpan(reactiveCallbackParent))); + trace.hasSpansSatisfyingExactly(assertions); + }); + } +} diff --git a/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackRoutesTest.java b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackRoutesTest.java new file mode 100644 index 000000000000..e5e02ef2c24f --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.4/testing/src/main/java/io/opentelemetry/instrumentation/ratpack/server/AbstractRatpackRoutesTest.java @@ -0,0 +1,171 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.server; + +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo; +import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.satisfies; +import static io.opentelemetry.semconv.ClientAttributes.CLIENT_ADDRESS; +import static io.opentelemetry.semconv.HttpAttributes.HTTP_REQUEST_METHOD; +import static io.opentelemetry.semconv.HttpAttributes.HTTP_RESPONSE_STATUS_CODE; +import static io.opentelemetry.semconv.HttpAttributes.HTTP_ROUTE; +import static io.opentelemetry.semconv.NetworkAttributes.NETWORK_PEER_ADDRESS; +import static io.opentelemetry.semconv.NetworkAttributes.NETWORK_PEER_PORT; +import static io.opentelemetry.semconv.NetworkAttributes.NETWORK_PROTOCOL_VERSION; +import static io.opentelemetry.semconv.ServerAttributes.SERVER_ADDRESS; +import static io.opentelemetry.semconv.ServerAttributes.SERVER_PORT; +import static io.opentelemetry.semconv.UrlAttributes.URL_PATH; +import static io.opentelemetry.semconv.UrlAttributes.URL_QUERY; +import static io.opentelemetry.semconv.UrlAttributes.URL_SCHEME; +import static io.opentelemetry.semconv.UserAgentAttributes.USER_AGENT_ORIGINAL; +import static org.assertj.core.api.Assertions.assertThat; + +import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.SpanKind; +import io.opentelemetry.instrumentation.test.utils.PortUtils; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.sdk.testing.assertj.SpanDataAssert; +import io.opentelemetry.testing.internal.armeria.client.WebClient; +import io.opentelemetry.testing.internal.armeria.common.AggregatedHttpResponse; +import java.net.InetAddress; +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; +import java.util.stream.Stream; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import ratpack.func.Action; +import ratpack.handling.Chain; +import ratpack.path.PathBinding; +import ratpack.server.RatpackServer; +import ratpack.server.RatpackServerSpec; + +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +public abstract class AbstractRatpackRoutesTest { + + private static RatpackServer app; + private static WebClient client; + + protected abstract InstrumentationExtension testing(); + + protected abstract void configure(RatpackServerSpec serverSpec) throws Exception; + + protected abstract boolean hasHandlerSpan(); + + @BeforeAll + void setUp() throws Exception { + app = + RatpackServer.start( + ratpackServerSpec -> { + ratpackServerSpec.serverConfig( + serverConfigBuilder -> { + serverConfigBuilder.port(PortUtils.findOpenPort()); + serverConfigBuilder.address(InetAddress.getByName("localhost")); + }); + + Action action = + chain -> + chain.all( + context -> + context.render(context.get(PathBinding.class).getDescription())); + ratpackServerSpec.handlers( + chain -> { + chain.prefix("a", action); + chain.prefix("b/::\\d+", action); + chain.prefix("c/:val?", action); + chain.prefix("d/:val", action); + chain.prefix("e/:val?:\\d+", action); + chain.prefix("f/:val:\\d+", action); + }); + + configure(ratpackServerSpec); + }); + + // Force HTTP/1 with h1c to prevent tracing of upgrade request. + client = WebClient.of("h1c://localhost:" + app.getBindPort()); + } + + @AfterAll + void cleanUp() throws Exception { + app.stop(); + } + + private static Stream provideBindingArguments() { + return Stream.of( + Arguments.of("a", "a"), + Arguments.of("b/123", "b/::\\d+"), + Arguments.of("c", "c/:val?"), + Arguments.of("c/123", "c/:val?"), + Arguments.of("c/foo", "c/:val?"), + Arguments.of("d/123", "d/:val"), + Arguments.of("d/foo", "d/:val"), + Arguments.of("e", "e/:val?:\\d+"), + Arguments.of("e/123", "e/:val?:\\d+"), + Arguments.of("e/foo", "e/:val?:\\d+"), + Arguments.of("f/123", "f/:val:\\d+")); + } + + @ParameterizedTest + @MethodSource("provideBindingArguments") + void bindingsForPath(String path, String route) { + AggregatedHttpResponse response = client.get(path).aggregate().join(); + + assertThat(response.status().code()).isEqualTo(200); + assertThat(response.contentUtf8()).isEqualTo(route); + + testing() + .waitAndAssertTraces( + trace -> { + List> assertions = new ArrayList<>(); + assertions.add( + span -> + span.hasName("GET /" + route) + .hasKind(SpanKind.SERVER) + .hasNoParent() + .hasAttributesSatisfyingExactly( + equalTo(NETWORK_PROTOCOL_VERSION, "1.1"), + equalTo(SERVER_ADDRESS, "localhost"), + equalTo(SERVER_PORT, app.getBindPort()), + equalTo(CLIENT_ADDRESS, hasHandlerSpan() ? "127.0.0.1" : null), + equalTo(NETWORK_PEER_ADDRESS, hasHandlerSpan() ? "127.0.0.1" : null), + satisfies( + NETWORK_PEER_PORT, + port -> + port.satisfiesAnyOf( + val -> assertThat(val).isInstanceOf(Long.class), + val -> assertThat(val).isNull())), + satisfies( + NETWORK_PEER_PORT, + val -> { + if (hasHandlerSpan()) { + val.isInstanceOf(Long.class); + } else { + val.isNull(); + } + }), + equalTo(HTTP_REQUEST_METHOD, "GET"), + equalTo(HTTP_RESPONSE_STATUS_CODE, 200), + satisfies(USER_AGENT_ORIGINAL, val -> val.isInstanceOf(String.class)), + equalTo(URL_SCHEME, "http"), + equalTo(URL_PATH, "/" + path), + satisfies(URL_QUERY, val -> val.isNullOrEmpty()), + equalTo(HTTP_ROUTE, "/" + route))); + if (hasHandlerSpan()) { + assertions.add( + span -> + span.hasName("/" + route) + .hasKind(SpanKind.INTERNAL) + .hasParent(trace.getSpan(0)) + .hasAttributes(Attributes.empty())); + } + + trace.hasSpansSatisfyingExactly(assertions); + }); + } +} 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 deleted file mode 100644 index dc1cc42df27f..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackAsyncHttpServerTest.groovy +++ /dev/null @@ -1,22 +0,0 @@ -/* - * 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 deleted file mode 100644 index 87dc2848b1ff..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackForkedHttpServerTest.groovy +++ /dev/null @@ -1,27 +0,0 @@ -/* - * 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 deleted file mode 100644 index 3fd085dde585..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackHttpServerTest.groovy +++ /dev/null @@ -1,22 +0,0 @@ -/* - * 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 deleted file mode 100644 index e52bd4f93c1e..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/groovy/server/RatpackRoutesTest.groovy +++ /dev/null @@ -1,21 +0,0 @@ -/* - * 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/client/RatpackForkedHttpClientTest.java similarity index 93% rename from instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackForkedHttpClientTest.java rename to instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/client/RatpackForkedHttpClientTest.java index 509d08576c80..50b4559605f1 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/client/RatpackForkedHttpClientTest.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7.client; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackForkedHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; 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/client/RatpackHttpClientTest.java similarity index 93% rename from instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackHttpClientTest.java rename to instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/client/RatpackHttpClientTest.java index 53e6e22734d5..4395c516ee24 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/client/RatpackHttpClientTest.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7.client; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; 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/client/RatpackPooledHttpClientTest.java similarity index 93% rename from instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackPooledHttpClientTest.java rename to instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/client/RatpackPooledHttpClientTest.java index 396b4db4da64..502ab905d468 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/client/RatpackPooledHttpClientTest.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7.client; import io.opentelemetry.instrumentation.ratpack.client.AbstractRatpackPooledHttpClientTest; import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestUtils.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/client/RatpackTestUtils.java similarity index 92% rename from instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestUtils.java rename to instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/client/RatpackTestUtils.java index 4c4a9418f507..d75d59f65bf3 100644 --- a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/RatpackTestUtils.java +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/client/RatpackTestUtils.java @@ -3,7 +3,7 @@ * SPDX-License-Identifier: Apache-2.0 */ -package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7; +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7.client; import io.netty.channel.ConnectTimeoutException; import java.net.URI; diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackAsyncHttpServerTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackAsyncHttpServerTest.java new file mode 100644 index 000000000000..2e4463247003 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackAsyncHttpServerTest.java @@ -0,0 +1,30 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7.server; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackAsyncHttpServerTest; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackAsyncHttpServerTest extends AbstractRatpackAsyncHttpServerTest { + + @RegisterExtension + public static final InstrumentationExtension testing = + HttpServerInstrumentationExtension.forAgent(); + + @Override + protected void configure(RatpackServerSpec serverSpec) {} + + @Override + protected void configure(HttpServerTestOptions options) { + super.configure(options); + + options.setHasResponseCustomizer(endpoint -> true); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackForkedHttpServerTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackForkedHttpServerTest.java new file mode 100644 index 000000000000..82263021f29b --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackForkedHttpServerTest.java @@ -0,0 +1,31 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7.server; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackForkedHttpServerTest; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackForkedHttpServerTest extends AbstractRatpackForkedHttpServerTest { + + @RegisterExtension + public static final InstrumentationExtension testing = + HttpServerInstrumentationExtension.forAgent(); + + @Override + protected void configure(RatpackServerSpec serverSpec) {} + + @Override + protected void configure(HttpServerTestOptions options) { + super.configure(options); + + options.setHasResponseCustomizer(endpoint -> true); + options.setTestHttpPipelining(false); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackHttpServerTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackHttpServerTest.java new file mode 100644 index 000000000000..f7fc286992cf --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackHttpServerTest.java @@ -0,0 +1,30 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7.server; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackHttpServerTest; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackHttpServerTest extends AbstractRatpackHttpServerTest { + + @RegisterExtension + public static final InstrumentationExtension testing = + HttpServerInstrumentationExtension.forAgent(); + + @Override + protected void configure(RatpackServerSpec serverSpec) {} + + @Override + protected void configure(HttpServerTestOptions options) { + super.configure(options); + + options.setHasResponseCustomizer(endpoint -> true); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackRoutesTest.java b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackRoutesTest.java new file mode 100644 index 000000000000..451605eb19c8 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/javaagent/src/test/java/io/opentelemetry/javaagent/instrumentation/ratpack/v1_7/server/RatpackRoutesTest.java @@ -0,0 +1,31 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.javaagent.instrumentation.ratpack.v1_7.server; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackRoutesTest; +import io.opentelemetry.instrumentation.testing.junit.AgentInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackRoutesTest extends AbstractRatpackRoutesTest { + + @RegisterExtension + static final InstrumentationExtension testing = AgentInstrumentationExtension.create(); + + @Override + protected InstrumentationExtension testing() { + return testing; + } + + @Override + protected void configure(RatpackServerSpec serverSpec) {} + + @Override + protected boolean hasHandlerSpan() { + return true; + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackAsyncHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackAsyncHttpServerTest.groovy deleted file mode 100644 index c391c85a5ec3..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackAsyncHttpServerTest.groovy +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack.v1_7.server - -import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackAsyncHttpServerTest -import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackTelemetry -import io.opentelemetry.instrumentation.test.LibraryTestTrait -import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpServerTest -import io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint -import ratpack.server.RatpackServerSpec - -class RatpackAsyncHttpServerTest extends AbstractRatpackAsyncHttpServerTest implements LibraryTestTrait { - @Override - void configure(RatpackServerSpec serverSpec) { - RatpackTelemetry telemetry = RatpackTelemetry.builder(openTelemetry) - .setCapturedServerRequestHeaders([AbstractHttpServerTest.TEST_REQUEST_HEADER]) - .setCapturedServerResponseHeaders([AbstractHttpServerTest.TEST_RESPONSE_HEADER]) - .build() - serverSpec.registryOf { - telemetry.configureServerRegistry(it) - } - } - - @Override - boolean hasHandlerSpan(ServerEndpoint endpoint) { - false - } -} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackForkedHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackForkedHttpServerTest.groovy deleted file mode 100644 index a5e5657074d3..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackForkedHttpServerTest.groovy +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack.v1_7.server - -import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackForkedHttpServerTest -import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackTelemetry -import io.opentelemetry.instrumentation.test.LibraryTestTrait -import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpServerTest -import io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint -import ratpack.server.RatpackServerSpec - -class RatpackForkedHttpServerTest extends AbstractRatpackForkedHttpServerTest implements LibraryTestTrait { - @Override - void configure(RatpackServerSpec serverSpec) { - RatpackTelemetry telemetry = RatpackTelemetry.builder(openTelemetry) - .setCapturedServerRequestHeaders([AbstractHttpServerTest.TEST_REQUEST_HEADER]) - .setCapturedServerResponseHeaders([AbstractHttpServerTest.TEST_RESPONSE_HEADER]) - .build() - serverSpec.registryOf { - telemetry.configureServerRegistry(it) - } - } - - @Override - boolean hasHandlerSpan(ServerEndpoint endpoint) { - false - } -} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackHttpServerTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackHttpServerTest.groovy deleted file mode 100644 index 72f1a0f43189..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackHttpServerTest.groovy +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack.v1_7.server - -import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackHttpServerTest -import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackTelemetry -import io.opentelemetry.instrumentation.test.LibraryTestTrait -import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpServerTest -import io.opentelemetry.instrumentation.testing.junit.http.ServerEndpoint -import ratpack.server.RatpackServerSpec - -class RatpackHttpServerTest extends AbstractRatpackHttpServerTest implements LibraryTestTrait { - @Override - void configure(RatpackServerSpec serverSpec) { - RatpackTelemetry telemetry = RatpackTelemetry.builder(openTelemetry) - .setCapturedServerRequestHeaders([AbstractHttpServerTest.TEST_REQUEST_HEADER]) - .setCapturedServerResponseHeaders([AbstractHttpServerTest.TEST_RESPONSE_HEADER]) - .build() - serverSpec.registryOf { - telemetry.configureServerRegistry(it) - } - } - - @Override - boolean hasHandlerSpan(ServerEndpoint endpoint) { - false - } -} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackRoutesTest.groovy b/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackRoutesTest.groovy deleted file mode 100644 index 0d5004b71050..000000000000 --- a/instrumentation/ratpack/ratpack-1.7/library/src/test/groovy/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackRoutesTest.groovy +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright The OpenTelemetry Authors - * SPDX-License-Identifier: Apache-2.0 - */ - -package io.opentelemetry.instrumentation.ratpack.v1_7.server - -import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackRoutesTest -import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackTelemetry -import io.opentelemetry.instrumentation.test.LibraryTestTrait -import ratpack.server.RatpackServerSpec - -class RatpackRoutesTest extends AbstractRatpackRoutesTest implements LibraryTestTrait { - @Override - void configure(RatpackServerSpec serverSpec) { - RatpackTelemetry telemetry = RatpackTelemetry.create(openTelemetry) - serverSpec.registryOf { - telemetry.configureServerRegistry(it) - } - } - - @Override - boolean hasHandlerSpan() { - return false - } -} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackAsyncHttpServerTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackAsyncHttpServerTest.java new file mode 100644 index 000000000000..ae496f03b4e1 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackAsyncHttpServerTest.java @@ -0,0 +1,43 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.v1_7.server; + +import static java.util.Collections.singletonList; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackAsyncHttpServerTest; +import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackTelemetry; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpServerTest; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackAsyncHttpServerTest extends AbstractRatpackAsyncHttpServerTest { + + @RegisterExtension + public static final InstrumentationExtension testing = + HttpServerInstrumentationExtension.forLibrary(); + + @Override + protected void configure(RatpackServerSpec serverSpec) throws Exception { + RatpackTelemetry telemetry = + RatpackTelemetry.builder(testing.getOpenTelemetry()) + .setCapturedServerRequestHeaders( + singletonList(AbstractHttpServerTest.TEST_REQUEST_HEADER)) + .setCapturedServerResponseHeaders( + singletonList(AbstractHttpServerTest.TEST_RESPONSE_HEADER)) + .build(); + serverSpec.registryOf(telemetry::configureServerRegistry); + } + + @Override + protected void configure(HttpServerTestOptions options) { + super.configure(options); + + options.setHasHandlerSpan(endpoint -> false); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackForkedHttpServerTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackForkedHttpServerTest.java new file mode 100644 index 000000000000..0c18d081cd07 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackForkedHttpServerTest.java @@ -0,0 +1,43 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.v1_7.server; + +import static java.util.Collections.singletonList; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackForkedHttpServerTest; +import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackTelemetry; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpServerTest; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackForkedHttpServerTest extends AbstractRatpackForkedHttpServerTest { + + @RegisterExtension + public static final InstrumentationExtension testing = + HttpServerInstrumentationExtension.forLibrary(); + + @Override + protected void configure(RatpackServerSpec serverSpec) throws Exception { + RatpackTelemetry telemetry = + RatpackTelemetry.builder(testing.getOpenTelemetry()) + .setCapturedServerRequestHeaders( + singletonList(AbstractHttpServerTest.TEST_REQUEST_HEADER)) + .setCapturedServerResponseHeaders( + singletonList(AbstractHttpServerTest.TEST_RESPONSE_HEADER)) + .build(); + serverSpec.registryOf(telemetry::configureServerRegistry); + } + + @Override + protected void configure(HttpServerTestOptions options) { + super.configure(options); + + options.setHasHandlerSpan(endpoint -> false); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackHttpServerTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackHttpServerTest.java new file mode 100644 index 000000000000..1a00d239d28f --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackHttpServerTest.java @@ -0,0 +1,43 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.v1_7.server; + +import static java.util.Collections.singletonList; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackHttpServerTest; +import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackTelemetry; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.AbstractHttpServerTest; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerInstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.http.HttpServerTestOptions; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackHttpServerTest extends AbstractRatpackHttpServerTest { + + @RegisterExtension + public static final InstrumentationExtension testing = + HttpServerInstrumentationExtension.forLibrary(); + + @Override + protected void configure(RatpackServerSpec serverSpec) throws Exception { + RatpackTelemetry telemetry = + RatpackTelemetry.builder(testing.getOpenTelemetry()) + .setCapturedServerRequestHeaders( + singletonList(AbstractHttpServerTest.TEST_REQUEST_HEADER)) + .setCapturedServerResponseHeaders( + singletonList(AbstractHttpServerTest.TEST_RESPONSE_HEADER)) + .build(); + serverSpec.registryOf(telemetry::configureServerRegistry); + } + + @Override + protected void configure(HttpServerTestOptions options) { + super.configure(options); + + options.setHasHandlerSpan(endpoint -> false); + } +} diff --git a/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackRoutesTest.java b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackRoutesTest.java new file mode 100644 index 000000000000..8a1edc9993e8 --- /dev/null +++ b/instrumentation/ratpack/ratpack-1.7/library/src/test/java/io/opentelemetry/instrumentation/ratpack/v1_7/server/RatpackRoutesTest.java @@ -0,0 +1,35 @@ +/* + * Copyright The OpenTelemetry Authors + * SPDX-License-Identifier: Apache-2.0 + */ + +package io.opentelemetry.instrumentation.ratpack.v1_7.server; + +import io.opentelemetry.instrumentation.ratpack.server.AbstractRatpackRoutesTest; +import io.opentelemetry.instrumentation.ratpack.v1_7.RatpackTelemetry; +import io.opentelemetry.instrumentation.testing.junit.InstrumentationExtension; +import io.opentelemetry.instrumentation.testing.junit.LibraryInstrumentationExtension; +import org.junit.jupiter.api.extension.RegisterExtension; +import ratpack.server.RatpackServerSpec; + +class RatpackRoutesTest extends AbstractRatpackRoutesTest { + + @RegisterExtension + static final InstrumentationExtension testing = LibraryInstrumentationExtension.create(); + + @Override + protected InstrumentationExtension testing() { + return testing; + } + + @Override + protected void configure(RatpackServerSpec serverSpec) throws Exception { + RatpackTelemetry telemetry = RatpackTelemetry.create(testing.getOpenTelemetry()); + serverSpec.registryOf(telemetry::configureServerRegistry); + } + + @Override + protected boolean hasHandlerSpan() { + return false; + } +} diff --git a/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpServerTest.java b/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpServerTest.java index 55ae8e2dba00..d8c6ce62aea5 100644 --- a/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpServerTest.java +++ b/testing-common/src/main/java/io/opentelemetry/instrumentation/testing/junit/http/AbstractHttpServerTest.java @@ -879,6 +879,10 @@ public final boolean hasHttpRouteAttribute(ServerEndpoint endpoint) { return options.httpAttributes.apply(endpoint).contains(HttpAttributes.HTTP_ROUTE); } + public final boolean hasHandlerSpan(ServerEndpoint endpoint) { + return options.hasHandlerSpan.test(endpoint); + } + public String expectedHttpRoute(ServerEndpoint endpoint, String method) { // no need to compute route if we're not expecting it if (!hasHttpRouteAttribute(endpoint)) {