fix(micrometer): Use injected scopes in the meter registry

Use the supplied IScopes for metric recording and diagnostic logging
instead of bypassing it through the static Sentry API. Default standalone
constructors to ScopesAdapter so current-context resolution is preserved.

Pass the Spring scopes bean through all three Boot integrations while
retaining initialization ordering. Cover injected metrics, logging, and
Spring wiring with regression tests.

Refs #6116
Co-Authored-By: Claude <noreply@anthropic.com>

Author: adinauer

sentry-micrometer/api/sentry-micrometer.api

@@ -6,6 +6,7 @@ public final class io/sentry/micrometer/BuildConfig {
 public final class io/sentry/micrometer/SentryMeterRegistry : io/micrometer/core/instrument/MeterRegistry {
 	public fun <init> ()V
 	public fun <init> (J)V
+	public fun <init> (Lio/sentry/IScopes;J)V
 	public fun close ()V
 }
 

sentry-micrometer/src/main/java/io/sentry/micrometer/SentryMeterRegistry.java

@@ -22,12 +22,14 @@
 import io.micrometer.core.instrument.internal.DefaultLongTaskTimer;
 import io.micrometer.core.instrument.internal.DefaultMeter;
 import io.micrometer.core.instrument.util.NamedThreadFactory;
-import io.sentry.Sentry;
+import io.sentry.IScopes;
+import io.sentry.ScopesAdapter;
 import io.sentry.SentryAttributes;
 import io.sentry.SentryIntegrationPackageStorage;
 import io.sentry.SentryLevel;
 import io.sentry.metrics.MetricsUnit;
 import io.sentry.util.ExceptionUtils;
+import io.sentry.util.Objects;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.Executors;
@@ -44,6 +46,7 @@ public final class SentryMeterRegistry extends MeterRegistry {
   private static final @NotNull String INTEGRATION_NAME = "Micrometer";
   private static final long DEFAULT_POLL_INTERVAL_MILLIS = 60_000;
 
+  private final @NotNull IScopes scopes;
   private final @Nullable ScheduledExecutorService scheduler;
   private final @Nullable ScheduledFuture<?> pollingTask;
 
@@ -63,14 +66,25 @@ public SentryMeterRegistry() {
    * <p>A zero interval disables passive meter polling. Negative intervals are not supported.
    */
   public SentryMeterRegistry(final long pollIntervalMillis) {
-    this(pollIntervalMillis, Clock.SYSTEM, createScheduler(pollIntervalMillis));
+    this(ScopesAdapter.getInstance(), pollIntervalMillis);
+  }
+
+  /**
+   * Creates a registry with the given scopes and passive meter polling interval in milliseconds.
+   *
+   * <p>A zero interval disables passive meter polling. Negative intervals are not supported.
+   */
+  public SentryMeterRegistry(final @NotNull IScopes scopes, final long pollIntervalMillis) {
+    this(scopes, pollIntervalMillis, Clock.SYSTEM, createScheduler(pollIntervalMillis));
   }
 
   SentryMeterRegistry(
+      final @NotNull IScopes scopes,
       final long pollIntervalMillis,
       final @NotNull Clock clock,
       final @Nullable ScheduledExecutorService scheduler) {
     super(clock);
+    this.scopes = Objects.requireNonNull(scopes, "Scopes are required");
     validatePollInterval(pollIntervalMillis);
     if (pollIntervalMillis > 0 && scheduler == null) {
       throw new IllegalArgumentException(
@@ -165,7 +179,7 @@ public SentryMeterRegistry(final long pollIntervalMillis) {
       final @NotNull Meter.Id id,
       final @NotNull Meter.Type type,
       final @NotNull Iterable<Measurement> measurements) {
-    Sentry.getCurrentScopes()
+    scopes
         .getOptions()
         .getLogger()
         .log(
@@ -189,7 +203,7 @@ void captureCounter(final @NotNull SentryMetricInfo metricInfo, final double val
     if (isClosed()) {
       return;
     }
-    Sentry.getCurrentScopes()
+    scopes
         .metrics()
         .count(metricInfo.getName(), value, metricInfo.getUnit(), metricInfo.createParameters());
   }
@@ -198,7 +212,7 @@ void captureDistribution(final @NotNull SentryMetricInfo metricInfo, final doubl
     if (isClosed()) {
       return;
     }
-    Sentry.getCurrentScopes()
+    scopes
         .metrics()
         .distribution(
             metricInfo.getName(), value, metricInfo.getUnit(), metricInfo.createParameters());
@@ -208,7 +222,7 @@ void captureGauge(final @NotNull SentryMetricInfo metricInfo, final double value
     if (isClosed()) {
       return;
     }
-    Sentry.getCurrentScopes()
+    scopes
         .metrics()
         .gauge(metricInfo.getName(), value, metricInfo.getUnit(), metricInfo.createParameters());
   }
@@ -231,7 +245,7 @@ void pollMeters() {
   }
 
   void logPollingFailure(final @NotNull Throwable throwable, final @NotNull String meterName) {
-    Sentry.getCurrentScopes()
+    scopes
         .getOptions()
         .getLogger()
         .log(

sentry-micrometer/src/test/kotlin/io/sentry/micrometer/SentryFunctionTimerTest.kt

@@ -4,6 +4,7 @@ import com.google.common.truth.Truth.assertThat
 import io.micrometer.core.instrument.Clock
 import io.micrometer.core.instrument.FunctionTimer
 import io.sentry.IScopes
+import io.sentry.ScopesAdapter
 import io.sentry.Sentry
 import io.sentry.SentryOptions
 import io.sentry.metrics.IMetricsApi
@@ -357,7 +358,8 @@ class SentryFunctionTimerTest {
     val scheduler = mock<ScheduledExecutorService>()
     val task = mock<ScheduledFuture<Unit>>()
     whenever(scheduler.scheduleAtFixedRate(any(), any(), any(), any())).thenReturn(task)
-    return SentryMeterRegistry(60_000, Clock.SYSTEM, scheduler).also(registries::add)
+    return SentryMeterRegistry(ScopesAdapter.getInstance(), 60_000, Clock.SYSTEM, scheduler)
+      .also(registries::add)
   }
 
   private fun installMetricsApi(): IMetricsApi {

sentry-micrometer/src/test/kotlin/io/sentry/micrometer/SentryMeterRegistryPollingTest.kt

@@ -8,6 +8,7 @@ import io.micrometer.core.instrument.LongTaskTimer
 import io.micrometer.core.instrument.MockClock
 import io.micrometer.core.instrument.TimeGauge
 import io.sentry.IScopes
+import io.sentry.ScopesAdapter
 import io.sentry.Sentry
 import io.sentry.SentryOptions
 import io.sentry.metrics.IMetricsApi
@@ -66,7 +67,8 @@ class SentryMeterRegistryPollingTest {
       )
       .thenReturn(task)
 
-    val registry = track(SentryMeterRegistry(2500, Clock.SYSTEM, scheduler))
+    val registry =
+      track(SentryMeterRegistry(ScopesAdapter.getInstance(), 2500, Clock.SYSTEM, scheduler))
     val value = AtomicReference(4.5)
     Gauge.builder("scheduled", value) { it.get() }.strongReference(true).register(registry)
     val scheduledPoll = argumentCaptor<Runnable>()
@@ -107,7 +109,7 @@ class SentryMeterRegistryPollingTest {
   @Test
   fun `zero interval ignores an available scheduler`() {
     val scheduler = mock<ScheduledExecutorService>()
-    track(SentryMeterRegistry(0, Clock.SYSTEM, scheduler))
+    track(SentryMeterRegistry(ScopesAdapter.getInstance(), 0, Clock.SYSTEM, scheduler))
 
     verifyNoInteractions(scheduler)
   }
@@ -406,7 +408,7 @@ class SentryMeterRegistryPollingTest {
     val scheduler = mock<ScheduledExecutorService>()
     val task = mock<ScheduledFuture<Unit>>()
     whenever(scheduler.scheduleAtFixedRate(any(), any(), any(), any())).thenReturn(task)
-    return track(SentryMeterRegistry(60_000, clock, scheduler))
+    return track(SentryMeterRegistry(ScopesAdapter.getInstance(), 60_000, clock, scheduler))
   }
 
   private fun track(registry: SentryMeterRegistry): SentryMeterRegistry {

sentry-micrometer/src/test/kotlin/io/sentry/micrometer/SentryMeterRegistryTest.kt

@@ -3,6 +3,7 @@ package io.sentry.micrometer
 import com.google.common.truth.Truth.assertThat
 import io.micrometer.core.instrument.Counter
 import io.micrometer.core.instrument.DistributionSummary
+import io.micrometer.core.instrument.Gauge
 import io.micrometer.core.instrument.Measurement
 import io.micrometer.core.instrument.Meter
 import io.micrometer.core.instrument.Statistic
@@ -12,10 +13,12 @@ import io.micrometer.core.instrument.config.MeterFilter
 import io.micrometer.core.instrument.config.NamingConvention
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry
 import io.sentry.Hint
+import io.sentry.ILogger
 import io.sentry.IScopes
 import io.sentry.ISentryClient
 import io.sentry.Sentry
 import io.sentry.SentryIntegrationPackageStorage
+import io.sentry.SentryLevel
 import io.sentry.SentryMetricsEvent
 import io.sentry.SentryOptions
 import io.sentry.metrics.IMetricsApi
@@ -166,6 +169,58 @@ class SentryMeterRegistryTest {
     verify(second).count(eq("counter"), eq(2.0), anyOrNull(), any())
   }
 
+  @Test
+  fun `injected scopes receive active and passive metrics instead of global scopes`() {
+    val globalMetrics = installMetricsApi()
+    val metrics = mock<IMetricsApi>()
+    val scopes = mock<IScopes>()
+    whenever(scopes.metrics()).thenReturn(metrics)
+    val registry = SentryMeterRegistry(scopes, 0).also(registries::add)
+
+    registry.counter("counter").increment(2.0)
+    registry.timer("timer").record(3, TimeUnit.MILLISECONDS)
+    registry.summary("summary").record(4.0)
+    Gauge.builder("gauge", Supplier { 5.0 }).register(registry)
+    registry.pollMeters()
+
+    verify(metrics).count(eq("counter"), eq(2.0), anyOrNull(), any())
+    verify(metrics).distribution(eq("timer"), eq(3.0), eq(MetricsUnit.Duration.MILLISECOND), any())
+    verify(metrics).distribution(eq("summary"), eq(4.0), anyOrNull(), any())
+    verify(metrics).gauge(eq("gauge"), eq(5.0), anyOrNull(), any())
+    verifyNoInteractions(globalMetrics)
+  }
+
+  @Test
+  fun `diagnostic logging uses injected scopes`() {
+    val logger = mock<ILogger>()
+    val options =
+      SentryOptions().apply {
+        isDebug = true
+        setLogger(logger)
+      }
+    val scopes = mock<IScopes>()
+    whenever(scopes.options).thenReturn(options)
+    val registry = SentryMeterRegistry(scopes, 0).also(registries::add)
+    val failure = IllegalStateException("poll failed")
+
+    Meter.builder(
+        "custom",
+        Meter.Type.OTHER,
+        listOf(Measurement(Supplier { 7.0 }, Statistic.VALUE)),
+      )
+      .register(registry)
+    registry.logPollingFailure(failure, "gauge")
+
+    verify(logger)
+      .log(
+        SentryLevel.DEBUG,
+        "Micrometer meter type %s is not supported for Sentry export.",
+        Meter.Type.OTHER,
+      )
+    verify(logger)
+      .log(SentryLevel.DEBUG, failure, "Failed to publish Micrometer meter %s to Sentry.", "gauge")
+  }
+
   @Test
   fun `registry created before Sentry init forwards after initialization`() {
     Sentry.close()

sentry-spring-boot-4/src/main/java/io/sentry/spring/boot4/SentryMicrometerConfiguration.java

@@ -15,6 +15,6 @@ final class SentryMicrometerConfiguration {
   @ConditionalOnMissingBean(SentryMeterRegistry.class)
   public @NotNull SentryMeterRegistry sentryMeterRegistry(
       final @NotNull IScopes scopes, final @NotNull SentryProperties properties) {
-    return new SentryMeterRegistry(properties.getMicrometer().getPollIntervalMillis());
+    return new SentryMeterRegistry(scopes, properties.getMicrometer().getPollIntervalMillis());
   }
 }

sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryMicrometerConfigurationTest.kt

@@ -5,10 +5,17 @@ import io.micrometer.core.instrument.composite.CompositeMeterRegistry
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry
 import io.sentry.IScopes
 import io.sentry.Sentry
+import io.sentry.metrics.IMetricsApi
 import io.sentry.micrometer.SentryMeterRegistry
 import kotlin.test.AfterTest
 import kotlin.test.Test
 import org.assertj.core.api.Assertions.assertThat
+import org.mockito.kotlin.any
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
 import org.springframework.boot.autoconfigure.AutoConfigurations
 import org.springframework.boot.micrometer.metrics.autoconfigure.CompositeMeterRegistryAutoConfiguration
 import org.springframework.boot.micrometer.metrics.autoconfigure.MetricsAutoConfiguration
@@ -72,6 +79,24 @@ class SentryMicrometerConfigurationTest {
     assertThat(registry!!.isClosed).isTrue()
   }
 
+  @Test
+  fun `registry uses the injected scopes bean`() {
+    val scopes = mock<IScopes>()
+    val metrics = mock<IMetricsApi>()
+    whenever(scopes.metrics()).thenReturn(metrics)
+    val properties = SentryProperties().apply { micrometer.pollIntervalMillis = 0 }
+
+    ApplicationContextRunner()
+      .withUserConfiguration(SentryMicrometerConfiguration::class.java)
+      .withBean(IScopes::class.java, { scopes })
+      .withBean(SentryProperties::class.java, { properties })
+      .run {
+        it.getBean(SentryMeterRegistry::class.java).counter("requests").increment(2.0)
+
+        verify(metrics).count(eq("requests"), eq(2.0), anyOrNull(), any())
+      }
+  }
+
   @Test
   fun `integration is absent when Sentry auto-configuration is disabled`() {
     ApplicationContextRunner()

sentry-spring-boot-jakarta/src/main/java/io/sentry/spring/boot/jakarta/SentryMicrometerConfiguration.java

@@ -15,6 +15,6 @@ final class SentryMicrometerConfiguration {
   @ConditionalOnMissingBean(SentryMeterRegistry.class)
   public @NotNull SentryMeterRegistry sentryMeterRegistry(
       final @NotNull IScopes scopes, final @NotNull SentryProperties properties) {
-    return new SentryMeterRegistry(properties.getMicrometer().getPollIntervalMillis());
+    return new SentryMeterRegistry(scopes, properties.getMicrometer().getPollIntervalMillis());
   }
 }

sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryMicrometerConfigurationTest.kt

@@ -5,10 +5,17 @@ import io.micrometer.core.instrument.composite.CompositeMeterRegistry
 import io.micrometer.core.instrument.simple.SimpleMeterRegistry
 import io.sentry.IScopes
 import io.sentry.Sentry
+import io.sentry.metrics.IMetricsApi
 import io.sentry.micrometer.SentryMeterRegistry
 import kotlin.test.AfterTest
 import kotlin.test.Test
 import org.assertj.core.api.Assertions.assertThat
+import org.mockito.kotlin.any
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
 import org.springframework.boot.actuate.autoconfigure.metrics.CompositeMeterRegistryAutoConfiguration
 import org.springframework.boot.actuate.autoconfigure.metrics.MetricsAutoConfiguration
 import org.springframework.boot.autoconfigure.AutoConfigurations
@@ -72,6 +79,24 @@ class SentryMicrometerConfigurationTest {
     assertThat(registry!!.isClosed).isTrue()
   }
 
+  @Test
+  fun `registry uses the injected scopes bean`() {
+    val scopes = mock<IScopes>()
+    val metrics = mock<IMetricsApi>()
+    whenever(scopes.metrics()).thenReturn(metrics)
+    val properties = SentryProperties().apply { micrometer.pollIntervalMillis = 0 }
+
+    ApplicationContextRunner()
+      .withUserConfiguration(SentryMicrometerConfiguration::class.java)
+      .withBean(IScopes::class.java, { scopes })
+      .withBean(SentryProperties::class.java, { properties })
+      .run {
+        it.getBean(SentryMeterRegistry::class.java).counter("requests").increment(2.0)
+
+        verify(metrics).count(eq("requests"), eq(2.0), anyOrNull(), any())
+      }
+  }
+
   @Test
   fun `integration is absent when Sentry auto-configuration is disabled`() {
     ApplicationContextRunner()

sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryMicrometerConfiguration.java

@@ -15,6 +15,6 @@ final class SentryMicrometerConfiguration {
   @ConditionalOnMissingBean(SentryMeterRegistry.class)
   public @NotNull SentryMeterRegistry sentryMeterRegistry(
       final @NotNull IScopes scopes, final @NotNull SentryProperties properties) {
-    return new SentryMeterRegistry(properties.getMicrometer().getPollIntervalMillis());
+    return new SentryMeterRegistry(scopes, properties.getMicrometer().getPollIntervalMillis());
   }
 }