perf(core): Limit no-init class probing to isClassAvailable

The previous change made loadClass itself skip class initialization,
which affected callers that load a class to actually use it (NDK
integration, OTEL span factory and scopes storage). Restore loadClass
to its initializing behavior and confine the non-initializing probe to
isClassAvailable, which is only ever used for classpath availability
checks. This keeps SDK init cheap while leaving real-use callers
unchanged.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: runningcode

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

@@ -12,17 +12,23 @@
 public class LoadClass {
 
   /**
-   * Try to load a class via reflection
+   * 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<?> 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) {
     try {
-      // Don't initialize the class just to probe for availability; it gets initialized lazily on
-      // first use. This avoids running unrelated static initializers during SDK init.
-      return Class.forName(clazz, false, LoadClass.class.getClassLoader());
+      return Class.forName(clazz, initialize, LoadClass.class.getClassLoader());
     } catch (ClassNotFoundException e) {
       if (logger != null) {
         logger.log(SentryLevel.INFO, "Class not available: " + clazz);
@@ -39,15 +45,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

@@ -4,6 +4,7 @@ import kotlin.test.Test
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
+import kotlin.test.assertTrue
 
 class LoadClassTest {
   @Test
@@ -26,24 +27,44 @@ class LoadClassTest {
   }
 
   @Test
-  fun `loadClass does not run the static initializer of the probed class`() {
+  fun `isClassAvailable does not run the static initializer of the probed class`() {
     // Reading the flag initializes the flag holder, not the probe.
-    assertFalse(LoadClassNoInitFlag.initialized)
+    assertFalse(IsClassAvailableNoInitFlag.initialized)
 
     // Obtaining the name via ::class.java does not initialize the probe either.
-    LoadClass().loadClass(LoadClassNoInitProbe::class.java.name, null)
+    LoadClass()
+      .isClassAvailable(IsClassAvailableNoInitProbe::class.java.name, null as io.sentry.ILogger?)
 
     // Availability probing must not trigger the probe's static initializer.
-    assertFalse(LoadClassNoInitFlag.initialized)
+    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 LoadClassNoInitFlag {
+private object LoadClassInitFlag {
   @JvmField var initialized = false
 }
 
-private object LoadClassNoInitProbe {
+private object LoadClassInitProbe {
   init {
-    LoadClassNoInitFlag.initialized = true
+    LoadClassInitFlag.initialized = true
   }
 }