Move observation support classes to scheduling.support package

jhoeller · jhoeller · commit f0fe58f0ecb8 · 2023-07-08T14:57:02.000+02:00
Avoids a package cycle between config and support (only config->support allowed). See gh-29883
diff --git a/framework-docs/modules/ROOT/pages/integration/observability.adoc b/framework-docs/modules/ROOT/pages/integration/observability.adoc
@@ -91,7 +91,7 @@ This can be done by declaring a `SchedulingConfigurer` bean that sets the observ
 
 include-code::./ObservationSchedulingConfigurer[]
 
-It is using the `org.springframework.scheduling.config.DefaultScheduledTaskObservationConvention` by default, backed by the `ScheduledTaskObservationContext`.
+It is using the `org.springframework.scheduling.support.DefaultScheduledTaskObservationConvention` by default, backed by the `ScheduledTaskObservationContext`.
 You can configure a custom implementation on the `ObservationRegistry` directly.
 During the execution of the scheduled method, the current observation is restored in the `ThreadLocal` context or the Reactor context (if the scheduled method returns a `Mono` or `Flux` type).
 
diff --git a/spring-context/src/main/java/org/springframework/scheduling/annotation/ScheduledAnnotationReactiveSupport.java b/spring-context/src/main/java/org/springframework/scheduling/annotation/ScheduledAnnotationReactiveSupport.java
@@ -38,15 +38,15 @@
 import org.springframework.core.ReactiveAdapter;
 import org.springframework.core.ReactiveAdapterRegistry;
 import org.springframework.lang.Nullable;
-import org.springframework.scheduling.config.DefaultScheduledTaskObservationConvention;
-import org.springframework.scheduling.config.ScheduledTaskObservationContext;
-import org.springframework.scheduling.config.ScheduledTaskObservationConvention;
+import org.springframework.scheduling.support.DefaultScheduledTaskObservationConvention;
+import org.springframework.scheduling.support.ScheduledTaskObservationContext;
+import org.springframework.scheduling.support.ScheduledTaskObservationConvention;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.ReflectionUtils;
 import org.springframework.util.StringUtils;
 
