Bootstrap integration tests

jmx-scraper/build.gradle.kts

@@ -29,6 +29,9 @@ testing {
       dependencies {
         implementation("org.testcontainers:junit-jupiter")
         implementation("org.slf4j:slf4j-simple")
+        implementation("com.linecorp.armeria:armeria-junit5")
+        implementation("com.linecorp.armeria:armeria-grpc")
+        implementation("io.opentelemetry.proto:opentelemetry-proto:0.20.0-alpha")
       }
     }
   }

jmx-scraper/src/integrationTest/java/io/opentelemetry/contrib/jmxscraper/JmxScraperContainer.java

@@ -0,0 +1,115 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.jmxscraper;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.utility.MountableFile;
+
+/** Test container that allows to execute {@link JmxScraper} in an isolated container */
+public class JmxScraperContainer extends GenericContainer<JmxScraperContainer> {
+
+  private final String endpoint;
+  private final Set<String> targetSystems;
+  private String serviceUrl;
+  private int intervalMillis;
+  private final Set<String> customYaml;
+
+  public JmxScraperContainer(String otlpEndpoint) {
+    super("openjdk:8u272-jre-slim");
+
+    String scraperJarPath = System.getProperty("shadow.jar.path");
+    assertThat(scraperJarPath).isNotNull();
+
+    this.withCopyFileToContainer(MountableFile.forHostPath(scraperJarPath), "/scraper.jar")
+        .waitingFor(
+            Wait.forLogMessage(".*JMX scraping started.*", 1)
+                .withStartupTimeout(Duration.ofSeconds(10)));
+
+    this.endpoint = otlpEndpoint;
+    this.targetSystems = new HashSet<>();
+    this.customYaml = new HashSet<>();
+    this.intervalMillis = 1000;
+  }
+
+  @CanIgnoreReturnValue
+  public JmxScraperContainer withTargetSystem(String targetSystem) {
+    targetSystems.add(targetSystem);
+    return this;
+  }
+
+  @CanIgnoreReturnValue
+  public JmxScraperContainer withIntervalMillis(int intervalMillis) {
+    this.intervalMillis = intervalMillis;
+    return this;
+  }
+
+  @CanIgnoreReturnValue
+  public JmxScraperContainer withService(String host, int port) {
+    // TODO: adding a way to provide 'host:port' syntax would make this easier for end users
+    this.serviceUrl =
+        String.format(
+            Locale.getDefault(), "service:jmx:rmi:///jndi/rmi://%s:%d/jmxrmi", host, port);
+    return this;
+  }
+
+  @CanIgnoreReturnValue
+  public JmxScraperContainer withCustomYaml(String yamlPath) {
+    this.customYaml.add(yamlPath);
+    return this;
+  }
+
+  @Override
+  public void start() {
+    // for now only configure through JVM args
+    List<String> arguments = new ArrayList<>();
+    arguments.add("java");
+    arguments.add("-Dotel.exporter.otlp.endpoint=" + endpoint);
+
+    if (!targetSystems.isEmpty()) {
+      arguments.add("-Dotel.jmx.target.system=" + String.join(",", targetSystems));
+    }
+
+    if (serviceUrl == null) {
+      throw new IllegalStateException("Missing service URL");
+    }
+    arguments.add("-Dotel.jmx.service.url=" + serviceUrl);
+    arguments.add("-Dotel.jmx.interval.milliseconds=" + intervalMillis);
+
+    if (!customYaml.isEmpty()) {
+      int i = 0;
+      StringBuilder sb = new StringBuilder("-Dotel.jmx.config=");
+      for (String yaml : customYaml) {
+        String containerPath = "/custom_" + i + ".yaml";
+        this.withCopyFileToContainer(MountableFile.forClasspathResource(yaml), containerPath);
+        if (i > 0) {
+          sb.append(",");
+        }
+        sb.append(containerPath);
+        i++;
+      }
+      arguments.add(sb.toString());
+    }
+
+    arguments.add("-jar");
+    arguments.add("/scraper.jar");
+
+    this.withCommand(arguments.toArray(new String[0]));
+
+    logger().info("Starting scraper with command: " + String.join(" ", arguments));
+
+    super.start();
+  }
+}

