Add latestdeptest for spring boot 2 (#8622)

Author: amarziali

dd-java-agent/instrumentation/spring-webmvc-3.1/build.gradle

@@ -38,6 +38,9 @@ muzzle {
 
 apply from: "$rootDir/gradle/java.gradle"
 
+addTestSuite("latestDepTest")
+addTestSuiteExtendingForDir("latestDepForkedTest", "latestDepTest", "latestDepTest")
+
 dependencies {
   compileOnly group: 'org.springframework', name: 'spring-webmvc', version: '3.1.0.RELEASE'
   compileOnly group: 'javax.servlet', name: 'javax.servlet-api', version: '3.1.0'
@@ -81,4 +84,10 @@ dependencies {
   testImplementation "org.glassfish.jaxb:jaxb-runtime:2.3.2"
 
   testImplementation group: 'org.jboss.resteasy', name: 'resteasy-spring', version: '3.0.0.Final'
+
+  latestDepTestImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-test', version: '2.+'
+  latestDepTestImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.+'
+  latestDepTestImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-websocket', version: '2.+'
+  latestDepTestImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-security', version: '2.+'
+  latestDepTestImplementation group: 'org.springframework.security.oauth', name: 'spring-security-oauth2', version: '2.+'
 }

dd-java-agent/instrumentation/spring-webmvc-3.1/src/latestDepTest/groovy/datadog/trace/instrumentation/springweb/HandlerMappingResourceNameFilterForkedTest.groovy

@@ -0,0 +1,53 @@
+package datadog.trace.instrumentation.springweb
+
+import datadog.trace.agent.test.AgentTestRunner
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.context.annotation.ComponentScan
+import org.springframework.context.annotation.Configuration
+import org.springframework.mock.web.MockHttpServletRequest
+import org.springframework.test.context.ContextConfiguration
+import org.springframework.test.context.web.AnnotationConfigWebContextLoader
+import org.springframework.test.context.web.WebAppConfiguration
+import org.springframework.web.servlet.config.annotation.EnableWebMvc
+
+import javax.servlet.FilterChain
+import javax.servlet.http.HttpServletResponse
+
+import static datadog.trace.agent.test.utils.TraceUtils.runUnderTrace
+import static datadog.trace.bootstrap.instrumentation.api.AgentTracer.activeSpan
+import static datadog.trace.bootstrap.instrumentation.decorator.HttpServerDecorator.DD_SPAN_ATTRIBUTE
+
+@WebAppConfiguration // TODO this doesn't exist in 3.1.0 so will need rework if we want to test that version
+// https://mvnrepository.com/artifact/org.springframework/spring-test-mvc?repo=springio-plugins-release
+// https://github.com/spring-attic/spring-test-mvc
+@ContextConfiguration(classes = TestConfiguration, loader = AnnotationConfigWebContextLoader)
+class HandlerMappingResourceNameFilterForkedTest extends AgentTestRunner {
+  @EnableWebMvc
+  @Configuration
+  @ComponentScan(basePackages = "datadog.trace.instrumentation.springweb")
+  static class TestConfiguration {
+  }
+
+  @Autowired
+  HandlerMappingResourceNameFilter filter
+
+  def "test filter doesn't make externally visible changes to request object - url: #url"() {
+    given:
+    def request = new MockHttpServletRequest("GET", url)
+    def response = Mock(HttpServletResponse)
+    def filterChain = Mock(FilterChain)
+
+    when:
+    runUnderTrace("test-servlet", {
+      request.setAttribute(DD_SPAN_ATTRIBUTE, activeSpan())
+      filter.doFilterInternal(request, response, filterChain)
+    })
+
+    then:
+    assert request.getAttributeNames().toList() == [DD_SPAN_ATTRIBUTE]
+    0 * response._
+
+    where:
+    url << ["/single", "/not-found"]
+  }
+}

dd-java-agent/instrumentation/spring-webmvc-3.1/src/latestDepTest/groovy/datadog/trace/instrumentation/springweb/ResteasySpringBeanProcessorForkedTest.groovy

@@ -0,0 +1,62 @@
+package datadog.trace.instrumentation.springweb
+
+import datadog.trace.agent.test.AgentTestRunner
+import org.jboss.resteasy.plugins.spring.SpringBeanProcessor
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory
+import org.springframework.beans.factory.support.BeanDefinitionRegistry
+import org.springframework.beans.factory.support.GenericBeanDefinition
+import test.boot.TestProvider
+
+class ResteasySpringBeanProcessorForkedTest extends AgentTestRunner {
+
+  interface TestBeanFactory extends ConfigurableListableBeanFactory, BeanDefinitionRegistry {}
+
+  def "resteasy-spring should ignore our intercepting filter bean"() {
+    given:
+    def beanFactory = Mock(TestBeanFactory)
+    def originalDefinition = new HandlerMappingResourceNameFilter.BeanDefinition()
+    // trigger capture of the original 'beanClass' value
+    beanFactory.registerBeanDefinition('filter', originalDefinition)
+    // mimic situation where the original 'beanClass' value might be lost
+    def filterDefinition = originalDefinition.clone()
+    filterDefinition.setBeanClassName(originalDefinition.getBeanClassName()) // discards 'beanClass'
+    // simple test bean to make sure resteasy isn't ignoring all bean definitions
+    def testDefinition = Mock(GenericBeanDefinition)
+    testDefinition.getBeanClassName() >> TestProvider.name
+    testDefinition.isSingleton() >> true
+
+    and:
+    beanFactory.getBeanDefinitionNames() >> ['filter', 'test']
+    beanFactory.getBeanDefinition('filter') >> filterDefinition
+    beanFactory.getBeanDefinition('test') >> testDefinition
+
+    and:
+    def originalContext = Thread.currentThread().contextClassLoader
+    // mimic isolated setup where our filter bean is not visible to the resteasy-spring context
+    def isolatedContext = new ClassLoader(null) {
+        @Override
+        protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+          if (name == TestProvider.name) {
+            return TestProvider
+          }
+          throw new ClassNotFoundException(name)
+        }
+      }
+
+    and:
+    def resteasyProcessor = new SpringBeanProcessor()
+
+    when:
+    Thread.currentThread().contextClassLoader = isolatedContext
+    resteasyProcessor.postProcessBeanFactory(beanFactory)
+
+    then:
+    // should have skipped our filter bean, which is not of interest to resteasy
+    noExceptionThrown()
+    // simple test bean should still have been picked up
+    resteasyProcessor.providerNames == ['test'] as Set
+
+    cleanup:
+    Thread.currentThread().contextClassLoader = originalContext
+  }
+}

dd-java-agent/instrumentation/spring-webmvc-3.1/src/latestDepTest/groovy/datadog/trace/instrumentation/springweb/SingleEndpointController.java

@@ -0,0 +1,15 @@
+package datadog.trace.instrumentation.springweb;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+@Controller
+@RequestMapping("/single")
+public class SingleEndpointController {
+  @GetMapping
+  public @ResponseBody String get() {
+    return "Hello World";
+  }
+}

dd-java-agent/instrumentation/spring-webmvc-3.1/src/latestDepTest/groovy/test/SetupSpecHelper.groovy

@@ -0,0 +1,53 @@
+package test
+
+import datadog.appsec.api.blocking.BlockingContentType
+import datadog.trace.api.function.TriFunction
+import datadog.trace.api.gateway.BlockResponseFunction
+import datadog.trace.api.gateway.CallbackProvider
+import datadog.trace.api.gateway.EventType
+import datadog.trace.api.gateway.Events
+import datadog.trace.api.gateway.Flow
+import datadog.trace.api.gateway.RequestContext
+import datadog.trace.api.gateway.RequestContextSlot
+import datadog.trace.api.internal.TraceSegment
+import datadog.trace.bootstrap.instrumentation.api.AgentTracer
+import datadog.trace.bootstrap.instrumentation.api.URIDataAdapter
+import datadog.trace.instrumentation.servlet.ServletBlockingHelper
+import org.springframework.web.context.request.RequestContextHolder
+import org.springframework.web.context.request.ServletRequestAttributes
+
+class SetupSpecHelper {
+  static void provideBlockResponseFunction() {
+
+    EventType<TriFunction<RequestContext, String, URIDataAdapter, Flow<Void>>> uriEvent = Events.get().requestMethodUriRaw()
+
+    // get original callback
+    CallbackProvider provider = AgentTracer.get().getCallbackProvider(RequestContextSlot.APPSEC)
+    TriFunction<RequestContext, String, URIDataAdapter, Flow<Void>> origUriCallback = provider.getCallback(uriEvent)
+
+    // wrap the original IG callbacks
+    def ss = AgentTracer.get().getSubscriptionService(RequestContextSlot.APPSEC)
+    ss.reset(uriEvent)
+    ss.registerCallback(uriEvent, new TriFunction<RequestContext, String, URIDataAdapter, Flow<Void>>() {
+        @Override
+        Flow<Void> apply(RequestContext requestContext, String s, URIDataAdapter uriDataAdapter) {
+          requestContext.setBlockResponseFunction(TestSpringBlockResponseFunction.INSTANCE)
+          origUriCallback.apply(requestContext, s, uriDataAdapter)
+        }
+      })
+  }
+
+  enum TestSpringBlockResponseFunction implements BlockResponseFunction {
+    INSTANCE
+
+    @Override
+    boolean tryCommitBlockingResponse(TraceSegment segment, int statusCode, BlockingContentType templateType, Map<String, String> extraHeaders) {
+      ServletRequestAttributes attributes = RequestContextHolder.requestAttributes
+      if (attributes) {
+        ServletBlockingHelper
+          .commitBlockingResponse(segment, attributes.request, attributes.response, statusCode, templateType, extraHeaders)
+      }
+      true
+    }
+  }
+}

dd-java-agent/instrumentation/spring-webmvc-3.1/src/latestDepTest/groovy/test/boot/AppConfig.groovy

@@ -0,0 +1,55 @@
+package test.boot
+
+import org.apache.catalina.connector.Connector
+import org.springframework.boot.autoconfigure.SpringBootApplication
+import org.springframework.boot.web.embedded.tomcat.TomcatConnectorCustomizer
+import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory
+import org.springframework.boot.web.server.WebServerFactoryCustomizer
+import org.springframework.boot.web.servlet.filter.OrderedRequestContextFilter
+import org.springframework.context.annotation.Bean
+import org.springframework.core.Ordered
+import org.springframework.web.filter.RequestContextFilter
+import org.springframework.web.servlet.config.annotation.PathMatchConfigurer
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter
+import org.springframework.web.util.UrlPathHelper
+
+// Component scan defeats the purpose of configuring with specific classes
+@SpringBootApplication(scanBasePackages = "doesnotexist")
+class AppConfig extends WebMvcConfigurerAdapter {
+
+  @Bean
+  WebServerFactoryCustomizer webServerFactoryCustomizer() {
+    def factory = new WebServerFactoryCustomizer<TomcatServletWebServerFactory> () {
+        @Override
+        void customize(TomcatServletWebServerFactory factory) {
+          factory.addConnectorCustomizers(new TomcatConnectorCustomizer() {
+              @Override
+              void customize(Connector connector) {
+                connector.setEnableLookups(true)
+              }
+            })
+        }
+      }
+    return factory
+  }
+
+  @Override
+  void configurePathMatch(PathMatchConfigurer configurer) {
+    configurer.urlPathHelper = new UrlPathHelper(
+      removeSemicolonContent: false
+      )
+  }
+
+  // Replace the default request context filter so that it has higher precedence
+  // and that the following events are correctly ordered:
+  // * server attributes are registered by the RequestContextFilter. HttpServletRequest and
+  //   HttpServletResponse are available on thread locals
+  // * HiddenHttpMethodFilter tries to read the parameter _method
+  // * org.apache.tomcat.util.http.Parameters.processParameters, an instrumented method, is called
+  // * the instrumentation gives instructions to block
+  // * the BlockResponseFunction is called. The BlockResponseFunction has access to the server attributes
+  @Bean
+  RequestContextFilter requestContextFilter() {
+    new OrderedRequestContextFilter(order: Ordered.HIGHEST_PRECEDENCE)
+  }
+}

dd-java-agent/instrumentation/spring-webmvc-3.1/src/latestDepTest/groovy/test/boot/AuthServerConfig.groovy

@@ -0,0 +1,10 @@
+package test.boot
+
+import org.springframework.context.annotation.Configuration
+import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter
+import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer
+
+@Configuration
+@EnableAuthorizationServer
+class AuthServerConfig extends AuthorizationServerConfigurerAdapter {
+}

dd-java-agent/instrumentation/spring-webmvc-3.1/src/latestDepTest/groovy/test/boot/CustomBeanClassloaderTest.groovy

@@ -0,0 +1,11 @@
+package test.boot
+
+import org.springframework.boot.SpringApplication
+
+class CustomBeanClassloaderTest extends SpringBootBasedTest {
+
+  @Override
+  SpringApplication application() {
+    return new SpringApplication(AppConfig, SecurityConfig, AuthServerConfig, CustomClassloaderConfig, TestController, WebsocketConfig)
+  }
+}

dd-java-agent/instrumentation/spring-webmvc-3.1/src/latestDepTest/groovy/test/boot/CustomClassloaderConfig.groovy

@@ -0,0 +1,43 @@
+package test.boot
+
+import groovy.transform.CompileStatic
+import org.springframework.beans.BeansException
+import org.springframework.beans.factory.config.BeanFactoryPostProcessor
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+/**
+ * Sets the bean classloader to one that explicitly filters datadog classes
+ * The goal is to test a classloader that we didn't inject.  With our test
+ * setup, its easier to filter than create a new one
+ */
+@Configuration
+class CustomClassloaderConfig {
+
+  @Bean
+  BeanFactoryPostProcessor postProcessor() {
+    return new BeanFactoryPostProcessor() {
+        @Override
+        void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
+          beanFactory.setBeanClassLoader(new DatadogFilteringClassloader(this.getClass().getClassLoader()))
+        }
+      }
+  }
+}
+
+@CompileStatic // avoid references to java.lang.Module (in super$2$loadClass)
+class DatadogFilteringClassloader extends URLClassLoader {
+  DatadogFilteringClassloader(ClassLoader parent) {
+    super(new URL[0], parent)
+  }
+
+  protected Class<?> loadClass(String className, boolean resolve)
+  throws ClassNotFoundException {
+    if (className.startsWith("datadog")) {
+      throw new ClassNotFoundException()
+    }
+
+    return super.loadClass(className, resolve)
+  }
+}