refactor

Author: amarziali

dd-java-agent/agent-tooling/build.gradle

@@ -24,16 +24,17 @@ sourceSets {
       srcDirs = [file('src/test/java21')]
     }
   }
-  register("test_java25") {
-    java {
-      srcDirs = [file('src/test/java25')]
-    }
+  named("main_java25") {
+    compileClasspath += sourceSets.main.output
+    runtimeClasspath += sourceSets.main.output
   }
   named("test") {
     compileClasspath += sourceSets.test_java11.output
     runtimeClasspath += sourceSets.test_java11.output
     compileClasspath += sourceSets.test_java21.output
     runtimeClasspath += sourceSets.test_java21.output
+    compileClasspath += sourceSets.main_java25.output
+    runtimeClasspath += sourceSets.main_java25.output
   }
 }
 
@@ -47,10 +48,6 @@ configurations {
   named("test_java11Implementation") {
     extendsFrom testImplementation
   }
-
-  named("test_java25Implementation") {
-    extendsFrom testImplementation
-  }
 }
 
 
@@ -76,8 +73,6 @@ dependencies {
   testImplementation libs.bytebuddy
   testImplementation group: 'com.google.guava', name: 'guava-testlib', version: '20.0'
 
-  test_java25Implementation libs.bundles.junit5
-  test_java25Implementation sourceSets.main_java25.output
 
   jmhImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-web', version: '2.3.5.RELEASE'
 }
@@ -133,30 +128,6 @@ tasks.named("compileTest_java21Java") {
     )
 }
 
