convert groovy smoke tests to java

Author: zeitlinger

smoke-tests/src/test/groovy/io/opentelemetry/smoketest/AgentDebugLoggingTest.groovy

@@ -0,0 +1,32 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.smoketest;
+
+import java.time.Duration;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledIf;
+
+@DisabledIf("io.opentelemetry.smoketest.TestContainerManager#useWindowsContainers")
+public class AgentDebugLoggingTest extends JavaSmokeTest {
+  @Override
+  protected String getTargetImage(String jdk) {
+    return "ghcr.io/open-telemetry/opentelemetry-java-instrumentation/smoke-test-spring-boot:jdk"
+        + jdk
+        + "-20211213.1570880324";
+  }
+
+  @Override
+  protected TargetWaitStrategy getWaitStrategy() {
+    return new TargetWaitStrategy.Log(
+        Duration.ofMinutes(1), ".*DEBUG io.opentelemetry.javaagent.tooling.VersionLogger.*");
+  }
+
+  @Test
+  public void verify_that_debug_logging_is_working() {
+    startTarget(8);
+    stopTarget();
+  }
+}

smoke-tests/src/test/groovy/io/opentelemetry/smoketest/SecurityManagerSmokeTest.groovy

@@ -0,0 +1,125 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.smoketest;
+
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
+
+import io.opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest;
+import io.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest;
+import io.opentelemetry.sdk.trace.data.SpanData;
+import io.opentelemetry.smoketest.windows.WindowsTestContainerManager;
+import io.opentelemetry.testing.internal.armeria.client.WebClient;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import org.junit.jupiter.api.BeforeEach;
+import org.testcontainers.containers.output.OutputFrame;
+
+public abstract class JavaSmokeTest {
+  protected static final TestContainerManager containerManager = createContainerManager();
+  private JavaTelemetryRetriever telemetryRetriever;
+
+  protected String agentPath =
+      System.getProperty("io.opentelemetry.smoketest.agent.shadowJar.path");
+
+  protected WebClient client() {
+    return WebClient.of("h1c://localhost:" + containerManager.getTargetMappedPort(8080));
+  }
+
+  /** Subclasses can override this method to pass jvm arguments in another environment variable */
+  protected String getJvmArgsEnvVarName() {
+    return "JAVA_TOOL_OPTIONS";
+  }
+
+  /** Subclasses can override this method to customise target application's environment */
+  protected Map<String, String> getExtraEnv() {
+    return emptyMap();
+  }
+
+  /** Subclasses can override this method to disable setting default service name */
+  protected boolean getSetServiceName() {
+    return true;
+  }
+
+  /** Subclasses can override this method to provide additional files to copy to target container */
+  protected List<ResourceMapping> getExtraResources() {
+    return emptyList();
+  }
+
+  /**
+   * Subclasses can override this method to provide additional ports that should be exposed from the
+   * target container
+   */
+  protected List<Integer> getExtraPorts() {
+    return emptyList();
+  }
+
+  @BeforeEach
+  void setUp() {
+    containerManager.startEnvironmentOnce();
+    telemetryRetriever = new JavaTelemetryRetriever(containerManager.getBackendMappedPort());
+  }
+
+  public Consumer<OutputFrame> startTarget(int jdk) {
+    return startTarget(String.valueOf(jdk), null, false);
+  }
+
+  public Consumer<OutputFrame> startTarget(String jdk, String serverVersion, boolean windows) {
+    String targetImage = getTargetImage(jdk, serverVersion, windows);
+    return containerManager.startTarget(
+        targetImage,
+        agentPath,
+        getJvmArgsEnvVarName(),
+        getExtraEnv(),
+        getSetServiceName(),
+        getExtraResources(),
+        getExtraPorts(),
+        getWaitStrategy(),
+        getCommand());
+  }
+
+  protected abstract String getTargetImage(String jdk);
+
+  protected String getTargetImage(String jdk, String serverVersion, boolean windows) {
+    return getTargetImage(jdk);
+  }
+
+  protected TargetWaitStrategy getWaitStrategy() {
+    return null;
+  }
+
+  protected String[] getCommand() {
+    return null;
+  }
+
+  public void cleanup() {
+    telemetryRetriever.clearTelemetry();
+  }
+
+  public void stopTarget() {
+    containerManager.stopTarget();
+  }
+
+  protected List<SpanData> waitForTraces() {
+    return telemetryRetriever.waitForTraces();
+  }
+
+  protected Collection<ExportMetricsServiceRequest> waitForMetrics() {
+    return telemetryRetriever.waitForMetrics();
+  }
+
+  protected Collection<ExportLogsServiceRequest> waitForLogs() {
+    return telemetryRetriever.waitForLogs();
+  }
+
+  private static TestContainerManager createContainerManager() {
+    return TestContainerManager.useWindowsContainers()
+        ? new WindowsTestContainerManager()
+        : new LinuxTestContainerManager();
+  }
+}

