Rename PetClinic and Agent (#81)

In this commit, we are simply renaming PetClinic and Agent to
VehicleInventoryService and DistroConfig. We are doing this change so we
can have multiple people working on this in parallel without stepping on
toes.

Note that there are a few occurences of PetClinic/Agent that were not
changed - in these cases, we know that we will be deleting this logic,
so we did not bother updating now (e.g. AgentResolver).

Testing: 
```
dev-dsk-thp-2a-bd3a87ed % ./gradlew test

> Task :compileTestJava
Note: Some input files use or override a deprecated API.
Note: Recompile with -Xlint:deprecation for details.

Deprecated Gradle features were used in this build, making it incompatible with Gradle 9.0.

You can use '--warning-mode all' to show the individual deprecation warnings and determine if they come from your own scripts or plugins.

For more on this, please refer to https://docs.gradle.org/8.6/userguide/command_line_interface.html#sec:command_line_warnings in the Gradle documentation.

BUILD SUCCESSFUL in 5m 45s
3 actionable tasks: 3 executed
```

By submitting this pull request, I confirm that you can use, modify,
copy, and redistribute this contribution, under the terms of your
choice.

Author: thpierce

performance-tests/README.md

@@ -3,14 +3,14 @@
 - [Process](#process)
 - [What do we measure?](#what-do-we-measure)
 - [Config](#config)
-- [Agents](#agents)
+- [DistroConfigs](#distroConfigs)
 - [Automation](#automation)
 - [Setup and Usage](#setup-and-usage)
 - [Visualization](#visualization)
 
 This directory will contain tools and utilities
 that help us to measure the performance overhead introduced by
-the agent and to measure how this overhead changes over time.
+the distro and to measure how this overhead changes over time.
 
 The overhead tests here should be considered a "macro" benchmark. They serve to measure high-level
 overhead as perceived by the operator of a "typical" application. Tests are performed on a Java 11
@@ -20,25 +20,25 @@ distribution from [Eclipse Temurin](https://projects.eclipse.org/projects/adopti
 
 There is one dynamic test here called [OverheadTests](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/benchmark-overhead/src/test/java/io/opentelemetry/OverheadTests.java).
 The `@TestFactory` method creates a test pass for each of the [defined configurations](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/benchmark-overhead/src/test/java/io/opentelemetry/config/Configs.java).
-Before the tests run, a single collector instance is started. Each test pass has one or more agents configured and those are tested in series.
-For each agent defined in a configuration, the test runner (using [testcontainers](https://www.testcontainers.org/)) will:
+Before the tests run, a single collector instance is started. Each test pass has one or more distroConfigs and those are tested in series.
+For each distro defined in a configuration, the test runner (using [testcontainers](https://www.testcontainers.org/)) will:
 
 1. create a fresh postgres instance and populate it with initial data.
-2. create a fresh instance of [spring-petclinic-rest](https://github.com/spring-petclinic/spring-petclinic-rest) instrumented with the specified agent
+2. create a fresh instance of [spring-petclinic-rest](https://github.com/spring-petclinic/spring-petclinic-rest) instrumented with the specified distroConfig
 3. measure the time until the petclinic app is marked "healthy" and then write it to a file.
 4. if configured, perform a warmup phase. During the warmup phase, a bit of traffic is generated in order to get the application into a steady state (primarily helping facilitate jit compilations). Currently, we use a 30 second warmup time.
 5. start a JFR recording by running `jcmd` inside the petclinic container
 6. run the [k6 test script](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/benchmark-overhead/k6/basic.js) with the configured number of iterations through the file and the configured number of concurrent virtual users (VUs).
 7. after k6 completes, petclinic is shut down
 8. after petclinic is shut down, postgres is shut down
 
-And this repeats for every agent configured in each test configuration.
+And this repeats for every distro configured in each test configuration.
 
 After all the tests are complete, the results are collected and committed back to the `/results` subdirectory as csv and summary text files.
 
 ## What do we measure?
 
-For each test pass, we record the following metrics in order to compare agents and determine
+For each test pass, we record the following metrics in order to compare distroConfigs and determine
 relative overhead.
 
 | metric name              | units  | description                                                                  |
@@ -53,7 +53,7 @@ relative overhead.
 | Request p95              | ms     | 95th percentile time to handle a single web requ4st (measured at the caller) |
 | Iteration mean           | ms     | average time to do a single pass through the k6 test script                  |
 | Iteration p95            | ms     | 95th percentile time to do a single pass through the k6 test script          |
-| Peak threads             | #      | Highest number of running threads in the VM, including agent threads         |
+| Peak threads             | #      | Highest number of running threads in the VM, including distroConfig threads  |
 | Network read mean        | bits/s | Average network read rate                                                    |
 | Network write mean       | bits/s | Average network write rate                                                   |
 | Average JVM user CPU     | %      | Average observed user CPU (range 0.0-1.0)                                    |
@@ -68,26 +68,26 @@ Each config contains the following:
 
 - name
 - description
-- list of agents (see below)
+- list of distroConfigs (see below)
 - maxRequestRate (optional, used to throttle traffic)
 - concurrentConnections (number of concurrent virtual users [VUs])
 - totalIterations - the number of passes to make through the k6 test script
 - warmupSeconds - how long to wait before starting conducting measurements
 
 Currently, we test:
 
-- no agent versus latest released agent
-- no agent versus latest snapshot
+- no distro versus latest released distro
+- no distro versus latest snapshot
 - latest release vs. latest snapshot
 
 Additional configurations can be created by submitting a PR against the `Configs` class.
 
-### Agents
+### DistroConfigs
 
-An agent is defined in code as a name, description, optional URL, and optional additional
-arguments to be passed to the JVM (not including `-javaagent:`). New agents may be defined
-by creating new instances of the `Agent` class. The `AgentResolver` is used to download
-the relevant agent jar for an `Agent` definition.
+An distroConfig is defined in code as a name, description, optional URL, and optional additional
+arguments to be passed to the JVM (not including `-javaagent:`). New distroConfigs may be defined
+by creating new instances of the `Distro` class. The `AgentResolver` is used to download
+the relevant distroConfig jar for an `Distro` definition.
 
 ## Automation
 

performance-tests/src/test/java/io/opentelemetry/OverheadTests.java

@@ -8,13 +8,13 @@
 import static org.junit.jupiter.api.Assertions.fail;
 import static org.junit.jupiter.api.DynamicTest.dynamicTest;
 
-import io.opentelemetry.agents.Agent;
 import io.opentelemetry.config.Configs;
 import io.opentelemetry.config.TestConfig;
 import io.opentelemetry.containers.CollectorContainer;
 import io.opentelemetry.containers.K6Container;
-import io.opentelemetry.containers.PetClinicRestContainer;
 import io.opentelemetry.containers.PostgresContainer;
+import io.opentelemetry.containers.VehicleInventoryServiceContainer;
+import io.opentelemetry.distros.DistroConfig;
 import io.opentelemetry.results.AppPerfResults;
 import io.opentelemetry.results.MainResultsPersister;
 import io.opentelemetry.results.ResultsCollector;
@@ -63,11 +63,11 @@ Stream<DynamicTest> runAllTestConfigurations() {
   void runTestConfig(TestConfig config) {
     runDurations.clear();
     config
-        .getAgents()
+        .getDistroConfigs()
         .forEach(
-            agent -> {
+            distroConfig -> {
               try {
-                runAppOnce(config, agent);
+                runAppOnce(config, distroConfig);
               } catch (Exception e) {
                 fail("Unhandled exception in " + config.getName(), e);
               }
@@ -77,40 +77,43 @@ void runTestConfig(TestConfig config) {
     new MainResultsPersister(config).write(results);
   }
 
-  void runAppOnce(TestConfig config, Agent agent) throws Exception {
+  void runAppOnce(TestConfig config, DistroConfig distroConfig) throws Exception {
     GenericContainer<?> postgres = new PostgresContainer(NETWORK).build();
     postgres.start();
 
-    GenericContainer<?> petclinic =
-        new PetClinicRestContainer(NETWORK, collector, agent, namingConventions).build();
+    GenericContainer<?> vehicleInventoryService =
+        new VehicleInventoryServiceContainer(NETWORK, collector, distroConfig, namingConventions)
+            .build();
     long start = System.currentTimeMillis();
-    petclinic.start();
-    writeStartupTimeFile(agent, start);
+    vehicleInventoryService.start();
+    writeStartupTimeFile(distroConfig, start);
 
     if (config.getWarmupSeconds() > 0) {
-      doWarmupPhase(config, petclinic);
+      doWarmupPhase(config, vehicleInventoryService);
     }
 
     long testStart = System.currentTimeMillis();
-    startRecording(agent, petclinic);
+    startRecording(distroConfig, vehicleInventoryService);
 
-    GenericContainer<?> k6 = new K6Container(NETWORK, agent, config, namingConventions).build();
+    GenericContainer<?> k6 =
+        new K6Container(NETWORK, distroConfig, config, namingConventions).build();
     k6.start();
 
     long runDuration = System.currentTimeMillis() - testStart;
-    runDurations.put(agent.getName(), runDuration);
+    runDurations.put(distroConfig.getName(), runDuration);
 
     // This is required to get a graceful exit of the VM before testcontainers kills it forcibly.
     // Without it, our jfr file will be empty.
-    petclinic.execInContainer("kill", "1");
-    while (petclinic.isRunning()) {
+    vehicleInventoryService.execInContainer("kill", "1");
+    while (vehicleInventoryService.isRunning()) {
       TimeUnit.MILLISECONDS.sleep(500);
     }
     postgres.stop();
   }
 
-  private void startRecording(Agent agent, GenericContainer<?> petclinic) throws Exception {
-    Path outFile = namingConventions.container.jfrFile(agent);
+  private void startRecording(
+      DistroConfig distroConfig, GenericContainer<?> vehicleInventoryService) throws Exception {
+    Path outFile = namingConventions.container.jfrFile(distroConfig);
     String[] command = {
       "jcmd",
       "1",
@@ -120,10 +123,10 @@ private void startRecording(Agent agent, GenericContainer<?> petclinic) throws E
       "name=petclinic",
       "filename=" + outFile
     };
-    petclinic.execInContainer(command);
+    vehicleInventoryService.execInContainer(command);
   }
 
-  private void doWarmupPhase(TestConfig testConfig, GenericContainer<?> petclinic)
+  private void doWarmupPhase(TestConfig testConfig, GenericContainer<?> vehicleInventoryService)
       throws IOException, InterruptedException {
     System.out.println(
         "Performing startup warming phase for " + testConfig.getWarmupSeconds() + " seconds...");
@@ -139,7 +142,7 @@ private void doWarmupPhase(TestConfig testConfig, GenericContainer<?> petclinic)
       "name=warmup",
       "filename=warmup.jfr"
     };
-    petclinic.execInContainer(startCommand);
+    vehicleInventoryService.execInContainer(startCommand);
 
     long deadline =
         System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(testConfig.getWarmupSeconds());
@@ -155,14 +158,14 @@ private void doWarmupPhase(TestConfig testConfig, GenericContainer<?> petclinic)
 
     System.out.println("Stopping disposable JFR warmup recording...");
     String[] stopCommand = {"jcmd", "1", "JFR.stop", "name=warmup"};
-    petclinic.execInContainer(stopCommand);
+    vehicleInventoryService.execInContainer(stopCommand);
 
     System.out.println("Warmup complete.");
   }
 
-  private void writeStartupTimeFile(Agent agent, long start) throws IOException {
+  private void writeStartupTimeFile(DistroConfig distroConfig, long start) throws IOException {
     long delta = System.currentTimeMillis() - start;
-    Path startupPath = namingConventions.local.startupDurationFile(agent);
+    Path startupPath = namingConventions.local.startupDurationFile(distroConfig);
     Files.writeString(startupPath, String.valueOf(delta));
   }
 }

performance-tests/src/test/java/io/opentelemetry/config/Configs.java

@@ -5,7 +5,7 @@
 
 package io.opentelemetry.config;
 
-import io.opentelemetry.agents.Agent;
+import io.opentelemetry.distros.DistroConfig;
 import java.util.Arrays;
 import java.util.stream.Stream;
 
@@ -14,8 +14,9 @@ public enum Configs {
   RELEASE(
       TestConfig.builder()
           .name("release")
-          .description("compares no agent, latest stable, and latest snapshot agents")
-          .withAgents(Agent.NONE, Agent.LATEST_RELEASE, Agent.LATEST_SNAPSHOT)
+          .description("compares no distro, latest stable, and latest snapshot distro")
+          .withDistroConfigs(
+              DistroConfig.NONE, DistroConfig.LATEST_RELEASE, DistroConfig.LATEST_SNAPSHOT)
           .warmupSeconds(60)
           .build());
 

performance-tests/src/test/java/io/opentelemetry/config/TestConfig.java

@@ -5,7 +5,7 @@
 
 package io.opentelemetry.config;
 
-import io.opentelemetry.agents.Agent;
+import io.opentelemetry.distros.DistroConfig;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -20,7 +20,7 @@ public class TestConfig {
 
   private final String name;
   private final String description;
-  private final List<Agent> agents;
+  private final List<DistroConfig> distroConfigs;
   private final int maxRequestRate;
   private final int concurrentConnections;
   private final int totalIterations;
@@ -29,7 +29,7 @@ public class TestConfig {
   public TestConfig(Builder builder) {
     this.name = builder.name;
     this.description = builder.description;
-    this.agents = Collections.unmodifiableList(builder.agents);
+    this.distroConfigs = Collections.unmodifiableList(builder.distroConfigs);
     this.maxRequestRate = builder.maxRequestRate;
     this.concurrentConnections = builder.concurrentConnections;
     this.totalIterations = builder.totalIterations;
@@ -44,8 +44,8 @@ public String getDescription() {
     return description;
   }
 
-  public List<Agent> getAgents() {
-    return Collections.unmodifiableList(agents);
+  public List<DistroConfig> getDistroConfigs() {
+    return Collections.unmodifiableList(distroConfigs);
   }
 
   public int getMaxRequestRate() {
@@ -71,7 +71,7 @@ public static Builder builder() {
   static class Builder {
     private String name;
     private String description;
-    private List<Agent> agents = new ArrayList<>();
+    private List<DistroConfig> distroConfigs = new ArrayList<>();
     private int maxRequestRate = DEFAULT_MAX_REQUEST_RATE;
     private int concurrentConnections = DEFAULT_CONCURRENT_CONNECTIONS;
     private int totalIterations = DEFAULT_TOTAL_ITERATIONS;
@@ -87,8 +87,8 @@ Builder description(String description) {
       return this;
     }
 
-    Builder withAgents(Agent... agents) {
-      this.agents.addAll(Arrays.asList(agents));
+    Builder withDistroConfigs(DistroConfig... distroConfigs) {
+      this.distroConfigs.addAll(Arrays.asList(distroConfigs));
       return this;
     }
 

performance-tests/src/test/java/io/opentelemetry/containers/K6Container.java

@@ -5,8 +5,8 @@
 
 package io.opentelemetry.containers;
 
-import io.opentelemetry.agents.Agent;
 import io.opentelemetry.config.TestConfig;
+import io.opentelemetry.distros.DistroConfig;
 import io.opentelemetry.util.NamingConventions;
 import java.nio.file.Path;
 import java.time.Duration;
@@ -22,20 +22,23 @@
 public class K6Container {
   private static final Logger logger = LoggerFactory.getLogger(K6Container.class);
   private final Network network;
-  private final Agent agent;
+  private final DistroConfig distroConfig;
   private final TestConfig config;
   private final NamingConventions namingConventions;
 
   public K6Container(
-      Network network, Agent agent, TestConfig config, NamingConventions namingConvention) {
+      Network network,
+      DistroConfig distroConfig,
+      TestConfig config,
+      NamingConventions namingConvention) {
     this.network = network;
-    this.agent = agent;
+    this.distroConfig = distroConfig;
     this.config = config;
     this.namingConventions = namingConvention;
   }
 
   public GenericContainer<?> build() {
-    Path k6OutputFile = namingConventions.container.k6Results(agent);
+    Path k6OutputFile = namingConventions.container.k6Results(distroConfig);
     return new GenericContainer<>(DockerImageName.parse("loadimpact/k6"))
         .withNetwork(network)
         .withNetworkAliases("k6")

performance-tests/src/test/java/io/opentelemetry/containers/PetClinicRestContainer.java renamed to performance-tests/src/test/java/io/opentelemetry/containers/VehicleInventoryServiceContainer.java

@@ -5,8 +5,8 @@
 
 package io.opentelemetry.containers;
 
-import io.opentelemetry.agents.Agent;
-import io.opentelemetry.agents.AgentResolver;
+import io.opentelemetry.distros.AgentResolver;
+import io.opentelemetry.distros.DistroConfig;
 import io.opentelemetry.util.NamingConventions;
 import java.nio.file.Path;
 import java.util.ArrayList;
@@ -24,28 +24,32 @@
 import org.testcontainers.utility.DockerImageName;
 import org.testcontainers.utility.MountableFile;
 
-public class PetClinicRestContainer {
+public class VehicleInventoryServiceContainer {
 
-  private static final Logger logger = LoggerFactory.getLogger(PetClinicRestContainer.class);
+  private static final Logger logger =
+      LoggerFactory.getLogger(VehicleInventoryServiceContainer.class);
   private static final int PETCLINIC_PORT = 9966;
   private final AgentResolver agentResolver = new AgentResolver();
 
   private final Network network;
   private final Startable collector;
-  private final Agent agent;
+  private final DistroConfig distroConfig;
   private final NamingConventions namingConventions;
 
-  public PetClinicRestContainer(
-      Network network, Startable collector, Agent agent, NamingConventions namingConventions) {
+  public VehicleInventoryServiceContainer(
+      Network network,
+      Startable collector,
+      DistroConfig distroConfig,
+      NamingConventions namingConventions) {
     this.network = network;
     this.collector = collector;
-    this.agent = agent;
+    this.distroConfig = distroConfig;
     this.namingConventions = namingConventions;
   }
 
   public GenericContainer<?> build() throws Exception {
 
-    Optional<Path> agentJar = agentResolver.resolve(this.agent);
+    Optional<Path> agentJar = agentResolver.resolve(this.distroConfig);
 
     GenericContainer<?> container =
         new GenericContainer<>(
@@ -89,7 +93,7 @@ private String[] buildCommandline(Optional<Path> agentJar) {
                 "-Dotel.exporter.otlp.insecure=true",
                 "-Dotel.exporter.otlp.endpoint=http://collector:4317",
                 "-Dotel.resource.attributes=service.name=petclinic-otel-overhead"));
-    result.addAll(this.agent.getAdditionalJvmArgs());
+    result.addAll(this.distroConfig.getAdditionalJvmArgs());
     agentJar.ifPresent(path -> result.add("-javaagent:/app/" + path.getFileName()));
 
     result.add("-jar");