-tasks.named("compileTest_java25Java") {
-  configureCompiler(
-    it,
-    25,
-    JavaVersion.VERSION_1_8,
-    "Java 25 test sourceset, compiled with Java 25 but targeting Java 8 bytecode."
-    )
-}
-
-tasks.register("test_java25", Test) {
-  description = "Runs tests from test_java25 sourceset that require Java 25+"
-  group = "verification"
-  testClassesDirs = sourceSets.test_java25.output.classesDirs
-  classpath = sourceSets.test_java25.runtimeClasspath
-  useJUnitPlatform()
-  testJvmConstraints {
-    minJavaVersion = JavaVersion.VERSION_25
-  }
-}
-
-tasks.named("test") {
-  dependsOn(tasks.named("test_java25"))
-}
-
 tasks.named("jmh") {
   dependsOn(tasks.named("compileTestJava"))
   outputs.upToDateWhen { false }

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/TracerInstaller.java

@@ -1,7 +1,6 @@
 package datadog.trace.agent.tooling;
 
 import datadog.communication.ddagent.SharedCommunicationObjects;
-import datadog.environment.JavaVirtualMachine;
 import datadog.environment.OperatingSystem;
 import datadog.trace.api.Config;
 import datadog.trace.api.GlobalTracer;
@@ -10,9 +9,9 @@
 import datadog.trace.bootstrap.instrumentation.api.ProfilingContextIntegration;
 import datadog.trace.core.CoreTracer;
 import datadog.trace.core.servicediscovery.ForeignMemoryWriter;
+import datadog.trace.core.servicediscovery.ForeignMemoryWriterFactory;
 import datadog.trace.core.servicediscovery.ServiceDiscovery;
 import datadog.trace.core.servicediscovery.ServiceDiscoveryFactory;
-import de.thetaphi.forbiddenapis.SuppressForbidden;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -58,25 +57,12 @@ private static ServiceDiscoveryFactory serviceDiscoveryFactory() {
     return TracerInstaller::initServiceDiscovery;
   }
 
-  @SuppressForbidden // intentional use of Class.forName
   private static ServiceDiscovery initServiceDiscovery() {
-    try {
-      // use reflection to load MemFDUnixWriter so it doesn't get picked up when we
-      // transitively look for all tracer class dependencies to install in GraalVM via
-      // VMRuntimeInstrumentation
-      final Class<?> memFdClass;
-      if (JavaVirtualMachine.isJavaVersionAtLeast(25)) {
-        memFdClass =
-            Class.forName("datadog.trace.agent.tooling.servicediscovery.ForeignMemoryWriterImpl");
-      } else {
-        memFdClass = Class.forName("datadog.trace.agent.tooling.servicediscovery.MemFDUnixWriter");
-      }
-      ForeignMemoryWriter memFd = (ForeignMemoryWriter) memFdClass.getConstructor().newInstance();
-      return new ServiceDiscovery(memFd);
-    } catch (Throwable e) {
-      log.debug("service discovery not supported", e);
-      return null;
+    final ForeignMemoryWriter writer = new ForeignMemoryWriterFactory().get();
+    if (writer != null) {
+      return new ServiceDiscovery(writer);
     }
+    return null;
   }
 
   public static void installGlobalTracer(final CoreTracer tracer) {

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/servicediscovery/MemFDUnixWriter.java

@@ -2,26 +2,23 @@
 
 import static datadog.trace.api.telemetry.LogCollector.SEND_TELEMETRY;
 
-import com.sun.jna.Library;
-import com.sun.jna.Memory;
 import com.sun.jna.Native;
-import com.sun.jna.NativeLong;
-import com.sun.jna.Pointer;
 import datadog.environment.OperatingSystem;
+import datadog.environment.SystemProperties;
 import datadog.trace.core.servicediscovery.ForeignMemoryWriter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class MemFDUnixWriter implements ForeignMemoryWriter {
+abstract class MemFDUnixWriter implements ForeignMemoryWriter {
   private static final Logger log = LoggerFactory.getLogger(MemFDUnixWriter.class);
 
-  private interface LibC extends Library {
-    int syscall(int number, Object... args);
+  protected abstract long syscall(long number, String name, int flags);
 
-    NativeLong write(int fd, Pointer buf, NativeLong count);
+  protected abstract long write(int fd, byte[] payload);
 
-    int fcntl(int fd, int cmd, int arg);
-  }
+  protected abstract int fcntl(int fd, int cmd, int arg);
+
+  protected abstract int getLastError();
 
   // https://elixir.bootlin.com/linux/v6.17.1/source/include/uapi/linux/memfd.h#L8-L9
   private static final int MFD_CLOEXEC = 0x0001;
@@ -36,36 +33,33 @@ private interface LibC extends Library {
   private static final int F_SEAL_GROW = 0x0004;
 
   @Override
-  public void write(String fileName, byte[] payload) {
-    final LibC libc = Native.load("c", LibC.class);
-
+  public final void write(String fileName, byte[] payload) {
     OperatingSystem.Architecture arch = OperatingSystem.architecture();
     int memfdSyscall = getMemfdSyscall(arch);
     if (memfdSyscall <= 0) {
-      log.debug(SEND_TELEMETRY, "service discovery not supported for arch={}", arch);
+      log.debug(
+          SEND_TELEMETRY,
+          "service discovery not supported for arch={}",
+          SystemProperties.get("os.arch"));
       return;
     }
-    int memFd = libc.syscall(memfdSyscall, fileName, MFD_CLOEXEC | MFD_ALLOW_SEALING);
+    int memFd = (int) syscall(memfdSyscall, fileName, MFD_CLOEXEC | MFD_ALLOW_SEALING);
     if (memFd < 0) {
-      log.warn("{} memfd create failed, errno={}", fileName, Native.getLastError());
+      log.warn("{} memfd create failed, errno={}", fileName, getLastError());
       return;
     }
 
     log.debug("{} memfd created (fd={})", fileName, memFd);
 
-    Memory buf = new Memory(payload.length);
-    buf.write(0, payload, 0, payload.length);
-
-    NativeLong written = libc.write(memFd, buf, new NativeLong(payload.length));
-    if (written.longValue() != payload.length) {
+    long written = write(memFd, payload);
+    if (written != payload.length) {
       log.warn("write to {} memfd failed errno={}", fileName, Native.getLastError());
       return;
     }
-    log.debug("wrote {} bytes to memfd {}", written.longValue(), memFd);
-    int returnCode = libc.fcntl(memFd, F_ADD_SEALS, F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_SEAL);
+    log.debug("wrote {} bytes to memfd {}", written, memFd);
+    int returnCode = fcntl(memFd, F_ADD_SEALS, F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_SEAL);
     if (returnCode == -1) {
       log.warn("failed to add seal to {} memfd errno={}", fileName, Native.getLastError());
-      return;
     }
     // memfd is not closed to keep it readable for the lifetime of the process.
   }

dd-java-agent/agent-tooling/src/main/java/datadog/trace/agent/tooling/servicediscovery/MemFDUnixWriterJNA.java

@@ -0,0 +1,41 @@
+package datadog.trace.agent.tooling.servicediscovery;
+
+import com.sun.jna.Library;
+import com.sun.jna.Memory;
+import com.sun.jna.Native;
+import com.sun.jna.NativeLong;
+import com.sun.jna.Pointer;
+
+public final class MemFDUnixWriterJNA extends MemFDUnixWriter {
+  private final LibC libc = Native.load("c", LibC.class);
+
+  private interface LibC extends Library {
+    long syscall(long number, Object... args);
+
+    NativeLong write(int fd, Pointer buf, NativeLong count);
+
+    int fcntl(int fd, int cmd, int arg);
+  }
+
+  @Override
+  protected long syscall(long number, String name, int flags) {
+    return libc.syscall(number, name, flags);
+  }
+
+  @Override
+  protected long write(int fd, byte[] payload) {
+    Memory buf = new Memory(payload.length);
+    buf.write(0, payload, 0, payload.length);
+    return libc.write(fd, buf, new NativeLong(payload.length)).longValue();
+  }
+
+  @Override
+  protected int fcntl(int fd, int cmd, int arg) {
+    return libc.fcntl(fd, cmd, arg);
+  }
+
+  @Override
+  protected int getLastError() {
+    return Native.getLastError();
+  }
+}