DataDog · wconti27 · Jun 7, 2026 · Jun 8, 2026 · chatgpt-codex-connector · Jun 8, 2026
@@ -67,8 +67,8 @@ dependencies {
   spring6TestImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-data-jpa', version: '3.0.0'
 
   latestDepTestImplementation group: 'com.h2database', name: 'h2', version: '+'
-  latestDepTestImplementation group: 'org.springframework', name: 'spring-context', version: '6.+'
-  latestDepTestImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-data-jpa', version: '3.+'
+  latestDepTestImplementation group: 'org.springframework', name: 'spring-context', version: '7.+'
+  latestDepTestImplementation group: 'org.springframework.boot', name: 'spring-boot-starter-data-jpa', version: '4.+'
 }
 
 tasks.named("latestDepForkedTest", Test) {

@@ -51,6 +51,9 @@ private Object invokeWithSpan(CharSequence spanName) throws Throwable {
     AgentSpan span = startSpan("spring-scheduling", spanName);
     try (AgentScope scope = activateSpan(span)) {
       return delegate.proceed();
+    } catch (Throwable throwable) {
+      DECORATE.onError(span, throwable);
+      throw throwable;
     } finally {
       span.finish();
     }

@@ -0,0 +1,12 @@
+import java.util.concurrent.CompletableFuture;
+import org.springframework.scheduling.annotation.Async;
+
+public class AsyncErrorTask {
+
+  public static final String ERROR_MESSAGE = "async boom";
+
+  @Async
+  public CompletableFuture<Integer> asyncThrow() {
+    throw new IllegalStateException(ERROR_MESSAGE);
+  }
+}
@@ -0,0 +1,13 @@
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableAsync;
+
+@Configuration
+@EnableAsync
+public class AsyncErrorTaskConfig {
+
+  @Bean
+  AsyncErrorTask asyncErrorTask() {
+    return new AsyncErrorTask();
+  }
+}
@@ -0,0 +1,24 @@
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import org.springframework.scheduling.annotation.Scheduled;
+
+public class ScheduledErrorTask implements Runnable {
+
+  public static final String ERROR_MESSAGE = "scheduled boom";
+
+  private final CountDownLatch latch = new CountDownLatch(1);
+
+  @Scheduled(fixedRate = 5000)
+  @Override
+  public void run() {
+    try {
+      throw new IllegalStateException(ERROR_MESSAGE);
+    } finally {
+      latch.countDown();
+    }
+  }
+
+  public boolean blockUntilExecute() throws InterruptedException {
+    return latch.await(10, TimeUnit.SECONDS);
+  }
+}
@@ -0,0 +1,13 @@
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+@Configuration
+@EnableScheduling
+public class ScheduledErrorTaskConfig {
+
+  @Bean
+  public ScheduledErrorTask scheduledErrorTask() {
+    return new ScheduledErrorTask();
+  }
+}
@@ -0,0 +1,32 @@
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import datadog.trace.agent.test.AbstractInstrumentationTest;
+import datadog.trace.test.util.Flaky;
+import java.util.concurrent.TimeUnit;
+import javax.sql.DataSource;
+import org.junit.jupiter.api.Test;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+class ShedlockTest extends AbstractInstrumentationTest {
+
+  @Flaky("task.invocationCount() == 0")
+  @Test
+  void shouldNotDisableShedlock() throws InterruptedException {
+    AnnotationConfigApplicationContext context =
+        new AnnotationConfigApplicationContext(ShedlockConfig.class);
+    try {
+      JdbcTemplate jdbcTemplate = new JdbcTemplate(context.getBean(DataSource.class));
+      jdbcTemplate.execute(
+          "CREATE TABLE shedlock(name VARCHAR(64) NOT NULL PRIMARY KEY, lock_until TIMESTAMP NOT NULL,\n"
+              + "    locked_at TIMESTAMP NOT NULL, locked_by VARCHAR(255) NOT NULL);");
+      ShedLockedTask task = context.getBean(ShedLockedTask.class);
+
+      // lock is held for more than one second: wait, then verify the task ran exactly once
+      task.awaitInvocation(1000, TimeUnit.MILLISECONDS);
+      assertEquals(1, task.invocationCount());
+    } finally {
+      context.close();
+    }
+  }
+}
@@ -0,0 +1,39 @@
+import static datadog.trace.agent.test.assertions.SpanMatcher.span;
+import static datadog.trace.agent.test.assertions.TagsMatcher.defaultTags;
+import static datadog.trace.agent.test.assertions.TagsMatcher.error;
+import static datadog.trace.agent.test.assertions.TraceMatcher.trace;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import datadog.trace.agent.test.AbstractInstrumentationTest;
+import org.junit.jupiter.api.Test;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+
+/**
+ * Verifies that when an {@code @Async} method throws an exception, the span produced by the
+ * spring-scheduling instrumentation captures the error and the associated error tags.
+ */
+class SpringAsyncErrorTest extends AbstractInstrumentationTest {
+
+  @Test
+  void asyncMethodErrorIsCaptured() {
+    AnnotationConfigApplicationContext context =
+        new AnnotationConfigApplicationContext(AsyncErrorTaskConfig.class);
+    try {
+      AsyncErrorTask asyncErrorTask = context.getBean(AsyncErrorTask.class);
+
+      // The exception thrown inside the @Async method propagates back through the returned future.
+      assertThrows(Throwable.class, () -> asyncErrorTask.asyncThrow().join());
+
+      assertTraces(
+          trace(
+              span()
+                  .resourceName(name -> "AsyncErrorTask.asyncThrow".contentEquals(name))
+                  .error(true)
+                  .tags(
+                      defaultTags(),
+                      error(IllegalStateException.class, AsyncErrorTask.ERROR_MESSAGE))));
+    } finally {
+      context.close();
+    }
+  }
+}