jmx scraper connection test

jmx-scraper/README.md

@@ -81,8 +81,19 @@ be set through the standard `JAVA_TOOL_OPTIONS` environment variable using the `
 
 ## Troubleshooting
 
+### Exported metrics
+
 In order to investigate when and what metrics are being captured and sent, setting the `otel.metrics.exporter`
-configuration option to include `logging` exporter provides log messages when metrics are being exported.
+configuration option to include `logging` exporter provides log messages when metrics are being exported
+
+### JMX connection test
+
+Connection to the remote JVM through the JMX can be tested by adding the `-test` argument.
+When doing so, the JMX Scraper will only test the connection to the remote JVM with provided configuration
+and exit.
+
+- Connection OK: `JMX connection test OK` message is written to standard output and exit status = `0`
+- Connection ERROR: `JMX connection test ERROR` message is written to standard output and exit status = `1`
 
 ## Extra libraries in classpath
 

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

@@ -0,0 +1,133 @@
+/*
+ * 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.util.function.Function;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.Network;
+import org.testcontainers.containers.output.Slf4jLogConsumer;
+
+/**
+ * Tests all supported ways to connect to remote JMX interface. This indirectly tests
+ * JmxConnectionBuilder and relies on containers to minimize the JMX/RMI network complications which
+ * are not NAT-friendly.
+ */
+public class JmxConnectionTest {
+
+  // OTLP endpoint is not used in test mode, but still has to be provided
+  private static final String DUMMY_OTLP_ENDPOINT = "http://dummy-otlp-endpoint:8080/";
+  private static final String SCRAPER_BASE_IMAGE = "openjdk:8u342-jre-slim";
+
+  private static final int JMX_PORT = 9999;
+  private static final String APP_HOST = "app";
+
+  private static final Logger jmxScraperLogger = LoggerFactory.getLogger("JmxScraperContainer");
+  private static final Logger appLogger = LoggerFactory.getLogger("TestAppContainer");
+
+  private static Network network;
+
+  @BeforeAll
+  static void beforeAll() {
+    network = Network.newNetwork();
+  }
+
+  @AfterAll
+  static void afterAll() {
+    network.close();
+  }
+
+  @Test
+  void connectionError() {
+    try (JmxScraperContainer scraper = scraperContainer().withRmiServiceUrl("unknown_host", 1234)) {
+      scraper.start();
+      waitTerminated(scraper);
+      checkConnectionLogs(scraper, /* expectedOk= */ false);
+    }
+  }
+
+  @Test
+  void connectNoAuth() {
+    connectionTest(
+        app -> app.withJmxPort(JMX_PORT), scraper -> scraper.withRmiServiceUrl(APP_HOST, JMX_PORT));
+  }
+
+  @Test
+  void userPassword() {
+    String login = "user";
+    String pwd = "t0p!Secret";
+    connectionTest(
+        app -> app.withJmxPort(JMX_PORT).withUserAuth(login, pwd),
+        scraper -> scraper.withRmiServiceUrl(APP_HOST, JMX_PORT).withUser(login).withPassword(pwd));
+  }
+
+  private static void connectionTest(
+      Function<TestAppContainer, TestAppContainer> customizeApp,
+      Function<JmxScraperContainer, JmxScraperContainer> customizeScraper) {
+    try (TestAppContainer app = customizeApp.apply(appContainer())) {
+      app.start();
+      try (JmxScraperContainer scraper = customizeScraper.apply(scraperContainer())) {
+        scraper.start();
+        waitTerminated(scraper);
+        checkConnectionLogs(scraper, /* expectedOk= */ true);
+      }
+    }
+  }
+
+  private static void checkConnectionLogs(JmxScraperContainer scraper, boolean expectedOk) {
+
+    String[] logLines = scraper.getLogs().split("\n");
+    String lastLine = logLines[logLines.length - 1];
+
+    if (expectedOk) {
+      assertThat(lastLine)
+          .describedAs("should log connection success")
+          .endsWith("JMX connection test OK");
+    } else {
+      assertThat(lastLine)
+          .describedAs("should log connection failure")
+          .endsWith("JMX connection test ERROR");
+    }
+  }
+
+  private static void waitTerminated(GenericContainer<?> container) {
+    int retries = 10;
+    while (retries > 0 && container.isRunning()) {
+      retries--;
+      try {
+        Thread.sleep(100);
+      } catch (InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+    }
+    assertThat(retries)
+        .describedAs("container should stop when testing connection")
+        .isNotEqualTo(0);
+  }
+
+  private static JmxScraperContainer scraperContainer() {
+    return new JmxScraperContainer(DUMMY_OTLP_ENDPOINT, SCRAPER_BASE_IMAGE)
+        .withLogConsumer(new Slf4jLogConsumer(jmxScraperLogger))
+        .withNetwork(network)
+        // mandatory to have a target system even if we don't collect metrics
+        .withTargetSystem("jvm")
+        // we are only testing JMX connection here
+        .withTestJmx();
+  }
+
+  private static TestAppContainer appContainer() {
+    return new TestAppContainer()
+        .withLogConsumer(new Slf4jLogConsumer(appLogger))
+        .withNetwork(network)
+        .withNetworkAliases(APP_HOST);
+  }
+}

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

@@ -28,17 +28,15 @@ public class JmxScraperContainer extends GenericContainer<JmxScraperContainer> {
   private String user;
   private String password;
   private final List<String> extraJars;
+  private boolean testJmx;
 
   public JmxScraperContainer(String otlpEndpoint, String baseImage) {
     super(baseImage);
 
     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.withCopyFileToContainer(MountableFile.forHostPath(scraperJarPath), "/scraper.jar");
 
     this.endpoint = otlpEndpoint;
     this.targetSystems = new HashSet<>();
@@ -108,6 +106,12 @@ public JmxScraperContainer withCustomYaml(String yamlPath) {
     return this;
   }
 
+  @CanIgnoreReturnValue
+  public JmxScraperContainer withTestJmx() {
+    this.testJmx = true;
+    return this;
+  }
+
   @Override
   public void start() {
     // for now only configure through JVM args
@@ -152,6 +156,15 @@ public void start() {
       arguments.add("io.opentelemetry.contrib.jmxscraper.JmxScraper");
     }
 
+    if (testJmx) {
+      arguments.add("-test");
+      this.waitingFor(Wait.forLogMessage(".*JMX connection test.*", 1));
+    } else {
+      this.waitingFor(
+          Wait.forLogMessage(".*JMX scraping started.*", 1)
+              .withStartupTimeout(Duration.ofSeconds(10)));
+    }
+
     this.withCommand(arguments.toArray(new String[0]));
 
     logger().info("Starting scraper with command: " + String.join(" ", arguments));

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

@@ -61,28 +61,6 @@ public TestAppContainer withUserAuth(String login, String pwd) {
     return this;
   }
 
-  /**
-   * Configures app container for host-to-container access, port will be used as-is from host to
-   * work-around JMX in docker. This is optional on Linux as there is a network route and the
-   * container is accessible, but not on Mac where the container runs in an isolated VM.
-   *
-   * @param port port to use, must be available on host.
-   * @return this
-   */
-  @CanIgnoreReturnValue
-  public TestAppContainer withHostAccessFixedJmxPort(int port) {
-    // To get host->container JMX connection working docker must expose JMX/RMI port under the same
-    // port number. Because of this testcontainers' standard exposed port randomization approach
-    // can't be used.
-    // Explanation:
-    // https://forums.docker.com/t/exposing-mapped-jmx-ports-from-multiple-containers/5287/6
-    properties.put("com.sun.management.jmxremote.port", Integer.toString(port));
-    properties.put("com.sun.management.jmxremote.rmi.port", Integer.toString(port));
-    properties.put("java.rmi.server.hostname", getHost());
-    addFixedExposedPort(port, port);
-    return this;
-  }
-
   @Override
   public void start() {
     // TODO: add support for ssl