Static instrumenter logic - a new agent distro (#319)

* static agent distro

* add app.jar to integration test & update README.md

* update javadoc

* add libs

* add test classes

* review part 1

* add comment to JarTest

* review part 2

* review part 3

* remove libs

* move repository definition

* define snapshot repo in jmx-metrics & switch to new dependency in agent-extension

Author: anosek-an

dependencyManagement/build.gradle.kts

@@ -20,6 +20,7 @@ val DEPENDENCY_BOMS = listOf(
     "io.grpc:grpc-bom:1.42.1",
     "io.opentelemetry:opentelemetry-bom:1.13.0",
     "io.opentelemetry:opentelemetry-bom-alpha:1.13.0-alpha",
+    "io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom-alpha:1.14.0-alpha-SNAPSHOT",
     "org.testcontainers:testcontainers-bom:1.16.3"
 )
 

jmx-metrics/build.gradle.kts

@@ -18,6 +18,9 @@ repositories {
       includeGroupByRegex("""org\.terracotta.*""")
     }
   }
+  maven {
+    url = uri("https://oss.sonatype.org/content/repositories/snapshots")
+  }
   mavenLocal()
 }
 

settings.gradle.kts

@@ -14,6 +14,9 @@ plugins {
 dependencyResolutionManagement {
   repositories {
     mavenCentral()
+    maven {
+      url = uri("https://oss.sonatype.org/content/repositories/snapshots")
+    }
     mavenLocal()
   }
 }
@@ -47,4 +50,6 @@ include(":samplers")
 include(":static-instrumenter:agent-instrumenter")
 include(":static-instrumenter:gradle-plugin")
 include(":static-instrumenter:maven-plugin")
+include(":static-instrumenter:agent-extension")
+include(":static-instrumenter:bootstrap")
 include(":static-instrumenter:test-app")

static-instrumenter/README.md

@@ -6,7 +6,16 @@
 
 Module enhancing OpenTelemetry Java Agent for static instrumentation. The modified agent is capable of instrumenting and saving a new JAR with all relevant instrumentations applied and necessary helper class-code included.
 
-In order to statically instrument a JAR, modified agent needs to be both attached (`-javaagent:`) and run as the main method (`io.opentelemetry.contrib.staticinstrumenter.Main` class).
+In order to statically instrument a JAR, modified agent needs to be both attached (`-javaagent:`) and run as the main method (`io.opentelemetry.contrib.staticinstrumenter.agent.main.Main` class).
+:
+
+To instrument you app use `opentelemetry-static-agent.jar` and pass the main class of the agent:
+
+`java -javaagent:opentelemetry-static-agent.jar -cp your-app.jar io.opentelemetry.contrib.staticinstrumenter.agent.main.Main output-folder`
+
+To run an instrumented app pass the `-Dio.opentelemetry.javaagent.shaded.io.opentelemetry.context.contextStorageProvider=default` option and add `no-inst-agent.jar` to the classpath:
+
+`java -Dio.opentelemetry.javaagent.shaded.io.opentelemetry.context.contextStorageProvider=default -cp output-folder/your-app.jar:no-inst-agent.jar org.example.YourMainClass`
 
 ### Gradle plugin
 

static-instrumenter/agent-extension/build.gradle.kts

@@ -0,0 +1,26 @@
+plugins {
+  id("otel.java-conventions")
+}
+
+description = "Extension for OpenTelemetry Java Agent"
+
+dependencies {
+  annotationProcessor("com.google.auto.service:auto-service")
+  compileOnly("com.google.auto.service:auto-service")
+
+  compileOnly("io.opentelemetry.javaagent:opentelemetry-javaagent-tooling")
+  compileOnly("io.opentelemetry.instrumentation:opentelemetry-instrumentation-api")
+  compileOnly("io.opentelemetry.javaagent:opentelemetry-javaagent-extension-api")
+  compileOnly("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure")
+  compileOnly("io.opentelemetry.javaagent:opentelemetry-muzzle")
+
+  compileOnly(project(":static-instrumenter:bootstrap"))
+}
+
+tasks {
+  withType<JavaCompile>().configureEach {
+    with(options) {
+      release.set(11)
+    }
+  }
+}

static-instrumenter/agent-extension/src/main/java/io/opentelemetry/contrib/staticinstrumenter/config/StaticPackagesConfigurer.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.staticinstrumenter.config;
+
+import com.google.auto.service.AutoService;
+import io.opentelemetry.instrumentation.api.config.Config;
+import io.opentelemetry.javaagent.tooling.bootstrap.BootstrapPackagesBuilder;
+import io.opentelemetry.javaagent.tooling.bootstrap.BootstrapPackagesConfigurer;
+
+/**
+ * Makes classes from {@link io.opentelemetry.contrib.staticinstrumenter.agent.main} package
+ * available both in agent's premain and static instrumenter's main.
+ */
+@AutoService(BootstrapPackagesConfigurer.class)
+public class StaticPackagesConfigurer implements BootstrapPackagesConfigurer {
+
+  @Override
+  public void configure(Config config, BootstrapPackagesBuilder builder) {
+    builder.add("io.opentelemetry.contrib.staticinstrumenter.agent.main");
+  }
+}

static-instrumenter/agent-extension/src/main/java/io/opentelemetry/contrib/staticinstrumenter/extension/AdditionalClassesInjectorListener.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.staticinstrumenter.extension;
+
+import io.opentelemetry.contrib.staticinstrumenter.agent.main.AdditionalClasses;
+import io.opentelemetry.javaagent.tooling.HelperInjectorListener;
+import java.util.Map;
+
+/**
+ * A listener to be registered in {@link io.opentelemetry.javaagent.tooling.HelperInjector}. It
+ * saves all additional classes created by the agent to the AdditionalClasses class.
+ */
+public class AdditionalClassesInjectorListener implements HelperInjectorListener {
+
+  @Override
+  public void onInjection(Map<String, byte[]> classnameToBytes) {
+    for (Map.Entry<String, byte[]> classEntry : classnameToBytes.entrySet()) {
+      String classFileName = classEntry.getKey().replace(".", "/") + ".class";
+      AdditionalClasses.put(classFileName, classEntry.getValue());
+    }
+  }
+}

static-instrumenter/agent-extension/src/main/java/io/opentelemetry/contrib/staticinstrumenter/extension/AdditionalClassesInjectorListenerInstaller.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.contrib.staticinstrumenter.extension;
+
+import com.google.auto.service.AutoService;
+import io.opentelemetry.instrumentation.api.config.Config;
+import io.opentelemetry.javaagent.extension.AgentListener;
+import io.opentelemetry.javaagent.tooling.HelperInjector;
+import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
+
+/**
+ * Configures a listener on {@link io.opentelemetry.javaagent.tooling.HelperInjector} before the
+ * agents starts. The listener enables passing additional classes created by the agent to the static
+ * instrumenter, which in turn saves them into the app jar.
+ */
+@AutoService(AgentListener.class)
+public class AdditionalClassesInjectorListenerInstaller implements AgentListener {
+
+  @Override
+  public void beforeAgent(
+      Config config, AutoConfiguredOpenTelemetrySdk autoConfiguredOpenTelemetrySdk) {
+    HelperInjector.setHelperInjectorListener(new AdditionalClassesInjectorListener());
+  }
+}

static-instrumenter/agent-instrumenter/build.gradle.kts

@@ -1,18 +1,134 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+
 plugins {
   id("otel.java-conventions")
+  id("com.github.johnrengelman.shadow") version "7.1.2"
+  id("org.unbroken-dome.test-sets") version "4.0.0"
 }
 
 description = "OpenTelemetry Java Static Instrumentation Agent"
 
+val javaagentLibs: Configuration by configurations.creating {
+  isCanBeResolved = true
+  isCanBeConsumed = false
+}
+
+val bootstrapLibs: Configuration by configurations.creating
+configurations.getByName("implementation").extendsFrom(bootstrapLibs)
+
+val javaagent: Configuration by configurations.creating
+configurations.getByName("implementation").extendsFrom(javaagent)
+
 dependencies {
+  annotationProcessor("com.google.auto.service:auto-service")
+  compileOnly("com.google.auto.service:auto-service")
+
   implementation("org.slf4j:slf4j-api")
   runtimeOnly("org.slf4j:slf4j-simple")
+
+  // TODO: remove snapshot once new agent is released
+  javaagent("io.opentelemetry.javaagent:opentelemetry-javaagent:1.14.0-SNAPSHOT")
+
+  bootstrapLibs(project(":static-instrumenter:bootstrap"))
+  javaagentLibs(project(":static-instrumenter:agent-extension"))
+}
+
+// TODO: migrate to JVM test suite plugin
+testSets {
+  create("integrationTest")
 }
 
 tasks {
+
+  val relocateJavaagentLibs by registering(ShadowJar::class) {
+    configurations = listOf(javaagentLibs)
+    duplicatesStrategy = DuplicatesStrategy.FAIL
+    archiveFileName.set("javaagentLibs-relocated.jar")
+  }
+
+  shadowJar {
+    configurations = listOf(javaagent, bootstrapLibs)
+
+    dependsOn(relocateJavaagentLibs)
+    isolateClasses(relocateJavaagentLibs.get().outputs.files)
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+
+    manifest {
+      attributes.put("Main-Class", "io.opentelemetry.contrib.staticinstrumenter.agent.main.Main")
+      attributes.put("Agent-Class", "io.opentelemetry.contrib.staticinstrumenter.agent.OpenTelemetryStaticAgent")
+      attributes.put("Premain-Class", "io.opentelemetry.contrib.staticinstrumenter.agent.OpenTelemetryStaticAgent")
+      attributes.put("Can-Redefine-Classes", "true")
+      attributes.put("Can-Retransform-Classes", "true")
+      attributes.put("Implementation-Vendor", "OpenTelemetry")
+      attributes.put("Implementation-Version", "demo-${project.version}")
+    }
+  }
+
+  // TODO: the resulting jar contains both inst and unpacked inst,
+  //  but we need only the unpacked inst here
+  val createNoInstAgent by registering(ShadowJar::class) {
+
+    configurations = listOf(javaagent)
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+
+    archiveClassifier.set("no-inst")
+
+    inputs.files.forEach {
+      if (it.name.endsWith(".jar")) {
+        from(zipTree(it)) {
+          include("inst/")
+          eachFile {
+            // drop inst/
+            relativePath = RelativePath(true, *relativePath.segments.drop(1).toTypedArray())
+            rename("(.*)\\.classdata\$", "\$1.class")
+          }
+        }
+      }
+    }
+  }
+
+  withType<ShadowJar>().configureEach {
+    // we depend on opentelemetry-instrumentation-api in agent-extension, so we need to relocate its usage
+    relocate("io.opentelemetry.instrumentation.api", "io.opentelemetry.javaagent.shaded.instrumentation.api")
+  }
+
   withType<JavaCompile>().configureEach {
     with(options) {
       release.set(11)
     }
   }
+
+  assemble {
+    dependsOn(shadowJar, createNoInstAgent)
+  }
+
+  val integrationTest by existing(Test::class) {
+    dependsOn(assemble)
+    jvmArgumentProviders.add(AgentJarsProvider(shadowJar.flatMap { it.archiveFile }, createNoInstAgent.flatMap { it.archiveFile }))
+  }
+}
+
+fun CopySpec.isolateClasses(jars: Iterable<File>) {
+  jars.forEach {
+    from(zipTree(it)) {
+      into("inst")
+      rename("^(.*)\\.class\$", "\$1.classdata")
+      // Rename LICENSE file since it clashes with license dir on non-case sensitive FSs (i.e. Mac)
+      rename("""^LICENSE$""", "LICENSE.renamed")
+      exclude("META-INF/INDEX.LIST")
+      exclude("META-INF/*.DSA")
+      exclude("META-INF/*.SF")
+    }
+  }
+}
+
+class AgentJarsProvider(
+  @InputFile
+  @PathSensitive(PathSensitivity.RELATIVE)
+  val agentJar: Provider<RegularFile>,
+  @InputFile
+  @PathSensitive(PathSensitivity.RELATIVE)
+  val noInstAgentJar: Provider<RegularFile>
+) : CommandLineArgumentProvider {
+  override fun asArguments(): Iterable<String> = listOf("-Dagent=${file(agentJar).path}", "-Dno.inst.agent=${file(noInstAgentJar).path}")
 }

static-instrumenter/agent-instrumenter/src/integrationTest/java/JarTest.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+final class JarTest {
+
+  private static final String INSTRUMENTATION_MAIN =
+      "io.opentelemetry.contrib.staticinstrumenter.agent.main.Main";
+  private static final String APP_MAIN = "org.example.SingleGetter";
+
+  @TempDir public Path outPath;
+
+  @Test
+  void testSampleJar() throws IOException, InterruptedException {
+    Path agentPath = Path.of(System.getProperty("agent"));
+    Path noInstAgentPath = Path.of(System.getProperty("no.inst.agent"));
+    // jar created in test-app module
+    Path appPath = getPath("app.jar");
+
+    ProcessBuilder instrumentationProcessBuilder =
+        new ProcessBuilder(
+            "java",
+            "-javaagent:" + agentPath,
+            "-cp",
+            appPath.toString(),
+            INSTRUMENTATION_MAIN,
+            outPath.toString());
+
+    Process instrumentationProcess = instrumentationProcessBuilder.start();
+    InputStream instrumentationIn = instrumentationProcess.getErrorStream();
+    instrumentationProcess.waitFor(10, TimeUnit.SECONDS);
+
+    String instrumentationLog =
+        new String(instrumentationIn.readAllBytes(), StandardCharsets.UTF_8);
+    assertThat(instrumentationProcess.exitValue()).isEqualTo(0);
+    assertThat(instrumentationLog).isNotEmpty();
+
+    Path resultAppPath = outPath.resolve("app.jar");
+    assertThat(Files.exists(resultAppPath)).isTrue();
+
+    ProcessBuilder runtimeProcessBuilder =
+        new ProcessBuilder(
+            "java",
+            "-Dotel.traces.exporter=logging",
+            "-Dio.opentelemetry.javaagent.shaded.io.opentelemetry.context.contextStorageProvider=default",
+            "-cp",
+            String.format("%s:%s", resultAppPath, noInstAgentPath),
+            APP_MAIN);
+
+    Process runtimeProcess = runtimeProcessBuilder.start();
+    InputStream err = runtimeProcess.getErrorStream();
+    runtimeProcess.waitFor(10, TimeUnit.SECONDS);
+
+    assertThat(runtimeProcess.exitValue()).isEqualTo(0);
+    assertThat(new String(err.readAllBytes(), StandardCharsets.UTF_8))
+        .startsWith(
+            "[main] INFO io.opentelemetry.exporter.logging.LoggingSpanExporter - 'HTTP GET'");
+  }
+
+  private static Path getPath(String resourceName) {
+    URL resourceURL = JarTest.class.getResource(resourceName);
+    assertThat(resourceURL).isNotNull();
+    return Path.of(resourceURL.getPath());
+  }
+}