merge(micrometer): Propagate injected scopes to ignored metrics

Merge the Spring Boot registry scopes change from #6116 into #6155.
Use the same injected scopes for registration filtering and recording so
custom scopes do not accidentally inherit global ignored-metric options.

Resolve test imports, supply options in injected-scope fixtures, and cover
filtering with distinct global and injected ignore lists. Preserve the
existing logging defaults and explicit override behavior.

Refs #6116
Refs #6155
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/SentryIgnoredMetricsFilter.java

@@ -4,7 +4,7 @@
 import io.micrometer.core.instrument.config.MeterFilter;
 import io.micrometer.core.instrument.config.MeterFilterReply;
 import io.sentry.FilterString;
-import io.sentry.Sentry;
+import io.sentry.IScopes;
 import io.sentry.util.MetricsUtils;
 import java.util.List;
 import java.util.Locale;
@@ -13,15 +13,18 @@
 
 final class SentryIgnoredMetricsFilter implements MeterFilter {
   private final @NotNull SentryMeterRegistry registry;
+  private final @NotNull IScopes scopes;
 
-  SentryIgnoredMetricsFilter(final @NotNull SentryMeterRegistry registry) {
+  SentryIgnoredMetricsFilter(
+      final @NotNull SentryMeterRegistry registry, final @NotNull IScopes scopes) {
     this.registry = registry;
+    this.scopes = scopes;
   }
 
   @Override
   public @NotNull MeterFilterReply accept(final @NotNull Meter.Id id) {
     final @Nullable List<FilterString> ignoredMetrics =
-        Sentry.getCurrentScopes().getOptions().getMetrics().getIgnoredMetrics();
+        scopes.getOptions().getMetrics().getIgnoredMetrics();
     if (ignoredMetrics == null || ignoredMetrics.isEmpty()) {
       return MeterFilterReply.NEUTRAL;
     }

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(
@@ -79,7 +93,7 @@ public SentryMeterRegistry(final long pollIntervalMillis) {
     this.scheduler = pollIntervalMillis == 0 ? null : scheduler;
     config()
         .namingConvention(NamingConvention.identity)
-        .meterFilter(new SentryIgnoredMetricsFilter(this))
+        .meterFilter(new SentryIgnoredMetricsFilter(this, scopes))
         .onMeterRemoved(this::onMeterRemoved);
     addIntegrationToSdkVersion(INTEGRATION_NAME);
     if (this.scheduler == null) {
@@ -168,7 +182,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(
@@ -192,7 +206,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());
   }
@@ -201,7 +215,7 @@ void captureDistribution(final @NotNull SentryMetricInfo metricInfo, final doubl
     if (isClosed()) {
       return;
     }
-    Sentry.getCurrentScopes()
+    scopes
         .metrics()
         .distribution(
             metricInfo.getName(), value, metricInfo.getUnit(), metricInfo.createParameters());
@@ -211,7 +225,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());
   }
@@ -234,7 +248,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/SentryIgnoredMetricsFilterTest.kt

@@ -62,6 +62,36 @@ class SentryIgnoredMetricsFilterTest {
     assertThat(events.allValues.map { it.name }).containsExactly("logback.events", "log4j2.events")
   }
 
+  @Test
+  fun `registration filtering and recording use injected scopes instead of global scopes`() {
+    options.metrics.addIgnoredMetric("global[.]blocked")
+    val injectedOptions =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        metrics.addIgnoredMetric("injected[.]blocked")
+      }
+    val injectedClient = mock<ISentryClient>()
+    whenever(injectedClient.isEnabled).thenReturn(true)
+    val scopes = createTestScopes(injectedOptions)
+    scopes.bindClient(injectedClient)
+
+    val injectedRegistry = SentryMeterRegistry(scopes, 0)
+    try {
+      injectedRegistry.counter("injected.blocked").increment()
+      injectedRegistry.counter("global.blocked").increment(2.0)
+
+      assertThat(injectedRegistry.find("injected.blocked").counter()).isNull()
+      assertThat(injectedRegistry.find("global.blocked").counter()).isNotNull()
+      val event = argumentCaptor<SentryMetricsEvent>()
+      verify(injectedClient).captureMetric(event.capture(), any(), anyOrNull())
+      assertThat(event.firstValue.name).isEqualTo("global.blocked")
+      assertThat(event.firstValue.value).isEqualTo(2.0)
+      verify(client, never()).captureMetric(any(), any(), anyOrNull())
+    } finally {
+      injectedRegistry.close()
+    }
+  }
+
   @Test
   fun `denied counter never invokes the metrics API even under a log flood`() {
     options.metrics.addIgnoredMetric("LOGBACK.EVENTS")

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,59 @@ 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)
+    whenever(scopes.options).thenReturn(SentryOptions())
+    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

@@ -6,10 +6,17 @@ import io.micrometer.core.instrument.simple.SimpleMeterRegistry
 import io.sentry.IScopes
 import io.sentry.Sentry
 import io.sentry.SentryOptions
+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
@@ -188,6 +195,25 @@ 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 }
+    whenever(scopes.options).thenReturn(properties)
+
+    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());
   }
 }