jmx-scraper/src/integrationTest/java/io/opentelemetry/contrib/jmxscraper/TestAppContainer.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.jmxscraper;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+import org.testcontainers.shaded.com.google.errorprone.annotations.CanIgnoreReturnValue;
+import org.testcontainers.utility.MountableFile;
+
+/** Test container that allows to execute {@link TestApp} in an isolated container */
+public class TestAppContainer extends GenericContainer<TestAppContainer> {
+
+  private final Map<String, String> properties;
+  private int port;
+  private String login;
+  private String pwd;
+
+  public TestAppContainer() {
+    super("openjdk:8u272-jre-slim");
+
+    this.properties = new HashMap<>();
+
+    String appJar = System.getProperty("app.jar.path");
+    assertThat(Paths.get(appJar)).isNotEmptyFile().isReadable();
+
+    this.withCopyFileToContainer(MountableFile.forHostPath(appJar), "/app.jar")
+        .waitingFor(
+            Wait.forLogMessage(TestApp.APP_STARTED_MSG + "\\n", 1)
+                .withStartupTimeout(Duration.ofSeconds(5)))
+        .withCommand("java", "-jar", "/app.jar");
+  }
+
+  @CanIgnoreReturnValue
+  public TestAppContainer withJmxPort(int port) {
+    this.port = port;
+    properties.put("com.sun.management.jmxremote.port", Integer.toString(port));
+    return this.withExposedPorts(port);
+  }
+
+  @CanIgnoreReturnValue
+  public TestAppContainer withUserAuth(String login, String pwd) {
+    this.login = login;
+    this.pwd = pwd;
+    return this;
+  }
+
+  @Override
+  protected void doStart() {
+    super.doStart();
+  }
+
+  @Override
+  public void start() {
+
+    // TODO: add support for ssl
+    properties.put("com.sun.management.jmxremote.ssl", "false");
+
+    if (pwd == null) {
+      properties.put("com.sun.management.jmxremote.authenticate", "false");
+    } else {
+      properties.put("com.sun.management.jmxremote.authenticate", "true");
+
+      Path pwdFile = createPwdFile(login, pwd);
+      this.withCopyFileToContainer(MountableFile.forHostPath(pwdFile), "/jmx.password");
+      properties.put("com.sun.management.jmxremote.password.file", "/jmx.password");
+
+      Path accessFile = createAccessFile(login);
+      this.withCopyFileToContainer(MountableFile.forHostPath(accessFile), "/jmx.access");
+      properties.put("com.sun.management.jmxremote.access.file", "/jmx.access");
+    }
+
+    String confArgs =
+        properties.entrySet().stream()
+            .map(
+                e -> {
+                  String s = "-D" + e.getKey();
+                  if (!e.getValue().isEmpty()) {
+                    s += "=" + e.getValue();
+                  }
+                  return s;
+                })
+            .collect(Collectors.joining(" "));
+
+    this.withEnv("JAVA_TOOL_OPTIONS", confArgs);
+
+    logger().info("Test application JAVA_TOOL_OPTIONS = " + confArgs);
+
+    super.start();
+
+    logger().info("Test application JMX port mapped to {}:{}", getHost(), getMappedPort(port));
+  }
+
+  private static Path createPwdFile(String login, String pwd) {
+    try {
+      Path path = Files.createTempFile("test", ".pwd");
+      writeLine(path, String.format("%s %s", login, pwd));
+      return path;
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private static Path createAccessFile(String login) {
+    try {
+      Path path = Files.createTempFile("test", ".pwd");
+      writeLine(path, String.format("%s %s", login, "readwrite"));
+      return path;
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private static void writeLine(Path path, String line) throws IOException {
+    line = line + "\n";
+    Files.write(path, line.getBytes(StandardCharsets.UTF_8));
+  }
+}