perf(core): [Init Reflection 2] Cache class lookups and collapse double probes

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## Unreleased
+
+### Performance
+
+- Probe class availability without initializing the class during SDK init ([#5635](https://github.com/getsentry/sentry-java/pull/5635))
+- Cache reflective class lookups and avoid double-probing during SDK init ([#5636](https://github.com/getsentry/sentry-java/pull/5636))
+
 ## 8.45.0
 
 ### Features

sentry/src/main/java/io/sentry/ScopesStorageFactory.java

@@ -23,24 +23,23 @@ public final class ScopesStorageFactory {
   private static @NotNull IScopesStorage createInternal(
       final @NotNull LoadClass loadClass, final @NotNull ILogger logger) {
     if (Platform.isJvm()) {
-      if (loadClass.isClassAvailable(OTEL_SCOPES_STORAGE, logger)) {
-        Class<?> otelScopesStorageClazz = loadClass.loadClass(OTEL_SCOPES_STORAGE, logger);
-        if (otelScopesStorageClazz != null) {
-          try {
-            final @Nullable Object otelScopesStorage =
-                otelScopesStorageClazz.getDeclaredConstructor().newInstance();
-            if (otelScopesStorage instanceof IScopesStorage) {
-              return (IScopesStorage) otelScopesStorage;
-            }
-          } catch (InstantiationException e) {
-            // TODO log
-          } catch (IllegalAccessException e) {
-            // TODO log
-          } catch (InvocationTargetException e) {
-            // TODO log
-          } catch (NoSuchMethodException e) {
-            // TODO log
+      final @Nullable Class<?> otelScopesStorageClazz =
+          loadClass.loadClass(OTEL_SCOPES_STORAGE, logger);
+      if (otelScopesStorageClazz != null) {
+        try {
+          final @Nullable Object otelScopesStorage =
+              otelScopesStorageClazz.getDeclaredConstructor().newInstance();
+          if (otelScopesStorage instanceof IScopesStorage) {
+            return (IScopesStorage) otelScopesStorage;
           }
+        } catch (InstantiationException e) {
+          // TODO log
+        } catch (IllegalAccessException e) {
+          // TODO log
+        } catch (InvocationTargetException e) {
+          // TODO log
+        } catch (NoSuchMethodException e) {
+          // TODO log
         }
       }
     }

sentry/src/main/java/io/sentry/SpanFactoryFactory.java

@@ -15,24 +15,23 @@ public final class SpanFactoryFactory {
   public static @NotNull ISpanFactory create(
       final @NotNull LoadClass loadClass, final @NotNull ILogger logger) {
     if (Platform.isJvm()) {
-      if (loadClass.isClassAvailable(OTEL_SPAN_FACTORY, logger)) {
-        Class<?> otelSpanFactoryClazz = loadClass.loadClass(OTEL_SPAN_FACTORY, logger);
-        if (otelSpanFactoryClazz != null) {
-          try {
-            final @Nullable Object otelSpanFactory =
-                otelSpanFactoryClazz.getDeclaredConstructor().newInstance();
-            if (otelSpanFactory instanceof ISpanFactory) {
-              return (ISpanFactory) otelSpanFactory;
-            }
-          } catch (InstantiationException e) {
-            // TODO log
-          } catch (IllegalAccessException e) {
-            // TODO log
-          } catch (InvocationTargetException e) {
-            // TODO log
-          } catch (NoSuchMethodException e) {
-            // TODO log
+      final @Nullable Class<?> otelSpanFactoryClazz =
+          loadClass.loadClass(OTEL_SPAN_FACTORY, logger);
+      if (otelSpanFactoryClazz != null) {
+        try {
+          final @Nullable Object otelSpanFactory =
+              otelSpanFactoryClazz.getDeclaredConstructor().newInstance();
+          if (otelSpanFactory instanceof ISpanFactory) {
+            return (ISpanFactory) otelSpanFactory;
           }
+        } catch (InstantiationException e) {
+          // TODO log
+        } catch (IllegalAccessException e) {
+          // TODO log
+        } catch (InvocationTargetException e) {
+          // TODO log
+        } catch (NoSuchMethodException e) {
+          // TODO log
         }
       }
     }

sentry/src/main/java/io/sentry/util/LoadClass.java

@@ -4,24 +4,52 @@
 import io.sentry.ILogger;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 /** An Adapter for making Class.forName testable */
 @Open
 public class LoadClass {
 
+  /** Sentinel cached for class names that are known to be unavailable. */
+  private static final Object NOT_AVAILABLE = new Object();
+
   /**
-   * Try to load a class via reflection
+   * Whether a class is on the classpath does not change during the lifetime of the process, so
+   * results are cached to avoid repeated {@link Class#forName} lookups (and the exceptions they
+   * throw for absent classes) when the same class is probed more than once.
+   */
+  private static final Map<String, Object> CLASSES = new ConcurrentHashMap<>();
+
+  /**
+   * Loads and initializes a class via reflection. Use this when you intend to actually use the
+   * class (e.g. instantiate it or invoke its methods). The returned class is fully initialized, so
+   * its static initializers run. To merely check whether a class is on the classpath, use {@link
+   * #isClassAvailable} instead, which avoids running those initializers.
    *
    * @param clazz the full class name
    * @param logger an instance of ILogger
    * @return a Class&lt;?&gt; if it's available, or null
    */
   public @Nullable Class<?> loadClass(final @NotNull String clazz, final @Nullable ILogger logger) {
+    return loadClass(clazz, logger, true);
+  }
+
+  private @Nullable Class<?> loadClass(
+      final @NotNull String clazz, final @Nullable ILogger logger, final boolean initialize) {
+    final @Nullable Object cached = CLASSES.get(clazz);
+    if (cached != null) {
+      return cached == NOT_AVAILABLE ? null : (Class<?>) cached;
+    }
     try {
-      return Class.forName(clazz);
+      final Class<?> loadedClass =
+          Class.forName(clazz, initialize, LoadClass.class.getClassLoader());
+      CLASSES.put(clazz, loadedClass);
+      return loadedClass;
     } catch (ClassNotFoundException e) {
+      CLASSES.put(clazz, NOT_AVAILABLE);
       if (logger != null) {
         logger.log(SentryLevel.INFO, "Class not available: " + clazz);
       }
@@ -37,15 +65,35 @@ public class LoadClass {
     return null;
   }
 
+  /**
+   * Probes whether a class is on the classpath without initializing it. Use this for availability
+   * checks (e.g. deciding whether to register an integration); the class is not initialized, so its
+   * static initializers do not run until something actually uses it. This keeps SDK init cheap by
+   * not triggering unrelated initializers. If you need to use the class, use {@link #loadClass}
+   * instead.
+   *
+   * @param clazz the full class name
+   * @param logger an instance of ILogger
+   * @return true if the class is on the classpath
+   */
   public boolean isClassAvailable(final @NotNull String clazz, final @Nullable ILogger logger) {
-    return loadClass(clazz, logger) != null;
+    return loadClass(clazz, logger, false) != null;
   }
 
   public boolean isClassAvailable(
       final @NotNull String clazz, final @Nullable SentryOptions options) {
     return isClassAvailable(clazz, options != null ? options.getLogger() : null);
   }
 
+  /**
+   * Like {@link #isClassAvailable}, but defers the (non-initializing) availability check until the
+   * result is first read. Use this when the check itself should not run during SDK init but only
+   * later, on first access.
+   *
+   * @param clazz the full class name
+   * @param logger an instance of ILogger
+   * @return a lazily-evaluated availability check
+   */
   public LazyEvaluator<Boolean> isClassAvailableLazy(
       final @NotNull String clazz, final @Nullable ILogger logger) {
     return new LazyEvaluator<>(() -> isClassAvailable(clazz, logger));

sentry/src/test/java/io/sentry/util/LoadClassTest.kt

@@ -0,0 +1,70 @@
+package io.sentry.util
+
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class LoadClassTest {
+  @Test
+  fun `loadClass returns the class when it is available`() {
+    assertNotNull(LoadClass().loadClass("io.sentry.SentryEvent", null))
+  }
+
+  @Test
+  fun `loadClass returns null when the class is not available`() {
+    assertNull(LoadClass().loadClass("io.sentry.ThisClassDoesNotExist", null))
+  }
+
+  @Test
+  fun `isClassAvailable reflects whether the class is on the classpath`() {
+    val loadClass = LoadClass()
+    assertNotNull(loadClass.loadClass("io.sentry.SentryEvent", null))
+    assertFalse(
+      loadClass.isClassAvailable("io.sentry.ThisClassDoesNotExist", null as io.sentry.ILogger?)
+    )
+  }
+
+  @Test
+  fun `isClassAvailable does not run the static initializer of the probed class`() {
+    // Reading the flag initializes the flag holder, not the probe.
+    assertFalse(IsClassAvailableNoInitFlag.initialized)
+
+    // Obtaining the name via ::class.java does not initialize the probe either.
+    LoadClass()
+      .isClassAvailable(IsClassAvailableNoInitProbe::class.java.name, null as io.sentry.ILogger?)
+
+    // Availability probing must not trigger the probe's static initializer.
+    assertFalse(IsClassAvailableNoInitFlag.initialized)
+  }
+
+  @Test
+  fun `loadClass runs the static initializer of the loaded class`() {
+    assertFalse(LoadClassInitFlag.initialized)
+
+    LoadClass().loadClass(LoadClassInitProbe::class.java.name, null)
+
+    assertTrue(LoadClassInitFlag.initialized)
+  }
+}
+
+private object IsClassAvailableNoInitFlag {
+  @JvmField var initialized = false
+}
+
+private object IsClassAvailableNoInitProbe {
+  init {
+    IsClassAvailableNoInitFlag.initialized = true
+  }
+}
+
+private object LoadClassInitFlag {
+  @JvmField var initialized = false
+}
+
+private object LoadClassInitProbe {
+  init {
+    LoadClassInitFlag.initialized = true
+  }
+}