builder

Author: zeitlinger

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

@@ -12,17 +12,18 @@
 
 @DisabledIf("io.opentelemetry.smoketest.TestContainerManager#useWindowsContainers")
 class AgentDebugLoggingTest extends JavaSmokeTest {
-  @Override
-  protected String getTargetImage(String jdk) {
-    return "ghcr.io/open-telemetry/opentelemetry-java-instrumentation/smoke-test-spring-boot:jdk"
-        + jdk
-        + "-20250915.17728045097";
-  }
 
-  @Override
-  protected TargetWaitStrategy getWaitStrategy() {
-    return new TargetWaitStrategy.Log(
-        Duration.ofMinutes(1), ".*DEBUG io.opentelemetry.javaagent.tooling.VersionLogger.*");
+  public AgentDebugLoggingTest() {
+    super(
+        SmokeTestTarget.builder(
+                jdk ->
+                    "ghcr.io/open-telemetry/opentelemetry-java-instrumentation/smoke-test-spring-boot:jdk"
+                        + jdk
+                        + "-20250915.17728045097")
+            .waitStrategy(
+                new TargetWaitStrategy.Log(
+                    Duration.ofMinutes(1),
+                    ".*DEBUG io.opentelemetry.javaagent.tooling.VersionLogger.*")));
   }
 
   @DisplayName("verifies that debug logging is working by checking for a debug log on startup")

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

@@ -21,29 +21,24 @@
 
 @DisabledIf("io.opentelemetry.smoketest.TestContainerManager#useWindowsContainers")
 class DeclarativeConfigurationSmokeTest extends JavaSmokeTest {
-  @Override
-  protected String getTargetImage(String jdk) {
-    return "ghcr.io/open-telemetry/opentelemetry-java-instrumentation/smoke-test-spring-boot:jdk"
-        + jdk
-        + "-20241021.11448062567";
+
+  public DeclarativeConfigurationSmokeTest() {
+    super(
+        SmokeTestTarget.builder(
+                jdk ->
+                    "ghcr.io/open-telemetry/opentelemetry-java-instrumentation/smoke-test-spring-boot:jdk"
+                        + jdk
+                        + "-20241021.11448062567")
+                .waitStrategy(new TargetWaitStrategy.Log(
+                        Duration.ofMinutes(1), ".*Started SpringbootApplication in.*"))
+            .env("OTEL_EXPERIMENTAL_CONFIG_FILE", "declarative-config.yaml"));
   }
 
   @Override
   protected List<ResourceMapping> getExtraResources() {
     return List.of(ResourceMapping.of("declarative-config.yaml", "/declarative-config.yaml"));
   }
 
-  @Override
-  protected Map<String, String> getExtraEnv() {
-    return Map.of("OTEL_EXPERIMENTAL_CONFIG_FILE", "declarative-config.yaml");
-  }
-
-  @Override
-  protected TargetWaitStrategy getWaitStrategy() {
-    return new TargetWaitStrategy.Log(
-        Duration.ofMinutes(1), ".*Started SpringbootApplication in.*");
-  }
-
   @ParameterizedTest
   @ValueSource(ints = {8, 11, 17})
   void springBootSmokeTest(int jdk) {

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

@@ -33,43 +33,25 @@ public abstract class JavaSmokeTest implements TelemetryRetrieverProvider {
   private static final Pattern TRACE_ID_PATTERN =
       Pattern.compile(".*trace_id=(?<traceId>[a-zA-Z0-9]+).*");
   protected static final TestContainerManager containerManager = createContainerManager();
+
+  private final SmokeTestTarget target;
   private static TelemetryRetriever telemetryRetriever;
 
   protected String agentPath =
       System.getProperty("io.opentelemetry.smoketest.agent.shadowJar.path");
 
   @RegisterExtension static final AutoCleanupExtension autoCleanup = AutoCleanupExtension.create();
 
-  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;
+  public JavaSmokeTest(SmokeTestTarget.Builder builder) {
+    this.target = customize(builder).build();
   }
 
-  /** Subclasses can override this method to provide additional files to copy to target container */
-  protected List<ResourceMapping> getExtraResources() {
-    return emptyList();
+  protected SmokeTestTarget.Builder customize(SmokeTestTarget.Builder builder) {
+    return builder;
   }
 
-  /**
-   * Subclasses can override this method to provide additional ports that should be exposed from the
-   * target container
-   */
-  protected List<Integer> getExtraPorts() {
-    return emptyList();
+  public WebClient client() {
+    return WebClient.of("h1c://localhost:" + containerManager.getTargetMappedPort(8080));
   }
 
   @BeforeAll
@@ -83,33 +65,19 @@ protected Consumer<OutputFrame> startTarget(int jdk) {
   }
 
   protected Consumer<OutputFrame> startTarget(String jdk, String serverVersion, boolean windows) {
-    String targetImage = getTargetImage(jdk, serverVersion, windows);
+    String targetImage = target.getGetTargetImage(jdk, serverVersion, windows);
     autoCleanup.deferCleanup(() -> containerManager.stopTarget());
 
     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;
+        target.getJvmArgsEnvVarName(),
+        target.getExtraEnv(),
+        target.getSetServiceName(),
+        target.getExtraResources(),
+        target.getExtraPorts(),
+        target.getWaitStrategy(),
+        target.getCommand());
   }
 
   protected static void assertVersionLogged(Consumer<OutputFrame> output, String version) {

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

@@ -5,28 +5,29 @@
 
 package io.opentelemetry.smoketest;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import io.opentelemetry.sdk.logs.data.LogRecordData;
-import java.time.Duration;
-import java.util.Collection;
 import org.junit.jupiter.api.condition.DisabledIf;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
 
+import java.time.Duration;
+import java.util.Collection;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
 @DisabledIf("io.opentelemetry.smoketest.TestContainerManager#useWindowsContainers")
 class LogsSmokeTest 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), ".*Started SpringbootApplication in.*");
+  public LogsSmokeTest() {
+    super(
+        SmokeTestTarget.builder(
+                jdk ->
+                    "ghcr.io/open-telemetry/opentelemetry-java-instrumentation/smoke-test-spring-boot:jdk"
+                        + jdk
+                        + "-20211213.1570880324")
+            .waitStrategy(
+                new TargetWaitStrategy.Log(
+                    Duration.ofMinutes(1), ".*Started SpringbootApplication in.*")));
   }
 
   @ParameterizedTest

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

@@ -0,0 +1,172 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.smoketest;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+import static java.util.Collections.emptyMap;
+
+public class SmokeTestTarget {
+
+  @FunctionalInterface
+  interface GetTargetImage {
+    String getTargetImage(String jdk, String serverVersion, boolean windows);
+  }
+
+  private final GetTargetImage getTargetImage;
+
+  private final String[] command;
+  private final String jvmArgsEnvVarName;
+  private final boolean setServiceName;
+  private final Map<String, String> extraEnv;
+  private final List<ResourceMapping> extraResources;
+  private final TargetWaitStrategy waitStrategy;
+  private final List<Integer> extraPorts;
+
+  public SmokeTestTarget(
+      GetTargetImage getTargetImage,
+      String[] command,
+      String jvmArgsEnvVarName,
+      boolean setServiceName,
+      Map<String, String> extraEnv,
+      List<ResourceMapping> extraResources,
+      TargetWaitStrategy waitStrategy,
+      List<Integer> extraPorts) {
+    this.getTargetImage = getTargetImage;
+    this.command = command;
+    this.jvmArgsEnvVarName = jvmArgsEnvVarName;
+    this.setServiceName = setServiceName;
+    this.extraEnv = extraEnv;
+    this.extraResources = extraResources;
+    this.waitStrategy = waitStrategy;
+    this.extraPorts = extraPorts;
+  }
+
+    public GetTargetImage getGetTargetImage() {
+        return getTargetImage;
+    }
+
+    public String[] getCommand() {
+    return command;
+  }
+
+  /** Subclasses can override this method to pass jvm arguments in another environment variable */
+  public String getJvmArgsEnvVarName() {
+    return jvmArgsEnvVarName;
+  }
+
+  /** Subclasses can override this method to customise target application's environment */
+  public Map<String, String> getExtraEnv() {
+    return extraEnv;
+  }
+
+  /** Subclasses can override this method to disable setting default service name */
+  public boolean getSetServiceName() {
+    return setServiceName;
+  }
+
+  /** Subclasses can override this method to provide additional files to copy to target container */
+  public List<ResourceMapping> getExtraResources() {
+    return extraResources;
+  }
+
+  /**
+   * Subclasses can override this method to provide additional ports that should be exposed from the
+   * target container
+   */
+  public List<Integer> getExtraPorts() {
+    return extraPorts;
+  }
+
+  public TargetWaitStrategy getWaitStrategy() {
+    return waitStrategy;
+  }
+
+  public static Builder builder(Function<String, String> getTargetImage) {
+    return builder((jdk, serverVersion, windows) -> getTargetImage.apply(jdk));
+  }
+
+  public static Builder builder(GetTargetImage getTargetImage) {
+    return new Builder(getTargetImage);
+  }
+
+  public static Builder springBoot() {
+    return builder(
+            jdk ->
+                "ghcr.io/open-telemetry/opentelemetry-java-instrumentation/smoke-test-spring-boot:jdk"
+                    + jdk
+                    + "-20211213.1570880324")
+        .waitStrategy(
+            new TargetWaitStrategy.Log(
+                Duration.ofMinutes(1), ".*Started SpringbootApplication in.*"));
+  }
+
+  public static class Builder {
+    private final GetTargetImage getTargetImage;
+    private String[] command;
+    private String jvmArgsEnvVarName = "JAVA_TOOL_OPTIONS";
+    private boolean setServiceName = true;
+    private Map<String, String> extraEnv;
+    private List<ResourceMapping> extraResources;
+    private TargetWaitStrategy waitStrategy;
+    private List<Integer> extraPorts;
+
+    private Builder(GetTargetImage getTargetImage) {
+      this.getTargetImage = getTargetImage;
+      this.extraEnv = emptyMap();
+    }
+
+    public Builder command(String... command) {
+      this.command = command;
+      return this;
+    }
+
+    public Builder jvmArgsEnvVarName(String jvmArgsEnvVarName) {
+      this.jvmArgsEnvVarName = jvmArgsEnvVarName;
+      return this;
+    }
+
+    public Builder setServiceName(boolean setServiceName) {
+      this.setServiceName = setServiceName;
+      return this;
+    }
+
+    public Builder env(String key, String value) {
+      this.extraEnv.put(key, value);
+      return this;
+    }
+
+    public Builder extraResources(ResourceMapping... resources) {
+      this.extraResources = List.of(resources);
+      return this;
+    }
+
+    public Builder waitStrategy(TargetWaitStrategy waitStrategy) {
+      this.waitStrategy = waitStrategy;
+      return this;
+    }
+
+    public Builder extraPorts(Integer... ports) {
+      this.extraPorts = List.of(ports);
+      return this;
+    }
+
+    public SmokeTestTarget build() {
+      return new SmokeTestTarget(
+          getTargetImage,
+          command,
+          jvmArgsEnvVarName,
+          setServiceName,
+          extraEnv,
+          extraResources,
+          waitStrategy,
+          extraPorts);
+    }
+  }
+}

smoke-tests/src/test/java/io/opentelemetry/smoketest/propagation/B3MultiPropagationTest.java

@@ -5,13 +5,14 @@
 
 package io.opentelemetry.smoketest.propagation;
 
-import java.util.Map;
+import io.opentelemetry.smoketest.SmokeTestTarget;
 import org.junit.jupiter.api.condition.DisabledIf;
 
 @DisabledIf("io.opentelemetry.smoketest.TestContainerManager#useWindowsContainers")
 class B3MultiPropagationTest extends PropagationTest {
+
   @Override
-  protected Map<String, String> getExtraEnv() {
-    return Map.of("otel.propagators", "b3multi");
+  protected SmokeTestTarget.Builder customize(SmokeTestTarget.Builder builder) {
+    return builder.env("otel.propagators", "b3multi");
   }
 }