smoke-tests/src/test/java/io/opentelemetry/smoketest/AgentDebugLoggingTest.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.smoketest;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.protobuf.GeneratedMessage;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.util.JsonFormat;
+import io.opentelemetry.javaagent.testing.common.AgentTestingExporterAccess;
+import io.opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest;
+import io.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest;
+import io.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest;
+import io.opentelemetry.sdk.trace.data.SpanData;
+import io.opentelemetry.testing.internal.armeria.client.WebClient;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class JavaTelemetryRetriever {
+  private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+  private final WebClient client;
+
+  public JavaTelemetryRetriever(int backendPort) {
+    client = WebClient.of("http://localhost:" + backendPort);
+  }
+
+  public void clearTelemetry() {
+    client.get("/clear").aggregate().join();
+  }
+
+  public List<SpanData> waitForTraces() {
+    Collection<ExportTraceServiceRequest> collection =
+        waitForTelemetry("get-traces", () -> ExportTraceServiceRequest.newBuilder());
+    Stream<io.opentelemetry.proto.trace.v1.Span> objectStream =
+        collection.stream()
+            .flatMap(
+                req ->
+                    req.getResourceSpansList().stream()
+                        .flatMap(
+                            rs ->
+                                rs.getScopeSpansList().stream()
+                                    .flatMap(ss -> ss.getSpansList().stream())));
+
+    return AgentTestingExporterAccess.getSpanData(
+        collection.stream().flatMap(req -> req.getResourceSpansList().stream()));
+  }
+
+  public Collection<ExportMetricsServiceRequest> waitForMetrics() {
+    return waitForTelemetry("get-metrics", () -> ExportMetricsServiceRequest.newBuilder());
+  }
+
+  public Collection<ExportLogsServiceRequest> waitForLogs() {
+    return waitForTelemetry("get-logs", () -> ExportLogsServiceRequest.newBuilder());
+  }
+
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  private <T extends GeneratedMessage, B extends GeneratedMessage.Builder>
+      Collection<T> waitForTelemetry(String path, Supplier<B> builderConstructor) {
+    try {
+      return OBJECT_MAPPER
+          .readTree(waitForContent(path))
+          .valueStream()
+          .map(
+              it -> {
+                B builder = builderConstructor.get();
+                // TODO: Register parser into object mapper to avoid de -> re -> deserialize.
+                try {
+                  JsonFormat.parser().merge(OBJECT_MAPPER.writeValueAsString(it), builder);
+                  return (T) builder.build();
+                } catch (InvalidProtocolBufferException | JsonProcessingException e) {
+                  throw new RuntimeException(e);
+                }
+              })
+          .collect(Collectors.toList());
+    } catch (JsonProcessingException | InterruptedException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private String waitForContent(String path) throws InterruptedException {
+    long previousSize = 0;
+    long deadline = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(30);
+    String content = "[]";
+    while (System.currentTimeMillis() < deadline) {
+      content = client.get(path).aggregate().join().contentUtf8();
+      if (content.length() > 2 && content.length() == previousSize) {
+        break;
+      }
+
+      previousSize = content.length();
+      System.out.println("Current content size " + previousSize);
+      TimeUnit.MILLISECONDS.sleep(500);
+    }
+
+    return content;
+  }
+
+  public final WebClient getClient() {
+    return client;
+  }
+}

smoke-tests/src/test/java/io/opentelemetry/smoketest/JavaSmokeTest.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.smoketest;
+
+import static io.opentelemetry.sdk.testing.assertj.TracesAssert.assertThat;
+
+import java.util.Collections;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledIf;
+
+@DisabledIf("io.opentelemetry.smoketest.TestContainerManager#useWindowsContainers")
+public class SecurityManagerSmokeTest extends JavaSmokeTest {
+  @Override
+  protected String getTargetImage(String jdk) {
+    return "ghcr.io/open-telemetry/opentelemetry-java-instrumentation/smoke-test-security-manager:jdk"
+        + jdk
+        + "-20241021.11448062560";
+  }
+
+  @Override
+  protected Map<String, String> getExtraEnv() {
+    return Collections.singletonMap(
+        "OTEL_JAVAAGENT_EXPERIMENTAL_SECURITY_MANAGER_SUPPORT_ENABLED", "true");
+  }
+
+  @Test
+  public void security_manager_smoke_test_on_JDK__jdk(int jdk) {
+    startTarget(jdk);
+
+    assertThat(waitForTraces())
+        .hasTracesSatisfyingExactly(
+            trace -> trace.hasSpansSatisfyingExactly(span -> span.hasName("test")));
+
+    stopTarget();
+
+    //    where: DefaultGroovyMethods.leftShift(jdk, new ArrayList<Integer>(Arrays.asList(8, 11, 17,
+    // 21, 23)));
+  }
+}