Merge pull request DataDog#5816 from DataDog/jpbempel/smoke-tests

Add metric smoke tests

Author: jpbempel

dd-smoke-tests/debugger-integration-tests/src/test/java/datadog/smoketest/AgentDebuggerIntegrationTest.java

@@ -0,0 +1,88 @@
+package datadog.smoketest;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import com.datadog.debugger.agent.JsonSnapshotSerializer;
+import com.datadog.debugger.probe.LogProbe;
+import com.datadog.debugger.sink.Snapshot;
+import com.squareup.moshi.JsonAdapter;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import okhttp3.mockwebserver.MockResponse;
+import okhttp3.mockwebserver.RecordedRequest;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class AgentDebuggerIntegrationTest extends SimpleAppDebuggerIntegrationTest {
+  @Test
+  @DisplayName("testLatestJdk")
+  void testLatestJdk() throws Exception {
+    final String EXPECTED_UPLOADS = "3";
+    LogProbe probe = LogProbe.builder().where("App", "getGreeting").build();
+    setCurrentConfiguration(createConfig(probe));
+    String classpath = System.getProperty("datadog.smoketest.shadowJar.external.path");
+    if (classpath == null) {
+      return; // execute test only if classpath is provided for the latest jdk
+    }
+    List<String> commandParams = getDebuggerCommandParams();
+    targetProcess =
+        ProcessBuilderHelper.createProcessBuilder(
+                classpath, commandParams, logFilePath, "App", EXPECTED_UPLOADS)
+            .start();
+    RecordedRequest request = retrieveSnapshotRequest();
+    assertNotNull(request);
+    assertFalse(logHasErrors(logFilePath, it -> false));
+    String bodyStr = request.getBody().readUtf8();
+    LOG.info("got snapshot: {}", bodyStr);
+    JsonAdapter<List<JsonSnapshotSerializer.IntakeRequest>> adapter = createAdapterForSnapshot();
+    Snapshot snapshot = adapter.fromJson(bodyStr).get(0).getDebugger().getSnapshot();
+    assertNotNull(snapshot);
+  }
+
+  @Test
+  @DisplayName("testShutdown")
+  void testShutdown() throws Exception {
+    final String METHOD_NAME = "emptyMethod";
+    final String EXPECTED_UPLOADS = "3";
+    LogProbe probe =
+        LogProbe.builder().probeId(PROBE_ID).where(MAIN_CLASS_NAME, METHOD_NAME).build();
+    setCurrentConfiguration(createConfig(probe));
+    targetProcess = createProcessBuilder(logFilePath, METHOD_NAME, EXPECTED_UPLOADS).start();
+
+    RecordedRequest request = retrieveSnapshotRequest();
+    assertFalse(logHasErrors(logFilePath, it -> false));
+    assertNotNull(request);
+    assertTrue(request.getBodySize() > 0);
+
+    // Wait for the app exit with some extra time.
+    // The expectation is that agent doesn't prevent app from exiting.
+    assertTrue(targetProcess.waitFor(REQUEST_WAIT_TIMEOUT + 10, TimeUnit.SECONDS));
+  }
+
+  @Test
+  @DisplayName("testDestroy")
+  void testDestroy() throws Exception {
+    final String METHOD_NAME = "fullMethod";
+    final String EXPECTED_UPLOADS = "3";
+    LogProbe probe =
+        LogProbe.builder().probeId(PROBE_ID).where(MAIN_CLASS_NAME, METHOD_NAME).build();
+    setCurrentConfiguration(createConfig(probe));
+    datadogAgentServer.enqueue(
+        new MockResponse()
+            .setHeadersDelay(REQUEST_WAIT_TIMEOUT * 2, TimeUnit.SECONDS)
+            .setResponseCode(200));
+    // wait for 3 snapshots (2 status + 1 snapshot)
+    targetProcess = createProcessBuilder(logFilePath, METHOD_NAME, EXPECTED_UPLOADS).start();
+
+    RecordedRequest request = retrieveSnapshotRequest();
+    assertNotNull(request);
+    assertTrue(request.getBodySize() > 0);
+    retrieveSnapshotRequest();
+    targetProcess.destroy();
+    // Wait for the app exit with some extra time.
+    // The expectation is that agent doesn't prevent app from exiting.
+    assertTrue(targetProcess.waitFor(REQUEST_WAIT_TIMEOUT + 10, TimeUnit.SECONDS));
+  }
+}

dd-smoke-tests/debugger-integration-tests/src/test/java/datadog/smoketest/BaseIntegrationTest.java

@@ -8,12 +8,16 @@
 import com.datadog.debugger.agent.JsonSnapshotSerializer;
 import com.datadog.debugger.agent.ProbeStatus;
 import com.datadog.debugger.probe.LogProbe;
+import com.datadog.debugger.probe.MetricProbe;
 import com.datadog.debugger.util.MoshiHelper;
 import com.datadog.debugger.util.MoshiSnapshotTestHelper;
 import com.squareup.moshi.JsonAdapter;
 import com.squareup.moshi.Types;
 import datadog.trace.bootstrap.debugger.CapturedContext;
 import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.SocketException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -23,6 +27,8 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.UUID;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 import okhttp3.HttpUrl;
