Add Jakarta EE9 Equivalents of all libraries (#962)

Add Jakarta EE9 Equivalents of all libraries

This is the second attempt at this. This version however is
significantly simpler than the previous version since we had
already converted all of the tests to a simpler undertow only
implementation, removing the Dropwizard dependency which
inadvertently bumped all of our dependencies past compatible
versions.

Tests have been consciously dropped in the non-jakarta versions as
the dependencies get messed up with those.

Similarly, revapi was dropped from the non-jakarta versions because of
a quirk in how that plugin works. It's not providing value here anyways though.

Author: mglazer

settings.gradle

@@ -5,10 +5,13 @@ include 'tracing-api'
 include 'tracing-benchmarks'
 include 'tracing-demos'
 include 'tracing-jaxrs'
+include 'tracing-jaxrs-jakarta'
 include 'tracing-jersey'
+include 'tracing-jersey-jakarta'
 include 'tracing-okhttp3'
 include 'tracing-servlet'
+include 'tracing-servlet-jakarta'
 include 'tracing-test-utils'
 include 'tracing-undertow'
 
-include 'tracing-undertow-testing'
+include 'tracing-undertow-jakarta-testing'

tracing-jaxrs-jakarta/build.gradle

@@ -0,0 +1,31 @@
+/*
+ * (c) Copyright 2018 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'org.inferred.processors'
+
+apply plugin: 'com.palantir.external-publish-jar'
+apply plugin: 'com.palantir.revapi'
+
+dependencies {
+    api project(":tracing")
+    api "jakarta.ws.rs:jakarta.ws.rs-api"
+
+    testImplementation "ch.qos.logback:logback-classic"
+    testImplementation "org.junit.jupiter:junit-jupiter"
+    testImplementation "org.assertj:assertj-core"
+    testImplementation "org.jmock:jmock"
+    testImplementation "org.mockito:mockito-core"
+}

tracing-jaxrs-jakarta/src/main/java/com/palantir/tracing/jaxrs/JaxRsTracers.java

@@ -0,0 +1,55 @@
+/*
+ * (c) Copyright 2018 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.palantir.tracing.jaxrs;
+
+import com.palantir.tracing.CloseableSpan;
+import com.palantir.tracing.Detached;
+import com.palantir.tracing.DetachedSpan;
+import com.palantir.tracing.Tracers;
+import jakarta.ws.rs.WebApplicationException;
+import jakarta.ws.rs.core.StreamingOutput;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.concurrent.Callable;
+
+public final class JaxRsTracers {
+
+    private JaxRsTracers() {}
+
+    /** Like {@link Tracers#wrap(Callable)}, but for StreamingOutputs. */
+    public static StreamingOutput wrap(StreamingOutput delegate) {
+        return new TracingAwareStreamingOutput(delegate);
+    }
+
+    private static class TracingAwareStreamingOutput implements StreamingOutput {
+
+        private final StreamingOutput delegate;
+        private final Detached detached;
+
+        TracingAwareStreamingOutput(StreamingOutput delegate) {
+            this.delegate = delegate;
+            this.detached = DetachedSpan.detach();
+        }
+
+        @Override
+        public void write(OutputStream output) throws IOException, WebApplicationException {
+            try (CloseableSpan ignored = detached.childSpan("streaming-output")) {
+                delegate.write(output);
+            }
+        }
+    }
+}

tracing-jaxrs/src/test/java/com/palantir/tracing/jaxrs/JaxRsTracersTest.java renamed to tracing-jaxrs-jakarta/src/test/java/com/palantir/tracing/jaxrs/JaxRsTracersTest.java

@@ -20,9 +20,9 @@
 
 import com.palantir.tracing.AlwaysSampler;
 import com.palantir.tracing.Tracer;
+import jakarta.ws.rs.core.StreamingOutput;
 import java.io.ByteArrayOutputStream;