-import static org.springframework.scheduling.config.ScheduledTaskObservationDocumentation.TASKS_SCHEDULED_EXECUTION;
+import static org.springframework.scheduling.support.ScheduledTaskObservationDocumentation.TASKS_SCHEDULED_EXECUTION;
 
 /**
  * Helper class for @{@link ScheduledAnnotationBeanPostProcessor} to support reactive
diff --git a/spring-context/src/main/java/org/springframework/scheduling/support/DefaultScheduledTaskObservationConvention.java b/spring-context/src/main/java/org/springframework/scheduling/support/DefaultScheduledTaskObservationConvention.java
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-package org.springframework.scheduling.config;
+package org.springframework.scheduling.support;
 
 import io.micrometer.common.KeyValue;
 import io.micrometer.common.KeyValues;
 
 import org.springframework.util.StringUtils;
 
-import static org.springframework.scheduling.config.ScheduledTaskObservationDocumentation.LowCardinalityKeyNames;
+import static org.springframework.scheduling.support.ScheduledTaskObservationDocumentation.LowCardinalityKeyNames;
 
 /**
  * Default implementation for {@link ScheduledTaskObservationConvention}.
diff --git a/spring-context/src/main/java/org/springframework/scheduling/support/ScheduledMethodRunnable.java b/spring-context/src/main/java/org/springframework/scheduling/support/ScheduledMethodRunnable.java
@@ -24,10 +24,6 @@
 import io.micrometer.observation.Observation;
 import io.micrometer.observation.ObservationRegistry;
 
-import org.springframework.scheduling.config.DefaultScheduledTaskObservationConvention;
-import org.springframework.scheduling.config.ScheduledTaskObservationContext;
-import org.springframework.scheduling.config.ScheduledTaskObservationConvention;
-import org.springframework.scheduling.config.ScheduledTaskObservationDocumentation;
 import org.springframework.util.ReflectionUtils;
 
 /**
@@ -42,14 +38,16 @@
  */
 public class ScheduledMethodRunnable implements Runnable {
 
-	private static final ScheduledTaskObservationConvention DEFAULT_CONVENTION = new DefaultScheduledTaskObservationConvention();
+	private static final ScheduledTaskObservationConvention DEFAULT_CONVENTION =
+			new DefaultScheduledTaskObservationConvention();
 
 	private final Object target;
 
 	private final Method method;
 
 	private final Supplier<ObservationRegistry> observationRegistrySupplier;
 
+
 	/**
 	 * Create a {@code ScheduledMethodRunnable} for the given target instance,
 	 * calling the specified method.
diff --git a/spring-context/src/main/java/org/springframework/scheduling/support/ScheduledTaskObservationContext.java b/spring-context/src/main/java/org/springframework/scheduling/support/ScheduledTaskObservationContext.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.scheduling.config;
+package org.springframework.scheduling.support;
 
 import java.lang.reflect.Method;
 
@@ -23,8 +23,9 @@
 import org.springframework.util.ClassUtils;
 
 /**
- * Context that holds information for observation metadata collection
- * during the {@link ScheduledTaskObservationDocumentation#TASKS_SCHEDULED_EXECUTION execution of scheduled tasks}.
+ * Context that holds information for observation metadata collection during the
+ * {@link ScheduledTaskObservationDocumentation#TASKS_SCHEDULED_EXECUTION execution of scheduled tasks}.
+ *
  * @author Brian Clozel
  * @since 6.1
  */
@@ -36,6 +37,7 @@ public class ScheduledTaskObservationContext extends Observation.Context {
 
 	private boolean complete;
 
+
 	/**
 	 * Create a new observation context for a task, given the target object
 	 * and the method to be called.
@@ -47,6 +49,7 @@ public ScheduledTaskObservationContext(Object target, Method method) {
 		this.method = method;
 	}
 
+
 	/**
 	 * Return the type of the target object.
 	 */
@@ -77,4 +80,5 @@ public boolean isComplete() {
 	public void setComplete(boolean complete) {
 		this.complete = complete;
 	}
+
 }
diff --git a/spring-context/src/main/java/org/springframework/scheduling/support/ScheduledTaskObservationConvention.java b/spring-context/src/main/java/org/springframework/scheduling/support/ScheduledTaskObservationConvention.java
@@ -14,14 +14,15 @@
  * limitations under the License.
  */
 
-package org.springframework.scheduling.config;
+package org.springframework.scheduling.support;
 
 import io.micrometer.observation.Observation;
 import io.micrometer.observation.ObservationConvention;
 
 /**
  * Interface for an {@link ObservationConvention} for
  * {@link ScheduledTaskObservationDocumentation#TASKS_SCHEDULED_EXECUTION scheduled task executions}.
+ *
  * @author Brian Clozel
  * @since 6.1
  */
diff --git a/spring-context/src/main/java/org/springframework/scheduling/support/ScheduledTaskObservationDocumentation.java b/spring-context/src/main/java/org/springframework/scheduling/support/ScheduledTaskObservationDocumentation.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.scheduling.config;
+package org.springframework.scheduling.support;
 
 import io.micrometer.common.KeyValue;
 import io.micrometer.common.docs.KeyName;
@@ -24,8 +24,10 @@
 
 /**
  * Documented {@link io.micrometer.common.KeyValue KeyValues} for the observations on
- * executions of {@link org.springframework.scheduling.annotation.Scheduled scheduled tasks}.
- * <p>This class is used by automated tools to document KeyValues attached to the {@code @Scheduled} observations.
+ * executions of {@link org.springframework.scheduling.annotation.Scheduled scheduled tasks}
+ *
+ * <p>This class is used by automated tools to document KeyValues attached to the
+ * {@code @Scheduled} observations.
  *
  * @author Brian Clozel
  * @since 6.1
@@ -40,19 +42,17 @@ public enum ScheduledTaskObservationDocumentation implements ObservationDocument
 		public Class<? extends ObservationConvention<? extends Observation.Context>> getDefaultConvention() {
 			return DefaultScheduledTaskObservationConvention.class;
 		}
-
 		@Override
 		public KeyName[] getLowCardinalityKeyNames() {
 			return LowCardinalityKeyNames.values();
 		}
-
 		@Override
 		public KeyName[] getHighCardinalityKeyNames() {
 			return new KeyName[] {};
 		}
-
 	};
 
+
 	public enum LowCardinalityKeyNames implements KeyName {
 
 		/**
diff --git a/spring-context/src/test/java/org/springframework/scheduling/annotation/ScheduledAnnotationBeanPostProcessorObservabilityTests.java b/spring-context/src/test/java/org/springframework/scheduling/annotation/ScheduledAnnotationBeanPostProcessorObservabilityTests.java
@@ -36,8 +36,8 @@
 import org.springframework.core.task.SimpleAsyncTaskExecutor;
 import org.springframework.scheduling.config.ScheduledTask;
 import org.springframework.scheduling.config.ScheduledTaskHolder;
-import org.springframework.scheduling.config.ScheduledTaskObservationContext;
 import org.springframework.scheduling.config.ScheduledTaskRegistrar;
+import org.springframework.scheduling.support.ScheduledTaskObservationContext;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -55,11 +55,13 @@ class ScheduledAnnotationBeanPostProcessorObservabilityTests {
 
 	private final TestObservationRegistry observationRegistry = TestObservationRegistry.create();
 
+
 	@AfterEach
 	void closeContext() {
 		context.close();
 	}
 
+
 	@Test
 	void shouldRecordSuccessObservationsForTasks() throws Exception {
 		registerScheduledBean(FixedDelayBean.class);
@@ -185,6 +187,7 @@ private TestObservationRegistryAssert.TestObservationRegistryAssertReturningObse
 				.hasObservationWithNameEqualTo("tasks.scheduled.execution").that();
 	}
 
+
 	static abstract class TaskTester {
 
 		ObservationRegistry observationRegistry;
@@ -200,13 +203,13 @@ public void await() throws InterruptedException {
 		}
 	}
 
+
 	static class FixedDelayBean extends TaskTester {
 
 		@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)
 		public void fixedDelay() {
 			this.latch.countDown();
 		}
-
 	}
 
 
@@ -217,28 +220,28 @@ public void error() {
 			this.latch.countDown();
 			throw new IllegalStateException("test error");
 		}
-
 	}
 
+
 	static class FixedDelayReactiveBean extends TaskTester {
 
 		@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)
 		public Mono<Object> fixedDelay() {
 			return Mono.empty().doOnTerminate(() -> this.latch.countDown());
 		}
-
 	}
 
+
 	static class FixedDelayReactiveErrorBean extends TaskTester {
 
 		@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)
 		public Mono<Object> error() {
 			return Mono.error(new IllegalStateException("test error"))
 					.doOnTerminate(() -> this.latch.countDown());
 		}
-
 	}
 
+
 	static class CancelledTaskBean extends TaskTester {
 
 		@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)
@@ -251,19 +254,19 @@ public void cancelled() {
 				// ignore cancelled task
 			}
 		}
-
 	}
 
+
 	static class CancelledReactiveTaskBean extends TaskTester {
 
 		@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)
 		public Flux<Long> cancelled() {
 			return Flux.interval(Duration.ZERO, Duration.ofSeconds(1))
 					.doOnNext(el -> this.latch.countDown());
 		}
-
 	}
 
+
 	static class CurrentObservationBean extends TaskTester {
 
 		@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)
@@ -272,9 +275,9 @@ public void hasCurrentObservation() {
 			assertThat(this.observationRegistry.getCurrentObservation().getContext()).isInstanceOf(ScheduledTaskObservationContext.class);
 			this.latch.countDown();
 		}
-
 	}
 
+
 	static class CurrentObservationReactiveBean extends TaskTester {
 
 		@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)
@@ -290,7 +293,6 @@ public void doFirst() throws Throwable {
 					})
 					.doOnTerminate(() -> this.latch.countDown());
 		}
-
 	}
 
 }
diff --git a/spring-context/src/test/java/org/springframework/scheduling/support/DefaultScheduledTaskObservationConventionTests.java b/spring-context/src/test/java/org/springframework/scheduling/support/DefaultScheduledTaskObservationConventionTests.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.springframework.scheduling.config;
+package org.springframework.scheduling.support;
 
 
 import java.lang.reflect.Method;
@@ -37,6 +37,7 @@ class DefaultScheduledTaskObservationConventionTests {
 
 	private final ScheduledTaskObservationConvention convention = new DefaultScheduledTaskObservationConvention();
 
+
 	@Test
 	void observationShouldHaveDefaultName() {
 		assertThat(convention.getName()).isEqualTo("tasks.scheduled.execution");
@@ -92,17 +93,16 @@ void observationShouldHaveUnknownOutcome() {
 	}
 
 
-	static class BeanWithScheduledMethods implements TaskProcessor {
-
-		public void process() {
+	interface TaskProcessor {
 
-		}
+		void process();
 	}
 
-	interface TaskProcessor {
 
-		void process();
+	static class BeanWithScheduledMethods implements TaskProcessor {
 
+		public void process() {
+		}
 	}
 
 }

Original file line number	Diff line number	Diff line change
`@@ -36,8 +36,8 @@`
`36`	`36`	`import org.springframework.core.task.SimpleAsyncTaskExecutor;`
`37`	`37`	`import org.springframework.scheduling.config.ScheduledTask;`
`38`	`38`	`import org.springframework.scheduling.config.ScheduledTaskHolder;`
`39`		`-import org.springframework.scheduling.config.ScheduledTaskObservationContext;`
`40`	`39`	`import org.springframework.scheduling.config.ScheduledTaskRegistrar;`
	`40`	`+import org.springframework.scheduling.support.ScheduledTaskObservationContext;`
`41`	`41`
`42`	`42`	`import static org.assertj.core.api.Assertions.assertThat;`
`43`	`43`
`@@ -55,11 +55,13 @@ class ScheduledAnnotationBeanPostProcessorObservabilityTests {`
`55`	`55`
`56`	`56`	`private final TestObservationRegistry observationRegistry = TestObservationRegistry.create();`
`57`	`57`
	`58`	`+`
`58`	`59`	`@AfterEach`
`59`	`60`	`void closeContext() {`
`60`	`61`	`context.close();`
`61`	`62`	`}`
`62`	`63`
	`64`	`+`
`63`	`65`	`@Test`
`64`	`66`	`void shouldRecordSuccessObservationsForTasks() throws Exception {`
`65`	`67`	`registerScheduledBean(FixedDelayBean.class);`
`@@ -185,6 +187,7 @@ private TestObservationRegistryAssert.TestObservationRegistryAssertReturningObse`
`185`	`187`	`.hasObservationWithNameEqualTo("tasks.scheduled.execution").that();`
`186`	`188`	`}`
`187`	`189`
	`190`	`+`
`188`	`191`	`static abstract class TaskTester {`
`189`	`192`
`190`	`193`	`ObservationRegistry observationRegistry;`
`@@ -200,13 +203,13 @@ public void await() throws InterruptedException {`
`200`	`203`	`}`
`201`	`204`	`}`
`202`	`205`
	`206`	`+`
`203`	`207`	`static class FixedDelayBean extends TaskTester {`
`204`	`208`
`205`	`209`	`@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)`
`206`	`210`	`public void fixedDelay() {`
`207`	`211`	`this.latch.countDown();`
`208`	`212`	`}`
`209`		`-`
`210`	`213`	`}`
`211`	`214`
`212`	`215`
`@@ -217,28 +220,28 @@ public void error() {`
`217`	`220`	`this.latch.countDown();`
`218`	`221`	`throw new IllegalStateException("test error");`
`219`	`222`	`}`
`220`		`-`
`221`	`223`	`}`
`222`	`224`
	`225`	`+`
`223`	`226`	`static class FixedDelayReactiveBean extends TaskTester {`
`224`	`227`
`225`	`228`	`@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)`
`226`	`229`	`public Mono<Object> fixedDelay() {`
`227`	`230`	`return Mono.empty().doOnTerminate(() -> this.latch.countDown());`
`228`	`231`	`}`
`229`		`-`
`230`	`232`	`}`
`231`	`233`
	`234`	`+`
`232`	`235`	`static class FixedDelayReactiveErrorBean extends TaskTester {`
`233`	`236`
`234`	`237`	`@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)`
`235`	`238`	`public Mono<Object> error() {`
`236`	`239`	`return Mono.error(new IllegalStateException("test error"))`
`237`	`240`	`.doOnTerminate(() -> this.latch.countDown());`
`238`	`241`	`}`
`239`		`-`
`240`	`242`	`}`
`241`	`243`
	`244`	`+`
`242`	`245`	`static class CancelledTaskBean extends TaskTester {`
`243`	`246`
`244`	`247`	`@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)`
`@@ -251,19 +254,19 @@ public void cancelled() {`
`251`	`254`	`// ignore cancelled task`
`252`	`255`	`}`
`253`	`256`	`}`
`254`		`-`
`255`	`257`	`}`
`256`	`258`
	`259`	`+`
`257`	`260`	`static class CancelledReactiveTaskBean extends TaskTester {`
`258`	`261`
`259`	`262`	`@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)`
`260`	`263`	`public Flux<Long> cancelled() {`
`261`	`264`	`return Flux.interval(Duration.ZERO, Duration.ofSeconds(1))`
`262`	`265`	`.doOnNext(el -> this.latch.countDown());`
`263`	`266`	`}`
`264`		`-`
`265`	`267`	`}`
`266`	`268`
	`269`	`+`
`267`	`270`	`static class CurrentObservationBean extends TaskTester {`
`268`	`271`
`269`	`272`	`@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)`
`@@ -272,9 +275,9 @@ public void hasCurrentObservation() {`
`272`	`275`	`assertThat(this.observationRegistry.getCurrentObservation().getContext()).isInstanceOf(ScheduledTaskObservationContext.class);`
`273`	`276`	`this.latch.countDown();`
`274`	`277`	`}`
`275`		`-`
`276`	`278`	`}`
`277`	`279`
	`280`	`+`
`278`	`281`	`static class CurrentObservationReactiveBean extends TaskTester {`
`279`	`282`
`280`	`283`	`@Scheduled(fixedDelay = 10_000, initialDelay = 5_000)`
`@@ -290,7 +293,6 @@ public void doFirst() throws Throwable {`
`290`	`293`	`})`
`291`	`294`	`.doOnTerminate(() -> this.latch.countDown());`
`292`	`295`	`}`
`293`		`-`
`294`	`296`	`}`
`295`	`297`
`296`	`298`	`}`