feat(spring): Add an option to monitor all @Scheduled methods in Spring Boot 4

CHANGELOG.md

@@ -9,7 +9,7 @@
 
 ### Features
 
-- Monitor every Spring `@Scheduled` method with Sentry Crons by setting `sentry.monitor-scheduled-tasks=true`, without adding `@SentryCheckIn` to each method. Sentry creates each monitor from the method's `@Scheduled` schedule. Exclude methods with `sentry.exclude-scheduled-tasks` ([#6275](https://github.com/getsentry/sentry-java/pull/6275), [#6276](https://github.com/getsentry/sentry-java/pull/6276))
+- Monitor every Spring `@Scheduled` method with Sentry Crons by setting `sentry.monitor-scheduled-tasks=true`, without adding `@SentryCheckIn` to each method. Sentry creates each monitor from the method's `@Scheduled` schedule. Exclude methods with `sentry.exclude-scheduled-tasks` ([#6275](https://github.com/getsentry/sentry-java/pull/6275), [#6276](https://github.com/getsentry/sentry-java/pull/6276), [#6277](https://github.com/getsentry/sentry-java/pull/6277))
 - Quartz `SentryJobListener` can send a monitor config derived from the trigger with check-ins, so Sentry creates or updates the monitor from code. Set the `sentry-upsert-monitor-config` job or trigger data key to `"true"` to send the schedule ([#6216](https://github.com/getsentry/sentry-java/pull/6216))
 - Send a monitor config derived from Spring `@Scheduled` with `@SentryCheckIn` check-ins, so Sentry creates or updates the monitor from code. Set `@SentryCheckIn(upsertMonitorConfig = true)` to send the schedule ([#6215](https://github.com/getsentry/sentry-java/pull/6215))
 

sentry-spring-7/api/sentry-spring-7.api

@@ -148,6 +148,7 @@ public abstract interface annotation class io/sentry/spring7/checkin/SentryCheck
 public class io/sentry/spring7/checkin/SentryCheckInAdvice : org/aopalliance/intercept/MethodInterceptor, org/springframework/context/EmbeddedValueResolverAware {
 	public fun <init> ()V
 	public fun <init> (Lio/sentry/IScopes;)V
+	public fun <init> (Lio/sentry/IScopes;Z)V
 	public fun invoke (Lorg/aopalliance/intercept/MethodInvocation;)Ljava/lang/Object;
 	public fun setEmbeddedValueResolver (Lorg/springframework/util/StringValueResolver;)V
 }
@@ -168,6 +169,11 @@ public class io/sentry/spring7/checkin/SentryQuartzConfiguration {
 	public fun schedulerFactoryBeanCustomizer ()Lorg/springframework/boot/quartz/autoconfigure/SchedulerFactoryBeanCustomizer;
 }
 
+public final class io/sentry/spring7/checkin/SentryScheduledCheckInPointcut : org/springframework/aop/support/StaticMethodMatcherPointcut {
+	public fun <init> (Ljava/util/List;)V
+	public fun matches (Ljava/lang/reflect/Method;Ljava/lang/Class;)Z
+}
+
 public final class io/sentry/spring7/checkin/SentrySchedulerFactoryBeanCustomizer : org/springframework/boot/quartz/autoconfigure/SchedulerFactoryBeanCustomizer {
 	public fun <init> ()V
 	public fun customize (Lorg/springframework/scheduling/quartz/SchedulerFactoryBean;)V

sentry-spring-7/src/main/java/io/sentry/spring7/checkin/SentryCheckInAdvice.java

@@ -15,12 +15,16 @@
 import io.sentry.util.Objects;
 import io.sentry.util.TracingUtils;
 import java.lang.reflect.Method;
+import java.nio.charset.StandardCharsets;
 import java.time.Duration;
 import java.time.format.DateTimeParseException;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+import java.util.zip.CRC32;
 import org.aopalliance.intercept.MethodInterceptor;
 import org.aopalliance.intercept.MethodInvocation;
 import org.jetbrains.annotations.ApiStatus;
@@ -49,19 +53,38 @@ public class SentryCheckInAdvice implements MethodInterceptor, EmbeddedValueReso
           "org.springframework.scheduling.support.CronExpression",
           SentryCheckInAdvice.class.getClassLoader());
 
+  private static final @NotNull Pattern WORD_BOUNDARY =
+      Pattern.compile("(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])");
+  private static final int MAX_SLUG_LENGTH = 50;
+
   private final @NotNull IScopes scopes;
 
+  private final boolean monitorScheduledTasks;
+
   private @Nullable StringValueResolver resolver;
 
   private final @NotNull Map<Method, CachedMonitorConfig> monitorConfigs =
       new ConcurrentHashMap<>();
 
+  private final @NotNull Map<String, String> derivedSlugOwners = new ConcurrentHashMap<>();
+
+  private final @NotNull Set<String> collidingSlugs = ConcurrentHashMap.newKeySet();
+
   public SentryCheckInAdvice() {
     this(ScopesAdapter.getInstance());
   }
 
   public SentryCheckInAdvice(final @NotNull IScopes scopes) {
+    this(scopes, false);
+  }
+
+  /**
+   * @param monitorScheduledTasks whether to also monitor {@code @Scheduled} methods without {@link
+   *     SentryCheckIn}, using a slug derived from the class and method name
+   */
+  public SentryCheckInAdvice(final @NotNull IScopes scopes, final boolean monitorScheduledTasks) {
     this.scopes = Objects.requireNonNull(scopes, "scopes are required");
+    this.monitorScheduledTasks = monitorScheduledTasks;
   }
 
   @Override
@@ -75,6 +98,25 @@ public SentryCheckInAdvice(final @NotNull IScopes scopes) {
     SentryCheckIn checkInAnnotation =
         AnnotationUtils.findAnnotation(mostSpecificMethod, SentryCheckIn.class);
     if (checkInAnnotation == null) {
+      if (monitorScheduledTasks && isScheduled(mostSpecificMethod)) {
+        final @NotNull Class<?> targetClass =
+            target != null ? target.getClass() : mostSpecificMethod.getDeclaringClass();
+        final @NotNull String taskName = scheduledTaskName(targetClass, mostSpecificMethod);
+        final @Nullable MonitorConfig monitorConfig = monitorConfig(mostSpecificMethod);
+        if (monitorConfig == null) {
+          scopes
+              .getOptions()
+              .getLogger()
+              .log(
+                  SentryLevel.DEBUG,
+                  "Not monitoring %s because Sentry Crons can't express its @Scheduled schedule.",
+                  taskName);
+          return invocation.proceed();
+        }
+        final @NotNull String monitorSlug = scheduledTaskSlug(taskName);
+        warnOnSlugCollision(monitorSlug, targetClass, mostSpecificMethod);
+        return captureCheckIns(invocation, monitorSlug, false, monitorConfig);
+      }
       return invocation.proceed();
     }
 
@@ -114,7 +156,15 @@ public SentryCheckInAdvice(final @NotNull IScopes scopes) {
         !isHeartbeatOnly && checkInAnnotation.upsertMonitorConfig()
             ? monitorConfig(mostSpecificMethod)
             : null;
+    return captureCheckIns(invocation, monitorSlug, isHeartbeatOnly, monitorConfig);
+  }
 
+  private @Nullable Object captureCheckIns(
+      final @NotNull MethodInvocation invocation,
+      final @NotNull String monitorSlug,
+      final boolean isHeartbeatOnly,
+      final @Nullable MonitorConfig monitorConfig)
+      throws Throwable {
     try (final @NotNull ISentryLifecycleToken ignored =
             scopes.forkedScopes("SentryCheckInAdvice").makeCurrent()) {
       TracingUtils.startNewTrace(scopes);
@@ -143,6 +193,58 @@ public SentryCheckInAdvice(final @NotNull IScopes scopes) {
     }
   }
 
+  private void warnOnSlugCollision(
+      final @NotNull String monitorSlug,
+      final @NotNull Class<?> targetClass,
+      final @NotNull Method method) {
+    final @NotNull String identity =
+        ClassUtils.getUserClass(targetClass).getName() + "." + method.getName();
+    final @Nullable String owner = derivedSlugOwners.putIfAbsent(monitorSlug, identity);
+    if (owner != null && !owner.equals(identity) && collidingSlugs.add(monitorSlug)) {
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(
+              SentryLevel.WARNING,
+              "Monitor slug \"%s\" is used by both %s and %s, so their check-ins go to one monitor. Add @SentryCheckIn(\"your-slug\") to one of them.",
+              monitorSlug,
+              owner,
+              identity);
+    }
+  }
+
+  static boolean isScheduled(final @NotNull Method method) {
+    return !AnnotatedElementUtils.getMergedRepeatableAnnotations(
+            method, Scheduled.class, Schedules.class)
+        .isEmpty();
+  }
+
+  /** {@code ClassName.methodName}, with nested classes as {@code Outer.Inner}. */
+  static @NotNull String scheduledTaskName(
+      final @NotNull Class<?> targetClass, final @NotNull Method method) {
+    return ClassUtils.getShortName(ClassUtils.getUserClass(targetClass)) + "." + method.getName();
+  }
+
+  static @NotNull String scheduledTaskSlug(final @NotNull String taskName) {
+    final @NotNull String slug =
+        WORD_BOUNDARY
+            .matcher(taskName)
+            .replaceAll("-")
+            .toLowerCase(Locale.ROOT)
+            .replaceAll("[^a-z0-9]+", "-")
+            .replaceAll("^-+|-+$", "");
+    if (slug.length() <= MAX_SLUG_LENGTH) {
+      return slug;
+    }
+    // keep truncated slugs unique
+    final @NotNull CRC32 crc = new CRC32();
+    crc.update(slug.getBytes(StandardCharsets.UTF_8));
+    final @NotNull String hash = String.format(Locale.ROOT, "%08x", crc.getValue());
+    return slug.substring(0, MAX_SLUG_LENGTH - hash.length() - 1).replaceAll("-+$", "")
+        + "-"
+        + hash;
+  }
+
   private @Nullable MonitorConfig monitorConfig(final @NotNull Method method) {
     return monitorConfigs.computeIfAbsent(
             method, key -> new CachedMonitorConfig(monitorConfigFromScheduled(key)))
@@ -177,10 +279,7 @@ public SentryCheckInAdvice(final @NotNull IScopes scopes) {
       scopes
           .getOptions()
           .getLogger()
-          .log(
-              SentryLevel.WARNING,
-              "Could not derive a monitor config from @Scheduled for method annotated with @SentryCheckIn.",
-              e);
+          .log(SentryLevel.WARNING, "Could not derive a monitor config from @Scheduled.", e);
       return null;
     }
   }
@@ -211,7 +310,7 @@ public SentryCheckInAdvice(final @NotNull IScopes scopes) {
           .getLogger()
           .log(
               SentryLevel.DEBUG,
-              "Not sending a monitor config for @SentryCheckIn because the @Scheduled period '%s' could not be parsed.",
+              "Not sending a monitor config because the @Scheduled period '%s' could not be parsed.",
               trimmed);
     }
     return millis;

sentry-spring-7/src/main/java/io/sentry/spring7/checkin/SentryScheduledCheckInPointcut.java

@@ -0,0 +1,66 @@
+package io.sentry.spring7.checkin;
+
+import io.sentry.FilterString;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.List;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.aop.support.StaticMethodMatcherPointcut;
+import org.springframework.core.ReactiveAdapterRegistry;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.util.ClassUtils;
+
+/**
+ * Matches {@code @Scheduled} methods without {@link SentryCheckIn}, except excluded ones. Excludes
+ * match the task name ({@code ClassName.methodName}) exactly or as a regex.
+ */
+@ApiStatus.Internal
+public final class SentryScheduledCheckInPointcut extends StaticMethodMatcherPointcut {
+  private final @NotNull List<FilterString> excludedScheduledTasks = new ArrayList<>();
+
+  public SentryScheduledCheckInPointcut(final @Nullable List<String> excludedScheduledTasks) {
+    if (excludedScheduledTasks != null) {
+      for (final @NotNull String task : excludedScheduledTasks) {
+        if (!task.trim().isEmpty()) {
+          this.excludedScheduledTasks.add(new FilterString(task.trim()));
+        }
+      }
+    }
+  }
+
+  @Override
+  public boolean matches(final @NotNull Method method, final @NotNull Class<?> targetClass) {
+    final @NotNull Class<?> userClass = ClassUtils.getUserClass(targetClass);
+    // CGLIB can't intercept these, and Spring calls private and static methods on the target
+    final int modifiers = method.getModifiers();
+    if (Modifier.isFinal(userClass.getModifiers())
+        || Modifier.isFinal(modifiers)
+        || Modifier.isPrivate(modifiers)
+        || Modifier.isStatic(modifiers)) {
+      return false;
+    }
+    final @NotNull Method specificMethod = AopUtils.getMostSpecificMethod(method, userClass);
+    if (!SentryCheckInAdvice.isScheduled(specificMethod)
+        || AnnotationUtils.findAnnotation(specificMethod, SentryCheckIn.class) != null) {
+      return false;
+    }
+    // Spring calls reactive and suspend methods once and subscribes to the result on each run
+    if (specificMethod.getParameterCount() > 0
+        || ReactiveAdapterRegistry.getSharedInstance().getAdapter(specificMethod.getReturnType())
+            != null) {
+      return false;
+    }
+    final @NotNull String taskName =
+        SentryCheckInAdvice.scheduledTaskName(userClass, specificMethod);
+    for (final @NotNull FilterString excluded : excludedScheduledTasks) {
+      if (excluded.getFilterString().equals(taskName) || excluded.matches(taskName)) {
+        return false;
+      }
+    }
+    return true;
+  }
+}