@@ -44,7 +50,9 @@ public abstract class BaseIntegrationTest {
   protected static final int REQUEST_WAIT_TIMEOUT = 10;
   private static final Path LOG_FILE_BASE =
       Paths.get(
-          buildDirectory(), "reports", "testProcess." + DebuggerIntegrationTest.class.getName());
+          buildDirectory(),
+          "reports",
+          "testProcess." + SimpleAppDebuggerIntegrationTest.class.getName());
   private static final String INFO_CONTENT =
       "{\"endpoints\": [\"v0.4/traces\", \"debugger/v1/input\", \"v0.7/config\"]}";
   private static final MockResponse AGENT_INFO_RESPONSE =
@@ -54,7 +62,7 @@ public abstract class BaseIntegrationTest {
 
   protected MockWebServer datadogAgentServer;
   private MockDispatcher probeMockDispatcher;
-
+  private StatsDServer statsDServer;
   private HttpUrl probeUrl;
   private HttpUrl snapshotUrl;
   protected Path logFilePath;
@@ -77,6 +85,9 @@ void setup(TestInfo testInfo) throws Exception {
     probeUrl = datadogAgentServer.url(PROBE_URL_PATH);
     LOG.info("DatadogAgentServer on {}", datadogAgentServer.getPort());
     snapshotUrl = datadogAgentServer.url(SNAPSHOT_URL_PATH);
+    statsDServer = new StatsDServer();
+    statsDServer.start();
+    LOG.info("statsDServer on {}", statsDServer.getPort());
     logFilePath = LOG_FILE_BASE.resolve(testInfo.getDisplayName() + ".log");
   }
 
@@ -86,6 +97,7 @@ void teardown() throws Exception {
       targetProcess.destroyForcibly();
     }
     datadogAgentServer.shutdown();
+    statsDServer.close();
   }
 
   protected ProcessBuilder createProcessBuilder(Path logFilePath, String... params) {
@@ -109,16 +121,10 @@ protected List<String> getDebuggerCommandParams() {
             "-Ddd.jmxfetch.start-delay=0",
             "-Ddd.jmxfetch.enabled=false",
             "-Ddd.dynamic.instrumentation.enabled=true",
-            // "-Ddd.remote_config.enabled=true", // default
             "-Ddd.remote_config.poll_interval.seconds=1",
-            /*"-Ddd.remote_config.integrity_check.enabled=false",
-            "-Ddd.dynamic.instrumentation.probe.url=http://localhost:"
-                + probeServer.getPort()
-                + PROBE_URL_PATH,
-            "-Ddd.dynamic.instrumentation.snapshot.url=http://localhost:"
-                + snapshotServer.getPort()
-                + SNAPSHOT_URL_PATH,*/
             "-Ddd.trace.agent.url=http://localhost:" + datadogAgentServer.getPort(),
+            "-Ddd.jmxfetch.statsd.port=" + statsDServer.getPort(),
+            "-Ddd.dynamic.instrumentation.classfile.dump.enabled=true",
             // to verify each snapshot upload one by one
             "-Ddd.dynamic.instrumentation.upload.batch.size=1",
             // flush uploads every 100ms to have quick tests
@@ -156,6 +162,10 @@ protected ProbeStatus retrieveProbeStatusRequest() throws Exception {
     return probeStatuses.get(0);
   }
 
+  protected String retrieveStatsdMessage(String str) {
+    return statsDServer.waitForMessage(str);
+  }
+
   private MockResponse datadogAgentDispatch(RecordedRequest request) {
     LOG.info("datadogAgentDispatch request path: {}", request.getPath());
     if (request.getPath().equals("/info")) {
@@ -221,6 +231,13 @@ protected Configuration createConfig(LogProbe logProbe) {
     return createConfig(Arrays.asList(logProbe));
   }
 
+  protected Configuration createMetricConfig(MetricProbe metricProbe) {
+    return Configuration.builder()
+        .setService(getAppId())
+        .addMetricProbes(Collections.singletonList(metricProbe))
+        .build();
+  }
+
   protected Configuration createConfig(Collection<LogProbe> logProbes) {
     return new Configuration(getAppId(), logProbes);
   }
@@ -301,4 +318,60 @@ public void setDispatcher(Function<RecordedRequest, MockResponse> dispatcher) {
       this.dispatcher = dispatcher;
     }
   }
+
+  private static class StatsDServer extends Thread {
+    private final DatagramSocket socket;
+    private final BlockingQueue<String> msgQueue = new ArrayBlockingQueue<>(32);
+    private volatile String lastMessage;
+    private volatile boolean running = true;
+
+    StatsDServer() throws SocketException {
+      socket = new DatagramSocket();
+    }
+
+    @Override
+    public void run() {
+      byte[] buf = new byte[1024];
+      DatagramPacket packet = new DatagramPacket(buf, buf.length);
+      while (running) {
+        try {
+          socket.receive(packet);
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+        lastMessage = new String(packet.getData(), 0, packet.getLength());
+        System.out.println("received statsd: " + lastMessage);
+        try {
+          msgQueue.offer(lastMessage, 30, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+          throw new RuntimeException(e);
+        }
+      }
+      socket.close();
+    }
+
+    String lastMessage() {
+      return lastMessage;
+    }
+
+    String waitForMessage(String str) {
+      String msg;
+      do {
+        try {
+          msg = msgQueue.poll(30, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+          throw new RuntimeException(e);
+        }
+      } while (msg != null && !msg.contains(str));
+      return msg;
+    }
+
+    void close() {
+      running = false;
+    }
+
+    int getPort() {
+      return socket.getLocalPort();
+    }
+  }
 }