open-telemetry
/
opentelemetry-java-instrumentation
mirror of https://github.com/open-telemetry/opentelemetry-java-instrumentation.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Migrate servlet tests to HttpServerTest 

Currently missing the authentication tests which need to be added to the parent, but other than that, testing is more thorough.

Discovered that trace propagation for Jetty Async is currently busted so I commented that portion of the test out until we can get it fixed.
This commit is contained in:
Tyler Benson 2019-07-23 14:20:58 -07:00
parent 023fb397b5
commit c3203dace8
15 changed files with 656 additions and 598 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
dd-java-agent/instrumentation/netty-4.0/src/test/groovy/Netty40ServerTest.groovy
View File

@ -37,8 +37,6 @@ class Netty40ServerTest extends HttpServerTest<NettyHttpServerDecorator> {
@Override @Override
void startServer(int port) { void startServer(int port) {
// def handlers = [new HttpServerCodec()]
def handlers = [new HttpRequestDecoder(), new HttpResponseEncoder()]
eventLoopGroup = new NioEventLoopGroup() eventLoopGroup = new NioEventLoopGroup()
ServerBootstrap bootstrap = new ServerBootstrap() ServerBootstrap bootstrap = new ServerBootstrap()
@ -47,6 +45,8 @@ class Netty40ServerTest extends HttpServerTest<NettyHttpServerDecorator> {
.childHandler([ .childHandler([
initChannel: { ch -> initChannel: { ch ->
ChannelPipeline pipeline = ch.pipeline() ChannelPipeline pipeline = ch.pipeline()
// def handlers = [new HttpServerCodec()]
def handlers = [new HttpRequestDecoder(), new HttpResponseEncoder()]
handlers.each { pipeline.addLast(it) } handlers.each { pipeline.addLast(it) }
pipeline.addLast([ pipeline.addLast([
channelRead0 : { ctx, msg -> channelRead0 : { ctx, msg ->

2
dd-java-agent/instrumentation/netty-4.0/src/test/groovy/NettyServerTestInstrumentation.java
View File

@ -15,7 +15,7 @@ public class NettyServerTestInstrumentation implements Instrumenter {
.transform( .transform(
new AgentBuilder.Transformer.ForAdvice() new AgentBuilder.Transformer.ForAdvice()
.advice( .advice(
named("fireChannelRead"), named("channelRead"),
HttpServerTestAdvice.ServerEntryAdvice.class.getName())); HttpServerTestAdvice.ServerEntryAdvice.class.getName()));
} }
} }

4
dd-java-agent/instrumentation/netty-4.1/src/test/groovy/Netty41ServerTest.groovy
View File

@ -37,8 +37,6 @@ class Netty41ServerTest extends HttpServerTest<NettyHttpServerDecorator> {
@Override @Override
void startServer(int port) { void startServer(int port) {
def handlers = [new HttpServerCodec()]
// def handlers = [new HttpRequestDecoder(), new HttpResponseEncoder()]
eventLoopGroup = new NioEventLoopGroup() eventLoopGroup = new NioEventLoopGroup()
ServerBootstrap bootstrap = new ServerBootstrap() ServerBootstrap bootstrap = new ServerBootstrap()
@ -47,6 +45,8 @@ class Netty41ServerTest extends HttpServerTest<NettyHttpServerDecorator> {
.childHandler([ .childHandler([
initChannel: { ch -> initChannel: { ch ->
ChannelPipeline pipeline = ch.pipeline() ChannelPipeline pipeline = ch.pipeline()
def handlers = [new HttpServerCodec()]
// def handlers = [new HttpRequestDecoder(), new HttpResponseEncoder()]
handlers.each { pipeline.addLast(it) } handlers.each { pipeline.addLast(it) }
pipeline.addLast([ pipeline.addLast([
channelRead0 : { ctx, msg -> channelRead0 : { ctx, msg ->

2
dd-java-agent/instrumentation/netty-4.1/src/test/groovy/NettyServerTestInstrumentation.java
View File

@ -15,7 +15,7 @@ public class NettyServerTestInstrumentation implements Instrumenter {
.transform( .transform(
new AgentBuilder.Transformer.ForAdvice() new AgentBuilder.Transformer.ForAdvice()
.advice( .advice(
named("fireChannelRead"), named("channelRead"),
HttpServerTestAdvice.ServerEntryAdvice.class.getName())); HttpServerTestAdvice.ServerEntryAdvice.class.getName()));
} }
} }

1
dd-java-agent/instrumentation/servlet-3/servlet-3.gradle
View File

@ -35,6 +35,7 @@ dependencies {
testCompile(project(':dd-java-agent:testing')) { testCompile(project(':dd-java-agent:testing')) {
exclude group: 'org.eclipse.jetty', module: 'jetty-server' exclude group: 'org.eclipse.jetty', module: 'jetty-server'
} }
testCompile project(':dd-java-agent:instrumentation:java-concurrent')
testCompile project(':dd-java-agent:instrumentation:jetty-8') // See if there's any conflicts. testCompile project(':dd-java-agent:instrumentation:jetty-8') // See if there's any conflicts.
testCompile group: 'org.eclipse.jetty', name: 'jetty-server', version: '8.2.0.v20160908' testCompile group: 'org.eclipse.jetty', name: 'jetty-server', version: '8.2.0.v20160908'
testCompile group: 'org.eclipse.jetty', name: 'jetty-servlet', version: '8.2.0.v20160908' testCompile group: 'org.eclipse.jetty', name: 'jetty-servlet', version: '8.2.0.v20160908'

9
dd-java-agent/instrumentation/servlet-3/src/main/java/datadog/trace/instrumentation/servlet3/Servlet3Advice.java
View File

@ -33,13 +33,12 @@ public class Servlet3Advice {
final HttpServletRequest httpServletRequest = (HttpServletRequest) req; final HttpServletRequest httpServletRequest = (HttpServletRequest) req;
final SpanContext extractedContext = final SpanContext extractedContext =
GlobalTracer.get() GlobalTracer.get()
.extract( .extract(Format.Builtin.HTTP_HEADERS, new HttpServletRequestExtractAdapter(httpServletRequest));
Format.Builtin.HTTP_HEADERS,
new HttpServletRequestExtractAdapter(httpServletRequest));
final Scope scope = final Scope scope =
GlobalTracer.get() GlobalTracer.get()
.buildSpan("servlet.request") .buildSpan("servlet.request")
.ignoreActiveSpan()
.asChildOf(extractedContext) .asChildOf(extractedContext)
.withTag("span.origin.type", servlet.getClass().getName()) .withTag("span.origin.type", servlet.getClass().getName())
.startActive(false); .startActive(false);
@ -84,7 +83,11 @@ public class Servlet3Advice {
// exception is thrown in filter chain, but status code is incorrect // exception is thrown in filter chain, but status code is incorrect
Tags.HTTP_STATUS.set(span, 500); Tags.HTTP_STATUS.set(span, 500);
} }
if (throwable.getCause() == null) {
DECORATE.onError(span, throwable); DECORATE.onError(span, throwable);
} else {
DECORATE.onError(span, throwable.getCause());
}
DECORATE.beforeFinish(span); DECORATE.beforeFinish(span);
req.removeAttribute(SERVLET_SPAN); req.removeAttribute(SERVLET_SPAN);
span.finish(); // Finish the span manually since finishSpanOnClose was false span.finish(); // Finish the span manually since finishSpanOnClose was false

8
dd-java-agent/instrumentation/servlet-3/src/main/java/datadog/trace/instrumentation/servlet3/TagSettingAsyncListener.java
View File

@ -8,6 +8,7 @@ import java.io.IOException;
import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicBoolean;
import javax.servlet.AsyncEvent; import javax.servlet.AsyncEvent;
import javax.servlet.AsyncListener; import javax.servlet.AsyncListener;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
public class TagSettingAsyncListener implements AsyncListener { public class TagSettingAsyncListener implements AsyncListener {
@ -41,12 +42,17 @@ public class TagSettingAsyncListener implements AsyncListener {
@Override @Override
public void onError(final AsyncEvent event) throws IOException { public void onError(final AsyncEvent event) throws IOException {
if (event.getThrowable() != null && activated.compareAndSet(false, true)) { if (event.getThrowable() != null && activated.compareAndSet(false, true)) {
DECORATE.onResponse(span, (HttpServletResponse) event.getSuppliedResponse());
if (((HttpServletResponse) event.getSuppliedResponse()).getStatus() if (((HttpServletResponse) event.getSuppliedResponse()).getStatus()
== HttpServletResponse.SC_OK) { == HttpServletResponse.SC_OK) {
// exception is thrown in filter chain, but status code is incorrect // exception is thrown in filter chain, but status code is incorrect
Tags.HTTP_STATUS.set(span, 500); Tags.HTTP_STATUS.set(span, 500);
} }
DECORATE.onError(span, event.getThrowable()); Throwable throwable = event.getThrowable();
if(throwable instanceof ServletException && throwable.getCause() != null) {
throwable = throwable.getCause();
}
DECORATE.onError(span, throwable);
DECORATE.beforeFinish(span); DECORATE.beforeFinish(span);
span.finish(); span.finish();
} }

513
dd-java-agent/instrumentation/servlet-3/src/test/groovy/AbstractServlet3Test.groovy
View File

@ -1,461 +1,108 @@
import datadog.trace.agent.test.AgentTestRunner import datadog.trace.agent.test.asserts.TraceAssert
import datadog.trace.agent.test.utils.OkHttpUtils import datadog.trace.agent.test.base.HttpServerTest
import datadog.trace.agent.test.utils.PortUtils
import datadog.trace.api.DDSpanTypes import datadog.trace.api.DDSpanTypes
import datadog.trace.api.DDTags import datadog.trace.instrumentation.servlet3.Servlet3Decorator
import okhttp3.Credentials import io.opentracing.tag.Tags
import okhttp3.Interceptor
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import org.apache.catalina.core.ApplicationFilterChain
import spock.lang.Shared
import spock.lang.Unroll
import javax.servlet.Servlet import javax.servlet.Servlet
import okhttp3.Request
import org.apache.catalina.core.ApplicationFilterChain
// Need to be explicit to unroll inherited tests: import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.AUTH_REQUIRED
@Unroll import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.ERROR
abstract class AbstractServlet3Test<CONTEXT> extends AgentTestRunner { import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.EXCEPTION
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.REDIRECT
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.SUCCESS
@Shared abstract class AbstractServlet3Test<CONTEXT> extends HttpServerTest<Servlet3Decorator> {
OkHttpClient client = OkHttpUtils.clientBuilder().addNetworkInterceptor(new Interceptor() {
@Override @Override
Response intercept(Interceptor.Chain chain) throws IOException { URI buildAddress() {
def response = chain.proceed(chain.request()) return new URI("http://localhost:$port/$context/")
TEST_WRITER.waitForTraces(1)
return response
} }
})
.build()
@Shared @Override
int port = PortUtils.randomOpenPort() Servlet3Decorator decorator() {
@Shared return Servlet3Decorator.DECORATE
protected String user = "user" }
@Shared
protected String pass = "password" @Override
String expectedServiceName() {
context
}
@Override
String expectedOperationName() {
return "servlet.request"
}
// FIXME: Add authentication tests back in...
// @Shared
// protected String user = "user"
// @Shared
// protected String pass = "password"
abstract String getContext() abstract String getContext()
abstract void addServlet(CONTEXT context, String url, Class<Servlet> servlet) Class<Servlet> servlet = servlet()
abstract Class<Servlet> servlet()
abstract void addServlet(CONTEXT context, String path, Class<Servlet> servlet)
protected void setupServlets(CONTEXT context) { protected void setupServlets(CONTEXT context) {
addServlet(context, "/sync", TestServlet3.Sync) def servlet = servlet()
addServlet(context, "/auth/sync", TestServlet3.Sync)
addServlet(context, "/async", TestServlet3.Async) addServlet(context, SUCCESS.path, servlet)
addServlet(context, "/auth/async", TestServlet3.Async) addServlet(context, ERROR.path, servlet)
addServlet(context, "/blocking", TestServlet3.BlockingAsync) addServlet(context, EXCEPTION.path, servlet)
addServlet(context, "/dispatch/sync", TestServlet3.DispatchSync) addServlet(context, REDIRECT.path, servlet)
addServlet(context, "/dispatch/async", TestServlet3.DispatchAsync) addServlet(context, AUTH_REQUIRED.path, servlet)
addServlet(context, "/dispatch/recursive", TestServlet3.DispatchRecursive)
addServlet(context, "/recursive", TestServlet3.DispatchRecursive)
addServlet(context, "/fake", TestServlet3.FakeAsync)
} }
def "test #path servlet call (auth: #auth, distributed tracing: #distributedTracing)"() { protected ServerEndpoint lastRequest
setup: @Override
def requestBuilder = new Request.Builder() Request.Builder request(ServerEndpoint uri, String _method, String body) {
.url("http://localhost:$port/$context/$path") lastRequest = uri
.get() super.request(uri, _method, body)
if (distributedTracing) {
requestBuilder.header("x-datadog-trace-id", "123")
requestBuilder.header("x-datadog-parent-id", "456")
} }
if (auth) {
requestBuilder.header("Authorization", Credentials.basic(user, pass))
}
def response = client.newCall(requestBuilder.build()).execute()
expect: @Override
response.body().string().trim() == expectedResponse void serverSpan(TraceAssert trace, int index, String _traceId = null, String _parentId = null, String method = "GET", ServerEndpoint endpoint = SUCCESS) {
trace.span(index) {
assertTraces(1) { serviceName expectedServiceName()
trace(0, 1) { operationName expectedOperationName()
span(0) { resourceName endpoint.status == 404 ? "404" : "$method ${endpoint.resolve(address).path}"
if (distributedTracing) { spanType DDSpanTypes.HTTP_SERVER
traceId "123" errored endpoint.errored
parentId "456" if (_parentId != null) {
traceId _traceId
parentId _parentId
} else { } else {
parent() parent()
} }
serviceName context
operationName "servlet.request"
resourceName "GET /$context/$path"
spanType DDSpanTypes.HTTP_SERVER
errored false
tags { tags {
"http.url" "http://localhost:$port/$context/$path"
"http.method" "GET"
"span.kind" "server"
"component" "java-web-servlet"
"peer.hostname" "127.0.0.1"
"peer.ipv4" "127.0.0.1"
"peer.port" Integer
"span.origin.type" { it == "TestServlet3\$$origin" || it == ApplicationFilterChain.name }
"servlet.context" "/$context" "servlet.context" "/$context"
"http.status_code" 200 "span.origin.type" { it == servlet.name || it == ApplicationFilterChain.name }
if (auth) {
"$DDTags.USER_NAME" user
}
defaultTags(distributedTracing)
}
}
}
}
where:
path | expectedResponse | auth | origin | distributedTracing
"async" | "Hello Async" | false | "Async" | false
"sync" | "Hello Sync" | false | "Sync" | false
"auth/async" | "Hello Async" | true | "Async" | false
"auth/sync" | "Hello Sync" | true | "Sync" | false
"blocking" | "Hello BlockingAsync" | false | "BlockingAsync" | false
"fake" | "Hello FakeAsync" | false | "FakeAsync" | false
"async" | "Hello Async" | false | "Async" | true
"sync" | "Hello Sync" | false | "Sync" | true
"auth/async" | "Hello Async" | true | "Async" | true
"auth/sync" | "Hello Sync" | true | "Sync" | true
"blocking" | "Hello BlockingAsync" | false | "BlockingAsync" | true
"fake" | "Hello FakeAsync" | false | "FakeAsync" | true
}
def "test dispatch #path with depth #depth, distributed tracing: #distributedTracing"() {
setup:
def requestBuilder = new Request.Builder()
.url("http://localhost:$port/$context/dispatch/$path?depth=$depth")
.get()
if (distributedTracing) {
requestBuilder.header("x-datadog-trace-id", "123")
requestBuilder.header("x-datadog-parent-id", "456")
}
def response = client.newCall(requestBuilder.build()).execute()
expect:
response.body().string().trim() == "Hello $origin"
assertTraces(2 + depth) {
for (int i = 0; i < depth; i++) {
trace(i, 1) {
span(0) {
if (i == 0) {
if (distributedTracing) {
traceId "123"
parentId "456"
} else {
parent()
}
} else {
childOf TEST_WRITER[i - 1][0]
}
serviceName context
operationName "servlet.request"
resourceName "GET /$context/dispatch/$path"
spanType DDSpanTypes.HTTP_SERVER
errored false
tags {
"http.url" "http://localhost:$port/$context/dispatch/$path"
"http.method" "GET"
"span.kind" "server"
"component" "java-web-servlet"
"peer.hostname" "127.0.0.1"
"peer.ipv4" "127.0.0.1"
"peer.port" Integer
"span.origin.type" { it == "TestServlet3\$Dispatch$origin" || it == ApplicationFilterChain.name }
"http.status_code" 200
"servlet.context" "/$context"
"servlet.dispatch" "/dispatch/recursive?depth=${depth - i - 1}"
defaultTags(i > 0 ? true : distributedTracing)
}
}
}
}
// In case of recursive requests or sync request the most 'bottom' span is closed before its parent
trace(depth, 1) {
span(0) {
serviceName context
operationName "servlet.request"
resourceName "GET /$context/$path"
spanType DDSpanTypes.HTTP_SERVER
errored false
childOf TEST_WRITER[depth + 1][0]
tags {
"http.url" "http://localhost:$port/$context/$path"
"http.method" "GET"
"span.kind" "server"
"component" "java-web-servlet"
"peer.hostname" "127.0.0.1"
"peer.ipv4" "127.0.0.1"
"peer.port" Integer
"span.origin.type" {
it == "TestServlet3\$$origin" || it == "TestServlet3\$DispatchRecursive" || it == ApplicationFilterChain.name
}
"http.status_code" 200
"servlet.context" "/$context"
defaultTags(true) defaultTags(true)
"$Tags.COMPONENT.key" serverDecorator.component()
if (endpoint.errored) {
"$Tags.ERROR.key" endpoint.errored
"error.msg" { it == null || it == EXCEPTION.body}
"error.type" { it == null || it == Exception.name}
"error.stack" { it == null || it instanceof String}
} }
} "$Tags.HTTP_STATUS.key" endpoint.status
} "$Tags.HTTP_URL.key" "${endpoint.resolve(address)}"
trace(depth + 1, 1) { // if (tagQueryString) {
span(0) { // "$DDTags.HTTP_QUERY" uri.query
if (depth > 0) { // "$DDTags.HTTP_FRAGMENT" { it == null || it == uri.fragment } // Optional
childOf TEST_WRITER[depth - 1][0] // }
} else { "$Tags.PEER_HOSTNAME.key" "localhost"
if (distributedTracing) { "$Tags.PEER_PORT.key" Integer
traceId "123" "$Tags.PEER_HOST_IPV4.key" { it == null || it == "127.0.0.1" } // Optional
parentId "456" "$Tags.HTTP_METHOD.key" method
} else { "$Tags.SPAN_KIND.key" Tags.SPAN_KIND_SERVER
parent()
}
}
serviceName context
operationName "servlet.request"
resourceName "GET /$context/dispatch/$path"
spanType DDSpanTypes.HTTP_SERVER
errored false
tags {
"http.url" "http://localhost:$port/$context/dispatch/$path"
"http.method" "GET"
"span.kind" "server"
"component" "java-web-servlet"
"peer.hostname" "127.0.0.1"
"peer.ipv4" "127.0.0.1"
"peer.port" Integer
"span.origin.type" { it == "TestServlet3\$Dispatch$origin" || it == ApplicationFilterChain.name }
"http.status_code" 200
"servlet.context" "/$context"
"servlet.dispatch" "/$path"
defaultTags(depth > 0 ? true : distributedTracing)
} }
} }
} }
} }
where:
path | distributedTracing | depth
"sync" | true | 0
"sync" | false | 0
"recursive" | true | 0
"recursive" | false | 0
"recursive" | true | 1
"recursive" | false | 1
"recursive" | true | 20
"recursive" | false | 20
origin = path.capitalize()
}
def "test dispatch async #path with depth #depth, distributed tracing: #distributedTracing"() {
setup:
def requestBuilder = new Request.Builder()
.url("http://localhost:$port/$context/dispatch/$path")
.get()
if (distributedTracing) {
requestBuilder.header("x-datadog-trace-id", "123")
requestBuilder.header("x-datadog-parent-id", "456")
}
def response = client.newCall(requestBuilder.build()).execute()
expect:
response.body().string().trim() == "Hello $origin"
assertTraces(2) {
// Async requests have their parent span closed before child span
trace(0, 1) {
span(0) {
if (distributedTracing) {
traceId "123"
parentId "456"
} else {
parent()
}
serviceName context
operationName "servlet.request"
resourceName "GET /$context/dispatch/$path"
spanType DDSpanTypes.HTTP_SERVER
errored false
tags {
"http.url" "http://localhost:$port/$context/dispatch/$path"
"http.method" "GET"
"span.kind" "server"
"component" "java-web-servlet"
"peer.hostname" "127.0.0.1"
"peer.ipv4" "127.0.0.1"
"peer.port" Integer
"span.origin.type" { it == "TestServlet3\$Dispatch$origin" || it == ApplicationFilterChain.name }
"http.status_code" 200
"servlet.context" "/$context"
"servlet.dispatch" "/$path"
defaultTags(distributedTracing)
}
}
}
trace(1, 1) {
span(0) {
serviceName context
operationName "servlet.request"
resourceName "GET /$context/$path"
spanType DDSpanTypes.HTTP_SERVER
errored false
childOf TEST_WRITER[0][0]
tags {
"http.url" "http://localhost:$port/$context/$path"
"http.method" "GET"
"span.kind" "server"
"component" "java-web-servlet"
"peer.hostname" "127.0.0.1"
"peer.ipv4" "127.0.0.1"
"peer.port" Integer
"span.origin.type" {
it == "TestServlet3\$$origin" || it == "TestServlet3\$DispatchRecursive" || it == ApplicationFilterChain.name
}
"http.status_code" 200
"servlet.context" "/$context"
defaultTags(true)
}
}
}
}
where:
path | distributedTracing
"async" | true
"async" | false
origin = path.capitalize()
}
def "servlet instrumentation clears state after async request"() {
setup:
def request = new Request.Builder()
.url("http://localhost:$port/$context/$path")
.get()
.build()
def numTraces = 1
for (int i = 0; i < numTraces; ++i) {
client.newCall(request).execute()
}
expect:
assertTraces(dispatched ? numTraces * 2 : numTraces) {
for (int i = 0; (dispatched ? i + 1 : i) < TEST_WRITER.size(); i += (dispatched ? 2 : 1)) {
if (dispatched) {
trace(i, 1) {
span(0) {
operationName "servlet.request"
resourceName "GET /$context/dispatch/async"
spanType DDSpanTypes.HTTP_SERVER
parent()
}
}
}
trace(dispatched ? i + 1 : i, 1) {
span(0) {
operationName "servlet.request"
resourceName "GET /$context/async"
spanType DDSpanTypes.HTTP_SERVER
if (dispatched) {
childOf TEST_WRITER[i][0]
} else {
parent()
}
}
}
}
}
where:
path | dispatched
"async" | false
"dispatch/async" | true
}
def "test #path error servlet call"() {
setup:
def request = new Request.Builder()
.url("http://localhost:$port/$context/$path?error=true")
.get()
.build()
def response = client.newCall(request).execute()
expect:
response.body().string().trim() != expectedResponse
assertTraces(1) {
trace(0, 1) {
span(0) {
serviceName context
operationName "servlet.request"
resourceName "GET /$context/$path"
spanType DDSpanTypes.HTTP_SERVER
errored true
parent()
tags {
"http.url" "http://localhost:$port/$context/$path"
"http.method" "GET"
"span.kind" "server"
"component" "java-web-servlet"
"peer.hostname" "127.0.0.1"
"peer.ipv4" "127.0.0.1"
"peer.port" Integer
"span.origin.type" { it == "TestServlet3\$$origin" || it == ApplicationFilterChain.name }
"servlet.context" "/$context"
"http.status_code" 500
errorTags(RuntimeException, "some $path error")
defaultTags()
}
}
}
}
where:
path | expectedResponse
//"async" | "Hello Async" // FIXME: I can't seem get the async error handler to trigger
"sync" | "Hello Sync"
origin = path.capitalize()
}
def "test #path non-throwing-error servlet call"() {
setup:
def request = new Request.Builder()
.url("http://localhost:$port/$context/$path?non-throwing-error=true")
.get()
.build()
def response = client.newCall(request).execute()
expect:
response.body().string().trim() != expectedResponse
assertTraces(1) {
trace(0, 1) {
span(0) {
serviceName context
operationName "servlet.request"
resourceName "GET /$context/$path"
spanType DDSpanTypes.HTTP_SERVER
errored true
parent()
tags {
"http.url" "http://localhost:$port/$context/$path"
"http.method" "GET"
"span.kind" "server"
"component" "java-web-servlet"
"peer.hostname" "127.0.0.1"
"peer.ipv4" "127.0.0.1"
"peer.port" Integer
"span.origin.type" { it == "TestServlet3\$$origin" || it == ApplicationFilterChain.name }
"servlet.context" "/$context"
"http.status_code" 500
"error" true
defaultTags()
}
}
}
}
where:
path | expectedResponse
"sync" | "Hello Sync"
origin = path.capitalize()
}
}

222
dd-java-agent/instrumentation/servlet-3/src/test/groovy/JettyServlet3Test.groovy
View File

@ -1,27 +1,47 @@
import datadog.trace.agent.test.utils.PortUtils import datadog.trace.agent.test.asserts.ListWriterAssert
import org.eclipse.jetty.security.ConstraintMapping import datadog.trace.api.DDSpanTypes
import org.eclipse.jetty.security.ConstraintSecurityHandler import groovy.transform.stc.ClosureParams
import org.eclipse.jetty.security.HashLoginService import groovy.transform.stc.SimpleType
import org.eclipse.jetty.security.LoginService import io.opentracing.tag.Tags
import org.eclipse.jetty.security.authentication.BasicAuthenticator import javax.servlet.Servlet
import javax.servlet.http.HttpServletRequest
import org.apache.catalina.core.ApplicationFilterChain
import org.eclipse.jetty.server.Server import org.eclipse.jetty.server.Server
import org.eclipse.jetty.server.handler.ErrorHandler
import org.eclipse.jetty.servlet.ServletContextHandler import org.eclipse.jetty.servlet.ServletContextHandler
import org.eclipse.jetty.util.security.Constraint
import spock.lang.Shared import spock.lang.Shared
import javax.servlet.Servlet import static datadog.trace.agent.test.asserts.TraceAssert.assertTrace
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.AUTH_REQUIRED
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.ERROR
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.EXCEPTION
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.REDIRECT
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.SUCCESS
import static datadog.trace.agent.test.utils.TraceUtils.basicSpan
class JettyServlet3Test extends AbstractServlet3Test<ServletContextHandler> { abstract class JettyServlet3Test extends AbstractServlet3Test<ServletContextHandler> {
@Shared @Shared
private Server jettyServer private Server jettyServer
def setupSpec() { @Override
port = PortUtils.randomOpenPort() boolean testNotFound() {
false
}
@Override
void startServer(int port) {
jettyServer = new Server(port) jettyServer = new Server(port)
jettyServer.connectors.each { it.resolveNames = true } // get localhost instead of 127.0.0.1
ServletContextHandler servletContext = new ServletContextHandler(null, "/$context") ServletContextHandler servletContext = new ServletContextHandler(null, "/$context")
setupAuthentication(jettyServer, servletContext) servletContext.errorHandler = new ErrorHandler() {
protected void handleErrorPage(HttpServletRequest request, Writer writer, int code, String message) throws IOException {
Throwable th = (Throwable)request.getAttribute("javax.servlet.error.exception");
writer.write(th.message)
}
}
// setupAuthentication(jettyServer, servletContext)
setupServlets(servletContext) setupServlets(servletContext)
jettyServer.setHandler(servletContext) jettyServer.setHandler(servletContext)
@ -31,7 +51,8 @@ class JettyServlet3Test extends AbstractServlet3Test<ServletContextHandler> {
"Jetty server: http://localhost:" + port + "/") "Jetty server: http://localhost:" + port + "/")
} }
def cleanupSpec() { @Override
void stopServer() {
jettyServer.stop() jettyServer.stop()
jettyServer.destroy() jettyServer.destroy()
} }
@ -42,30 +63,163 @@ class JettyServlet3Test extends AbstractServlet3Test<ServletContextHandler> {
} }
@Override @Override
void addServlet(ServletContextHandler servletContext, String url, Class<Servlet> servlet) { void addServlet(ServletContextHandler servletContext, String path, Class<Servlet> servlet) {
servletContext.addServlet(servlet, url) servletContext.addServlet(servlet, path)
} }
static setupAuthentication(Server jettyServer, ServletContextHandler servletContext) { // FIXME: Add authentication tests back in...
ConstraintSecurityHandler authConfig = new ConstraintSecurityHandler() // static setupAuthentication(Server jettyServer, ServletContextHandler servletContext) {
// ConstraintSecurityHandler authConfig = new ConstraintSecurityHandler()
//
// Constraint constraint = new Constraint()
// constraint.setName("auth")
// constraint.setAuthenticate(true)
// constraint.setRoles("role")
//
// ConstraintMapping mapping = new ConstraintMapping()
// mapping.setPathSpec("/auth/*")
// mapping.setConstraint(constraint)
//
// authConfig.setConstraintMappings(mapping)
// authConfig.setAuthenticator(new BasicAuthenticator())
//
// LoginService loginService = new HashLoginService("TestRealm",
// "src/test/resources/realm.properties")
// authConfig.setLoginService(loginService)
// jettyServer.addBean(loginService)
//
// servletContext.setSecurityHandler(authConfig)
// }
}
Constraint constraint = new Constraint() class JettyServlet3TestSync extends JettyServlet3Test {
constraint.setName("auth")
constraint.setAuthenticate(true)
constraint.setRoles("role")
ConstraintMapping mapping = new ConstraintMapping() @Override
mapping.setPathSpec("/auth/*") Class<Servlet> servlet() {
mapping.setConstraint(constraint) TestServlet3.Sync
}
authConfig.setConstraintMappings(mapping) }
authConfig.setAuthenticator(new BasicAuthenticator())
// FIXME: Async context propagation for org.eclipse.jetty.util.thread.QueuedThreadPool.dispatch currently broken.
LoginService loginService = new HashLoginService("TestRealm", //class JettyServlet3TestAsync extends JettyServlet3Test {
"src/test/resources/realm.properties") //
authConfig.setLoginService(loginService) // @Override
jettyServer.addBean(loginService) // Class<Servlet> servlet() {
// TestServlet3.Async
servletContext.setSecurityHandler(authConfig) // }
//}
class JettyServlet3TestFakeAsync extends JettyServlet3Test {
@Override
Class<Servlet> servlet() {
TestServlet3.FakeAsync
}
}
class JettyServlet3TestDispatchImmediate extends JettyDispatchTest {
@Override
Class<Servlet> servlet() {
TestServlet3.Sync
}
@Override
protected void setupServlets(ServletContextHandler context) {
super.setupServlets(context)
addServlet(context, "/dispatch" + SUCCESS.path, TestServlet3.DispatchImmediate)
addServlet(context, "/dispatch" + ERROR.path, TestServlet3.DispatchImmediate)
addServlet(context, "/dispatch" + EXCEPTION.path, TestServlet3.DispatchImmediate)
addServlet(context, "/dispatch" + REDIRECT.path, TestServlet3.DispatchImmediate)
addServlet(context, "/dispatch" + AUTH_REQUIRED.path, TestServlet3.DispatchImmediate)
addServlet(context, "/dispatch/recursive", TestServlet3.DispatchRecursive)
}
}
// TODO: Behavior in this test is pretty inconsistent with expectations. Fix and reenable.
//class JettyServlet3TestDispatchAsync extends JettyDispatchTest {
// @Override
// Class<Servlet> servlet() {
// TestServlet3.Async
// }
//
// @Override
// protected void setupServlets(ServletContextHandler context) {
// super.setupServlets(context)
//
// addServlet(context, "/dispatch" + SUCCESS.path, TestServlet3.DispatchAsync)
// addServlet(context, "/dispatch" + ERROR.path, TestServlet3.DispatchAsync)
// addServlet(context, "/dispatch" + EXCEPTION.path, TestServlet3.DispatchAsync)
// addServlet(context, "/dispatch" + REDIRECT.path, TestServlet3.DispatchAsync)
// addServlet(context, "/dispatch" + AUTH_REQUIRED.path, TestServlet3.DispatchAsync)
// addServlet(context, "/dispatch/recursive", TestServlet3.DispatchRecursive)
// }
//}
abstract class JettyDispatchTest extends JettyServlet3Test {
@Override
URI buildAddress() {
return new URI("http://localhost:$port/$context/dispatch/")
}
@Override
void cleanAndAssertTraces(
final int size,
@ClosureParams(value = SimpleType, options = "datadog.trace.agent.test.asserts.ListWriterAssert")
@DelegatesTo(value = ListWriterAssert.class, strategy = Closure.DELEGATE_FIRST)
final Closure spec) {
// If this is failing, make sure HttpServerTestAdvice is applied correctly.
TEST_WRITER.waitForTraces(size + 2)
// TEST_WRITER is a CopyOnWriteArrayList, which doesn't support remove()
def toRemove = TEST_WRITER.find() {
it.size() == 1 && it.get(0).operationName == "TEST_SPAN"
}
assertTrace(toRemove, 1) {
basicSpan(it, 0, "TEST_SPAN", "ServerEntry")
}
TEST_WRITER.remove(toRemove)
// Validate dispatch trace
def dispatchTrace = TEST_WRITER.find() {
it.size() == 1 && it.get(0).resourceName.contains("/dispatch/")
}
assertTrace(dispatchTrace, 1) {
def endpoint = lastRequest
span(0) {
serviceName expectedServiceName()
operationName expectedOperationName()
resourceName endpoint.status == 404 ? "404" : "GET ${endpoint.resolve(address).path}"
spanType DDSpanTypes.HTTP_SERVER
errored endpoint.errored
// parent()
tags {
"servlet.context" "/$context"
"servlet.dispatch" endpoint.path
"span.origin.type" { it == TestServlet3.DispatchImmediate.name || it == TestServlet3.DispatchAsync.name || it == ApplicationFilterChain.name }
defaultTags(true)
"$Tags.COMPONENT.key" serverDecorator.component()
if (endpoint.errored) {
"$Tags.ERROR.key" endpoint.errored
"error.msg" { it == null || it == EXCEPTION.body}
"error.type" { it == null || it == Exception.name}
"error.stack" { it == null || it instanceof String}
}
"$Tags.HTTP_STATUS.key" endpoint.status
"$Tags.HTTP_URL.key" "${endpoint.resolve(address)}"
"$Tags.PEER_HOSTNAME.key" "localhost"
"$Tags.PEER_PORT.key" Integer
"$Tags.PEER_HOST_IPV4.key" { it == null || it == "127.0.0.1" } // Optional
"$Tags.HTTP_METHOD.key" "GET"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_SERVER
}
}
}
TEST_WRITER.remove(dispatchTrace)
// Make sure that the trace has a span with the dispatchTrace as a parent.
assert TEST_WRITER.any { it.any { it.parentId == dispatchTrace[0].spanId } }
} }
} }

24
dd-java-agent/instrumentation/servlet-3/src/test/groovy/ServletTestInstrumentation.java Normal file
View File

@ -0,0 +1,24 @@
import static net.bytebuddy.matcher.ElementMatchers.named;
import com.google.auto.service.AutoService;
import datadog.trace.agent.test.base.HttpServerTestAdvice;
import datadog.trace.agent.tooling.Instrumenter;
import net.bytebuddy.agent.builder.AgentBuilder;
@AutoService(Instrumenter.class)
public class ServletTestInstrumentation implements Instrumenter {
@Override
public AgentBuilder instrument(final AgentBuilder agentBuilder) {
return agentBuilder
// Jetty
.type(named("org.eclipse.jetty.server.AbstractHttpConnection"))
.transform(new AgentBuilder.Transformer.ForAdvice()
.advice(named("headerComplete"), HttpServerTestAdvice.ServerEntryAdvice.class.getName()))
// Tomcat
.type(named("org.apache.catalina.connector.CoyoteAdapter"))
.transform(new AgentBuilder.Transformer.ForAdvice()
.advice(named("service"), HttpServerTestAdvice.ServerEntryAdvice.class.getName()))
;
}
}

121
dd-java-agent/instrumentation/servlet-3/src/test/groovy/TestServlet3.groovy
View File

@ -1,80 +1,134 @@
import datadog.trace.agent.test.base.HttpServerTest
import groovy.servlet.AbstractHttpServlet import groovy.servlet.AbstractHttpServlet
import javax.servlet.annotation.WebServlet import javax.servlet.annotation.WebServlet
import javax.servlet.http.HttpServletRequest import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse import javax.servlet.http.HttpServletResponse
import java.util.concurrent.CountDownLatch
import java.util.concurrent.Phaser
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.ERROR
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.EXCEPTION
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.REDIRECT
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.SUCCESS
class TestServlet3 { class TestServlet3 {
@WebServlet @WebServlet
static class Sync extends AbstractHttpServlet { static class Sync extends AbstractHttpServlet {
@Override @Override
void doGet(HttpServletRequest req, HttpServletResponse resp) { protected void service(HttpServletRequest req, HttpServletResponse resp) {
if (req.getParameter("error") != null) { HttpServerTest.ServerEndpoint endpoint = HttpServerTest.ServerEndpoint.forPath(req.servletPath)
throw new RuntimeException("some sync error") HttpServerTest.controller(endpoint) {
resp.contentType = "text/plain"
switch (endpoint) {
case SUCCESS:
case ERROR:
resp.status = endpoint.status
resp.writer.print(endpoint.body)
break
case REDIRECT:
resp.sendRedirect(endpoint.body)
break
case EXCEPTION:
throw new Exception(endpoint.body)
} }
if (req.getParameter("non-throwing-error") != null) {
resp.sendError(500, "some sync error")
return
} }
resp.writer.print("Hello Sync")
} }
} }
@WebServlet(asyncSupported = true) @WebServlet(asyncSupported = true)
static class Async extends AbstractHttpServlet { static class Async extends AbstractHttpServlet {
@Override @Override
void doGet(HttpServletRequest req, HttpServletResponse resp) { protected void service(HttpServletRequest req, HttpServletResponse resp) {
def latch = new CountDownLatch(1) HttpServerTest.ServerEndpoint endpoint = HttpServerTest.ServerEndpoint.forPath(req.servletPath)
def phaser = new Phaser(2)
def context = req.startAsync() def context = req.startAsync()
context.start { context.start {
latch.await() try {
resp.writer.print("Hello Async") phaser.arrive()
HttpServerTest.controller(endpoint) {
resp.contentType = "text/plain"
switch (endpoint) {
case SUCCESS:
case ERROR:
resp.status = endpoint.status
resp.writer.print(endpoint.body)
context.complete() context.complete()
break
case REDIRECT:
resp.sendRedirect(endpoint.body)
context.complete()
break
case EXCEPTION:
resp.status = endpoint.status
resp.writer.print(endpoint.body)
context.complete()
throw new Exception(endpoint.body)
} }
latch.countDown() }
} finally {
phaser.arriveAndDeregister()
}
}
phaser.arriveAndAwaitAdvance()
phaser.arriveAndAwaitAdvance()
} }
} }
@WebServlet(asyncSupported = true) @WebServlet(asyncSupported = true)
static class BlockingAsync extends AbstractHttpServlet { static class FakeAsync extends AbstractHttpServlet {
@Override @Override
void doGet(HttpServletRequest req, HttpServletResponse resp) { protected void service(HttpServletRequest req, HttpServletResponse resp) {
def latch = new CountDownLatch(1)
def context = req.startAsync() def context = req.startAsync()
context.start { try {
resp.writer.print("Hello BlockingAsync") HttpServerTest.ServerEndpoint endpoint = HttpServerTest.ServerEndpoint.forPath(req.servletPath)
context.complete() HttpServerTest.controller(endpoint) {
latch.countDown() resp.contentType = "text/plain"
switch (endpoint) {
case SUCCESS:
case ERROR:
resp.status = endpoint.status
resp.writer.print(endpoint.body)
break
case REDIRECT:
resp.sendRedirect(endpoint.body)
break
case EXCEPTION:
throw new Exception(endpoint.body)
}
}
} finally {
context.complete()
} }
latch.await()
} }
} }
@WebServlet(asyncSupported = true) @WebServlet(asyncSupported = true)
static class DispatchSync extends AbstractHttpServlet { static class DispatchImmediate extends AbstractHttpServlet {
@Override @Override
void doGet(HttpServletRequest req, HttpServletResponse resp) { protected void service(HttpServletRequest req, HttpServletResponse resp) {
req.startAsync().dispatch("/sync") def target = req.servletPath.replace("/dispatch", "")
req.startAsync().dispatch(target)
} }
} }
@WebServlet(asyncSupported = true) @WebServlet(asyncSupported = true)
static class DispatchAsync extends AbstractHttpServlet { static class DispatchAsync extends AbstractHttpServlet {
@Override @Override
void doGet(HttpServletRequest req, HttpServletResponse resp) { protected void service(HttpServletRequest req, HttpServletResponse resp) {
def target = req.servletPath.replace("/dispatch", "")
def context = req.startAsync() def context = req.startAsync()
context.start { context.start {
context.dispatch("/async") context.dispatch(target)
} }
} }
} }
// TODO: Add tests for this!
@WebServlet(asyncSupported = true) @WebServlet(asyncSupported = true)
static class DispatchRecursive extends AbstractHttpServlet { static class DispatchRecursive extends AbstractHttpServlet {
@Override @Override
void doGet(HttpServletRequest req, HttpServletResponse resp) { protected void service(HttpServletRequest req, HttpServletResponse resp) {
if (req.servletPath.equals("/recursive")) { if (req.servletPath.equals("/recursive")) {
resp.writer.print("Hello Recursive") resp.writer.print("Hello Recursive")
return return
@ -87,15 +141,4 @@ class TestServlet3 {
} }
} }
} }
@WebServlet(asyncSupported = true)
static class FakeAsync extends AbstractHttpServlet {
@Override
void doGet(HttpServletRequest req, HttpServletResponse resp) {
def context = req.startAsync()
resp.writer.print("Hello FakeAsync")
context.complete()
}
}
} }

256
dd-java-agent/instrumentation/servlet-3/src/test/groovy/TomcatServlet3Test.groovy
View File

@ -1,33 +1,45 @@
import com.google.common.io.Files import com.google.common.io.Files
import datadog.trace.agent.test.asserts.ListWriterAssert
import datadog.trace.api.DDSpanTypes
import groovy.transform.stc.ClosureParams
import groovy.transform.stc.SimpleType
import io.opentracing.tag.Tags
import javax.servlet.Servlet
import org.apache.catalina.Context import org.apache.catalina.Context
import org.apache.catalina.LifecycleState import org.apache.catalina.connector.Request
import org.apache.catalina.realm.MemoryRealm import org.apache.catalina.connector.Response
import org.apache.catalina.realm.MessageDigestCredentialHandler import org.apache.catalina.core.ApplicationFilterChain
import org.apache.catalina.core.StandardHost
import org.apache.catalina.startup.Tomcat import org.apache.catalina.startup.Tomcat
import org.apache.catalina.valves.ErrorReportValve
import org.apache.tomcat.JarScanFilter import org.apache.tomcat.JarScanFilter
import org.apache.tomcat.JarScanType import org.apache.tomcat.JarScanType
import org.apache.tomcat.util.descriptor.web.LoginConfig
import org.apache.tomcat.util.descriptor.web.SecurityCollection
import org.apache.tomcat.util.descriptor.web.SecurityConstraint
import spock.lang.Shared import spock.lang.Shared
import javax.servlet.Servlet import static datadog.trace.agent.test.asserts.TraceAssert.assertTrace
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.AUTH_REQUIRED
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.ERROR
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.EXCEPTION
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.REDIRECT
import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.SUCCESS
import static datadog.trace.agent.test.utils.TraceUtils.basicSpan
class TomcatServlet3Test extends AbstractServlet3Test<Context> { abstract class TomcatServlet3Test extends AbstractServlet3Test<Context> {
@Shared @Shared
Tomcat tomcatServer Tomcat tomcatServer
@Shared
def baseDir = Files.createTempDir()
def setupSpec() { @Override
void startServer(int port) {
tomcatServer = new Tomcat() tomcatServer = new Tomcat()
tomcatServer.setPort(port)
tomcatServer.getConnector()
def baseDir = Files.createTempDir()
baseDir.deleteOnExit() baseDir.deleteOnExit()
tomcatServer.setBaseDir(baseDir.getAbsolutePath()) tomcatServer.setBaseDir(baseDir.getAbsolutePath())
tomcatServer.setPort(port)
tomcatServer.getConnector().enableLookups = true // get localhost instead of 127.0.0.1
final File applicationDir = new File(baseDir, "/webapps/ROOT") final File applicationDir = new File(baseDir, "/webapps/ROOT")
if (!applicationDir.exists()) { if (!applicationDir.exists()) {
applicationDir.mkdirs() applicationDir.mkdirs()
@ -42,15 +54,18 @@ class TomcatServlet3Test extends AbstractServlet3Test<Context> {
} }
}) })
setupAuthentication(tomcatServer, servletContext) // setupAuthentication(tomcatServer, servletContext)
setupServlets(servletContext) setupServlets(servletContext)
(tomcatServer.host as StandardHost).errorReportValveClass = ErrorHandlerValve.name
tomcatServer.start() tomcatServer.start()
System.out.println( System.out.println(
"Tomcat server: http://" + tomcatServer.getHost().getName() + ":" + port + "/") "Tomcat server: http://" + tomcatServer.getHost().getName() + ":" + port + "/")
} }
def cleanupSpec() { @Override
void stopServer() {
tomcatServer.stop() tomcatServer.stop()
tomcatServer.destroy() tomcatServer.destroy()
} }
@ -61,41 +76,196 @@ class TomcatServlet3Test extends AbstractServlet3Test<Context> {
} }
@Override @Override
void addServlet(Context servletContext, String url, Class<Servlet> servlet) { void addServlet(Context servletContext, String path, Class<Servlet> servlet) {
String name = UUID.randomUUID() String name = UUID.randomUUID()
Tomcat.addServlet(servletContext, name, servlet.newInstance()) Tomcat.addServlet(servletContext, name, servlet.newInstance())
servletContext.addServletMappingDecoded(url, name) servletContext.addServletMappingDecoded(path, name)
} }
private setupAuthentication(Tomcat server, Context servletContext) { // FIXME: Add authentication tests back in...
// Login Config // private setupAuthentication(Tomcat server, Context servletContext) {
LoginConfig authConfig = new LoginConfig() // // Login Config
authConfig.setAuthMethod("BASIC") // LoginConfig authConfig = new LoginConfig()
// authConfig.setAuthMethod("BASIC")
//
// // adding constraint with role "test"
// SecurityConstraint constraint = new SecurityConstraint()
// constraint.addAuthRole("role")
//
// // add constraint to a collection with pattern /second
// SecurityCollection collection = new SecurityCollection()
// collection.addPattern("/auth/*")
// constraint.addCollection(collection)
//
// servletContext.setLoginConfig(authConfig)
// // does the context need a auth role too?
// servletContext.addSecurityRole("role")
// servletContext.addConstraint(constraint)
//
// // add tomcat users to realm
// MemoryRealm realm = new MemoryRealm() {
// protected void startInternal() {
// credentialHandler = new MessageDigestCredentialHandler()
// setState(LifecycleState.STARTING)
// }
// }
// realm.addUser(user, pass, "role")
// server.getEngine().setRealm(realm)
//
// servletContext.setLoginConfig(authConfig)
// }
}
// adding constraint with role "test" class ErrorHandlerValve extends ErrorReportValve {
SecurityConstraint constraint = new SecurityConstraint() @Override
constraint.addAuthRole("role") protected void report(Request request, Response response, Throwable t) {
if (response.getStatus() < 400 || response.getContentWritten() > 0 || !response.setErrorReported()) {
// add constraint to a collection with pattern /second return
SecurityCollection collection = new SecurityCollection() }
collection.addPattern("/auth/*") try {
constraint.addCollection(collection) response.writer.print(t.cause.message)
} catch (IOException e) {
servletContext.setLoginConfig(authConfig) e.printStackTrace()
// does the context need a auth role too? }
servletContext.addSecurityRole("role")
servletContext.addConstraint(constraint)
// add tomcat users to realm
MemoryRealm realm = new MemoryRealm() {
protected void startInternal() {
credentialHandler = new MessageDigestCredentialHandler()
setState(LifecycleState.STARTING)
} }
} }
realm.addUser(user, pass, "role")
server.getEngine().setRealm(realm)
servletContext.setLoginConfig(authConfig) class TomcatServlet3TestSync extends TomcatServlet3Test {
@Override
Class<Servlet> servlet() {
TestServlet3.Sync
}
}
class TomcatServlet3TestAsync extends TomcatServlet3Test {
@Override
Class<Servlet> servlet() {
TestServlet3.Async
}
}
class TomcatServlet3TestFakeAsync extends TomcatServlet3Test {
@Override
Class<Servlet> servlet() {
TestServlet3.FakeAsync
}
}
class TomcatServlet3TestDispatchImmediate extends TomcatDispatchTest {
@Override
Class<Servlet> servlet() {
TestServlet3.Sync
}
@Override
boolean testNotFound() {
false
}
@Override
protected void setupServlets(Context context) {
super.setupServlets(context)
addServlet(context, "/dispatch" + SUCCESS.path, TestServlet3.DispatchImmediate)
addServlet(context, "/dispatch" + ERROR.path, TestServlet3.DispatchImmediate)
addServlet(context, "/dispatch" + EXCEPTION.path, TestServlet3.DispatchImmediate)
addServlet(context, "/dispatch" + REDIRECT.path, TestServlet3.DispatchImmediate)
addServlet(context, "/dispatch" + AUTH_REQUIRED.path, TestServlet3.DispatchImmediate)
addServlet(context, "/dispatch/recursive", TestServlet3.DispatchRecursive)
}
}
// TODO: Behavior in this test is pretty inconsistent with expectations. Fix and reenable.
//class TomcatServlet3TestDispatchAsync extends TomcatDispatchTest {
// @Override
// Class<Servlet> servlet() {
// TestServlet3.Async
// }
//
// @Override
// protected void setupServlets(Context context) {
// super.setupServlets(context)
//
// addServlet(context, "/dispatch" + SUCCESS.path, TestServlet3.DispatchAsync)
// addServlet(context, "/dispatch" + ERROR.path, TestServlet3.DispatchAsync)
// addServlet(context, "/dispatch" + EXCEPTION.path, TestServlet3.DispatchAsync)
// addServlet(context, "/dispatch" + REDIRECT.path, TestServlet3.DispatchAsync)
// addServlet(context, "/dispatch" + AUTH_REQUIRED.path, TestServlet3.DispatchAsync)
// addServlet(context, "/dispatch/recursive", TestServlet3.DispatchRecursive)
// }
//}
abstract class TomcatDispatchTest extends TomcatServlet3Test {
@Override
URI buildAddress() {
return new URI("http://localhost:$port/$context/dispatch/")
}
@Override
void cleanAndAssertTraces(
final int size,
@ClosureParams(value = SimpleType, options = "datadog.trace.agent.test.asserts.ListWriterAssert")
@DelegatesTo(value = ListWriterAssert.class, strategy = Closure.DELEGATE_FIRST)
final Closure spec) {
// If this is failing, make sure HttpServerTestAdvice is applied correctly.
TEST_WRITER.waitForTraces(size * 2)
// TEST_WRITER is a CopyOnWriteArrayList, which doesn't support remove()
def toRemove = TEST_WRITER.findAll() {
it.size() == 1 && it.get(0).operationName == "TEST_SPAN"
}
toRemove.each {
assertTrace(it, 1) {
basicSpan(it, 0, "TEST_SPAN", "ServerEntry")
}
}
assert toRemove.size() == size
TEST_WRITER.removeAll(toRemove)
// Validate dispatch trace
def dispatchTrace = TEST_WRITER.find() {
it.size() == 1 && it.get(0).resourceName.contains("/dispatch/")
}
assertTrace(dispatchTrace, 1) {
def endpoint = lastRequest
span(0) {
serviceName expectedServiceName()
operationName expectedOperationName()
resourceName endpoint.status == 404 ? "404" : "GET ${endpoint.resolve(address).path}"
spanType DDSpanTypes.HTTP_SERVER
errored endpoint.errored
// parent()
tags {
"servlet.context" "/$context"
"servlet.dispatch" endpoint.path
"span.origin.type" {
it == TestServlet3.DispatchImmediate.name || it == TestServlet3.DispatchAsync.name || it == ApplicationFilterChain.name
}
defaultTags(true)
"$Tags.COMPONENT.key" serverDecorator.component()
if (endpoint.errored) {
"$Tags.ERROR.key" endpoint.errored
"error.msg" { it == null || it == EXCEPTION.body}
"error.type" { it == null || it == Exception.name}
"error.stack" { it == null || it instanceof String}
}
"$Tags.HTTP_STATUS.key" endpoint.status
"$Tags.HTTP_URL.key" "${endpoint.resolve(address)}"
"$Tags.PEER_HOSTNAME.key" "localhost"
"$Tags.PEER_PORT.key" Integer
"$Tags.PEER_HOST_IPV4.key" { it == null || it == "127.0.0.1" } // Optional
"$Tags.HTTP_METHOD.key" "GET"
"$Tags.SPAN_KIND.key" Tags.SPAN_KIND_SERVER
}
}
}
TEST_WRITER.remove(dispatchTrace)
// Make sure that the trace has a span with the dispatchTrace as a parent.
assert TEST_WRITER.any { it.any { it.parentId == dispatchTrace[0].spanId } }
} }
} }

2
dd-java-agent/testing/src/main/groovy/datadog/trace/agent/test/asserts/TraceAssert.groovy
View File

@ -18,7 +18,7 @@ class TraceAssert {
static void assertTrace(List<DDSpan> trace, int expectedSize, static void assertTrace(List<DDSpan> trace, int expectedSize,
@ClosureParams(value = SimpleType, options = ['datadog.trace.agent.test.asserts.TraceAssert']) @ClosureParams(value = SimpleType, options = ['datadog.trace.agent.test.asserts.TraceAssert'])
@DelegatesTo(value = File, strategy = Closure.DELEGATE_FIRST) Closure spec) { @DelegatesTo(value = TraceAssert, strategy = Closure.DELEGATE_FIRST) Closure spec) {
assert trace.size() == expectedSize assert trace.size() == expectedSize
def asserter = new TraceAssert(trace) def asserter = new TraceAssert(trace)
def clone = (Closure) spec.clone() def clone = (Closure) spec.clone()

7
dd-java-agent/testing/src/main/groovy/datadog/trace/agent/test/base/HttpClientTest.groovy
View File

@ -21,6 +21,7 @@ import static datadog.trace.agent.test.utils.TraceUtils.basicSpan
import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace
import static org.junit.Assume.assumeTrue import static org.junit.Assume.assumeTrue
@Unroll
abstract class HttpClientTest<DECORATOR extends HttpClientDecorator> extends AgentTestRunner { abstract class HttpClientTest<DECORATOR extends HttpClientDecorator> extends AgentTestRunner {
protected static final BODY_METHODS = ["POST", "PUT"] protected static final BODY_METHODS = ["POST", "PUT"]
@ -69,7 +70,6 @@ abstract class HttpClientTest<DECORATOR extends HttpClientDecorator> extends Age
return null return null
} }
@Unroll
def "basic #method request #url - tagQueryString=#tagQueryString"() { def "basic #method request #url - tagQueryString=#tagQueryString"() {
when: when:
def status = withConfigOverride(Config.HTTP_CLIENT_TAG_QUERY_STRING, "$tagQueryString") { def status = withConfigOverride(Config.HTTP_CLIENT_TAG_QUERY_STRING, "$tagQueryString") {
@ -98,7 +98,6 @@ abstract class HttpClientTest<DECORATOR extends HttpClientDecorator> extends Age
url = server.address.resolve(path) url = server.address.resolve(path)
} }
@Unroll
def "basic #method request with parent"() { def "basic #method request with parent"() {
when: when:
def status = runUnderTrace("parent") { def status = runUnderTrace("parent") {
@ -121,7 +120,6 @@ abstract class HttpClientTest<DECORATOR extends HttpClientDecorator> extends Age
//FIXME: add tests for POST with large/chunked data //FIXME: add tests for POST with large/chunked data
@Unroll
def "basic #method request with split-by-domain"() { def "basic #method request with split-by-domain"() {
when: when:
def status = withConfigOverride(Config.HTTP_CLIENT_HOST_SPLIT_BY_DOMAIN, "true") { def status = withConfigOverride(Config.HTTP_CLIENT_HOST_SPLIT_BY_DOMAIN, "true") {
@ -212,7 +210,6 @@ abstract class HttpClientTest<DECORATOR extends HttpClientDecorator> extends Age
method = "GET" method = "GET"
} }
@Unroll
def "basic #method request with 1 redirect"() { def "basic #method request with 1 redirect"() {
given: given:
assumeTrue(testRedirects()) assumeTrue(testRedirects())
@ -235,7 +232,6 @@ abstract class HttpClientTest<DECORATOR extends HttpClientDecorator> extends Age
method = "GET" method = "GET"
} }
@Unroll
def "basic #method request with 2 redirects"() { def "basic #method request with 2 redirects"() {
given: given:
assumeTrue(testRedirects()) assumeTrue(testRedirects())
@ -259,7 +255,6 @@ abstract class HttpClientTest<DECORATOR extends HttpClientDecorator> extends Age
method = "GET" method = "GET"
} }
@Unroll
def "basic #method request with circular redirects"() { def "basic #method request with circular redirects"() {
given: given:
assumeTrue(testRedirects()) assumeTrue(testRedirects())

49
dd-java-agent/testing/src/main/groovy/datadog/trace/agent/test/base/HttpServerTest.groovy
View File

@ -14,7 +14,9 @@ import io.opentracing.tag.Tags
import okhttp3.HttpUrl import okhttp3.HttpUrl
import okhttp3.OkHttpClient import okhttp3.OkHttpClient
import okhttp3.Request import okhttp3.Request
import okhttp3.Response
import spock.lang.Shared import spock.lang.Shared
import spock.lang.Unroll
import java.util.concurrent.atomic.AtomicBoolean import java.util.concurrent.atomic.AtomicBoolean
@ -27,6 +29,7 @@ import static datadog.trace.agent.test.utils.TraceUtils.basicSpan
import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace
import static org.junit.Assume.assumeTrue import static org.junit.Assume.assumeTrue
@Unroll
abstract class HttpServerTest<DECORATOR extends HttpServerDecorator> extends AgentTestRunner { abstract class HttpServerTest<DECORATOR extends HttpServerDecorator> extends AgentTestRunner {
@Shared @Shared
@ -78,11 +81,13 @@ abstract class HttpServerTest<DECORATOR extends HttpServerDecorator> extends Age
private final String path private final String path
final int status final int status
final String body final String body
final Boolean errored
ServerEndpoint(String path, int status, String body) { ServerEndpoint(String path, int status, String body) {
this.path = path this.path = path
this.status = status this.status = status
this.body = body this.body = body
this.errored = status >= 500
} }
String getPath() { String getPath() {
@ -114,26 +119,33 @@ abstract class HttpServerTest<DECORATOR extends HttpServerDecorator> extends Age
} }
} }
def "test success"() { def "test success with #count requests"() {
setup: setup:
def request = request(SUCCESS, method, body).build() def request = request(SUCCESS, method, body).build()
def response = client.newCall(request).execute() List<Response> responses = (1..count).collect {
return client.newCall(request).execute()
}
expect: expect:
response.code() == SUCCESS.status responses.each { response ->
response.body().string() == SUCCESS.body assert response.code() == SUCCESS.status
assert response.body().string() == SUCCESS.body
}
and: and:
cleanAndAssertTraces(1) { cleanAndAssertTraces(count) {
trace(0, 2) { (1..count).eachWithIndex { val, i ->
trace(i, 2) {
serverSpan(it, 0) serverSpan(it, 0)
controllerSpan(it, 1, span(0)) controllerSpan(it, 1, span(0))
} }
} }
}
where: where:
method = "GET" method = "GET"
body = null body = null
count << [ 1, 4, 50 ] // make multiple requests.
} }
def "test success with parent"() { def "test success with parent"() {
@ -175,7 +187,7 @@ abstract class HttpServerTest<DECORATOR extends HttpServerDecorator> extends Age
and: and:
cleanAndAssertTraces(1) { cleanAndAssertTraces(1) {
trace(0, 2) { trace(0, 2) {
serverSpan(it, 0, null, null, method, ERROR, true) serverSpan(it, 0, null, null, method, ERROR)
controllerSpan(it, 1, span(0)) controllerSpan(it, 1, span(0))
} }
} }
@ -197,7 +209,7 @@ abstract class HttpServerTest<DECORATOR extends HttpServerDecorator> extends Age
and: and:
cleanAndAssertTraces(1) { cleanAndAssertTraces(1) {
trace(0, 2) { trace(0, 2) {
serverSpan(it, 0, null, null, method, EXCEPTION, true) serverSpan(it, 0, null, null, method, EXCEPTION)
controllerSpan(it, 1, span(0), EXCEPTION.body) controllerSpan(it, 1, span(0), EXCEPTION.body)
} }
} }
@ -237,17 +249,20 @@ abstract class HttpServerTest<DECORATOR extends HttpServerDecorator> extends Age
final Closure spec) { final Closure spec) {
// If this is failing, make sure HttpServerTestAdvice is applied correctly. // If this is failing, make sure HttpServerTestAdvice is applied correctly.
TEST_WRITER.waitForTraces(size + 1) TEST_WRITER.waitForTraces(size * 2)
// TEST_WRITER is a CopyOnWriteArrayList, which doesn't support remove() // TEST_WRITER is a CopyOnWriteArrayList, which doesn't support remove()
def toRemove = TEST_WRITER.find { def toRemove = TEST_WRITER.findAll() {
it.size() == 1 && it.get(0).operationName == "TEST_SPAN" it.size() == 1 && it.get(0).operationName == "TEST_SPAN"
} }
assertTrace(toRemove, 1) { toRemove.each {
assertTrace(it, 1) {
basicSpan(it, 0, "TEST_SPAN", "ServerEntry") basicSpan(it, 0, "TEST_SPAN", "ServerEntry")
} }
TEST_WRITER.remove(toRemove) }
assert toRemove.size() == size
TEST_WRITER.removeAll(toRemove)
super.assertTraces(size, spec) assertTraces(size, spec)
} }
void controllerSpan(TraceAssert trace, int index, Object parent, String errorMessage = null) { void controllerSpan(TraceAssert trace, int index, Object parent, String errorMessage = null) {
@ -267,13 +282,13 @@ abstract class HttpServerTest<DECORATOR extends HttpServerDecorator> extends Age
} }
// parent span must be cast otherwise it breaks debugging classloading (junit loads it early) // parent span must be cast otherwise it breaks debugging classloading (junit loads it early)
void serverSpan(TraceAssert trace, int index, String traceID = null, String parentID = null, String method = "GET", ServerEndpoint endpoint = SUCCESS, boolean error = false) { void serverSpan(TraceAssert trace, int index, String traceID = null, String parentID = null, String method = "GET", ServerEndpoint endpoint = SUCCESS) {
trace.span(index) { trace.span(index) {
serviceName expectedServiceName() serviceName expectedServiceName()
operationName expectedOperationName() operationName expectedOperationName()
resourceName endpoint.status == 404 ? "404" : "$method ${endpoint.resolve(address).path}" resourceName endpoint.status == 404 ? "404" : "$method ${endpoint.resolve(address).path}"
spanType DDSpanTypes.HTTP_SERVER spanType DDSpanTypes.HTTP_SERVER
errored error errored endpoint.errored
if (parentID != null) { if (parentID != null) {
traceId traceID traceId traceID
parentId parentID parentId parentID
@ -283,8 +298,8 @@ abstract class HttpServerTest<DECORATOR extends HttpServerDecorator> extends Age
tags { tags {
defaultTags(true) defaultTags(true)
"$Tags.COMPONENT.key" serverDecorator.component() "$Tags.COMPONENT.key" serverDecorator.component()
if (error) { if (endpoint.errored) {
"$Tags.ERROR.key" error "$Tags.ERROR.key" endpoint.errored
} }
"$Tags.HTTP_STATUS.key" endpoint.status "$Tags.HTTP_STATUS.key" endpoint.status
"$Tags.HTTP_URL.key" "${endpoint.resolve(address)}" "$Tags.HTTP_URL.key" "${endpoint.resolve(address)}"