-import javax.ws.rs.core.StreamingOutput;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public final class JaxRsTracersTest {
 

tracing-jaxrs/build.gradle

@@ -17,15 +17,12 @@
 apply plugin: 'org.inferred.processors'
 
 apply plugin: 'com.palantir.external-publish-jar'
-apply plugin: 'com.palantir.revapi'
+
+versionsLock {
+    disableJavaPluginDefaults()
+}
 
 dependencies {
     api project(":tracing")
-    api "jakarta.ws.rs:jakarta.ws.rs-api"
-
-    testImplementation "ch.qos.logback:logback-classic"
-    testImplementation "junit:junit"
-    testImplementation "org.assertj:assertj-core"
-    testImplementation "org.jmock:jmock"
-    testImplementation "org.mockito:mockito-core"
+    api "javax.ws.rs:javax.ws.rs-api"
 }

tracing-jersey-jakarta/build.gradle

@@ -0,0 +1,38 @@
+/*
+ * (c) Copyright 2018 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply plugin: 'com.palantir.external-publish-jar'
+apply plugin: 'com.palantir.revapi'
+
+dependencies {
+    api "org.glassfish.jersey.core:jersey-server"
+    api project(":tracing")
+
+    implementation 'com.google.guava:guava'
+    implementation 'jakarta.ws.rs:jakarta.ws.rs-api'
+    implementation project(':tracing-api')
+
+    testImplementation project(":tracing-undertow-jakarta-testing")
+    testImplementation 'org.glassfish.jersey.inject:jersey-hk2'
+    testImplementation "org.junit.jupiter:junit-jupiter"
+    testImplementation "org.assertj:assertj-core"
+    testImplementation "org.hamcrest:hamcrest-all"
+    testImplementation "org.mockito:mockito-core"
+    testImplementation "org.mockito:mockito-junit-jupiter"
+
+    // needed for MDC tests
+    testRuntimeOnly "org.apache.logging.log4j:log4j-slf4j-impl"
+}

tracing-jersey-jakarta/src/main/java/com/palantir/tracing/jersey/TraceEnrichingFilter.java

@@ -0,0 +1,177 @@
+/*
+ * (c) Copyright 2018 Palantir Technologies Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.palantir.tracing.jersey;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
+import com.palantir.tracing.Observability;
+import com.palantir.tracing.TagTranslator;
+import com.palantir.tracing.TraceMetadata;
+import com.palantir.tracing.Tracer;
+import com.palantir.tracing.Tracers;
+import com.palantir.tracing.api.SpanType;
+import com.palantir.tracing.api.TraceHttpHeaders;
+import com.palantir.tracing.api.TraceTags;
+import jakarta.annotation.Priority;
+import jakarta.ws.rs.container.ContainerRequestContext;
+import jakarta.ws.rs.container.ContainerRequestFilter;
+import jakarta.ws.rs.container.ContainerResponseContext;
+import jakarta.ws.rs.container.ContainerResponseFilter;
+import jakarta.ws.rs.core.Context;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.ext.Provider;
+import java.io.IOException;
+import java.util.Optional;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import org.glassfish.jersey.server.ExtendedUriInfo;
+import org.glassfish.jersey.server.model.Resource;
+
+// Default is `Priorities.USER` == 5000. This filter needs to execute earlier to ensure traces are ready to use.
+@Priority(500)
+@Provider
+public final class TraceEnrichingFilter implements ContainerRequestFilter, ContainerResponseFilter {
+    public static final TraceEnrichingFilter INSTANCE = new TraceEnrichingFilter();
+
+    /**
+     * This is the name of the trace id property we set on {@link ContainerRequestContext}.
+     */
+    public static final String TRACE_ID_PROPERTY_NAME = "com.palantir.tracing.traceId";
+
+    public static final String REQUEST_ID_PROPERTY_NAME = "com.palantir.tracing.requestId";
+
+    public static final String SAMPLED_PROPERTY_NAME = "com.palantir.tracing.sampled";
+
+    @VisibleForTesting
+    static final String FETCH_USER_AGENT_HEADER = "Fetch-User-Agent";
+
+    @Context
+    @SuppressWarnings("NullAway") // instantiated using by Jersey using reflection
+    private ExtendedUriInfo uriInfo;
+
+    // Handles incoming request
+    @Override
+    public void filter(ContainerRequestContext requestContext) throws IOException {
+        String path = getPathTemplate();
+
+        String operation = "Jersey: " + requestContext.getMethod() + " " + path;
+        // The following strings are all nullable
+        String traceId = requestContext.getHeaderString(TraceHttpHeaders.TRACE_ID);
+        String spanId = requestContext.getHeaderString(TraceHttpHeaders.SPAN_ID);
+        Optional<String> forUserAgent = getForUserAgent(requestContext);
+
+        // Set up thread-local span that inherits state from HTTP headers
+        if (Strings.isNullOrEmpty(traceId)) {
+            // HTTP request did not indicate a trace; initialize trace state and create a span.
+            Tracer.initTraceWithSpan(
+                    getObservabilityFromHeader(requestContext),
+                    Tracers.randomId(),
+                    forUserAgent,
+                    operation,
+                    SpanType.SERVER_INCOMING);
+        } else if (spanId == null) {
+            Tracer.initTraceWithSpan(
+                    getObservabilityFromHeader(requestContext),
+                    traceId,
+                    forUserAgent,
+                    operation,
+                    SpanType.SERVER_INCOMING);
+        } else {
+            // caller's span is this span's parent.
+            Tracer.initTraceWithSpan(
+                    getObservabilityFromHeader(requestContext),
+                    traceId,
+                    forUserAgent,
+                    operation,
+                    spanId,
+                    SpanType.SERVER_INCOMING);
+        }
+
+        // Give asynchronous downstream handlers access to the trace id
+        requestContext.setProperty(TRACE_ID_PROPERTY_NAME, Tracer.getTraceId());
+        requestContext.setProperty(SAMPLED_PROPERTY_NAME, Tracer.isTraceObservable());
+        Tracer.maybeGetTraceMetadata()
+                .flatMap(TraceMetadata::getRequestId)
+                .ifPresent(requestId -> requestContext.setProperty(REQUEST_ID_PROPERTY_NAME, requestId));
+    }
+
+    // Handles outgoing response
+    @Override
+    public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext)
+            throws IOException {
+        MultivaluedMap<String, Object> headers = responseContext.getHeaders();
+        if (Tracer.hasTraceId()) {
+            String traceId = Tracer.getTraceId();
+            Tracer.fastCompleteSpan(FunctionalTagTranslator.INSTANCE, sink -> {
+                sink.accept(TraceTags.HTTP_STATUS_CODE, Integer.toString(responseContext.getStatus()));
+                sink.accept(TraceTags.HTTP_URL_PATH_TEMPLATE, getPathTemplate());
+                sink.accept(TraceTags.HTTP_METHOD, requestContext.getMethod());
+                Object requestId = requestContext.getProperty(REQUEST_ID_PROPERTY_NAME);
+                if (requestId instanceof String) {
+                    sink.accept(TraceTags.HTTP_REQUEST_ID, (String) requestId);
+                }
+            });
+            headers.putSingle(TraceHttpHeaders.TRACE_ID, traceId);
+        } else {
+            // When the filter is called twice (e.g. an exception is thrown in a streaming call),
+            // the current trace will be empty. To allow clients to still get the trace ID corresponding to
+            // the failure, we retrieve it from the requestContext.
+            Optional.ofNullable(requestContext.getProperty(TRACE_ID_PROPERTY_NAME))
+                    .ifPresent(s -> headers.putSingle(TraceHttpHeaders.TRACE_ID, s));
+        }
+    }
+
+    // Force sample iff the context contains a "1" X-B3-Sampled header, force not sample if the header contains another
+    // non-empty value, or undecided if there is no such header or the header is empty.
+    private static Observability getObservabilityFromHeader(ContainerRequestContext context) {
+        String header = context.getHeaderString(TraceHttpHeaders.IS_SAMPLED);
+        if (Strings.isNullOrEmpty(header)) {
+            return Observability.UNDECIDED;
+        } else {
+            return "1".equals(header) ? Observability.SAMPLE : Observability.DO_NOT_SAMPLE;
+        }
+    }
+
+    private static Optional<String> getForUserAgent(ContainerRequestContext context) {
+        String forUserAgent = context.getHeaderString(TraceHttpHeaders.FOR_USER_AGENT);
+        if (forUserAgent != null) {
+            return Optional.of(forUserAgent);
+        }
+        String fetchUserAgent = context.getHeaderString(FETCH_USER_AGENT_HEADER);
+        if (fetchUserAgent != null) {
+            return Optional.of(fetchUserAgent);
+        }
+        return Optional.ofNullable(context.getHeaderString(HttpHeaders.USER_AGENT));
+    }
+
+    private String getPathTemplate() {
+        return Optional.ofNullable(uriInfo)
+                .map(ExtendedUriInfo::getMatchedModelResource)
+                .map(Resource::getPath)
+                .orElse("(unknown)");
+    }
+
+    private enum FunctionalTagTranslator implements TagTranslator<Consumer<BiConsumer<String, String>>> {
+        INSTANCE;
+
+        @Override
+        public <T> void translate(TagAdapter<T> adapter, T target, Consumer<BiConsumer<String, String>> data) {
+            data.accept((key, value) -> adapter.tag(target, key, value));
+        }
+    }
+}

tracing-jersey/src/test/java/com/palantir/tracing/jersey/TraceEnrichingFilterTest.java renamed to tracing-jersey-jakarta/src/test/java/com/palantir/tracing/jersey/TraceEnrichingFilterTest.java

@@ -35,15 +35,15 @@
 import com.palantir.tracing.api.TraceHttpHeaders;
 import com.palantir.tracing.api.TraceTags;
 import com.palantir.undertest.UndertowServerExtension;
-import javax.ws.rs.Consumes;
-import javax.ws.rs.GET;
-import javax.ws.rs.POST;
-import javax.ws.rs.Path;
-import javax.ws.rs.Produces;
-import javax.ws.rs.container.ContainerRequestContext;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.StreamingOutput;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.container.ContainerRequestContext;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.StreamingOutput;
 import org.apache.hc.client5.http.classic.methods.HttpGet;
 import org.apache.hc.client5.http.classic.methods.HttpPost;
 import org.apache.hc.core5.http.ContentType;