Attach repository interface name to each repository init event.

Make spring.data.repository.postprocessors conditional to reduce the number of events. Append full fragment diagnostics.

Author: mp911de

src/main/java/org/springframework/data/repository/core/support/RepositoryFactorySupport.java

@@ -277,28 +277,52 @@ public <T> T getRepository(Class<T> repositoryInterface, RepositoryFragments fra
 
 		ApplicationStartup applicationStartup = getStartup();
 
-		StartupStep repositoryInit = applicationStartup.start("spring.data.repository.init");
-		repositoryInit.tag("repository", () -> repositoryInterface.getName());
+		StartupStep repositoryInit = onEvent(applicationStartup, "spring.data.repository.init", repositoryInterface);
 
-		StartupStep repositoryMetadataStep = applicationStartup.start("spring.data.repository.metadata");
+		repositoryBaseClass.ifPresent(it -> repositoryInit.tag("baseClass", it.getName()));
+
+		StartupStep repositoryMetadataStep = onEvent(applicationStartup, "spring.data.repository.metadata",
+				repositoryInterface);
 		RepositoryMetadata metadata = getRepositoryMetadata(repositoryInterface);
 		repositoryMetadataStep.end();
 
-		StartupStep repositoryCompositionStep = applicationStartup.start("spring.data.repository.composition");
-		repositoryCompositionStep.tag("fragment.count", () -> String.valueOf(fragments.size()));
+		StartupStep repositoryCompositionStep = onEvent(applicationStartup, "spring.data.repository.composition",
+				repositoryInterface);
+		repositoryCompositionStep.tag("fragment.count", String.valueOf(fragments.size()));
 
 		RepositoryComposition composition = getRepositoryComposition(metadata, fragments);
 		RepositoryInformation information = getRepositoryInformation(metadata, composition);
+
+		repositoryCompositionStep.tag("fragments", () -> {
+
+			StringBuilder fragmentsTag = new StringBuilder();
+
+			for (RepositoryFragment<?> fragment : composition.getFragments()) {
+
+				if (fragmentsTag.length() > 0) {
+					fragmentsTag.append(";");
+				}
+
+				fragmentsTag.append(fragment.getSignatureContributor().getName());
+				fragmentsTag.append(fragment.getImplementation().map(it -> ":" + it.getClass().getName()).orElse(""));
+			}
+
+			return fragmentsTag.toString();
+		});
+
 		repositoryCompositionStep.end();
 
 		validate(information, composition);
 
-		StartupStep repositoryTargetStep = applicationStartup.start("spring.data.repository.target");
+		StartupStep repositoryTargetStep = onEvent(applicationStartup, "spring.data.repository.target",
+				repositoryInterface);
 		Object target = getTargetRepository(information);
+
+		repositoryTargetStep.tag("target", target.getClass().getName());
 		repositoryTargetStep.end();
 
 		// Create proxy
-		StartupStep repositoryProxyStep = applicationStartup.start("spring.data.repository.proxy");
+		StartupStep repositoryProxyStep = onEvent(applicationStartup, "spring.data.repository.proxy", repositoryInterface);
 		ProxyFactory result = new ProxyFactory();
 		result.setTarget(target);
 		result.setInterfaces(repositoryInterface, Repository.class, TransactionalProxy.class);
@@ -309,30 +333,33 @@ public <T> T getRepository(Class<T> repositoryInterface, RepositoryFragments fra
 
 		result.addAdvisor(ExposeInvocationInterceptor.ADVISOR);
 
-		StartupStep repositoryPostprocessorsStep = applicationStartup.start("spring.data.repository.postprocessors");
-		postProcessors.forEach(processor -> {
-
-			StartupStep singlePostProcessor = applicationStartup.start("spring.data.repository.postprocessor");
-			singlePostProcessor.tag("type", processor.getClass().getName());
-			processor.postProcess(result, information);
-			singlePostProcessor.end();
-		});
-		repositoryPostprocessorsStep.end();
+		if (!postProcessors.isEmpty()) {
+			StartupStep repositoryPostprocessorsStep = onEvent(applicationStartup, "spring.data.repository.postprocessors",
+					repositoryInterface);
+			postProcessors.forEach(processor -> {
+
+				StartupStep singlePostProcessor = onEvent(applicationStartup, "spring.data.repository.postprocessor",
+						repositoryInterface);
+				singlePostProcessor.tag("type", processor.getClass().getName());
+				processor.postProcess(result, information);
+				singlePostProcessor.end();
+			});
+			repositoryPostprocessorsStep.end();
+		}
 
 		if (DefaultMethodInvokingMethodInterceptor.hasDefaultMethods(repositoryInterface)) {
 			result.addAdvice(new DefaultMethodInvokingMethodInterceptor());
 		}
 
-		StartupStep queryExecutorsStep = applicationStartup.start("spring.data.repository.queryexecutors");
 		ProjectionFactory projectionFactory = getProjectionFactory(classLoader, beanFactory);
 		Optional<QueryLookupStrategy> queryLookupStrategy = getQueryLookupStrategy(queryLookupStrategyKey,
 				evaluationContextProvider);
 		result.addAdvice(new QueryExecutorMethodInterceptor(information, projectionFactory, queryLookupStrategy,
 				namedQueries, queryPostProcessors, methodInvocationListeners));
-		queryExecutorsStep.end();
 
-		composition = composition.append(RepositoryFragment.implemented(target));
-		result.addAdvice(new ImplementationMethodExecutionInterceptor(information, composition, methodInvocationListeners));
+		RepositoryComposition compositionToUse = composition.append(RepositoryFragment.implemented(target));
+		result.addAdvice(
+				new ImplementationMethodExecutionInterceptor(information, compositionToUse, methodInvocationListeners));
 
 		T repository = (T) result.getProxy(classLoader);
 		repositoryProxyStep.end();
@@ -359,6 +386,12 @@ ApplicationStartup getStartup() {
 		}
 	}
 
+	private StartupStep onEvent(ApplicationStartup applicationStartup, String name, Class<?> repositoryInterface) {
+
+		StartupStep step = applicationStartup.start(name);
+		return step.tag("repository", repositoryInterface.getName());
+	}
+
 	/**
 	 * Returns the {@link ProjectionFactory} to be used with the repository instances created.
 	 *

src/test/java/org/springframework/data/repository/core/support/RepositoryFactorySupportUnitTests.java

@@ -420,7 +420,6 @@ void callsApplicationStartupOnRepositoryInitialization() {
 		orderedInvocation.verify(startup).start("spring.data.repository.composition");
 		orderedInvocation.verify(startup).start("spring.data.repository.target");
 		orderedInvocation.verify(startup).start("spring.data.repository.proxy");
-		orderedInvocation.verify(startup).start("spring.data.repository.postprocessors");
 	}
 
 	private ConvertingRepository prepareConvertingRepository(final Object expectedValue) {