From 05461159eb2eed2827d34c35dc3d192d260fc06f Mon Sep 17 00:00:00 2001 From: buildmaster Date: Thu, 17 Sep 2020 05:29:17 +0000 Subject: [PATCH] Bumping versions --- .../cloud/sleuth/LocalServiceName.java | 3 +- ...stractSleuthMethodInvocationProcessor.java | 12 +- .../sleuth/annotation/DefaultSpanCreator.java | 9 +- ...eactorSleuthMethodInvocationProcessor.java | 10 +- ...eactorSleuthMethodInvocationProcessor.java | 61 +++--- .../annotation/SleuthAdvisorConfig.java | 18 +- .../annotation/SleuthAnnotationUtils.java | 16 +- .../SleuthMethodInvocationProcessor.java | 3 +- .../annotation/SpanTagAnnotationHandler.java | 39 ++-- .../SpelTagValueExpressionResolver.java | 12 +- .../sleuth/autoconfig/SleuthProperties.java | 6 +- .../autoconfig/SpanIgnoringSpanHandler.java | 9 +- .../autoconfig/TraceAutoConfiguration.java | 14 +- .../autoconfig/TraceBaggageConfiguration.java | 53 ++--- .../TraceEnvironmentPostProcessor.java | 13 +- .../async/AsyncCustomAutoConfiguration.java | 12 +- .../async/AsyncDefaultAutoConfiguration.java | 26 +-- .../async/ExecutorBeanPostProcessor.java | 111 ++++------- .../async/LazyTraceAsyncTaskExecutor.java | 9 +- .../instrument/async/LazyTraceExecutor.java | 9 +- .../LazyTraceScheduledThreadPoolExecutor.java | 157 ++++++--------- .../LazyTraceThreadPoolTaskExecutor.java | 38 ++-- .../LazyTraceThreadPoolTaskScheduler.java | 171 +++++++--------- .../async/SleuthContextListener.java | 6 +- .../instrument/async/TraceAsyncAspect.java | 3 +- .../TraceAsyncListenableTaskExecutor.java | 12 +- .../instrument/async/TraceCallable.java | 6 +- .../instrument/async/TraceRunnable.java | 6 +- .../async/TraceableExecutorService.java | 51 ++--- .../TraceableScheduledExecutorService.java | 47 ++--- ...SleuthCircuitBreakerAutoConfiguration.java | 6 +- .../circuitbreaker/TraceFunction.java | 3 +- .../circuitbreaker/TraceSupplier.java | 3 +- .../SpringAwareManagedChannelBuilder.java | 3 +- .../grpc/TraceGrpcAutoConfiguration.java | 3 +- ...racingManagedChannelBuilderCustomizer.java | 3 +- .../instrument/messaging/ConsumerSampler.java | 3 +- .../messaging/MessageHeaderPropagation.java | 36 ++-- .../messaging/MessagingSleuthOperators.java | 42 ++-- .../instrument/messaging/ProducerSampler.java | 3 +- .../SleuthKafkaStreamsConfiguration.java | 21 +- .../messaging/SleuthMessagingProperties.java | 3 +- .../TraceFunctionAutoConfiguration.java | 41 ++-- .../messaging/TraceMessageHandler.java | 55 ++---- .../messaging/TraceMessageHeaders.java | 4 +- .../TraceMessagingAutoConfiguration.java | 102 ++++------ ...aceSpringIntegrationAutoConfiguration.java | 32 ++- .../TraceWebSocketAutoConfiguration.java | 13 +- .../messaging/TracingChannelInterceptor.java | 85 +++----- ...ingConnectionFactoryBeanPostProcessor.java | 43 ++-- .../TracingMethodMessageHandlerAdapter.java | 9 +- .../TraceMongoDbAutoConfiguration.java | 9 +- .../quartz/TraceQuartzAutoConfiguration.java | 3 +- .../instrument/quartz/TracingJobListener.java | 9 +- .../instrument/reactor/ReactorSleuth.java | 30 ++- .../reactor/ScopePassingSpanSubscriber.java | 12 +- .../instrument/reactor/SpanSubscription.java | 3 +- .../TraceReactorAutoConfiguration.java | 54 ++--- .../redis/TraceRedisAutoConfiguration.java | 21 +- .../instrument/rpc/RpcClientSampler.java | 3 +- .../instrument/rpc/RpcServerSampler.java | 3 +- .../rpc/TraceRpcAutoConfiguration.java | 6 +- .../rxjava/RxJavaAutoConfiguration.java | 3 +- .../rxjava/SleuthRxJavaSchedulersHook.java | 22 +-- .../scheduling/TraceSchedulingAspect.java | 6 +- .../TraceSchedulingAutoConfiguration.java | 3 +- .../web/HttpClientRequestParser.java | 3 +- .../web/HttpClientResponseParser.java | 3 +- .../instrument/web/HttpClientSampler.java | 3 +- .../web/HttpServerRequestParser.java | 3 +- .../web/HttpServerResponseParser.java | 3 +- .../instrument/web/HttpServerSampler.java | 3 +- .../sleuth/instrument/web/ServletUtils.java | 3 +- .../web/SkipPatternConfiguration.java | 80 +++----- .../instrument/web/SleuthWebProperties.java | 3 +- .../web/TraceHttpAutoConfiguration.java | 22 +-- .../sleuth/instrument/web/TraceWebAspect.java | 10 +- .../sleuth/instrument/web/TraceWebFilter.java | 60 +++--- .../instrument/web/TraceWebMvcConfigurer.java | 3 +- .../web/TraceWebServletAutoConfiguration.java | 15 +- .../web/WebFluxSleuthOperators.java | 28 +-- .../client/HttpClientBeanPostProcessor.java | 36 ++-- .../TraceGatewayEnvironmentPostProcessor.java | 24 +-- .../client/TraceRequestHttpHeadersFilter.java | 23 +-- .../TraceWebAsyncClientAutoConfiguration.java | 3 +- .../TraceWebClientAutoConfiguration.java | 40 ++-- .../TraceWebClientBeanPostProcessor.java | 36 ++-- .../feign/FeignContextBeanPostProcessor.java | 6 +- .../web/client/feign/LazyClient.java | 3 +- .../client/feign/LazyTracingFeignClient.java | 8 +- .../OkHttpFeignClientBeanPostProcessor.java | 6 +- .../web/client/feign/TraceFeignAspect.java | 3 +- .../TraceFeignBlockingLoadBalancerClient.java | 13 +- .../TraceFeignClientAutoConfiguration.java | 9 +- .../web/client/feign/TraceFeignContext.java | 6 +- .../client/feign/TraceFeignObjectWrapper.java | 24 +-- .../web/client/feign/TracingFeignClient.java | 25 +-- .../sleuth/internal/DefaultSpanNamer.java | 3 +- .../cloud/sleuth/internal/LazyBean.java | 6 +- .../cloud/sleuth/internal/SpanNameUtil.java | 3 +- .../sampler/ProbabilityBasedSampler.java | 3 +- .../sampler/SamplerAutoConfiguration.java | 12 +- .../TracingJmsListenerEndpointRegistry.java | 38 ++-- ...PermitAllWebFluxSecurityConfiguration.java | 6 +- .../cloud/sleuth/SpanHandlerTests.java | 9 +- .../NullSpanTagAnnotationHandlerTests.java | 27 +-- ...hNewSpanParserAnnotationNoSleuthTests.java | 3 +- .../SleuthSpanCreatorAspectFluxTests.java | 52 ++--- .../SleuthSpanCreatorAspectMonoTests.java | 82 +++----- .../SleuthSpanCreatorAspectTests.java | 31 ++- ...uthSpanCreatorCircularDependencyTests.java | 3 +- .../SpanTagAnnotationHandlerTests.java | 28 +-- .../SpelTagValueExpressionResolverTests.java | 3 +- .../SpanIgnoringSpanHandlerTests.java | 26 +-- ...raceAutoConfigurationCustomizersTests.java | 17 +- ...gurationPropagationCustomizationTests.java | 28 ++- .../TraceAutoConfigurationTests.java | 40 ++-- ...oConfigurationWithDisabledSleuthTests.java | 3 +- .../TraceBaggageConfigurationTests.java | 126 +++++------- .../baggage/BaggageTagSpanHandlerTest.java | 3 +- .../CorrelationScopeDecoratorTest.java | 23 +-- .../SpringCloudSleuthDocTests.java | 28 +-- .../DefaultTestAutoConfiguration.java | 3 +- .../AsyncCustomAutoConfigurationTest.java | 9 +- .../AsyncDefaultAutoConfigurationTests.java | 3 +- .../instrument/async/AsyncDisabledTests.java | 3 +- .../async/ExecutorBeanPostProcessorTests.java | 164 ++++++---------- ...TraceScheduledThreadPoolExecutorTests.java | 3 +- ...LazyTraceThreadPoolTaskSchedulerTests.java | 75 +++---- .../async/SleuthContextListenerAccessor.java | 4 +- .../async/SleuthContextListenerTest.java | 6 +- .../async/TraceAsyncAspectTest.java | 10 +- .../TraceAsyncListenableTaskExecutorTest.java | 21 +- .../instrument/async/TraceCallableTests.java | 27 +-- .../instrument/async/TraceRunnableTests.java | 27 +-- .../async/TraceableExecutorServiceTests.java | 63 +++--- ...TraceableScheduledExecutorServiceTest.java | 73 +++---- .../CircuitBreakerIntegrationTests.java | 12 +- .../circuitbreaker/CircuitBreakerTests.java | 23 +-- .../KafkaFactoryBeanPostProcessorTests.java | 3 +- .../MessageHeaderPropagationTest.java | 9 +- .../MessageHeaderPropagation_NativeTest.java | 3 +- ...aStreamsConfigurationIntegrationTests.java | 22 +-- ...gingAutoConfigurationIntegrationTests.java | 6 +- ...ringIntegrationAutoConfigurationTests.java | 15 +- .../TracingChannelInterceptorTest.java | 133 +++++-------- .../TraceMongoDbAutoConfigurationTests.java | 18 +- .../instrument/multiple/DemoApplication.java | 3 +- .../MultipleHopsIntegrationTests.java | 38 ++-- .../opentracing/OpenTracingTest.java | 78 +++----- .../TraceQuartzAutoConfigurationTest.java | 5 +- .../quartz/TracingJobListenerTest.java | 55 ++---- ...utoConfigurationAccessorConfiguration.java | 3 +- ...eRpcAutoConfigurationIntegrationTests.java | 6 +- .../rpc/TraceRpcAutoConfigurationTests.java | 31 ++- .../TraceSchedulingAutoConfigurationTest.java | 14 +- .../web/CompositeHttpSamplerTests.java | 9 +- ...onfiguredSkipPatternsIntegrationTests.java | 14 +- ...ationTestsWithContextPathWithBasePath.java | 13 +- ...onTestsWithContextPathWithoutBasePath.java | 21 +- ...onTestsWithoutContextPathWithBasePath.java | 15 +- ...estsWithoutContextPathWithoutBasePath.java | 18 +- .../web/SkipPatternProviderConfigTest.java | 184 ++++++------------ .../instrument/web/TraceFilterTests.java | 75 +++---- .../web/TraceHttpAutoConfigurationTests.java | 114 ++++------- .../web/TraceNoWebEnvironmentTests.java | 3 +- .../TraceRestTemplateInterceptorTests.java | 40 ++-- .../web/TraceWebClientDisabledTests.java | 4 +- .../instrument/web/client/GH846Tests.java | 6 +- .../HttpClientBeanPostProcessorTest.java | 15 +- .../MultipleAsyncRestTemplateTests.java | 22 +-- ...ReactorNettyHttpClientSpringBootTests.java | 39 ++-- .../TraceRequestHttpHeadersFilterTests.java | 71 ++----- .../TraceResponseHttpHeadersFilterTests.java | 19 +- ...stTemplateInterceptorIntegrationTests.java | 17 +- .../TraceWebClientAutoConfigurationTests.java | 32 ++- .../TraceWebClientBeanPostProcessorTest.java | 26 +-- .../WebClientDiscoveryExceptionTests.java | 10 +- .../exception/WebClientExceptionTests.java | 13 +- .../web/client/feign/FeignRetriesTests.java | 27 ++- .../client/feign/TraceFeignAspectTests.java | 9 +- .../client/feign/TracingFeignClientTests.java | 26 ++- .../feign/TracingFeignObjectWrapperTests.java | 28 +-- .../client/integration/WebClientTests.java | 160 +++++++-------- .../cloud/sleuth/internal/LazyBeanTests.java | 6 +- .../sleuth/internal/SpanNameUtilTests.java | 6 +- .../sampler/ProbabilityBasedSamplerTests.java | 16 +- .../SamplerAutoConfigurationTests.java | 35 ++-- .../sample/SampleFeignApplicationTests.java | 3 +- .../src/main/java/sample/SampleService.java | 6 +- .../IntegrationTestZipkinSpanHandler.java | 3 +- .../MessagingApplicationTests.java | 64 +++--- .../java/tools/AbstractIntegrationTest.java | 9 +- .../java/tools/AssertingRestTemplate.java | 8 +- .../java/tools/RequestSendingRunnable.java | 14 +- .../src/main/java/tools/SpanUtil.java | 3 +- .../main/java/sample/SampleController.java | 12 +- .../test/java/integration/ZipkinTests.java | 43 ++-- .../main/java/sample/SampleController.java | 15 +- .../zipkin2/DefaultEndpointLocator.java | 14 +- .../DefaultZipkinRestTemplateCustomizer.java | 4 +- .../zipkin2/ZipkinAutoConfiguration.java | 54 +++-- .../LoadBalancerClientZipkinLoadBalancer.java | 3 +- .../zipkin2/sender/RestTemplateSender.java | 10 +- .../ZipkinActiveMqSenderConfiguration.java | 4 +- .../ZipkinKafkaSenderConfiguration.java | 3 +- .../ZipkinRabbitSenderConfiguration.java | 9 +- ...ZipkinRestTemplateSenderConfiguration.java | 36 ++-- .../zipkin2/sender/ZipkinSenderCondition.java | 9 +- ...pkinSenderConfigurationImportSelector.java | 3 +- ...faultEndpointLocatorConfigurationTest.java | 79 ++++---- .../zipkin2/ZipkinAutoConfigurationTests.java | 140 +++++-------- .../zipkin2/ZipkinDiscoveryClientTests.java | 32 ++- .../sender/RestTemplateSenderTest.java | 25 +-- ...inRestTemplateSenderConfigurationTest.java | 34 ++-- .../async/DefaultTestAutoConfiguration.java | 3 +- .../async/TraceAsyncIntegrationTests.java | 10 +- .../async/issues/issue410/Issue410Tests.java | 118 +++++------ .../async/issues/issue546/Issue546Tests.java | 19 +- ...lyCreatedLoadBalancerFeignClientTests.java | 9 +- ...dDelegateLoadBalancerFeignClientTests.java | 18 +- .../feign/issues/issue307/Issue307Tests.java | 8 +- .../feign/issues/issue362/Issue362Tests.java | 26 +-- .../feign/issues/issue393/Issue393Tests.java | 10 +- .../feign/issues/issue502/Issue502Tests.java | 9 +- .../grpc/GrpcTracingIntegrationTests.java | 21 +- .../instrument/grpc/stubs/HelloReply.java | 88 +++------ .../instrument/grpc/stubs/HelloRequest.java | 88 +++------ .../grpc/stubs/HelloServiceGrpc.java | 90 +++------ .../grpc/stubs/HelloServiceOuterClass.java | 34 ++-- .../TraceRedisAutoConfigurationTests.java | 9 +- .../ITTracingChannelInterceptorTests.java | 28 +-- .../JmsTracingConfigurationTest.java | 17 +- .../SleuthKafkaStreamsConfigurationTest.java | 3 +- .../messaging/StreamFunctionAdapterTests.java | 13 +- .../StreamMessageOperatorsTests.java | 52 ++--- ...extPropagationChannelInterceptorTests.java | 3 +- ...ceMessagingAutoConfiguration1664Tests.java | 3 +- .../TraceMessagingAutoConfigurationTests.java | 47 ++--- .../TraceStreamChannelInterceptorTests.java | 6 +- .../TraceWebSocketAutoConfigurationTests.java | 15 +- .../issue_943/HelloSpringIntegration.java | 3 +- .../issue_943/HelloWorldRestController.java | 12 +- .../issues/issue_943/Issue943Tests.java | 33 ++-- .../sleuth/instrument/util/SpanUtil.java | 3 +- .../web/AbstractMvcIntegrationTest.java | 3 +- .../web/TraceAsyncIntegrationTests.java | 32 ++- ...raceCustomFilterResponseInjectorTests.java | 23 +-- .../web/TraceFilterIntegrationTests.java | 93 ++++----- ...terWebIntegrationMultipleFiltersTests.java | 4 +- .../web/TraceFilterWebIntegrationTests.java | 48 ++--- .../instrument/web/TraceWebDisabledTests.java | 3 +- ...stTemplateTraceAspectIntegrationTests.java | 84 +++----- ...eWebAsyncClientAutoConfigurationTests.java | 23 +-- .../exceptionresolver/Issue585Tests.java | 25 +-- .../instrument/web/view/Issue469Tests.java | 9 +- .../cloud/sleuth/util/SpanUtil.java | 3 +- .../FlowsScopePassingSpanSubscriberTests.java | 18 +- .../reactor/Issue866Configuration.java | 10 +- ...ePassingSpanSubscriberSpringBootTests.java | 48 ++--- .../ScopePassingSpanSubscriberTests.java | 44 ++--- ...utoConfigurationAccessorConfiguration.java | 3 +- .../reactor/sample/FlatMapTests.java | 88 +++------ .../reactor/sample/ManualRequestSender.java | 29 ++- .../reactor/sample/RequestSender.java | 3 +- .../ITSpringConfiguredReactorClient.java | 24 +-- .../ReactorNettyHttpClientBraveTests.java | 14 +- .../client/TestHttpCallbackSubscriber.java | 3 +- .../web/client/WebClientBraveTests.java | 25 +-- ...eRpcAutoConfigurationIntegrationTests.java | 6 +- .../SleuthRxJavaSchedulersHookTests.java | 17 +- .../instrument/rxjava/SleuthRxJavaTests.java | 13 +- .../scheduling/TracingOnScheduledTests.java | 23 +-- .../sleuth/instrument/web/GH1102Tests.java | 7 +- .../instrument/web/TraceWebFluxTests.java | 64 +++--- .../cloud/sleuth/util/SpanUtil.java | 3 +- 276 files changed, 2590 insertions(+), 4452 deletions(-) diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/LocalServiceName.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/LocalServiceName.java index 05752b45f..04dafecf2 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/LocalServiceName.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/LocalServiceName.java @@ -30,8 +30,7 @@ import org.springframework.beans.factory.annotation.Value; * @author Marcin Grzejszczak * @since 2.2.0 */ -@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, - ElementType.ANNOTATION_TYPE }) +@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE }) @Retention(RetentionPolicy.RUNTIME) @Documented @Value("${spring.zipkin.service.name:${spring.application.name:default}}") diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/AbstractSleuthMethodInvocationProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/AbstractSleuthMethodInvocationProcessor.java index 7c3aeebaa..f598e8975 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/AbstractSleuthMethodInvocationProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/AbstractSleuthMethodInvocationProcessor.java @@ -32,11 +32,9 @@ import org.springframework.beans.factory.BeanFactoryAware; * * @author Marcin Grzejszczak */ -abstract class AbstractSleuthMethodInvocationProcessor - implements SleuthMethodInvocationProcessor, BeanFactoryAware { +abstract class AbstractSleuthMethodInvocationProcessor implements SleuthMethodInvocationProcessor, BeanFactoryAware { - private static final Log logger = LogFactory - .getLog(AbstractSleuthMethodInvocationProcessor.class); + private static final Log logger = LogFactory.getLog(AbstractSleuthMethodInvocationProcessor.class); private static final String CLASS_KEY = "class"; @@ -110,8 +108,7 @@ abstract class AbstractSleuthMethodInvocationProcessor CurrentTraceContext currentTraceContext() { if (this.currentTraceContext == null) { - this.currentTraceContext = this.beanFactory - .getBean(CurrentTraceContext.class); + this.currentTraceContext = this.beanFactory.getBean(CurrentTraceContext.class); } return this.currentTraceContext; } @@ -125,8 +122,7 @@ abstract class AbstractSleuthMethodInvocationProcessor SpanTagAnnotationHandler spanTagAnnotationHandler() { if (this.spanTagAnnotationHandler == null) { - this.spanTagAnnotationHandler = new SpanTagAnnotationHandler( - this.beanFactory); + this.spanTagAnnotationHandler = new SpanTagAnnotationHandler(this.beanFactory); } return this.spanTagAnnotationHandler; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/DefaultSpanCreator.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/DefaultSpanCreator.java index d4e963307..42103d946 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/DefaultSpanCreator.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/DefaultSpanCreator.java @@ -36,13 +36,12 @@ class DefaultSpanCreator implements NewSpanParser { @Override public void parse(MethodInvocation pjp, NewSpan newSpan, SpanCustomizer span) { - String name = newSpan == null || StringUtils.isEmpty(newSpan.name()) - ? pjp.getMethod().getName() : newSpan.name(); + String name = newSpan == null || StringUtils.isEmpty(newSpan.name()) ? pjp.getMethod().getName() + : newSpan.name(); String changedName = SpanNameUtil.toLowerHyphen(name); if (log.isDebugEnabled()) { - log.debug("For the class [" + pjp.getThis().getClass() + "] method " + "[" - + pjp.getMethod().getName() + "] will name the span [" + changedName - + "]"); + log.debug("For the class [" + pjp.getThis().getClass() + "] method " + "[" + pjp.getMethod().getName() + + "] will name the span [" + changedName + "]"); } span.name(changedName); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/NonReactorSleuthMethodInvocationProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/NonReactorSleuthMethodInvocationProcessor.java index a91ecaf87..2033cf69c 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/NonReactorSleuthMethodInvocationProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/NonReactorSleuthMethodInvocationProcessor.java @@ -28,17 +28,15 @@ import org.springframework.util.StringUtils; * @author Marcin Grzejszczak * @since 2.1.0 */ -class NonReactorSleuthMethodInvocationProcessor - extends AbstractSleuthMethodInvocationProcessor { +class NonReactorSleuthMethodInvocationProcessor extends AbstractSleuthMethodInvocationProcessor { @Override - public Object process(MethodInvocation invocation, NewSpan newSpan, - ContinueSpan continueSpan) throws Throwable { + public Object process(MethodInvocation invocation, NewSpan newSpan, ContinueSpan continueSpan) throws Throwable { return proceedUnderSynchronousSpan(invocation, newSpan, continueSpan); } - private Object proceedUnderSynchronousSpan(MethodInvocation invocation, - NewSpan newSpan, ContinueSpan continueSpan) throws Throwable { + private Object proceedUnderSynchronousSpan(MethodInvocation invocation, NewSpan newSpan, ContinueSpan continueSpan) + throws Throwable { Span span = tracer().currentSpan(); // in case of @ContinueSpan and no span in tracer we start new span and should // close it on completion diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/ReactorSleuthMethodInvocationProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/ReactorSleuthMethodInvocationProcessor.java index c98d9c611..803e938ea 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/ReactorSleuthMethodInvocationProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/ReactorSleuthMethodInvocationProcessor.java @@ -44,8 +44,7 @@ import org.springframework.util.StringUtils; * @author Marcin Grzejszczak * @since 2.1.0 */ -class ReactorSleuthMethodInvocationProcessor - extends AbstractSleuthMethodInvocationProcessor { +class ReactorSleuthMethodInvocationProcessor extends AbstractSleuthMethodInvocationProcessor { Tracing tracing; @@ -59,21 +58,19 @@ class ReactorSleuthMethodInvocationProcessor } @Override - public Object process(MethodInvocation invocation, NewSpan newSpan, - ContinueSpan continueSpan) throws Throwable { + public Object process(MethodInvocation invocation, NewSpan newSpan, ContinueSpan continueSpan) throws Throwable { Method method = invocation.getMethod(); if (isReactorReturnType(method.getReturnType())) { return proceedUnderReactorSpan(invocation, newSpan, continueSpan); } else { - return nonReactorSleuthMethodInvocationProcessor().process(invocation, - newSpan, continueSpan); + return nonReactorSleuthMethodInvocationProcessor().process(invocation, newSpan, continueSpan); } } @SuppressWarnings("unchecked") - private Object proceedUnderReactorSpan(MethodInvocation invocation, NewSpan newSpan, - ContinueSpan continueSpan) throws Throwable { + private Object proceedUnderReactorSpan(MethodInvocation invocation, NewSpan newSpan, ContinueSpan continueSpan) + throws Throwable { Span spanPrevious = tracer().currentSpan(); // in case of @ContinueSpan and no span in tracer we start new span and should // close it on completion @@ -89,16 +86,13 @@ class ReactorSleuthMethodInvocationProcessor Publisher publisher = (Publisher) invocation.proceed(); if (publisher instanceof Mono) { - return new MonoSpan((Mono) publisher, this, newSpan, span, invocation, - log); + return new MonoSpan((Mono) publisher, this, newSpan, span, invocation, log); } else if (publisher instanceof Flux) { - return new FluxSpan((Flux) publisher, this, newSpan, span, invocation, - log); + return new FluxSpan((Flux) publisher, this, newSpan, span, invocation, log); } else { - throw new IllegalArgumentException( - "Unexpected type of publisher: " + publisher.getClass()); + throw new IllegalArgumentException("Unexpected type of publisher: " + publisher.getClass()); } } @@ -109,8 +103,7 @@ class ReactorSleuthMethodInvocationProcessor private NonReactorSleuthMethodInvocationProcessor nonReactorSleuthMethodInvocationProcessor() { if (this.nonReactorSleuthMethodInvocationProcessor == null) { this.nonReactorSleuthMethodInvocationProcessor = new NonReactorSleuthMethodInvocationProcessor(); - this.nonReactorSleuthMethodInvocationProcessor - .setBeanFactory(this.beanFactory); + this.nonReactorSleuthMethodInvocationProcessor.setBeanFactory(this.beanFactory); } return this.nonReactorSleuthMethodInvocationProcessor; } @@ -129,9 +122,8 @@ class ReactorSleuthMethodInvocationProcessor final NewSpan newSpan; - FluxSpan(Flux source, ReactorSleuthMethodInvocationProcessor processor, - NewSpan newSpan, @Nullable Span span, MethodInvocation invocation, - String log) { + FluxSpan(Flux source, ReactorSleuthMethodInvocationProcessor processor, NewSpan newSpan, + @Nullable Span span, MethodInvocation invocation, String log) { super(source); this.span = span; this.newSpan = newSpan; @@ -155,10 +147,9 @@ class ReactorSleuthMethodInvocationProcessor else { span = this.span; } - try (Scope ws = this.processor.currentTraceContext() - .maybeScope(span.context())) { - this.source.subscribe(new SpanSubscriber(actual, this.processor, - this.invocation, this.span == null, span, this.log, this.hasLog)); + try (Scope ws = this.processor.currentTraceContext().maybeScope(span.context())) { + this.source.subscribe(new SpanSubscriber(actual, this.processor, this.invocation, this.span == null, + span, this.log, this.hasLog)); } } @@ -178,9 +169,8 @@ class ReactorSleuthMethodInvocationProcessor final NewSpan newSpan; - MonoSpan(Mono source, ReactorSleuthMethodInvocationProcessor processor, - NewSpan newSpan, @Nullable Span span, MethodInvocation invocation, - String log) { + MonoSpan(Mono source, ReactorSleuthMethodInvocationProcessor processor, NewSpan newSpan, + @Nullable Span span, MethodInvocation invocation, String log) { super(source); this.processor = processor; this.newSpan = newSpan; @@ -202,17 +192,15 @@ class ReactorSleuthMethodInvocationProcessor else { span = this.span; } - try (Scope ws = this.processor.currentTraceContext() - .maybeScope(span.context())) { - this.source.subscribe(new SpanSubscriber(actual, this.processor, - this.invocation, this.span == null, span, this.log, this.hasLog)); + try (Scope ws = this.processor.currentTraceContext().maybeScope(span.context())) { + this.source.subscribe(new SpanSubscriber(actual, this.processor, this.invocation, this.span == null, + span, this.log, this.hasLog)); } } } - private static final class SpanSubscriber - implements CoreSubscriber, Subscription, Scannable { + private static final class SpanSubscriber implements CoreSubscriber, Subscription, Scannable { final CoreSubscriber actual; @@ -232,10 +220,8 @@ class ReactorSleuthMethodInvocationProcessor Subscription parent; - SpanSubscriber(CoreSubscriber actual, - ReactorSleuthMethodInvocationProcessor processor, - MethodInvocation invocation, boolean isNewSpan, Span span, String log, - boolean hasLog) { + SpanSubscriber(CoreSubscriber actual, ReactorSleuthMethodInvocationProcessor processor, + MethodInvocation invocation, boolean isNewSpan, Span span, String log, boolean hasLog) { this.actual = actual; this.isNewSpan = isNewSpan; this.span = span; @@ -244,8 +230,7 @@ class ReactorSleuthMethodInvocationProcessor this.processor = processor; this.currentTraceContext = processor.tracing().currentTraceContext(); - this.context = actual.currentContext().put(TraceContext.class, - span.context()); + this.context = actual.currentContext().put(TraceContext.class, span.context()); processor.before(invocation, this.span, this.log, this.hasLog); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAdvisorConfig.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAdvisorConfig.java index 723eb1ff0..6efd69075 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAdvisorConfig.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAdvisorConfig.java @@ -120,8 +120,7 @@ class SleuthAdvisorConfig extends AbstractPointcutAdvisor implements BeanFactory /** * Checks if a class or a method is is annotated with Sleuth related annotations. */ - private final class AnnotationClassOrMethodOrArgsPointcut - extends DynamicMethodMatcherPointcut { + private final class AnnotationClassOrMethodOrArgsPointcut extends DynamicMethodMatcherPointcut { @Override public boolean matches(Method method, Class targetClass, Object... args) { @@ -136,8 +135,7 @@ class SleuthAdvisorConfig extends AbstractPointcutAdvisor implements BeanFactory @Override public boolean matches(Class clazz) { return new AnnotationClassOrMethodFilter(NewSpan.class).matches(clazz) - || new AnnotationClassOrMethodFilter(ContinueSpan.class) - .matches(clazz); + || new AnnotationClassOrMethodFilter(ContinueSpan.class).matches(clazz); } }; } @@ -180,12 +178,9 @@ class SleuthInterceptor implements IntroductionInterceptor, BeanFactoryAware { if (method == null) { return invocation.proceed(); } - Method mostSpecificMethod = AopUtils.getMostSpecificMethod(method, - invocation.getThis().getClass()); - NewSpan newSpan = SleuthAnnotationUtils.findAnnotation(mostSpecificMethod, - NewSpan.class); - ContinueSpan continueSpan = SleuthAnnotationUtils - .findAnnotation(mostSpecificMethod, ContinueSpan.class); + Method mostSpecificMethod = AopUtils.getMostSpecificMethod(method, invocation.getThis().getClass()); + NewSpan newSpan = SleuthAnnotationUtils.findAnnotation(mostSpecificMethod, NewSpan.class); + ContinueSpan continueSpan = SleuthAnnotationUtils.findAnnotation(mostSpecificMethod, ContinueSpan.class); if (newSpan == null && continueSpan == null) { return invocation.proceed(); } @@ -194,8 +189,7 @@ class SleuthInterceptor implements IntroductionInterceptor, BeanFactoryAware { private SleuthMethodInvocationProcessor methodInvocationProcessor() { if (this.methodInvocationProcessor == null) { - this.methodInvocationProcessor = this.beanFactory - .getBean(SleuthMethodInvocationProcessor.class); + this.methodInvocationProcessor = this.beanFactory.getBean(SleuthMethodInvocationProcessor.class); } return this.methodInvocationProcessor; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAnnotationUtils.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAnnotationUtils.java index d6e9be365..5144100ca 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAnnotationUtils.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthAnnotationUtils.java @@ -42,24 +42,21 @@ final class SleuthAnnotationUtils { } static boolean isMethodAnnotated(Method method) { - return findAnnotation(method, NewSpan.class) != null - || findAnnotation(method, ContinueSpan.class) != null; + return findAnnotation(method, NewSpan.class) != null || findAnnotation(method, ContinueSpan.class) != null; } static boolean hasAnnotatedParams(Method method, Object[] args) { return !findAnnotatedParameters(method, args).isEmpty(); } - static List findAnnotatedParameters(Method method, - Object[] args) { + static List findAnnotatedParameters(Method method, Object[] args) { Annotation[][] parameters = method.getParameterAnnotations(); List result = new ArrayList<>(); int i = 0; for (Annotation[] parameter : parameters) { for (Annotation parameter2 : parameter) { if (parameter2 instanceof SpanTag) { - result.add(new SleuthAnnotatedParameter(i, (SpanTag) parameter2, - args[i])); + result.add(new SleuthAnnotatedParameter(i, (SpanTag) parameter2, args[i])); } } i++; @@ -78,13 +75,12 @@ final class SleuthAnnotationUtils { T annotation = AnnotationUtils.findAnnotation(method, clazz); if (annotation == null) { try { - annotation = AnnotationUtils.findAnnotation(method.getDeclaringClass() - .getMethod(method.getName(), method.getParameterTypes()), clazz); + annotation = AnnotationUtils.findAnnotation( + method.getDeclaringClass().getMethod(method.getName(), method.getParameterTypes()), clazz); } catch (NoSuchMethodException | SecurityException ex) { if (log.isDebugEnabled()) { - log.debug("Exception occurred while tyring to find the annotation", - ex); + log.debug("Exception occurred while tyring to find the annotation", ex); } } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthMethodInvocationProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthMethodInvocationProcessor.java index 18cefc470..8c802efe6 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthMethodInvocationProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SleuthMethodInvocationProcessor.java @@ -26,7 +26,6 @@ import org.aopalliance.intercept.MethodInvocation; */ interface SleuthMethodInvocationProcessor { - Object process(MethodInvocation invocation, NewSpan newSpan, - ContinueSpan continueSpan) throws Throwable; + Object process(MethodInvocation invocation, NewSpan newSpan, ContinueSpan continueSpan) throws Throwable; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SpanTagAnnotationHandler.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SpanTagAnnotationHandler.java index 319485ca6..957de3d51 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SpanTagAnnotationHandler.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SpanTagAnnotationHandler.java @@ -56,13 +56,11 @@ class SpanTagAnnotationHandler { void addAnnotatedParameters(MethodInvocation pjp) { try { Method method = pjp.getMethod(); - Method mostSpecificMethod = AopUtils.getMostSpecificMethod(method, - pjp.getThis().getClass()); + Method mostSpecificMethod = AopUtils.getMostSpecificMethod(method, pjp.getThis().getClass()); List annotatedParameters = SleuthAnnotationUtils .findAnnotatedParameters(mostSpecificMethod, pjp.getArguments()); getAnnotationsFromInterfaces(pjp, mostSpecificMethod, annotatedParameters); - mergeAnnotatedMethodsIfNecessary(pjp, method, mostSpecificMethod, - annotatedParameters); + mergeAnnotatedMethodsIfNecessary(pjp, method, mostSpecificMethod, annotatedParameters); addAnnotatedArguments(annotatedParameters); } catch (SecurityException ex) { @@ -70,8 +68,7 @@ class SpanTagAnnotationHandler { } } - private void getAnnotationsFromInterfaces(MethodInvocation pjp, - Method mostSpecificMethod, + private void getAnnotationsFromInterfaces(MethodInvocation pjp, Method mostSpecificMethod, List annotatedParameters) { Class[] implementedInterfaces = pjp.getThis().getClass().getInterfaces(); if (implementedInterfaces.length > 0) { @@ -79,10 +76,8 @@ class SpanTagAnnotationHandler { for (Method methodFromInterface : implementedInterface.getMethods()) { if (methodsAreTheSame(mostSpecificMethod, methodFromInterface)) { List annotatedParametersForActualMethod = SleuthAnnotationUtils - .findAnnotatedParameters(methodFromInterface, - pjp.getArguments()); - mergeAnnotatedParameters(annotatedParameters, - annotatedParametersForActualMethod); + .findAnnotatedParameters(methodFromInterface, pjp.getArguments()); + mergeAnnotatedParameters(annotatedParameters, annotatedParametersForActualMethod); } } } @@ -90,25 +85,22 @@ class SpanTagAnnotationHandler { } private boolean methodsAreTheSame(Method mostSpecificMethod, Method method1) { - return method1.getName().equals(mostSpecificMethod.getName()) && Arrays.equals( - method1.getParameterTypes(), mostSpecificMethod.getParameterTypes()); + return method1.getName().equals(mostSpecificMethod.getName()) + && Arrays.equals(method1.getParameterTypes(), mostSpecificMethod.getParameterTypes()); } - private void mergeAnnotatedMethodsIfNecessary(MethodInvocation pjp, Method method, - Method mostSpecificMethod, + private void mergeAnnotatedMethodsIfNecessary(MethodInvocation pjp, Method method, Method mostSpecificMethod, List annotatedParameters) { // that can happen if we have an abstraction and a concrete class that is // annotated with @NewSpan annotation if (!method.equals(mostSpecificMethod)) { List annotatedParametersForActualMethod = SleuthAnnotationUtils .findAnnotatedParameters(method, pjp.getArguments()); - mergeAnnotatedParameters(annotatedParameters, - annotatedParametersForActualMethod); + mergeAnnotatedParameters(annotatedParameters, annotatedParametersForActualMethod); } } - private void mergeAnnotatedParameters( - List annotatedParametersIndices, + private void mergeAnnotatedParameters(List annotatedParametersIndices, List annotatedParametersIndicesForActualMethod) { for (SleuthAnnotatedParameter container : annotatedParametersIndicesForActualMethod) { final int index = container.parameterIndex; @@ -141,20 +133,19 @@ class SpanTagAnnotationHandler { } private String resolveTagKey(SleuthAnnotatedParameter container) { - return StringUtils.hasText(container.annotation.value()) - ? container.annotation.value() : container.annotation.key(); + return StringUtils.hasText(container.annotation.value()) ? container.annotation.value() + : container.annotation.key(); } String resolveTagValue(SpanTag annotation, Object argument) { String value = null; if (annotation.resolver() != NoOpTagValueResolver.class) { - TagValueResolver tagValueResolver = this.beanFactory - .getBean(annotation.resolver()); + TagValueResolver tagValueResolver = this.beanFactory.getBean(annotation.resolver()); value = tagValueResolver.resolve(argument); } else if (StringUtils.hasText(annotation.expression())) { - value = this.beanFactory.getBean(TagValueExpressionResolver.class) - .resolve(annotation.expression(), argument); + value = this.beanFactory.getBean(TagValueExpressionResolver.class).resolve(annotation.expression(), + argument); } else if (argument != null) { value = argument.toString(); diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SpelTagValueExpressionResolver.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SpelTagValueExpressionResolver.java index 5b45b8f29..e01021dcd 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SpelTagValueExpressionResolver.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/annotation/SpelTagValueExpressionResolver.java @@ -33,22 +33,18 @@ import org.springframework.expression.spel.support.SimpleEvaluationContext; */ class SpelTagValueExpressionResolver implements TagValueExpressionResolver { - private static final Log log = LogFactory - .getLog(SpelTagValueExpressionResolver.class); + private static final Log log = LogFactory.getLog(SpelTagValueExpressionResolver.class); @Override public String resolve(String expression, Object parameter) { try { - SimpleEvaluationContext context = SimpleEvaluationContext - .forReadOnlyDataBinding().build(); + SimpleEvaluationContext context = SimpleEvaluationContext.forReadOnlyDataBinding().build(); ExpressionParser expressionParser = new SpelExpressionParser(); - Expression expressionToEvaluate = expressionParser - .parseExpression(expression); + Expression expressionToEvaluate = expressionParser.parseExpression(expression); return expressionToEvaluate.getValue(context, parameter, String.class); } catch (Exception ex) { - log.error("Exception occurred while tying to evaluate the SPEL expression [" - + expression + "]", ex); + log.error("Exception occurred while tying to evaluate the SPEL expression [" + expression + "]", ex); } return parameter.toString(); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/SleuthProperties.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/SleuthProperties.java index b9b1dc3f5..0666b3fe3 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/SleuthProperties.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/SleuthProperties.java @@ -93,8 +93,7 @@ class SleuthProperties { /** * List of span names to ignore. They will not be sent to external systems. */ - private List spanNamePatternsToSkip = Arrays - .asList("^catalogWatchTaskScheduler$"); + private List spanNamePatternsToSkip = Arrays.asList("^catalogWatchTaskScheduler$"); /** * Additional list of span names to ignore. Will be appended to @@ -122,8 +121,7 @@ class SleuthProperties { return this.additionalSpanNamePatternsToIgnore; } - public void setAdditionalSpanNamePatternsToIgnore( - List additionalSpanNamePatternsToIgnore) { + public void setAdditionalSpanNamePatternsToIgnore(List additionalSpanNamePatternsToIgnore) { this.additionalSpanNamePatternsToIgnore = additionalSpanNamePatternsToIgnore; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/SpanIgnoringSpanHandler.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/SpanIgnoringSpanHandler.java index b1e272e6a..b20308608 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/SpanIgnoringSpanHandler.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/SpanIgnoringSpanHandler.java @@ -56,8 +56,7 @@ class SpanIgnoringSpanHandler extends SpanHandler { } List spanNamesToIgnore = spanNamesToIgnore(); String name = span.name(); - if (StringUtils.hasText(name) - && spanNamesToIgnore.stream().anyMatch(p -> p.matcher(name).matches())) { + if (StringUtils.hasText(name) && spanNamesToIgnore.stream().anyMatch(p -> p.matcher(name).matches())) { if (log.isDebugEnabled()) { log.debug("Will ignore a span with name [" + name + "]"); } @@ -67,16 +66,14 @@ class SpanIgnoringSpanHandler extends SpanHandler { } private List spanNamesToIgnore() { - return spanNames().stream() - .map(regex -> cache.computeIfAbsent(regex, Pattern::compile)) + return spanNames().stream().map(regex -> cache.computeIfAbsent(regex, Pattern::compile)) .collect(Collectors.toList()); } private List spanNames() { List spanNamesToIgnore = new ArrayList<>( this.sleuthProperties.getSpanHandler().getSpanNamePatternsToSkip()); - spanNamesToIgnore.addAll(this.sleuthProperties.getSpanHandler() - .getAdditionalSpanNamePatternsToIgnore()); + spanNamesToIgnore.addAll(this.sleuthProperties.getSpanHandler().getAdditionalSpanNamePatternsToIgnore()); return spanNamesToIgnore; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfiguration.java index ae3ff3064..39a45c433 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfiguration.java @@ -74,15 +74,12 @@ public class TraceAutoConfiguration { @ConditionalOnMissingBean // NOTE: stable bean name as might be used outside sleuth Tracing tracing(@LocalServiceName String serviceName, Propagation.Factory factory, - CurrentTraceContext currentTraceContext, Sampler sampler, - SleuthProperties sleuthProperties, @Nullable List spanHandlers, - @Nullable List tracingCustomizers) { + CurrentTraceContext currentTraceContext, Sampler sampler, SleuthProperties sleuthProperties, + @Nullable List spanHandlers, @Nullable List tracingCustomizers) { Tracing.Builder builder = Tracing.newBuilder().sampler(sampler) - .localServiceName(StringUtils.isEmpty(serviceName) ? DEFAULT_SERVICE_NAME - : serviceName) + .localServiceName(StringUtils.isEmpty(serviceName) ? DEFAULT_SERVICE_NAME : serviceName) .propagationFactory(factory).currentTraceContext(currentTraceContext) - .traceId128Bit(sleuthProperties.isTraceId128()) - .supportsJoin(sleuthProperties.isSupportsJoin()); + .traceId128Bit(sleuthProperties.isTraceId128()).supportsJoin(sleuthProperties.isSupportsJoin()); if (spanHandlers != null) { for (SpanHandler spanHandlerFactory : spanHandlers) { builder.addSpanHandler(spanHandlerFactory); @@ -143,8 +140,7 @@ public class TraceAutoConfiguration { } @Bean - @ConditionalOnProperty(value = "spring.sleuth.span-handler.enabled", - matchIfMissing = true) + @ConditionalOnProperty(value = "spring.sleuth.span-handler.enabled", matchIfMissing = true) SpanHandler spanIgnoringSpanHandler(SleuthProperties sleuthProperties) { return new SpanIgnoringSpanHandler(sleuthProperties); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceBaggageConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceBaggageConfiguration.java index 657c5c4e4..79410e164 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceBaggageConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceBaggageConfiguration.java @@ -122,36 +122,30 @@ class TraceBaggageConfiguration { @Bean @ConditionalOnMissingBean - Propagation.Factory sleuthPropagation( - BaggagePropagation.FactoryBuilder factoryBuilder, - @Qualifier(BAGGAGE_KEYS) List baggageKeys, - @Qualifier(LOCAL_KEYS) List localKeys, - @Qualifier(PROPAGATION_KEYS) List propagationKeys, - SleuthBaggageProperties sleuthBaggageProperties, + Propagation.Factory sleuthPropagation(BaggagePropagation.FactoryBuilder factoryBuilder, + @Qualifier(BAGGAGE_KEYS) List baggageKeys, @Qualifier(LOCAL_KEYS) List localKeys, + @Qualifier(PROPAGATION_KEYS) List propagationKeys, SleuthBaggageProperties sleuthBaggageProperties, @Nullable List baggagePropagationCustomizers) { - Set localFields = redirectOldPropertyToNew(LOCAL_KEYS, localKeys, - "spring.sleuth.baggage.local-fields", + Set localFields = redirectOldPropertyToNew(LOCAL_KEYS, localKeys, "spring.sleuth.baggage.local-fields", sleuthBaggageProperties.getLocalFields()); for (String fieldName : localFields) { factoryBuilder.add(SingleBaggageField.local(BaggageField.create(fieldName))); } - Set remoteFields = redirectOldPropertyToNew(PROPAGATION_KEYS, - propagationKeys, "spring.sleuth.baggage.remote-fields", - sleuthBaggageProperties.getRemoteFields()); + Set remoteFields = redirectOldPropertyToNew(PROPAGATION_KEYS, propagationKeys, + "spring.sleuth.baggage.remote-fields", sleuthBaggageProperties.getRemoteFields()); for (String fieldName : remoteFields) { factoryBuilder.add(SingleBaggageField.remote(BaggageField.create(fieldName))); } if (!baggageKeys.isEmpty()) { logger.warn("'" + BAGGAGE_KEYS + "' will be removed in a future release.\n" - + "To change header names define a @Bean of type " - + SingleBaggageField.class.getName()); + + "To change header names define a @Bean of type " + SingleBaggageField.class.getName()); for (String key : baggageKeys) { - factoryBuilder.add(SingleBaggageField.newBuilder(BaggageField.create(key)) - .addKeyName("baggage-" + key) // for HTTP + factoryBuilder.add(SingleBaggageField.newBuilder(BaggageField.create(key)).addKeyName("baggage-" + key) // for + // HTTP .addKeyName("baggage_" + key) // for messaging .build()); } @@ -165,8 +159,8 @@ class TraceBaggageConfiguration { return factoryBuilder.build(); } - static Set redirectOldPropertyToNew(String oldProperty, List oldValue, - String newProperty, List newValue) { + static Set redirectOldPropertyToNew(String oldProperty, List oldValue, String newProperty, + List newValue) { Set result = new TreeSet<>(String.CASE_INSENSITIVE_ORDER); result.addAll(newValue); if (!oldValue.isEmpty()) { @@ -187,22 +181,18 @@ class TraceBaggageConfiguration { @Bean @ConditionalOnMissingBean(CorrelationScopeDecorator.class) @ConditionalOnBean(CorrelationScopeDecorator.Builder.class) - @ConditionalOnProperty(value = "spring.sleuth.baggage.correlation-enabled", - matchIfMissing = true) - ScopeDecorator correlationScopeDecorator( - @Qualifier(WHITELISTED_MDC_KEYS) List whiteListedMDCKeys, + @ConditionalOnProperty(value = "spring.sleuth.baggage.correlation-enabled", matchIfMissing = true) + ScopeDecorator correlationScopeDecorator(@Qualifier(WHITELISTED_MDC_KEYS) List whiteListedMDCKeys, SleuthBaggageProperties sleuthBaggageProperties, @Nullable List correlationScopeCustomizers) { - Set correlationFields = redirectOldPropertyToNew(WHITELISTED_MDC_KEYS, - whiteListedMDCKeys, "spring.sleuth.baggage.correlation-fields", - sleuthBaggageProperties.getCorrelationFields()); + Set correlationFields = redirectOldPropertyToNew(WHITELISTED_MDC_KEYS, whiteListedMDCKeys, + "spring.sleuth.baggage.correlation-fields", sleuthBaggageProperties.getCorrelationFields()); // Add fields from properties CorrelationScopeDecorator.Builder builder = MDCScopeDecorator.newBuilder(); for (String field : correlationFields) { - builder.add(SingleCorrelationField.newBuilder(BaggageField.create(field)) - .build()); + builder.add(SingleCorrelationField.newBuilder(BaggageField.create(field)).build()); } // handle user overrides @@ -233,20 +223,17 @@ class TraceBaggageConfiguration { } @Bean - SpanHandler baggageTagSpanHandler( - @Qualifier(WHITELISTED_KEYS) List whiteListedKeys, + SpanHandler baggageTagSpanHandler(@Qualifier(WHITELISTED_KEYS) List whiteListedKeys, SleuthBaggageProperties sleuthBaggageProperties) { - Set tagFields = redirectOldPropertyToNew(WHITELISTED_KEYS, - whiteListedKeys, "spring.sleuth.baggage.tag-fields", - sleuthBaggageProperties.getTagFields()); + Set tagFields = redirectOldPropertyToNew(WHITELISTED_KEYS, whiteListedKeys, + "spring.sleuth.baggage.tag-fields", sleuthBaggageProperties.getTagFields()); if (tagFields.isEmpty()) { return SpanHandler.NOOP; // Brave ignores these } - return new BaggageTagSpanHandler(tagFields.stream().map(BaggageField::create) - .toArray(BaggageField[]::new)); + return new BaggageTagSpanHandler(tagFields.stream().map(BaggageField::create).toArray(BaggageField[]::new)); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceEnvironmentPostProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceEnvironmentPostProcessor.java index 4ee4d9858..56d3879ba 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceEnvironmentPostProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/autoconfig/TraceEnvironmentPostProcessor.java @@ -39,21 +39,18 @@ class TraceEnvironmentPostProcessor implements EnvironmentPostProcessor { private static final String PROPERTY_SOURCE_NAME = "defaultProperties"; @Override - public void postProcessEnvironment(ConfigurableEnvironment environment, - SpringApplication application) { + public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) { Map map = new HashMap(); // This doesn't work with all logging systems but it's a useful default so you see // traces in logs without having to configure it. - if (Boolean - .parseBoolean(environment.getProperty("spring.sleuth.enabled", "true"))) { - map.put("logging.pattern.level", "%5p [${spring.zipkin.service.name:" - + "${spring.application.name:}},%X{traceId:-},%X{spanId:-}]"); + if (Boolean.parseBoolean(environment.getProperty("spring.sleuth.enabled", "true"))) { + map.put("logging.pattern.level", + "%5p [${spring.zipkin.service.name:" + "${spring.application.name:}},%X{traceId:-},%X{spanId:-}]"); } addOrReplace(environment.getPropertySources(), map); } - private void addOrReplace(MutablePropertySources propertySources, - Map map) { + private void addOrReplace(MutablePropertySources propertySources, Map map) { MapPropertySource target = null; if (propertySources.contains(PROPERTY_SOURCE_NAME)) { PropertySource source = propertySources.get(PROPERTY_SOURCE_NAME); diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/AsyncCustomAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/AsyncCustomAutoConfiguration.java index f580dac9e..084d4742b 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/AsyncCustomAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/AsyncCustomAutoConfiguration.java @@ -39,24 +39,20 @@ import org.springframework.scheduling.annotation.AsyncConfigurer; @ConditionalOnBean(AsyncConfigurer.class) @AutoConfigureBefore(AsyncDefaultAutoConfiguration.class) @ConditionalOnProperty(value = "spring.sleuth.async.enabled", matchIfMissing = true) -@AutoConfigureAfter( - name = "org.springframework.cloud.sleuth.instrument.scheduling.TraceSchedulingAutoConfiguration") +@AutoConfigureAfter(name = "org.springframework.cloud.sleuth.instrument.scheduling.TraceSchedulingAutoConfiguration") class AsyncCustomAutoConfiguration implements BeanPostProcessor { @Autowired private BeanFactory beanFactory; @Override - public Object postProcessBeforeInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { - if (bean instanceof AsyncConfigurer - && !(bean instanceof LazyTraceAsyncCustomizer)) { + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { + if (bean instanceof AsyncConfigurer && !(bean instanceof LazyTraceAsyncCustomizer)) { AsyncConfigurer configurer = (AsyncConfigurer) bean; return new LazyTraceAsyncCustomizer(this.beanFactory, configurer); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/AsyncDefaultAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/AsyncDefaultAutoConfiguration.java index 9a28c917f..199bbd6f0 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/AsyncDefaultAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/AsyncDefaultAutoConfiguration.java @@ -59,10 +59,8 @@ import org.springframework.scheduling.annotation.AsyncConfigurerSupport; class AsyncDefaultAutoConfiguration { @Bean - @ConditionalOnProperty(value = "spring.sleuth.scheduled.enabled", - matchIfMissing = true) - public static ExecutorBeanPostProcessor executorBeanPostProcessor( - BeanFactory beanFactory) { + @ConditionalOnProperty(value = "spring.sleuth.scheduled.enabled", matchIfMissing = true) + public static ExecutorBeanPostProcessor executorBeanPostProcessor(BeanFactory beanFactory) { return new ExecutorBeanPostProcessor(beanFactory); } @@ -76,13 +74,11 @@ class AsyncDefaultAutoConfiguration { */ @Configuration(proxyBeanMethods = false) @ConditionalOnMissingBean(AsyncConfigurer.class) - @ConditionalOnProperty(value = "spring.sleuth.async.configurer.enabled", - matchIfMissing = true) + @ConditionalOnProperty(value = "spring.sleuth.async.configurer.enabled", matchIfMissing = true) @Role(BeanDefinition.ROLE_INFRASTRUCTURE) static class DefaultAsyncConfigurerSupport extends AsyncConfigurerSupport { - private static final Log log = LogFactory - .getLog(DefaultAsyncConfigurerSupport.class); + private static final Log log = LogFactory.getLog(DefaultAsyncConfigurerSupport.class); @Autowired private BeanFactory beanFactory; @@ -113,25 +109,21 @@ class AsyncDefaultAutoConfiguration { catch (NoUniqueBeanDefinitionException ex) { log.debug("Could not find unique TaskExecutor bean", ex); try { - return this.beanFactory.getBean( - AsyncExecutionAspectSupport.DEFAULT_TASK_EXECUTOR_BEAN_NAME, + return this.beanFactory.getBean(AsyncExecutionAspectSupport.DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class); } catch (NoSuchBeanDefinitionException ex2) { if (log.isInfoEnabled()) { - log.info( - "More than one TaskExecutor bean found within the context, and none is named " - + "'taskExecutor'. Mark one of them as primary or name it 'taskExecutor' (possibly " - + "as an alias) in order to use it for async processing: " - + ex.getBeanNamesFound()); + log.info("More than one TaskExecutor bean found within the context, and none is named " + + "'taskExecutor'. Mark one of them as primary or name it 'taskExecutor' (possibly " + + "as an alias) in order to use it for async processing: " + ex.getBeanNamesFound()); } } } catch (NoSuchBeanDefinitionException ex) { log.debug("Could not find default TaskExecutor bean", ex); try { - return this.beanFactory.getBean( - AsyncExecutionAspectSupport.DEFAULT_TASK_EXECUTOR_BEAN_NAME, + return this.beanFactory.getBean(AsyncExecutionAspectSupport.DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class); } catch (NoSuchBeanDefinitionException ex2) { diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/ExecutorBeanPostProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/ExecutorBeanPostProcessor.java index 73850f670..6998211b9 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/ExecutorBeanPostProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/ExecutorBeanPostProcessor.java @@ -64,18 +64,14 @@ class ExecutorBeanPostProcessor implements BeanPostProcessor { } @Override - public Object postProcessBeforeInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { - if (bean instanceof LazyTraceThreadPoolTaskExecutor - || bean instanceof TraceableScheduledExecutorService - || bean instanceof TraceableExecutorService - || bean instanceof LazyTraceAsyncTaskExecutor + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { + if (bean instanceof LazyTraceThreadPoolTaskExecutor || bean instanceof TraceableScheduledExecutorService + || bean instanceof TraceableExecutorService || bean instanceof LazyTraceAsyncTaskExecutor || bean instanceof LazyTraceExecutor) { log.info("Bean is already instrumented " + beanName); return bean; @@ -124,18 +120,14 @@ class ExecutorBeanPostProcessor implements BeanPostProcessor { boolean classFinal = Modifier.isFinal(bean.getClass().getModifiers()); boolean cglibProxy = !methodFinal && !classFinal; try { - return createProxy(bean, cglibProxy, new ExecutorMethodInterceptor<>(executor, - this.beanFactory, beanName)); + return createProxy(bean, cglibProxy, new ExecutorMethodInterceptor<>(executor, this.beanFactory, beanName)); } catch (AopConfigException ex) { if (cglibProxy) { if (log.isDebugEnabled()) { - log.debug( - "Exception occurred while trying to create a proxy, falling back to JDK proxy", - ex); + log.debug("Exception occurred while trying to create a proxy, falling back to JDK proxy", ex); } - return createProxy(bean, false, new ExecutorMethodInterceptor<>(executor, - this.beanFactory, beanName)); + return createProxy(bean, false, new ExecutorMethodInterceptor<>(executor, this.beanFactory, beanName)); } throw ex; } @@ -178,70 +170,58 @@ class ExecutorBeanPostProcessor implements BeanPostProcessor { return !sleuthAsyncProperties.getIgnoredBeans().contains(beanName); } - Object createThreadPoolTaskExecutorProxy(Object bean, boolean cglibProxy, - ThreadPoolTaskExecutor executor, String beanName) { + Object createThreadPoolTaskExecutorProxy(Object bean, boolean cglibProxy, ThreadPoolTaskExecutor executor, + String beanName) { if (!cglibProxy) { - return new LazyTraceThreadPoolTaskExecutor(this.beanFactory, executor, - beanName); + return new LazyTraceThreadPoolTaskExecutor(this.beanFactory, executor, beanName); } return getProxiedObject(bean, beanName, true, executor, - () -> new LazyTraceThreadPoolTaskExecutor(this.beanFactory, executor, - beanName)); + () -> new LazyTraceThreadPoolTaskExecutor(this.beanFactory, executor, beanName)); } - Supplier createThreadPoolTaskSchedulerProxy( - ThreadPoolTaskScheduler executor, String beanName) { - return () -> new LazyTraceThreadPoolTaskScheduler(this.beanFactory, executor, - beanName); + Supplier createThreadPoolTaskSchedulerProxy(ThreadPoolTaskScheduler executor, String beanName) { + return () -> new LazyTraceThreadPoolTaskScheduler(this.beanFactory, executor, beanName); } - Supplier createScheduledThreadPoolExecutorProxy( - ScheduledThreadPoolExecutor executor, String beanName) { - return () -> new LazyTraceScheduledThreadPoolExecutor(executor.getCorePoolSize(), - executor.getThreadFactory(), executor.getRejectedExecutionHandler(), - this.beanFactory, executor, beanName); + Supplier createScheduledThreadPoolExecutorProxy(ScheduledThreadPoolExecutor executor, String beanName) { + return () -> new LazyTraceScheduledThreadPoolExecutor(executor.getCorePoolSize(), executor.getThreadFactory(), + executor.getRejectedExecutionHandler(), this.beanFactory, executor, beanName); } - Object createExecutorServiceProxy(Object bean, boolean cglibProxy, - ExecutorService executor, String beanName) { + Object createExecutorServiceProxy(Object bean, boolean cglibProxy, ExecutorService executor, String beanName) { return getProxiedObject(bean, beanName, cglibProxy, executor, () -> { if (executor instanceof ScheduledExecutorService) { - return new TraceableScheduledExecutorService(this.beanFactory, executor, - beanName); + return new TraceableScheduledExecutorService(this.beanFactory, executor, beanName); } return new TraceableExecutorService(this.beanFactory, executor, beanName); }); } - Object createScheduledExecutorServiceProxy(Object bean, boolean cglibProxy, - ScheduledExecutorService executor, String beanName) { + Object createScheduledExecutorServiceProxy(Object bean, boolean cglibProxy, ScheduledExecutorService executor, + String beanName) { return getProxiedObject(bean, beanName, cglibProxy, executor, - () -> new TraceableScheduledExecutorService(this.beanFactory, executor, - beanName)); + () -> new TraceableScheduledExecutorService(this.beanFactory, executor, beanName)); } - Object createAsyncTaskExecutorProxy(Object bean, boolean cglibProxy, - AsyncTaskExecutor executor, String beanName) { + Object createAsyncTaskExecutorProxy(Object bean, boolean cglibProxy, AsyncTaskExecutor executor, String beanName) { return getProxiedObject(bean, beanName, cglibProxy, executor, () -> { if (bean instanceof ThreadPoolTaskScheduler) { - return new LazyTraceThreadPoolTaskScheduler(this.beanFactory, - (ThreadPoolTaskScheduler) executor, beanName); + return new LazyTraceThreadPoolTaskScheduler(this.beanFactory, (ThreadPoolTaskScheduler) executor, + beanName); } return new LazyTraceAsyncTaskExecutor(this.beanFactory, executor, beanName); }); } - private Object getProxiedObject(Object bean, String beanName, boolean cglibProxy, - Executor executor, Supplier supplier) { - ProxyFactoryBean factory = proxyFactoryBean(bean, beanName, cglibProxy, executor, - supplier); + private Object getProxiedObject(Object bean, String beanName, boolean cglibProxy, Executor executor, + Supplier supplier) { + ProxyFactoryBean factory = proxyFactoryBean(bean, beanName, cglibProxy, executor, supplier); try { return getObject(factory); } catch (Exception ex) { if (log.isDebugEnabled()) { - log.debug( - "Exception occurred while trying to get a proxy. Will fallback to a different implementation", + log.debug("Exception occurred while trying to get a proxy. Will fallback to a different implementation", ex); } try { @@ -250,38 +230,32 @@ class ExecutorBeanPostProcessor implements BeanPostProcessor { log.debug( "Will wrap ThreadPoolTaskScheduler in its tracing representation due to previous errors"); } - return createThreadPoolTaskSchedulerProxy( - (ThreadPoolTaskScheduler) bean, beanName).get(); + return createThreadPoolTaskSchedulerProxy((ThreadPoolTaskScheduler) bean, beanName).get(); } else if (bean instanceof ScheduledThreadPoolExecutor) { if (log.isDebugEnabled()) { log.debug( "Will wrap ScheduledThreadPoolExecutor in its tracing representation due to previous errors"); } - return createScheduledThreadPoolExecutorProxy( - (ScheduledThreadPoolExecutor) bean, beanName).get(); + return createScheduledThreadPoolExecutorProxy((ScheduledThreadPoolExecutor) bean, beanName).get(); } } catch (Exception ex2) { if (log.isDebugEnabled()) { - log.debug( - "Fallback for special wrappers failed, will try the tracing representation instead", - ex2); + log.debug("Fallback for special wrappers failed, will try the tracing representation instead", ex2); } } return supplier.get(); } } - private ProxyFactoryBean proxyFactoryBean(Object bean, String beanName, - boolean cglibProxy, Executor executor, Supplier supplier) { + private ProxyFactoryBean proxyFactoryBean(Object bean, String beanName, boolean cglibProxy, Executor executor, + Supplier supplier) { ProxyFactoryBean factory = new ProxyFactoryBean(); factory.setProxyTargetClass(cglibProxy); - factory.addAdvice(new ExecutorMethodInterceptor(executor, - this.beanFactory, beanName) { + factory.addAdvice(new ExecutorMethodInterceptor(executor, this.beanFactory, beanName) { @Override - Executor executor(BeanFactory beanFactory, Executor executor, - String beanName) { + Executor executor(BeanFactory beanFactory, Executor executor, String beanName) { return supplier.get(); } }); @@ -304,23 +278,19 @@ class ExecutorBeanPostProcessor implements BeanPostProcessor { private SleuthAsyncProperties asyncConfigurationProperties() { if (this.sleuthAsyncProperties == null) { - this.sleuthAsyncProperties = this.beanFactory - .getBean(SleuthAsyncProperties.class); + this.sleuthAsyncProperties = this.beanFactory.getBean(SleuthAsyncProperties.class); } return this.sleuthAsyncProperties; } private static boolean anyFinalMethods(T object) { try { - for (Method method : ReflectionUtils - .getAllDeclaredMethods(object.getClass())) { + for (Method method : ReflectionUtils.getAllDeclaredMethods(object.getClass())) { if (method.getDeclaringClass().equals(Object.class)) { continue; } - Method m = ReflectionUtils.findMethod(object.getClass(), method.getName(), - method.getParameterTypes()); - if (m != null && Modifier.isPublic(m.getModifiers()) - && Modifier.isFinal(m.getModifiers())) { + Method m = ReflectionUtils.findMethod(object.getClass(), method.getName(), method.getParameterTypes()); + if (m != null && Modifier.isPublic(m.getModifiers()) && Modifier.isFinal(m.getModifiers())) { return true; } } @@ -375,8 +345,7 @@ class ExecutorMethodInterceptor implements MethodInterceptor private Method getMethod(MethodInvocation invocation, Object object) { Method method = invocation.getMethod(); - return ReflectionUtils.findMethod(object.getClass(), method.getName(), - method.getParameterTypes()); + return ReflectionUtils.findMethod(object.getClass(), method.getName(), method.getParameterTypes()); } T executor(BeanFactory beanFactory, T executor, String beanName) { diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceAsyncTaskExecutor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceAsyncTaskExecutor.java index 9832561c8..691da2e65 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceAsyncTaskExecutor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceAsyncTaskExecutor.java @@ -51,15 +51,13 @@ public class LazyTraceAsyncTaskExecutor implements AsyncTaskExecutor { private SpanNamer spanNamer; - public LazyTraceAsyncTaskExecutor(BeanFactory beanFactory, - AsyncTaskExecutor delegate) { + public LazyTraceAsyncTaskExecutor(BeanFactory beanFactory, AsyncTaskExecutor delegate) { this.beanFactory = beanFactory; this.delegate = delegate; this.beanName = null; } - public LazyTraceAsyncTaskExecutor(BeanFactory beanFactory, AsyncTaskExecutor delegate, - String beanName) { + public LazyTraceAsyncTaskExecutor(BeanFactory beanFactory, AsyncTaskExecutor delegate, String beanName) { this.beanFactory = beanFactory; this.delegate = delegate; this.beanName = beanName; @@ -108,8 +106,7 @@ public class LazyTraceAsyncTaskExecutor implements AsyncTaskExecutor { this.spanNamer = this.beanFactory.getBean(SpanNamer.class); } catch (NoSuchBeanDefinitionException e) { - log.warn( - "SpanNamer bean not found - will provide a manually created instance"); + log.warn("SpanNamer bean not found - will provide a manually created instance"); return new DefaultSpanNamer(); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceExecutor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceExecutor.java index 6852f94a2..ee5814d7a 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceExecutor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceExecutor.java @@ -54,8 +54,7 @@ public class LazyTraceExecutor implements Executor { this.beanName = null; } - public LazyTraceExecutor(BeanFactory beanFactory, Executor delegate, - String beanName) { + public LazyTraceExecutor(BeanFactory beanFactory, Executor delegate, String beanName) { this.beanFactory = beanFactory; this.delegate = delegate; this.beanName = beanName; @@ -76,8 +75,7 @@ public class LazyTraceExecutor implements Executor { return; } } - this.delegate.execute( - new TraceRunnable(this.tracing, spanNamer(), command, this.beanName)); + this.delegate.execute(new TraceRunnable(this.tracing, spanNamer(), command, this.beanName)); } // due to some race conditions trace keys might not be ready yet @@ -87,8 +85,7 @@ public class LazyTraceExecutor implements Executor { this.spanNamer = this.beanFactory.getBean(SpanNamer.class); } catch (NoSuchBeanDefinitionException e) { - log.warn( - "SpanNamer bean not found - will provide a manually created instance"); + log.warn("SpanNamer bean not found - will provide a manually created instance"); return new DefaultSpanNamer(); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceScheduledThreadPoolExecutor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceScheduledThreadPoolExecutor.java index 0c30964b0..0575551e4 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceScheduledThreadPoolExecutor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceScheduledThreadPoolExecutor.java @@ -53,8 +53,7 @@ import org.springframework.util.ReflectionUtils; // TODO: Think of a better solution than this class LazyTraceScheduledThreadPoolExecutor extends ScheduledThreadPoolExecutor { - private static final Log log = LogFactory - .getLog(LazyTraceScheduledThreadPoolExecutor.class); + private static final Log log = LogFactory.getLog(LazyTraceScheduledThreadPoolExecutor.class); private final BeanFactory beanFactory; @@ -88,33 +87,25 @@ class LazyTraceScheduledThreadPoolExecutor extends ScheduledThreadPoolExecutor { this.beanFactory = beanFactory; this.delegate = delegate; this.beanName = beanName; - this.decorateTaskRunnable = ReflectionUtils.findMethod( - ScheduledThreadPoolExecutor.class, "decorateTask", Runnable.class, - RunnableScheduledFuture.class); + this.decorateTaskRunnable = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "decorateTask", + Runnable.class, RunnableScheduledFuture.class); makeAccessibleIfNotNull(this.decorateTaskRunnable); - this.decorateTaskCallable = ReflectionUtils.findMethod( - ScheduledThreadPoolExecutor.class, "decorateTaskCallable", Callable.class, - RunnableScheduledFuture.class); + this.decorateTaskCallable = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, + "decorateTaskCallable", Callable.class, RunnableScheduledFuture.class); makeAccessibleIfNotNull(this.decorateTaskCallable); - this.finalize = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, - "finalize", null); + this.finalize = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "finalize", null); makeAccessibleIfNotNull(this.finalize); - this.beforeExecute = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, - "beforeExecute", null); + this.beforeExecute = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "beforeExecute", null); makeAccessibleIfNotNull(this.beforeExecute); - this.afterExecute = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, - "afterExecute", null); + this.afterExecute = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "afterExecute", null); makeAccessibleIfNotNull(this.afterExecute); - this.terminated = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, - "terminated", null); + this.terminated = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "terminated", null); makeAccessibleIfNotNull(this.terminated); - this.newTaskForRunnable = ReflectionUtils.findMethod( - ScheduledThreadPoolExecutor.class, "newTaskFor", Runnable.class, - Object.class); + this.newTaskForRunnable = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "newTaskFor", + Runnable.class, Object.class); makeAccessibleIfNotNull(this.newTaskForRunnable); - this.newTaskForCallable = ReflectionUtils.findMethod( - ScheduledThreadPoolExecutor.class, "newTaskFor", Callable.class, - Object.class); + this.newTaskForCallable = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "newTaskFor", + Callable.class, Object.class); makeAccessibleIfNotNull(this.newTaskForCallable); } @@ -125,114 +116,89 @@ class LazyTraceScheduledThreadPoolExecutor extends ScheduledThreadPoolExecutor { } LazyTraceScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, - RejectedExecutionHandler handler, BeanFactory beanFactory, - ScheduledThreadPoolExecutor delegate, String beanName) { + RejectedExecutionHandler handler, BeanFactory beanFactory, ScheduledThreadPoolExecutor delegate, + String beanName) { super(corePoolSize, threadFactory, handler); this.beanFactory = beanFactory; this.delegate = delegate; this.beanName = beanName; - this.decorateTaskRunnable = ReflectionUtils.findMethod( - ScheduledThreadPoolExecutor.class, "decorateTask", Runnable.class, - RunnableScheduledFuture.class); + this.decorateTaskRunnable = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "decorateTask", + Runnable.class, RunnableScheduledFuture.class); makeAccessibleIfNotNull(this.decorateTaskRunnable); - this.decorateTaskCallable = ReflectionUtils.findMethod( - ScheduledThreadPoolExecutor.class, "decorateTaskCallable", Callable.class, - RunnableScheduledFuture.class); + this.decorateTaskCallable = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, + "decorateTaskCallable", Callable.class, RunnableScheduledFuture.class); makeAccessibleIfNotNull(this.decorateTaskCallable); - this.finalize = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, - "finalize", null); + this.finalize = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "finalize", null); makeAccessibleIfNotNull(this.finalize); - this.beforeExecute = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, - "beforeExecute", null); + this.beforeExecute = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "beforeExecute", null); makeAccessibleIfNotNull(this.beforeExecute); - this.afterExecute = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, - "afterExecute", null); + this.afterExecute = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "afterExecute", null); makeAccessibleIfNotNull(this.afterExecute); - this.terminated = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, - "terminated"); + this.terminated = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "terminated"); makeAccessibleIfNotNull(this.terminated); - this.newTaskForRunnable = ReflectionUtils.findMethod( - ScheduledThreadPoolExecutor.class, "newTaskFor", Runnable.class, - Object.class); + this.newTaskForRunnable = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "newTaskFor", + Runnable.class, Object.class); makeAccessibleIfNotNull(this.newTaskForRunnable); - this.newTaskForCallable = ReflectionUtils.findMethod( - ScheduledThreadPoolExecutor.class, "newTaskFor", Callable.class, - Object.class); + this.newTaskForCallable = ReflectionUtils.findMethod(ScheduledThreadPoolExecutor.class, "newTaskFor", + Callable.class, Object.class); makeAccessibleIfNotNull(this.newTaskForCallable); } @Override @SuppressWarnings("unchecked") - public RunnableScheduledFuture decorateTask(Runnable runnable, - RunnableScheduledFuture task) { - return (RunnableScheduledFuture) ReflectionUtils.invokeMethod( - this.decorateTaskRunnable, this.delegate, + public RunnableScheduledFuture decorateTask(Runnable runnable, RunnableScheduledFuture task) { + return (RunnableScheduledFuture) ReflectionUtils.invokeMethod(this.decorateTaskRunnable, this.delegate, new TraceRunnable(tracing(), spanNamer(), runnable, this.beanName), task); } @Override @SuppressWarnings("unchecked") - public RunnableScheduledFuture decorateTask(Callable callable, - RunnableScheduledFuture task) { - return (RunnableScheduledFuture) ReflectionUtils.invokeMethod( - this.decorateTaskCallable, this.delegate, - new TraceCallable<>(tracing(), spanNamer(), callable, this.beanName), - task); + public RunnableScheduledFuture decorateTask(Callable callable, RunnableScheduledFuture task) { + return (RunnableScheduledFuture) ReflectionUtils.invokeMethod(this.decorateTaskCallable, this.delegate, + new TraceCallable<>(tracing(), spanNamer(), callable, this.beanName), task); } @Override public ScheduledFuture schedule(Runnable command, long delay, TimeUnit unit) { - return this.delegate.schedule( - new TraceRunnable(tracing(), spanNamer(), command, this.beanName), delay, + return this.delegate.schedule(new TraceRunnable(tracing(), spanNamer(), command, this.beanName), delay, unit); + } + + @Override + public ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit) { + return this.delegate.schedule(new TraceCallable<>(tracing(), spanNamer(), callable, this.beanName), delay, unit); } @Override - public ScheduledFuture schedule(Callable callable, long delay, - TimeUnit unit) { - return this.delegate.schedule( - new TraceCallable<>(tracing(), spanNamer(), callable, this.beanName), - delay, unit); - } - - @Override - public ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay, - long period, TimeUnit unit) { - return this.delegate.scheduleAtFixedRate( - new TraceRunnable(tracing(), spanNamer(), command, this.beanName), + public ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) { + return this.delegate.scheduleAtFixedRate(new TraceRunnable(tracing(), spanNamer(), command, this.beanName), initialDelay, period, unit); } @Override - public ScheduledFuture scheduleWithFixedDelay(Runnable command, long initialDelay, - long delay, TimeUnit unit) { - return this.delegate.scheduleWithFixedDelay( - new TraceRunnable(tracing(), spanNamer(), command, this.beanName), + public ScheduledFuture scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) { + return this.delegate.scheduleWithFixedDelay(new TraceRunnable(tracing(), spanNamer(), command, this.beanName), initialDelay, delay, unit); } @Override public void execute(Runnable command) { - this.delegate.execute( - new TraceRunnable(tracing(), spanNamer(), command, this.beanName)); + this.delegate.execute(new TraceRunnable(tracing(), spanNamer(), command, this.beanName)); } @Override public Future submit(Runnable task) { - return this.delegate - .submit(new TraceRunnable(tracing(), spanNamer(), task, this.beanName)); + return this.delegate.submit(new TraceRunnable(tracing(), spanNamer(), task, this.beanName)); } @Override public Future submit(Runnable task, T result) { - return this.delegate.submit( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), result); + return this.delegate.submit(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), result); } @Override public Future submit(Callable task) { - return this.delegate - .submit(new TraceCallable<>(tracing(), spanNamer(), task, this.beanName)); + return this.delegate.submit(new TraceCallable<>(tracing(), spanNamer(), task, this.beanName)); } @Override @@ -296,8 +262,7 @@ class LazyTraceScheduledThreadPoolExecutor extends ScheduledThreadPoolExecutor { } @Override - public boolean awaitTermination(long timeout, TimeUnit unit) - throws InterruptedException { + public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { return this.delegate.awaitTermination(timeout, unit); } @@ -435,28 +400,23 @@ class LazyTraceScheduledThreadPoolExecutor extends ScheduledThreadPoolExecutor { @Override @SuppressWarnings("unchecked") public RunnableFuture newTaskFor(Runnable runnable, T value) { - return (RunnableFuture) ReflectionUtils.invokeMethod(this.newTaskForRunnable, - this.delegate, - new TraceRunnable(tracing(), spanNamer(), runnable, this.beanName), - value); + return (RunnableFuture) ReflectionUtils.invokeMethod(this.newTaskForRunnable, this.delegate, + new TraceRunnable(tracing(), spanNamer(), runnable, this.beanName), value); } @Override @SuppressWarnings("unchecked") public RunnableFuture newTaskFor(Callable callable) { - return (RunnableFuture) ReflectionUtils.invokeMethod(this.newTaskForCallable, - this.delegate, + return (RunnableFuture) ReflectionUtils.invokeMethod(this.newTaskForCallable, this.delegate, new TraceCallable<>(tracing(), spanNamer(), callable, this.beanName)); } @Override - public T invokeAny(Collection> tasks) - throws InterruptedException, ExecutionException { + public T invokeAny(Collection> tasks) throws InterruptedException, ExecutionException { return this.delegate.invokeAny(wrapCallableCollection(tasks)); } - private Collection> wrapCallableCollection( - Collection> tasks) { + private Collection> wrapCallableCollection(Collection> tasks) { List> ts = new ArrayList<>(); for (Callable task : tasks) { if (!(task instanceof TraceCallable)) { @@ -467,21 +427,19 @@ class LazyTraceScheduledThreadPoolExecutor extends ScheduledThreadPoolExecutor { } @Override - public T invokeAny(Collection> tasks, long timeout, - TimeUnit unit) + public T invokeAny(Collection> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return this.delegate.invokeAny(wrapCallableCollection(tasks), timeout, unit); } @Override - public List> invokeAll(Collection> tasks) - throws InterruptedException { + public List> invokeAll(Collection> tasks) throws InterruptedException { return this.delegate.invokeAll(wrapCallableCollection(tasks)); } @Override - public List> invokeAll(Collection> tasks, - long timeout, TimeUnit unit) throws InterruptedException { + public List> invokeAll(Collection> tasks, long timeout, TimeUnit unit) + throws InterruptedException { return this.delegate.invokeAll(wrapCallableCollection(tasks), timeout, unit); } @@ -498,8 +456,7 @@ class LazyTraceScheduledThreadPoolExecutor extends ScheduledThreadPoolExecutor { this.spanNamer = this.beanFactory.getBean(SpanNamer.class); } catch (NoSuchBeanDefinitionException e) { - log.warn( - "SpanNamer bean not found - will provide a manually created instance"); + log.warn("SpanNamer bean not found - will provide a manually created instance"); return new DefaultSpanNamer(); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskExecutor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskExecutor.java index c12ab05c8..919161657 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskExecutor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskExecutor.java @@ -44,8 +44,7 @@ import org.springframework.util.concurrent.ListenableFuture; // public as most types in this package were documented for use public class LazyTraceThreadPoolTaskExecutor extends ThreadPoolTaskExecutor { - private static final Log log = LogFactory - .getLog(LazyTraceThreadPoolTaskExecutor.class); + private static final Log log = LogFactory.getLog(LazyTraceThreadPoolTaskExecutor.class); private final BeanFactory beanFactory; @@ -57,15 +56,13 @@ public class LazyTraceThreadPoolTaskExecutor extends ThreadPoolTaskExecutor { private SpanNamer spanNamer; - public LazyTraceThreadPoolTaskExecutor(BeanFactory beanFactory, - ThreadPoolTaskExecutor delegate) { + public LazyTraceThreadPoolTaskExecutor(BeanFactory beanFactory, ThreadPoolTaskExecutor delegate) { this.beanFactory = beanFactory; this.delegate = delegate; this.beanName = null; } - public LazyTraceThreadPoolTaskExecutor(BeanFactory beanFactory, - ThreadPoolTaskExecutor delegate, String beanName) { + public LazyTraceThreadPoolTaskExecutor(BeanFactory beanFactory, ThreadPoolTaskExecutor delegate, String beanName) { this.beanFactory = beanFactory; this.delegate = delegate; this.beanName = beanName; @@ -79,10 +76,8 @@ public class LazyTraceThreadPoolTaskExecutor extends ThreadPoolTaskExecutor { @Override public void execute(Runnable task, long startTimeout) { - this.delegate.execute( - ContextUtil.isContextUnusable(this.beanFactory) ? task - : new TraceRunnable(tracing(), spanNamer(), task, this.beanName), - startTimeout); + this.delegate.execute(ContextUtil.isContextUnusable(this.beanFactory) ? task + : new TraceRunnable(tracing(), spanNamer(), task, this.beanName), startTimeout); } @Override @@ -99,17 +94,14 @@ public class LazyTraceThreadPoolTaskExecutor extends ThreadPoolTaskExecutor { @Override public ListenableFuture submitListenable(Runnable task) { - return this.delegate - .submitListenable(ContextUtil.isContextUnusable(this.beanFactory) ? task - : new TraceRunnable(tracing(), spanNamer(), task, this.beanName)); + return this.delegate.submitListenable(ContextUtil.isContextUnusable(this.beanFactory) ? task + : new TraceRunnable(tracing(), spanNamer(), task, this.beanName)); } @Override public ListenableFuture submitListenable(Callable task) { - return this.delegate - .submitListenable(ContextUtil.isContextUnusable(this.beanFactory) ? task - : new TraceCallable<>(tracing(), spanNamer(), task, - this.beanName)); + return this.delegate.submitListenable(ContextUtil.isContextUnusable(this.beanFactory) ? task + : new TraceCallable<>(tracing(), spanNamer(), task, this.beanName)); } @Override @@ -123,16 +115,13 @@ public class LazyTraceThreadPoolTaskExecutor extends ThreadPoolTaskExecutor { } @Override - public void setRejectedExecutionHandler( - RejectedExecutionHandler rejectedExecutionHandler) { + public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) { this.delegate.setRejectedExecutionHandler(rejectedExecutionHandler); } @Override - public void setWaitForTasksToCompleteOnShutdown( - boolean waitForJobsToCompleteOnShutdown) { - this.delegate - .setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); + public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) { + this.delegate.setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); } @Override @@ -296,8 +285,7 @@ public class LazyTraceThreadPoolTaskExecutor extends ThreadPoolTaskExecutor { this.spanNamer = this.beanFactory.getBean(SpanNamer.class); } catch (NoSuchBeanDefinitionException e) { - log.warn( - "SpanNamer bean not found - will provide a manually created instance"); + log.warn("SpanNamer bean not found - will provide a manually created instance"); return new DefaultSpanNamer(); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskScheduler.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskScheduler.java index 061f37d2b..4fe9d4c6f 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskScheduler.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskScheduler.java @@ -55,8 +55,7 @@ import org.springframework.util.concurrent.ListenableFuture; // TODO: Think of a better solution than this class LazyTraceThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { - private static final Log log = LogFactory - .getLog(LazyTraceThreadPoolTaskScheduler.class); + private static final Log log = LogFactory.getLog(LazyTraceThreadPoolTaskScheduler.class); private final BeanFactory beanFactory; @@ -78,25 +77,21 @@ class LazyTraceThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { private SpanNamer spanNamer; - LazyTraceThreadPoolTaskScheduler(BeanFactory beanFactory, - ThreadPoolTaskScheduler delegate, String beanName) { + LazyTraceThreadPoolTaskScheduler(BeanFactory beanFactory, ThreadPoolTaskScheduler delegate, String beanName) { this.beanFactory = beanFactory; this.delegate = delegate; this.beanName = beanName; - this.initializeExecutor = ReflectionUtils - .findMethod(ThreadPoolTaskScheduler.class, "initializeExecutor", null); + this.initializeExecutor = ReflectionUtils.findMethod(ThreadPoolTaskScheduler.class, "initializeExecutor", null); makeAccessibleIfNotNull(this.initializeExecutor); - this.createExecutor = ReflectionUtils.findMethod(ThreadPoolTaskScheduler.class, - "createExecutor", null); + this.createExecutor = ReflectionUtils.findMethod(ThreadPoolTaskScheduler.class, "createExecutor", null); makeAccessibleIfNotNull(this.createExecutor); - this.cancelRemainingTask = ReflectionUtils - .findMethod(ThreadPoolTaskScheduler.class, "cancelRemainingTask", null); + this.cancelRemainingTask = ReflectionUtils.findMethod(ThreadPoolTaskScheduler.class, "cancelRemainingTask", + null); makeAccessibleIfNotNull(this.cancelRemainingTask); - this.nextThreadName = ReflectionUtils.findMethod(ThreadPoolTaskScheduler.class, - "nextThreadName", null); + this.nextThreadName = ReflectionUtils.findMethod(ThreadPoolTaskScheduler.class, "nextThreadName", null); makeAccessibleIfNotNull(this.nextThreadName); - this.getDefaultThreadNamePrefix = ReflectionUtils.findMethod( - CustomizableThreadCreator.class, "getDefaultThreadNamePrefix", null); + this.getDefaultThreadNamePrefix = ReflectionUtils.findMethod(CustomizableThreadCreator.class, + "getDefaultThreadNamePrefix", null); makeAccessibleIfNotNull(this.getDefaultThreadNamePrefix); } @@ -124,54 +119,45 @@ class LazyTraceThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public ExecutorService initializeExecutor(ThreadFactory threadFactory, RejectedExecutionHandler rejectedExecutionHandler) { - ExecutorService executorService = (ExecutorService) ReflectionUtils.invokeMethod( - this.initializeExecutor, this.delegate, traceThreadFactory(threadFactory), + ExecutorService executorService = (ExecutorService) ReflectionUtils.invokeMethod(this.initializeExecutor, + this.delegate, traceThreadFactory(threadFactory), rejectedExecutionHandler); + if (executorService instanceof TraceableScheduledExecutorService) { + return executorService; + } + return new TraceableExecutorService(this.beanFactory, executorService, this.beanName); + } + + private ThreadFactory traceThreadFactory(ThreadFactory threadFactory) { + return r -> threadFactory.newThread(new TraceRunnable(tracing(), spanNamer(), r, this.beanName)); + } + + @Override + public ScheduledExecutorService createExecutor(int poolSize, ThreadFactory threadFactory, + RejectedExecutionHandler rejectedExecutionHandler) { + ScheduledExecutorService executorService = (ScheduledExecutorService) ReflectionUtils.invokeMethod( + this.createExecutor, this.delegate, poolSize, traceThreadFactory(threadFactory), rejectedExecutionHandler); if (executorService instanceof TraceableScheduledExecutorService) { return executorService; } - return new TraceableExecutorService(this.beanFactory, executorService, - this.beanName); - } - - private ThreadFactory traceThreadFactory(ThreadFactory threadFactory) { - return r -> threadFactory - .newThread(new TraceRunnable(tracing(), spanNamer(), r, this.beanName)); - } - - @Override - public ScheduledExecutorService createExecutor(int poolSize, - ThreadFactory threadFactory, - RejectedExecutionHandler rejectedExecutionHandler) { - ScheduledExecutorService executorService = (ScheduledExecutorService) ReflectionUtils - .invokeMethod(this.createExecutor, this.delegate, poolSize, - traceThreadFactory(threadFactory), rejectedExecutionHandler); - if (executorService instanceof TraceableScheduledExecutorService) { - return executorService; - } - return new TraceableScheduledExecutorService(this.beanFactory, executorService, - this.beanName); + return new TraceableScheduledExecutorService(this.beanFactory, executorService, this.beanName); } @Override public ScheduledExecutorService getScheduledExecutor() throws IllegalStateException { ScheduledExecutorService executor = this.delegate.getScheduledExecutor(); return executor instanceof TraceableScheduledExecutorService ? executor - : new TraceableScheduledExecutorService(this.beanFactory, executor, - this.beanName); + : new TraceableScheduledExecutorService(this.beanFactory, executor, this.beanName); } @Override - public ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor() - throws IllegalStateException { - ScheduledThreadPoolExecutor executor = this.delegate - .getScheduledThreadPoolExecutor(); + public ScheduledThreadPoolExecutor getScheduledThreadPoolExecutor() throws IllegalStateException { + ScheduledThreadPoolExecutor executor = this.delegate.getScheduledThreadPoolExecutor(); if (executor instanceof LazyTraceScheduledThreadPoolExecutor) { return executor; } - return new LazyTraceScheduledThreadPoolExecutor(executor.getCorePoolSize(), - executor.getThreadFactory(), executor.getRejectedExecutionHandler(), - this.beanFactory, executor, this.beanName); + return new LazyTraceScheduledThreadPoolExecutor(executor.getCorePoolSize(), executor.getThreadFactory(), + executor.getRejectedExecutionHandler(), this.beanFactory, executor, this.beanName); } @Override @@ -191,39 +177,32 @@ class LazyTraceThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override public void execute(Runnable task) { - this.delegate - .execute(new TraceRunnable(tracing(), spanNamer(), task, this.beanName)); + this.delegate.execute(new TraceRunnable(tracing(), spanNamer(), task, this.beanName)); } @Override public void execute(Runnable task, long startTimeout) { - this.delegate.execute( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), - startTimeout); + this.delegate.execute(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), startTimeout); } @Override public Future submit(Runnable task) { - return this.delegate - .submit(new TraceRunnable(tracing(), spanNamer(), task, this.beanName)); + return this.delegate.submit(new TraceRunnable(tracing(), spanNamer(), task, this.beanName)); } @Override public Future submit(Callable task) { - return this.delegate - .submit(new TraceCallable<>(tracing(), spanNamer(), task, this.beanName)); + return this.delegate.submit(new TraceCallable<>(tracing(), spanNamer(), task, this.beanName)); } @Override public ListenableFuture submitListenable(Runnable task) { - return this.delegate.submitListenable( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName)); + return this.delegate.submitListenable(new TraceRunnable(tracing(), spanNamer(), task, this.beanName)); } @Override public ListenableFuture submitListenable(Callable task) { - return this.delegate.submitListenable( - new TraceCallable<>(tracing(), spanNamer(), task, this.beanName)); + return this.delegate.submitListenable(new TraceCallable<>(tracing(), spanNamer(), task, this.beanName)); } @Override @@ -240,43 +219,36 @@ class LazyTraceThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { @Override @Nullable public ScheduledFuture schedule(Runnable task, Trigger trigger) { - return this.delegate.schedule( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), trigger); + return this.delegate.schedule(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), trigger); } @Override public ScheduledFuture schedule(Runnable task, Date startTime) { - return this.delegate.schedule( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), - startTime); + return this.delegate.schedule(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), startTime); } @Override - public ScheduledFuture scheduleAtFixedRate(Runnable task, Date startTime, - long period) { - return this.delegate.scheduleAtFixedRate( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), startTime, - period); + public ScheduledFuture scheduleAtFixedRate(Runnable task, Date startTime, long period) { + return this.delegate.scheduleAtFixedRate(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), + startTime, period); } @Override public ScheduledFuture scheduleAtFixedRate(Runnable task, long period) { - return this.delegate.scheduleAtFixedRate( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), period); + return this.delegate.scheduleAtFixedRate(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), + period); } @Override - public ScheduledFuture scheduleWithFixedDelay(Runnable task, Date startTime, - long delay) { - return this.delegate.scheduleWithFixedDelay( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), startTime, - delay); + public ScheduledFuture scheduleWithFixedDelay(Runnable task, Date startTime, long delay) { + return this.delegate.scheduleWithFixedDelay(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), + startTime, delay); } @Override public ScheduledFuture scheduleWithFixedDelay(Runnable task, long delay) { - return this.delegate.scheduleWithFixedDelay( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), delay); + return this.delegate.scheduleWithFixedDelay(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), + delay); } @Override @@ -290,16 +262,13 @@ class LazyTraceThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { } @Override - public void setRejectedExecutionHandler( - RejectedExecutionHandler rejectedExecutionHandler) { + public void setRejectedExecutionHandler(RejectedExecutionHandler rejectedExecutionHandler) { this.delegate.setRejectedExecutionHandler(rejectedExecutionHandler); } @Override - public void setWaitForTasksToCompleteOnShutdown( - boolean waitForJobsToCompleteOnShutdown) { - this.delegate - .setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); + public void setWaitForTasksToCompleteOnShutdown(boolean waitForJobsToCompleteOnShutdown) { + this.delegate.setWaitForTasksToCompleteOnShutdown(waitForJobsToCompleteOnShutdown); } @Override @@ -393,43 +362,36 @@ class LazyTraceThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { if (this.delegate == null) { return super.getDefaultThreadNamePrefix(); } - return (String) ReflectionUtils.invokeMethod(this.getDefaultThreadNamePrefix, - this.delegate); + return (String) ReflectionUtils.invokeMethod(this.getDefaultThreadNamePrefix, this.delegate); } @Override public ScheduledFuture schedule(Runnable task, Instant startTime) { - return this.delegate.schedule( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), - startTime); + return this.delegate.schedule(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), startTime); } @Override - public ScheduledFuture scheduleAtFixedRate(Runnable task, Instant startTime, - Duration period) { - return this.delegate.scheduleAtFixedRate( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), startTime, - period); + public ScheduledFuture scheduleAtFixedRate(Runnable task, Instant startTime, Duration period) { + return this.delegate.scheduleAtFixedRate(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), + startTime, period); } @Override public ScheduledFuture scheduleAtFixedRate(Runnable task, Duration period) { - return this.delegate.scheduleAtFixedRate( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), period); + return this.delegate.scheduleAtFixedRate(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), + period); } @Override - public ScheduledFuture scheduleWithFixedDelay(Runnable task, Instant startTime, - Duration delay) { - return this.delegate.scheduleWithFixedDelay( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), startTime, - delay); + public ScheduledFuture scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay) { + return this.delegate.scheduleWithFixedDelay(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), + startTime, delay); } @Override public ScheduledFuture scheduleWithFixedDelay(Runnable task, Duration delay) { - return this.delegate.scheduleWithFixedDelay( - new TraceRunnable(tracing(), spanNamer(), task, this.beanName), delay); + return this.delegate.scheduleWithFixedDelay(new TraceRunnable(tracing(), spanNamer(), task, this.beanName), + delay); } private Tracing tracing() { @@ -445,8 +407,7 @@ class LazyTraceThreadPoolTaskScheduler extends ThreadPoolTaskScheduler { this.spanNamer = this.beanFactory.getBean(SpanNamer.class); } catch (NoSuchBeanDefinitionException e) { - log.warn( - "SpanNamer bean not found - will provide a manually created instance"); + log.warn("SpanNamer bean not found - will provide a manually created instance"); return new DefaultSpanNamer(); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListener.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListener.java index 43bd8d126..c1f912dc9 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListener.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListener.java @@ -67,8 +67,7 @@ class SleuthContextListener implements SmartApplicationListener { @Override public void onApplicationEvent(ApplicationEvent event) { - if (event instanceof ContextRefreshedEvent - || event instanceof ContextClosedEvent) { + if (event instanceof ContextRefreshedEvent || event instanceof ContextClosedEvent) { if (log.isDebugEnabled()) { log.debug("Context refreshed or closed [" + event + "]"); } @@ -79,8 +78,7 @@ class SleuthContextListener implements SmartApplicationListener { beanFactory = ((ConfigurableApplicationContext) context).getBeanFactory(); } SleuthContextListener listener = CACHE.getOrDefault(beanFactory, this); - listener.refreshed.compareAndSet(false, - event instanceof ContextRefreshedEvent); + listener.refreshed.compareAndSet(false, event instanceof ContextRefreshedEvent); listener.closed.compareAndSet(false, event instanceof ContextClosedEvent); CACHE.put(beanFactory, listener); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncAspect.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncAspect.java index 92f501143..6dc22c95a 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncAspect.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncAspect.java @@ -79,8 +79,7 @@ class TraceAsyncAspect { private Method getMethod(ProceedingJoinPoint pjp, Object object) { MethodSignature signature = (MethodSignature) pjp.getSignature(); Method method = signature.getMethod(); - return ReflectionUtils.findMethod(object.getClass(), method.getName(), - method.getParameterTypes()); + return ReflectionUtils.findMethod(object.getClass(), method.getName(), method.getParameterTypes()); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncListenableTaskExecutor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncListenableTaskExecutor.java index 00cddd1d0..92785f857 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncListenableTaskExecutor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncListenableTaskExecutor.java @@ -40,28 +40,24 @@ public class TraceAsyncListenableTaskExecutor implements AsyncListenableTaskExec private final Tracing tracing; - TraceAsyncListenableTaskExecutor(AsyncListenableTaskExecutor delegate, - Tracing tracing) { + TraceAsyncListenableTaskExecutor(AsyncListenableTaskExecutor delegate, Tracing tracing) { this.delegate = delegate; this.tracing = tracing; } @Override public ListenableFuture submitListenable(Runnable task) { - return this.delegate - .submitListenable(this.tracing.currentTraceContext().wrap(task)); + return this.delegate.submitListenable(this.tracing.currentTraceContext().wrap(task)); } @Override public ListenableFuture submitListenable(Callable task) { - return this.delegate - .submitListenable(this.tracing.currentTraceContext().wrap(task)); + return this.delegate.submitListenable(this.tracing.currentTraceContext().wrap(task)); } @Override public void execute(Runnable task, long startTimeout) { - this.delegate.execute(this.tracing.currentTraceContext().wrap(task), - startTimeout); + this.delegate.execute(this.tracing.currentTraceContext().wrap(task), startTimeout); } @Override diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceCallable.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceCallable.java index 0b9561e90..4ead089eb 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceCallable.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceCallable.java @@ -55,8 +55,7 @@ public class TraceCallable implements Callable { this(tracing, spanNamer, delegate, null); } - public TraceCallable(Tracing tracing, SpanNamer spanNamer, Callable delegate, - String name) { + public TraceCallable(Tracing tracing, SpanNamer spanNamer, Callable delegate, String name) { this.tracer = tracing.tracer(); this.delegate = delegate; this.parent = tracing.currentTraceContext().get(); @@ -65,8 +64,7 @@ public class TraceCallable implements Callable { @Override public V call() throws Exception { - ScopedSpan span = this.tracer.startScopedSpanWithParent(this.spanName, - this.parent); + ScopedSpan span = this.tracer.startScopedSpanWithParent(this.spanName, this.parent); try { return this.delegate.call(); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceRunnable.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceRunnable.java index ea515f534..be4a46a24 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceRunnable.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceRunnable.java @@ -52,8 +52,7 @@ public class TraceRunnable implements Runnable { this(tracing, spanNamer, delegate, null); } - public TraceRunnable(Tracing tracing, SpanNamer spanNamer, Runnable delegate, - String name) { + public TraceRunnable(Tracing tracing, SpanNamer spanNamer, Runnable delegate, String name) { this.tracer = tracing.tracer(); this.delegate = delegate; this.parent = tracing.currentTraceContext().get(); @@ -62,8 +61,7 @@ public class TraceRunnable implements Runnable { @Override public void run() { - ScopedSpan span = this.tracer.startScopedSpanWithParent(this.spanName, - this.parent); + ScopedSpan span = this.tracer.startScopedSpanWithParent(this.spanName, this.parent); try { this.delegate.run(); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceableExecutorService.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceableExecutorService.java index 927e71cc2..88b18f897 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceableExecutorService.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceableExecutorService.java @@ -50,13 +50,11 @@ public class TraceableExecutorService implements ExecutorService { BeanFactory beanFactory; - public TraceableExecutorService(BeanFactory beanFactory, - final ExecutorService delegate) { + public TraceableExecutorService(BeanFactory beanFactory, final ExecutorService delegate) { this(beanFactory, delegate, null); } - public TraceableExecutorService(BeanFactory beanFactory, - final ExecutorService delegate, String spanName) { + public TraceableExecutorService(BeanFactory beanFactory, final ExecutorService delegate, String spanName) { this.delegate = delegate; this.beanFactory = beanFactory; this.spanName = spanName; @@ -89,8 +87,7 @@ public class TraceableExecutorService implements ExecutorService { } @Override - public boolean awaitTermination(long timeout, TimeUnit unit) - throws InterruptedException { + public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { return this.delegate.awaitTermination(timeout, unit); } @@ -102,10 +99,8 @@ public class TraceableExecutorService implements ExecutorService { @Override public Future submit(Runnable task, T result) { - return this.delegate.submit( - ContextUtil.isContextUnusable(this.beanFactory) ? task - : new TraceRunnable(tracing(), spanNamer(), task, this.spanName), - result); + return this.delegate.submit(ContextUtil.isContextUnusable(this.beanFactory) ? task + : new TraceRunnable(tracing(), spanNamer(), task, this.spanName), result); } @Override @@ -115,36 +110,32 @@ public class TraceableExecutorService implements ExecutorService { } @Override - public List> invokeAll(Collection> tasks) + public List> invokeAll(Collection> tasks) throws InterruptedException { + return this.delegate + .invokeAll(ContextUtil.isContextUnusable(this.beanFactory) ? tasks : wrapCallableCollection(tasks)); + } + + @Override + public List> invokeAll(Collection> tasks, long timeout, TimeUnit unit) throws InterruptedException { - return this.delegate.invokeAll(ContextUtil.isContextUnusable(this.beanFactory) - ? tasks : wrapCallableCollection(tasks)); + return this.delegate.invokeAll( + ContextUtil.isContextUnusable(this.beanFactory) ? tasks : wrapCallableCollection(tasks), timeout, unit); } @Override - public List> invokeAll(Collection> tasks, - long timeout, TimeUnit unit) throws InterruptedException { - return this.delegate.invokeAll(ContextUtil.isContextUnusable(this.beanFactory) - ? tasks : wrapCallableCollection(tasks), timeout, unit); + public T invokeAny(Collection> tasks) throws InterruptedException, ExecutionException { + return this.delegate + .invokeAny(ContextUtil.isContextUnusable(this.beanFactory) ? tasks : wrapCallableCollection(tasks)); } @Override - public T invokeAny(Collection> tasks) - throws InterruptedException, ExecutionException { - return this.delegate.invokeAny(ContextUtil.isContextUnusable(this.beanFactory) - ? tasks : wrapCallableCollection(tasks)); - } - - @Override - public T invokeAny(Collection> tasks, long timeout, - TimeUnit unit) + public T invokeAny(Collection> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { - return this.delegate.invokeAny(ContextUtil.isContextUnusable(this.beanFactory) - ? tasks : wrapCallableCollection(tasks), timeout, unit); + return this.delegate.invokeAny( + ContextUtil.isContextUnusable(this.beanFactory) ? tasks : wrapCallableCollection(tasks), timeout, unit); } - private Collection> wrapCallableCollection( - Collection> tasks) { + private Collection> wrapCallableCollection(Collection> tasks) { List> ts = new ArrayList<>(); for (Callable task : tasks) { if (!(task instanceof TraceCallable)) { diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceableScheduledExecutorService.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceableScheduledExecutorService.java index cbef777cd..2bd77df93 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceableScheduledExecutorService.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/async/TraceableScheduledExecutorService.java @@ -31,16 +31,13 @@ import org.springframework.beans.factory.BeanFactory; * @since 1.0.0 */ // public as most types in this package were documented for use -public class TraceableScheduledExecutorService extends TraceableExecutorService - implements ScheduledExecutorService { +public class TraceableScheduledExecutorService extends TraceableExecutorService implements ScheduledExecutorService { - public TraceableScheduledExecutorService(BeanFactory beanFactory, - final ExecutorService delegate) { + public TraceableScheduledExecutorService(BeanFactory beanFactory, final ExecutorService delegate) { super(beanFactory, delegate); } - public TraceableScheduledExecutorService(BeanFactory beanFactory, - final ExecutorService delegate, String beanName) { + public TraceableScheduledExecutorService(BeanFactory beanFactory, final ExecutorService delegate, String beanName) { super(beanFactory, delegate, beanName); } @@ -50,40 +47,30 @@ public class TraceableScheduledExecutorService extends TraceableExecutorService @Override public ScheduledFuture schedule(Runnable command, long delay, TimeUnit unit) { - return getScheduledExecutorService() - .schedule(ContextUtil.isContextUnusable(this.beanFactory) ? command - : new TraceRunnable(tracing(), spanNamer(), command, - this.spanName), - delay, unit); + return getScheduledExecutorService().schedule(ContextUtil.isContextUnusable(this.beanFactory) ? command + : new TraceRunnable(tracing(), spanNamer(), command, this.spanName), delay, unit); } @Override - public ScheduledFuture schedule(Callable callable, long delay, - TimeUnit unit) { - return getScheduledExecutorService() - .schedule(ContextUtil.isContextUnusable(this.beanFactory) ? callable - : new TraceCallable<>(tracing(), spanNamer(), callable, - this.spanName), - delay, unit); + public ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit) { + return getScheduledExecutorService().schedule(ContextUtil.isContextUnusable(this.beanFactory) ? callable + : new TraceCallable<>(tracing(), spanNamer(), callable, this.spanName), delay, unit); } @Override - public ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay, - long period, TimeUnit unit) { - return getScheduledExecutorService() - .scheduleAtFixedRate(ContextUtil.isContextUnusable(this.beanFactory) - ? command : new TraceRunnable(tracing(), spanNamer(), command, - this.spanName), - initialDelay, period, unit); + public ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) { + return getScheduledExecutorService().scheduleAtFixedRate( + ContextUtil.isContextUnusable(this.beanFactory) ? command + : new TraceRunnable(tracing(), spanNamer(), command, this.spanName), + initialDelay, period, unit); } @Override - public ScheduledFuture scheduleWithFixedDelay(Runnable command, long initialDelay, - long delay, TimeUnit unit) { + public ScheduledFuture scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) { return getScheduledExecutorService() - .scheduleWithFixedDelay(ContextUtil.isContextUnusable(this.beanFactory) - ? command : new TraceRunnable(tracing(), spanNamer(), command, - this.spanName), + .scheduleWithFixedDelay( + ContextUtil.isContextUnusable(this.beanFactory) ? command + : new TraceRunnable(tracing(), spanNamer(), command, this.spanName), initialDelay, delay, unit); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/SleuthCircuitBreakerAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/SleuthCircuitBreakerAutoConfiguration.java index f21a58e1d..2838ddf33 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/SleuthCircuitBreakerAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/SleuthCircuitBreakerAutoConfiguration.java @@ -47,8 +47,7 @@ import org.springframework.context.annotation.Configuration; @AutoConfigureAfter(TraceAutoConfiguration.class) @ConditionalOnClass(CircuitBreaker.class) @ConditionalOnBean(Tracing.class) -@ConditionalOnProperty(value = "spring.sleuth.circuitbreaker.enabled", - matchIfMissing = true) +@ConditionalOnProperty(value = "spring.sleuth.circuitbreaker.enabled", matchIfMissing = true) @EnableConfigurationProperties(SleuthCircuitBreakerProperties.class) class SleuthCircuitBreakerAutoConfiguration { @@ -93,8 +92,7 @@ class TraceCircuitBreaker implements CircuitBreaker { @Override public T run(Supplier toRun, Function fallback) { - return this.delegate.run(new TraceSupplier<>(this.tracer, toRun), - new TraceFunction<>(this.tracer, fallback)); + return this.delegate.run(new TraceSupplier<>(this.tracer, toRun), new TraceFunction<>(this.tracer, fallback)); } @Override diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/TraceFunction.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/TraceFunction.java index e9e6992c7..3830827e5 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/TraceFunction.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/TraceFunction.java @@ -56,8 +56,7 @@ class TraceFunction implements Function { } finally { if (tr != null) { - String message = tr.getMessage() == null ? tr.getClass().getSimpleName() - : tr.getMessage(); + String message = tr.getMessage() == null ? tr.getClass().getSimpleName() : tr.getMessage(); span.tag("error", message); } span.finish(); diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/TraceSupplier.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/TraceSupplier.java index 00095f65f..bbf4ab0ef 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/TraceSupplier.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/TraceSupplier.java @@ -56,8 +56,7 @@ class TraceSupplier implements Supplier { } finally { if (tr != null) { - String message = tr.getMessage() == null ? tr.getClass().getSimpleName() - : tr.getMessage(); + String message = tr.getMessage() == null ? tr.getClass().getSimpleName() : tr.getMessage(); span.tag("error", message); } span.finish(); diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/SpringAwareManagedChannelBuilder.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/SpringAwareManagedChannelBuilder.java index 07c2e8790..125303364 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/SpringAwareManagedChannelBuilder.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/SpringAwareManagedChannelBuilder.java @@ -40,8 +40,7 @@ public class SpringAwareManagedChannelBuilder { private List customizers; - public SpringAwareManagedChannelBuilder( - Optional> customizers) { + public SpringAwareManagedChannelBuilder(Optional> customizers) { this.customizers = customizers.orElse(null); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/TraceGrpcAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/TraceGrpcAutoConfiguration.java index fda8688c3..c1f5b5610 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/TraceGrpcAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/TraceGrpcAutoConfiguration.java @@ -68,8 +68,7 @@ class TraceGrpcAutoConfiguration { } @Bean - GrpcManagedChannelBuilderCustomizer tracingManagedChannelBuilderCustomizer( - GrpcTracing grpcTracing) { + GrpcManagedChannelBuilderCustomizer tracingManagedChannelBuilderCustomizer(GrpcTracing grpcTracing) { return new TracingManagedChannelBuilderCustomizer(grpcTracing); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/TracingManagedChannelBuilderCustomizer.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/TracingManagedChannelBuilderCustomizer.java index 7a95f6522..5e6438074 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/TracingManagedChannelBuilderCustomizer.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/grpc/TracingManagedChannelBuilderCustomizer.java @@ -22,8 +22,7 @@ import io.grpc.ManagedChannelBuilder; /** * @author Tyler Van Gorder */ -public class TracingManagedChannelBuilderCustomizer - implements GrpcManagedChannelBuilderCustomizer { +public class TracingManagedChannelBuilderCustomizer implements GrpcManagedChannelBuilderCustomizer { GrpcTracing grpcTracing; diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/ConsumerSampler.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/ConsumerSampler.java index 03c88d40c..0b81bfb36 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/ConsumerSampler.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/ConsumerSampler.java @@ -34,8 +34,7 @@ import org.springframework.beans.factory.annotation.Qualifier; * @since 2.2.0 * @see Qualifier */ -@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, - ElementType.ANNOTATION_TYPE }) +@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE }) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagation.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagation.java index 40369e51d..0f29a76a8 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagation.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagation.java @@ -37,16 +37,14 @@ import org.springframework.util.StringUtils; * * @author Marcin Grzejszczak */ -enum MessageHeaderPropagation - implements Propagation.Setter, +enum MessageHeaderPropagation implements Propagation.Setter, Propagation.Getter { INSTANCE; private static final Log log = LogFactory.getLog(MessageHeaderPropagation.class); - static Map propagationHeaders(Map headers, - List propagationHeaders) { + static Map propagationHeaders(Map headers, List propagationHeaders) { Map headersToCopy = new HashMap<>(); for (Map.Entry entry : headers.entrySet()) { if (propagationHeaders.contains(entry.getKey())) { @@ -56,21 +54,18 @@ enum MessageHeaderPropagation return headersToCopy; } - static void removeAnyTraceHeaders(MessageHeaderAccessor accessor, - List keysToRemove) { + static void removeAnyTraceHeaders(MessageHeaderAccessor accessor, List keysToRemove) { for (String keyToRemove : keysToRemove) { accessor.removeHeader(keyToRemove); if (accessor instanceof NativeMessageHeaderAccessor) { NativeMessageHeaderAccessor nativeAccessor = (NativeMessageHeaderAccessor) accessor; if (accessor.isMutable()) { // 1184 native headers can be an immutable map - ensureNativeHeadersAreMutable(nativeAccessor) - .removeNativeHeader(keyToRemove); + ensureNativeHeadersAreMutable(nativeAccessor).removeNativeHeader(keyToRemove); } } else { - Object nativeHeaders = accessor - .getHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS); + Object nativeHeaders = accessor.getHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS); if (nativeHeaders instanceof Map) { ((Map) nativeHeaders).remove(keyToRemove); } @@ -93,8 +88,7 @@ enum MessageHeaderPropagation nativeHeaderMap = nativeHeaderMap instanceof LinkedMultiValueMap ? nativeHeaderMap : new LinkedMultiValueMap<>(nativeHeaderMap); nativeAccessor.removeHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS); - nativeAccessor.setHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS, - nativeHeaderMap); + nativeAccessor.setHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS, nativeHeaderMap); return nativeAccessor; } @@ -105,8 +99,7 @@ enum MessageHeaderPropagation } catch (Exception ex) { if (log.isDebugEnabled()) { - log.debug("An exception happened when we tried to retrieve the [" + key - + "] from message", ex); + log.debug("An exception happened when we tried to retrieve the [" + key + "] from message", ex); } } } @@ -118,16 +111,13 @@ enum MessageHeaderPropagation ensureNativeHeadersAreMutable(nativeAccessor).setNativeHeader(key, value); } else { - Object nativeHeaders = accessor - .getHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS); + Object nativeHeaders = accessor.getHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS); if (nativeHeaders == null) { nativeHeaders = new LinkedMultiValueMap<>(); - accessor.setHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS, - nativeHeaders); + accessor.setHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS, nativeHeaders); } if (nativeHeaders instanceof Map) { - Map> copy = toNativeHeaderMap( - (Map>) nativeHeaders); + Map> copy = toNativeHeaderMap((Map>) nativeHeaders); copy.put(key, Collections.singletonList(value)); accessor.setHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS, copy); } @@ -148,8 +138,7 @@ enum MessageHeaderPropagation } catch (Exception ex) { if (log.isDebugEnabled()) { - log.debug("An exception happened when we tried to retrieve the [" + key - + "] from message", ex); + log.debug("An exception happened when we tried to retrieve the [" + key + "] from message", ex); } } return null; @@ -164,8 +153,7 @@ enum MessageHeaderPropagation } } else { - Object nativeHeaders = accessor - .getHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS); + Object nativeHeaders = accessor.getHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS); if (nativeHeaders instanceof Map) { Object result = ((Map) nativeHeaders).get(key); if (result instanceof List && !((List) result).isEmpty()) { diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/MessagingSleuthOperators.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/MessagingSleuthOperators.java index dccb9eb1a..cf10c3475 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/MessagingSleuthOperators.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/MessagingSleuthOperators.java @@ -64,17 +64,14 @@ public final class MessagingSleuthOperators { */ public static Message forInputMessage(Tracing tracing, Message message, Consumer> withSpanInScope) { - TraceMessageHandler traceMessageHandler = TraceMessageHandler - .forNonSpringIntegration(tracing); - MessageAndSpans wrappedInputMessage = traceMessageHandler - .wrapInputMessage(message, ""); + TraceMessageHandler traceMessageHandler = TraceMessageHandler.forNonSpringIntegration(tracing); + MessageAndSpans wrappedInputMessage = traceMessageHandler.wrapInputMessage(message, ""); if (log.isDebugEnabled()) { log.debug("Wrapped input msg " + wrappedInputMessage); } Tracer tracer = tracing.tracer(); Throwable t = null; - try (Tracer.SpanInScope ws = tracer - .withSpanInScope(wrappedInputMessage.childSpan.start())) { + try (Tracer.SpanInScope ws = tracer.withSpanInScope(wrappedInputMessage.childSpan.start())) { withSpanInScope.accept(wrappedInputMessage.msg); } catch (Exception e) { @@ -95,10 +92,8 @@ public final class MessagingSleuthOperators { * @return message with tracing context */ public static Message forInputMessage(Tracing tracing, Message message) { - TraceMessageHandler traceMessageHandler = TraceMessageHandler - .forNonSpringIntegration(tracing); - MessageAndSpans wrappedInputMessage = traceMessageHandler - .wrapInputMessage(message, ""); + TraceMessageHandler traceMessageHandler = TraceMessageHandler.forNonSpringIntegration(tracing); + MessageAndSpans wrappedInputMessage = traceMessageHandler.wrapInputMessage(message, ""); if (log.isDebugEnabled()) { log.debug("Wrapped input msg " + wrappedInputMessage); } @@ -112,10 +107,8 @@ public final class MessagingSleuthOperators { * @param input message type * @return function representation of input message with tracing context */ - public static Function, Message> asFunction(Tracing tracing, - Message inputMessage) { - return stringMessage -> MessagingSleuthOperators.forInputMessage(tracing, - inputMessage); + public static Function, Message> asFunction(Tracing tracing, Message inputMessage) { + return stringMessage -> MessagingSleuthOperators.forInputMessage(tracing, inputMessage); } /** @@ -126,8 +119,7 @@ public final class MessagingSleuthOperators { * @return span retrieved from message or {@code null} if there was no span */ public static Span spanFromMessage(Tracing tracing, Message message) { - TraceMessageHandler traceMessageHandler = TraceMessageHandler - .forNonSpringIntegration(tracing); + TraceMessageHandler traceMessageHandler = TraceMessageHandler.forNonSpringIntegration(tracing); Span span = traceMessageHandler.spanFromMessage(message); if (log.isDebugEnabled()) { log.debug("Found the following span in message " + span); @@ -143,8 +135,7 @@ public final class MessagingSleuthOperators { * be reported * @param - payload type */ - public static void withSpanInScope(Tracing tracing, Message message, - Consumer> withSpanInScope) { + public static void withSpanInScope(Tracing tracing, Message message, Consumer> withSpanInScope) { Span span = spanFromMessage(tracing, message); Tracer tracer = tracing.tracer(); try (Tracer.SpanInScope ws = tracer.withSpanInScope(span)) { @@ -179,8 +170,7 @@ public final class MessagingSleuthOperators { * @param - message payload * @return instrumented message */ - public static Message handleOutputMessage(Tracing tracing, - Message message) { + public static Message handleOutputMessage(Tracing tracing, Message message) { return handleOutputMessage(tracing, message, null); } @@ -194,10 +184,8 @@ public final class MessagingSleuthOperators { * @param - message payload * @return instrumented message */ - public static Message handleOutputMessage(Tracing tracing, Message message, - Throwable throwable) { - TraceMessageHandler traceMessageHandler = TraceMessageHandler - .forNonSpringIntegration(tracing); + public static Message handleOutputMessage(Tracing tracing, Message message, Throwable throwable) { + TraceMessageHandler traceMessageHandler = TraceMessageHandler.forNonSpringIntegration(tracing); Span span = traceMessageHandler.parentSpan(message); span = span != null ? span : traceMessageHandler.consumerSpan(message); if (span == null) { @@ -220,10 +208,8 @@ public final class MessagingSleuthOperators { * @param - message payload * @return instrumented message */ - public static Message afterMessageHandled(Tracing tracing, Message message, - Throwable ex) { - TraceMessageHandler traceMessageHandler = TraceMessageHandler - .forNonSpringIntegration(tracing); + public static Message afterMessageHandled(Tracing tracing, Message message, Throwable ex) { + TraceMessageHandler traceMessageHandler = TraceMessageHandler.forNonSpringIntegration(tracing); Span span = traceMessageHandler.spanFromMessage(message); traceMessageHandler.afterMessageHandled(span, ex); return message; diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/ProducerSampler.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/ProducerSampler.java index 04e607077..6d941fe06 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/ProducerSampler.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/ProducerSampler.java @@ -34,8 +34,7 @@ import org.springframework.beans.factory.annotation.Qualifier; * @since 2.2.0 * @see Qualifier */ -@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, - ElementType.ANNOTATION_TYPE }) +@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE }) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfiguration.java index 5b1d6cce5..70adfeeb6 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfiguration.java @@ -45,8 +45,7 @@ import org.springframework.kafka.config.StreamsBuilderFactoryBean; @ConditionalOnBean(Tracing.class) @AutoConfigureAfter({ TraceAutoConfiguration.class }) @OnMessagingEnabled -@ConditionalOnProperty(value = "spring.sleuth.messaging.kafka.streams.enabled", - matchIfMissing = true) +@ConditionalOnProperty(value = "spring.sleuth.messaging.kafka.streams.enabled", matchIfMissing = true) @ConditionalOnClass(KafkaStreams.class) class SleuthKafkaStreamsConfiguration { @@ -91,29 +90,23 @@ class SleuthKafkaStreamsConfiguration { */ class KafkaStreamsBuilderFactoryBeanPostProcessor implements BeanPostProcessor { - private static final Log log = LogFactory - .getLog(KafkaStreamsBuilderFactoryBeanPostProcessor.class); + private static final Log log = LogFactory.getLog(KafkaStreamsBuilderFactoryBeanPostProcessor.class); private final ObjectProvider objectProvider; - KafkaStreamsBuilderFactoryBeanPostProcessor( - ObjectProvider objectProvider) { + KafkaStreamsBuilderFactoryBeanPostProcessor(ObjectProvider objectProvider) { this.objectProvider = objectProvider; } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof StreamsBuilderFactoryBean) { // KafkaStreamsTracing is created in SleuthKafkaStreamsConfiguration above, so // should not be null here - KafkaStreamsTracing kafkaStreamsTracing = this.objectProvider - .getIfAvailable(); - ((StreamsBuilderFactoryBean) bean) - .setClientSupplier(kafkaStreamsTracing.kafkaClientSupplier()); + KafkaStreamsTracing kafkaStreamsTracing = this.objectProvider.getIfAvailable(); + ((StreamsBuilderFactoryBean) bean).setClientSupplier(kafkaStreamsTracing.kafkaClientSupplier()); if (log.isDebugEnabled()) { - log.debug( - "StreamsBuilderFactoryBean bean is auto-configured to enable tracing."); + log.debug("StreamsBuilderFactoryBean bean is auto-configured to enable tracing."); } } return bean; diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthMessagingProperties.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthMessagingProperties.java index a65a02b92..9b3817447 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthMessagingProperties.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthMessagingProperties.java @@ -60,8 +60,7 @@ class SleuthMessagingProperties { * Defaults to any channel name not matching the Hystrix Stream and functional * Stream channel names. */ - private String[] patterns = new String[] { "!hystrixStreamOutput*", "*", - "!channel*" }; + private String[] patterns = new String[] { "!hystrixStreamOutput*", "*", "!channel*" }; /** * Enable Spring Integration sleuth instrumentation. diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceFunctionAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceFunctionAutoConfiguration.java index 474ac9a66..293459eac 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceFunctionAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceFunctionAutoConfiguration.java @@ -56,8 +56,7 @@ import org.springframework.messaging.support.MessageBuilder; class TraceFunctionAutoConfiguration { @Bean - TraceFunctionAroundWrapper traceFunctionAroundWrapper(Environment environment, - Tracing tracing) { + TraceFunctionAroundWrapper traceFunctionAroundWrapper(Environment environment, Tracing tracing) { return new TraceFunctionAroundWrapper(environment, tracing); } @@ -80,23 +79,20 @@ class TraceFunctionAroundWrapper extends FunctionAroundWrapper } @Override - protected Object doApply(Message message, - SimpleFunctionRegistry.FunctionInvocationWrapper targetFunction) { - TraceMessageHandler traceMessageHandler = TraceMessageHandler - .forNonSpringIntegration(this.tracing); + protected Object doApply(Message message, SimpleFunctionRegistry.FunctionInvocationWrapper targetFunction) { + TraceMessageHandler traceMessageHandler = TraceMessageHandler.forNonSpringIntegration(this.tracing); if (log.isDebugEnabled()) { log.debug("Will retrieve the tracing headers from the message"); } - MessageAndSpans wrappedInputMessage = traceMessageHandler - .wrapInputMessage(message, inputDestination(targetFunction)); + MessageAndSpans wrappedInputMessage = traceMessageHandler.wrapInputMessage(message, + inputDestination(targetFunction)); if (log.isDebugEnabled()) { log.debug("Wrapped input msg " + wrappedInputMessage); } Tracer tracer = this.tracing.tracer(); Object result; Throwable throwable = null; - try (Tracer.SpanInScope ws = tracer - .withSpanInScope(wrappedInputMessage.childSpan.start())) { + try (Tracer.SpanInScope ws = tracer.withSpanInScope(wrappedInputMessage.childSpan.start())) { result = targetFunction.apply(wrappedInputMessage.msg); } catch (Exception e) { @@ -104,8 +100,7 @@ class TraceFunctionAroundWrapper extends FunctionAroundWrapper throw e; } finally { - traceMessageHandler.afterMessageHandled(wrappedInputMessage.childSpan, - throwable); + traceMessageHandler.afterMessageHandled(wrappedInputMessage.childSpan, throwable); } if (result == null) { if (log.isDebugEnabled()) { @@ -114,10 +109,8 @@ class TraceFunctionAroundWrapper extends FunctionAroundWrapper return null; } Message msgResult = toMessage(result); - MessageAndSpan wrappedOutputMessage = traceMessageHandler.wrapOutputMessage( - msgResult, - TraceContextOrSamplingFlags - .create(wrappedInputMessage.parentSpan.context()), + MessageAndSpan wrappedOutputMessage = traceMessageHandler.wrapOutputMessage(msgResult, + TraceContextOrSamplingFlags.create(wrappedInputMessage.parentSpan.context()), outputDestination(targetFunction)); if (log.isDebugEnabled()) { log.debug("Wrapped output msg " + wrappedOutputMessage); @@ -133,22 +126,16 @@ class TraceFunctionAroundWrapper extends FunctionAroundWrapper return (Message) result; } - private String inputDestination( - SimpleFunctionRegistry.FunctionInvocationWrapper targetFunction) { + private String inputDestination(SimpleFunctionRegistry.FunctionInvocationWrapper targetFunction) { String functionDefinition = targetFunction.getFunctionDefinition(); - return this.functionToDestinationCache - .computeIfAbsent(functionDefinition, - s -> this.environment.getProperty( - "spring.cloud.stream.bindings." + s + "-in-0.destination", - s)); + return this.functionToDestinationCache.computeIfAbsent(functionDefinition, + s -> this.environment.getProperty("spring.cloud.stream.bindings." + s + "-in-0.destination", s)); } - private String outputDestination( - SimpleFunctionRegistry.FunctionInvocationWrapper targetFunction) { + private String outputDestination(SimpleFunctionRegistry.FunctionInvocationWrapper targetFunction) { String functionDefinition = targetFunction.getFunctionDefinition(); return functionToDestinationCache.computeIfAbsent(functionDefinition, - s -> this.environment.getProperty( - "spring.cloud.stream.bindings." + s + "-out-0.destination", s)); + s -> this.environment.getProperty("spring.cloud.stream.bindings." + s + "-out-0.destination", s)); } @Override diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessageHandler.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessageHandler.java index b4be646a0..ac84c62f3 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessageHandler.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessageHandler.java @@ -86,8 +86,7 @@ class TraceMessageHandler { this.tracing = tracing; this.tracer = tracing.tracer(); this.injector = tracing.propagation().injector(MessageHeaderPropagation.INSTANCE); - this.extractor = tracing.propagation() - .extractor(MessageHeaderPropagation.INSTANCE); + this.extractor = tracing.propagation().extractor(MessageHeaderPropagation.INSTANCE); // TODO: Abstractions to reuse in TraceChannelInterceptors? this.preSendFunction = preSendFunction; this.preSendMessageManipulator = preSendMessageManipulator; @@ -96,17 +95,15 @@ class TraceMessageHandler { static TraceMessageHandler forNonSpringIntegration(Tracing tracing) { Tracer tracer = tracing.tracer(); - Function preSendFunction = ctx -> tracer - .nextSpan(TraceContextOrSamplingFlags.create(ctx)).name("handle").start(); - TriConsumer preSendMessageManipulator = ( - headers, parentSpan, childSpan) -> { + Function preSendFunction = ctx -> tracer.nextSpan(TraceContextOrSamplingFlags.create(ctx)) + .name("handle").start(); + TriConsumer preSendMessageManipulator = (headers, parentSpan, childSpan) -> { headers.setHeader("traceHandlerParentSpan", parentSpan); headers.setHeader(Span.class.getName(), childSpan); }; Function postReceiveFunction = ctx -> tracer .nextSpan(TraceContextOrSamplingFlags.create(ctx)); - return new TraceMessageHandler(tracing, preSendFunction, - preSendMessageManipulator, postReceiveFunction); + return new TraceMessageHandler(tracing, preSendFunction, preSendMessageManipulator, postReceiveFunction); } /** @@ -135,16 +132,14 @@ class TraceMessageHandler { clearTracingHeaders(headers); this.preSendMessageManipulator.accept(headers, consumerSpan, span); if (log.isDebugEnabled()) { - log.debug( - "Created a handle span after retrieving the message " + consumerSpan); + log.debug("Created a handle span after retrieving the message " + consumerSpan); } if (message instanceof ErrorMessage) { - return new MessageAndSpans(new ErrorMessage((Throwable) message.getPayload(), - headers.getMessageHeaders()), consumerSpan, span); + return new MessageAndSpans(new ErrorMessage((Throwable) message.getPayload(), headers.getMessageHeaders()), + consumerSpan, span); } headers.setImmutable(); - return new MessageAndSpans( - new GenericMessage<>(message.getPayload(), headers.getMessageHeaders()), + return new MessageAndSpans(new GenericMessage<>(message.getPayload(), headers.getMessageHeaders()), consumerSpan, span); } @@ -202,8 +197,8 @@ class TraceMessageHandler { * @param destinationName - destination to which the message should be sent * @return a tuple with the wrapped message and a corresponding span */ - MessageAndSpan wrapOutputMessage(Message message, - TraceContextOrSamplingFlags parentSpan, String destinationName) { + MessageAndSpan wrapOutputMessage(Message message, TraceContextOrSamplingFlags parentSpan, + String destinationName) { Message retrievedMessage = getMessage(message); MessageHeaderAccessor headers = mutableHeaderAccessor(retrievedMessage); Span span = this.outputMessageSpanFunction.apply(parentSpan.context()); @@ -213,12 +208,10 @@ class TraceMessageHandler { if (log.isDebugEnabled()) { log.debug("Created a new span output message " + span); } - return new MessageAndSpan(outputMessage(message, retrievedMessage, headers), - span); + return new MessageAndSpan(outputMessage(message, retrievedMessage, headers), span); } - private void markProducerSpan(MessageHeaderAccessor headers, Span span, - String destinationName) { + private void markProducerSpan(MessageHeaderAccessor headers, Span span, String destinationName) { if (!span.isNoop()) { span.kind(Span.Kind.PRODUCER).name("send").start(); span.remoteServiceName(toRemoteServiceName(headers)); @@ -238,25 +231,20 @@ class TraceMessageHandler { return REMOTE_SERVICE_NAME; } - private Message outputMessage(Message originalMessage, - Message retrievedMessage, MessageHeaderAccessor additionalHeaders) { - MessageHeaderAccessor headers = MessageHeaderAccessor - .getMutableAccessor(originalMessage); + private Message outputMessage(Message originalMessage, Message retrievedMessage, + MessageHeaderAccessor additionalHeaders) { + MessageHeaderAccessor headers = MessageHeaderAccessor.getMutableAccessor(originalMessage); clearTechnicalTracingHeaders(headers); if (originalMessage instanceof ErrorMessage) { ErrorMessage errorMessage = (ErrorMessage) originalMessage; - headers.copyHeaders(MessageHeaderPropagation.propagationHeaders( - additionalHeaders.getMessageHeaders(), + headers.copyHeaders(MessageHeaderPropagation.propagationHeaders(additionalHeaders.getMessageHeaders(), this.tracing.propagation().keys())); - return new ErrorMessage(errorMessage.getPayload(), - isWebSockets(headers) ? headers.getMessageHeaders() - : new MessageHeaders(headers.getMessageHeaders()), - errorMessage.getOriginalMessage()); + return new ErrorMessage(errorMessage.getPayload(), isWebSockets(headers) ? headers.getMessageHeaders() + : new MessageHeaders(headers.getMessageHeaders()), errorMessage.getOriginalMessage()); } headers.copyHeaders(additionalHeaders.getMessageHeaders()); return new GenericMessage<>(retrievedMessage.getPayload(), - isWebSockets(headers) ? headers.getMessageHeaders() - : new MessageHeaders(headers.getMessageHeaders())); + isWebSockets(headers) ? headers.getMessageHeaders() : new MessageHeaders(headers.getMessageHeaders())); } private boolean isWebSockets(MessageHeaderAccessor headerAccessor) { @@ -342,8 +330,7 @@ class MessageAndSpans { @Override public String toString() { - return "MessageAndSpans{" + "msg=" + msg + ", parentSpan=" + parentSpan - + ", childSpan=" + childSpan + '}'; + return "MessageAndSpans{" + "msg=" + msg + ", parentSpan=" + parentSpan + ", childSpan=" + childSpan + '}'; } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessageHeaders.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessageHeaders.java index 19b4d8b84..0aeae33cc 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessageHeaders.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessageHeaders.java @@ -61,8 +61,8 @@ public final class TraceMessageHeaders { */ public static final String SPAN_FLAGS_NAME = "spanFlags"; - static List HEADERS = Arrays.asList(SAMPLED_NAME, SPAN_FLAGS_NAME, - SPAN_ID_NAME, SPAN_NAME_NAME, TRACE_ID_NAME, PARENT_ID_NAME); + static List HEADERS = Arrays.asList(SAMPLED_NAME, SPAN_FLAGS_NAME, SPAN_ID_NAME, SPAN_NAME_NAME, + TRACE_ID_NAME, PARENT_ID_NAME); private TraceMessageHeaders() { } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfiguration.java index eec48bd12..86d653fc5 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfiguration.java @@ -82,8 +82,7 @@ import org.springframework.util.ReflectionUtils; @Configuration(proxyBeanMethods = false) @ConditionalOnBean(Tracing.class) @ConditionalOnClass(MessagingTracing.class) -@AutoConfigureAfter({ TraceAutoConfiguration.class, - TraceSpringMessagingAutoConfiguration.class }) +@AutoConfigureAfter({ TraceAutoConfiguration.class, TraceSpringMessagingAutoConfiguration.class }) @OnMessagingEnabled @EnableConfigurationProperties(SleuthMessagingProperties.class) // public allows @AutoConfigureAfter(TraceMessagingAutoConfiguration) @@ -114,16 +113,14 @@ public class TraceMessagingAutoConfiguration { } @Configuration(proxyBeanMethods = false) - @ConditionalOnProperty(value = "spring.sleuth.messaging.rabbit.enabled", - matchIfMissing = true) + @ConditionalOnProperty(value = "spring.sleuth.messaging.rabbit.enabled", matchIfMissing = true) @ConditionalOnClass(RabbitTemplate.class) protected static class SleuthRabbitConfiguration { @Bean // for tests @ConditionalOnMissingBean - static SleuthRabbitBeanPostProcessor sleuthRabbitBeanPostProcessor( - BeanFactory beanFactory) { + static SleuthRabbitBeanPostProcessor sleuthRabbitBeanPostProcessor(BeanFactory beanFactory) { return new SleuthRabbitBeanPostProcessor(beanFactory); } @@ -132,27 +129,21 @@ public class TraceMessagingAutoConfiguration { SpringRabbitTracing springRabbitTracing(MessagingTracing messagingTracing, SleuthMessagingProperties properties) { return SpringRabbitTracing.newBuilder(messagingTracing) - .remoteServiceName( - properties.getMessaging().getRabbit().getRemoteServiceName()) - .build(); + .remoteServiceName(properties.getMessaging().getRabbit().getRemoteServiceName()).build(); } } @Configuration(proxyBeanMethods = false) - @ConditionalOnProperty(value = "spring.sleuth.messaging.kafka.enabled", - matchIfMissing = true) + @ConditionalOnProperty(value = "spring.sleuth.messaging.kafka.enabled", matchIfMissing = true) @ConditionalOnClass(ProducerFactory.class) protected static class SleuthKafkaConfiguration { @Bean @ConditionalOnMissingBean - KafkaTracing kafkaTracing(MessagingTracing messagingTracing, - SleuthMessagingProperties properties) { + KafkaTracing kafkaTracing(MessagingTracing messagingTracing, SleuthMessagingProperties properties) { return KafkaTracing.newBuilder(messagingTracing) - .remoteServiceName( - properties.getMessaging().getKafka().getRemoteServiceName()) - .build(); + .remoteServiceName(properties.getMessaging().getKafka().getRemoteServiceName()).build(); } @Bean @@ -163,16 +154,14 @@ public class TraceMessagingAutoConfiguration { } @Bean - KafkaFactoryBeanPostProcessor kafkaFactoryBeanPostProcessor( - BeanFactory beanFactory) { + KafkaFactoryBeanPostProcessor kafkaFactoryBeanPostProcessor(BeanFactory beanFactory) { return new KafkaFactoryBeanPostProcessor(beanFactory); } } @Configuration(proxyBeanMethods = false) - @ConditionalOnProperty(value = "spring.sleuth.messaging.jms.enabled", - matchIfMissing = true) + @ConditionalOnProperty(value = "spring.sleuth.messaging.jms.enabled", matchIfMissing = true) @ConditionalOnClass(JmsListenerConfigurer.class) @ConditionalOnBean(JmsListenerEndpointRegistry.class) @Role(BeanDefinition.ROLE_INFRASTRUCTURE) @@ -180,31 +169,25 @@ public class TraceMessagingAutoConfiguration { @Bean @ConditionalOnMissingBean - JmsTracing jmsTracing(MessagingTracing messagingTracing, - SleuthMessagingProperties properties) { + JmsTracing jmsTracing(MessagingTracing messagingTracing, SleuthMessagingProperties properties) { return JmsTracing.newBuilder(messagingTracing) - .remoteServiceName( - properties.getMessaging().getJms().getRemoteServiceName()) - .build(); + .remoteServiceName(properties.getMessaging().getJms().getRemoteServiceName()).build(); } @Bean // for tests @ConditionalOnMissingBean - TracingConnectionFactoryBeanPostProcessor tracingConnectionFactoryBeanPostProcessor( - BeanFactory beanFactory) { + TracingConnectionFactoryBeanPostProcessor tracingConnectionFactoryBeanPostProcessor(BeanFactory beanFactory) { return new TracingConnectionFactoryBeanPostProcessor(beanFactory); } @Bean - JmsListenerConfigurer configureTracing(BeanFactory beanFactory, - JmsListenerEndpointRegistry defaultRegistry) { + JmsListenerConfigurer configureTracing(BeanFactory beanFactory, JmsListenerEndpointRegistry defaultRegistry) { return registrar -> { - TracingJmsBeanPostProcessor processor = beanFactory - .getBean(TracingJmsBeanPostProcessor.class); + TracingJmsBeanPostProcessor processor = beanFactory.getBean(TracingJmsBeanPostProcessor.class); JmsListenerEndpointRegistry registry = registrar.getEndpointRegistry(); - registrar.setEndpointRegistry((JmsListenerEndpointRegistry) processor - .wrap(registry == null ? defaultRegistry : registry)); + registrar.setEndpointRegistry( + (JmsListenerEndpointRegistry) processor.wrap(registry == null ? defaultRegistry : registry)); }; } @@ -229,14 +212,13 @@ class SleuthRabbitBeanPostProcessor implements BeanPostProcessor { } @Override - public Object postProcessBeforeInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof RabbitTemplate) { return rabbitTracing().decorateRabbitTemplate((RabbitTemplate) bean); } else if (bean instanceof SimpleRabbitListenerContainerFactory) { - return rabbitTracing().decorateSimpleRabbitListenerContainerFactory( - (SimpleRabbitListenerContainerFactory) bean); + return rabbitTracing() + .decorateSimpleRabbitListenerContainerFactory((SimpleRabbitListenerContainerFactory) bean); } return bean; } @@ -260,22 +242,17 @@ class KafkaFactoryBeanPostProcessor implements BeanPostProcessor { @SuppressWarnings("unchecked") @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof ConsumerFactory) { ConsumerFactory factory = (ConsumerFactory) bean; - if (factory.getPostProcessors().stream() - .noneMatch(o -> o instanceof TraceConsumerPostProcessor)) { - factory.addPostProcessor( - new TraceConsumerPostProcessor(this.beanFactory)); + if (factory.getPostProcessors().stream().noneMatch(o -> o instanceof TraceConsumerPostProcessor)) { + factory.addPostProcessor(new TraceConsumerPostProcessor(this.beanFactory)); } } else if (bean instanceof ProducerFactory) { ProducerFactory factory = (ProducerFactory) bean; - if (factory.getPostProcessors().stream() - .noneMatch(o -> o instanceof TraceProducerPostProcessor)) { - factory.addPostProcessor( - new TraceProducerPostProcessor(this.beanFactory)); + if (factory.getPostProcessors().stream().noneMatch(o -> o instanceof TraceProducerPostProcessor)) { + factory.addPostProcessor(new TraceProducerPostProcessor(this.beanFactory)); } } return bean; @@ -345,8 +322,8 @@ class SleuthKafkaAspect { SleuthKafkaAspect(KafkaTracing kafkaTracing, Tracer tracer) { this.kafkaTracing = kafkaTracing; this.tracer = tracer; - this.recordMessageConverter = ReflectionUtils.findField( - MessagingMessageListenerAdapter.class, "recordMessageConverter"); + this.recordMessageConverter = ReflectionUtils.findField(MessagingMessageListenerAdapter.class, + "recordMessageConverter"); } @Pointcut("execution(public * org.springframework.kafka.core.ProducerFactory.createProducer(..))") @@ -378,13 +355,11 @@ class SleuthKafkaAspect { } @Around("anyCreateListenerContainer() || anyCreateContainer()") - public Object wrapListenerContainerCreation(ProceedingJoinPoint pjp) - throws Throwable { + public Object wrapListenerContainerCreation(ProceedingJoinPoint pjp) throws Throwable { MessageListenerContainer listener = (MessageListenerContainer) pjp.proceed(); if (listener instanceof AbstractMessageListenerContainer) { AbstractMessageListenerContainer container = (AbstractMessageListenerContainer) listener; - Object someMessageListener = container.getContainerProperties() - .getMessageListener(); + Object someMessageListener = container.getContainerProperties().getMessageListener(); if (someMessageListener == null) { if (log.isDebugEnabled()) { log.debug("No message listener to wrap. Proceeding"); @@ -411,19 +386,16 @@ class SleuthKafkaAspect { Object createProxy(Object bean) { ProxyFactoryBean factory = new ProxyFactoryBean(); factory.setProxyTargetClass(true); - factory.addAdvice( - new MessageListenerMethodInterceptor(this.kafkaTracing, this.tracer)); + factory.addAdvice(new MessageListenerMethodInterceptor(this.kafkaTracing, this.tracer)); factory.setTarget(bean); return factory.getObject(); } } -class MessageListenerMethodInterceptor - implements MethodInterceptor { +class MessageListenerMethodInterceptor implements MethodInterceptor { - private static final Log log = LogFactory - .getLog(MessageListenerMethodInterceptor.class); + private static final Log log = LogFactory.getLog(MessageListenerMethodInterceptor.class); private final KafkaTracing kafkaTracing; @@ -447,8 +419,7 @@ class MessageListenerMethodInterceptor if (log.isDebugEnabled()) { log.debug("Wrapping onMessage call"); } - Span span = this.kafkaTracing.nextSpan((ConsumerRecord) record) - .name("on-message").start(); + Span span = this.kafkaTracing.nextSpan((ConsumerRecord) record).name("on-message").start(); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { return invocation.proceed(); } @@ -485,22 +456,19 @@ class TracingJmsBeanPostProcessor implements BeanPostProcessor { } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return wrap(bean); } Object wrap(Object bean) { if (typeMatches(bean)) { - return new TracingJmsListenerEndpointRegistry( - (JmsListenerEndpointRegistry) bean, this.beanFactory); + return new TracingJmsListenerEndpointRegistry((JmsListenerEndpointRegistry) bean, this.beanFactory); } return bean; } private boolean typeMatches(Object bean) { - return bean instanceof JmsListenerEndpointRegistry - && !(bean instanceof TracingJmsListenerEndpointRegistry); + return bean instanceof JmsListenerEndpointRegistry && !(bean instanceof TracingJmsListenerEndpointRegistry); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceSpringIntegrationAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceSpringIntegrationAutoConfiguration.java index 3bc2d2a27..4e89936f4 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceSpringIntegrationAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceSpringIntegrationAutoConfiguration.java @@ -51,29 +51,26 @@ import org.springframework.util.ObjectUtils; @Configuration(proxyBeanMethods = false) @ConditionalOnClass(GlobalChannelInterceptor.class) @ConditionalOnBean(Tracing.class) -@AutoConfigureAfter({ TraceAutoConfiguration.class, - TraceSpringMessagingAutoConfiguration.class }) +@AutoConfigureAfter({ TraceAutoConfiguration.class, TraceSpringMessagingAutoConfiguration.class }) @OnMessagingEnabled @EnableConfigurationProperties(SleuthMessagingProperties.class) @Conditional(TracingChannelInterceptorCondition.class) class TraceSpringIntegrationAutoConfiguration { @Bean - public GlobalChannelInterceptorWrapper tracingGlobalChannelInterceptorWrapper( - TracingChannelInterceptor interceptor, SleuthMessagingProperties properties) { - GlobalChannelInterceptorWrapper wrapper = new GlobalChannelInterceptorWrapper( - interceptor); + public GlobalChannelInterceptorWrapper tracingGlobalChannelInterceptorWrapper(TracingChannelInterceptor interceptor, + SleuthMessagingProperties properties) { + GlobalChannelInterceptorWrapper wrapper = new GlobalChannelInterceptorWrapper(interceptor); wrapper.setPatterns(properties.getIntegration().getPatterns()); return wrapper; } @Bean - TracingChannelInterceptor traceChannelInterceptor(Tracing tracing, - SleuthMessagingProperties properties, + TracingChannelInterceptor traceChannelInterceptor(Tracing tracing, SleuthMessagingProperties properties, Propagation.Setter traceMessagePropagationSetter, Propagation.Getter traceMessagePropagationGetter) { - return new TracingChannelInterceptor(tracing, properties, - traceMessagePropagationSetter, traceMessagePropagationGetter); + return new TracingChannelInterceptor(tracing, properties, traceMessagePropagationSetter, + traceMessagePropagationGetter); } } @@ -85,24 +82,21 @@ final class TracingChannelInterceptorCondition extends AnyNestedCondition { } @ConditionalOnMissingClass("org.springframework.cloud.function.context.FunctionCatalog") - @ConditionalOnProperty(value = "spring.sleuth.integration.enabled", - matchIfMissing = true) + @ConditionalOnProperty(value = "spring.sleuth.integration.enabled", matchIfMissing = true) static class OnFunctionMissing { } @ConditionalOnClass(FunctionCatalog.class) @Conditional(OnEnableBindingCondition.class) - @ConditionalOnProperty(value = "spring.sleuth.integration.enabled", - matchIfMissing = true) + @ConditionalOnProperty(value = "spring.sleuth.integration.enabled", matchIfMissing = true) static class OnFunctionPresentAndEnableBinding { } @ConditionalOnClass(FunctionCatalog.class) @Conditional(OnEnableBindingMissingCondition.class) - @ConditionalOnProperty(value = "spring.sleuth.integration.enabled", - havingValue = "true") + @ConditionalOnProperty(value = "spring.sleuth.integration.enabled", havingValue = "true") static class OnFunctionPresentEnableBindingOffAndIntegrationExplicitlyOn { } @@ -120,14 +114,12 @@ class OnEnableBindingCondition implements ConfigurationCondition { public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { Class clazz; try { - clazz = Class - .forName("org.springframework.cloud.stream.annotation.EnableBinding"); + clazz = Class.forName("org.springframework.cloud.stream.annotation.EnableBinding"); } catch (ClassNotFoundException e) { return false; } - return !ObjectUtils - .isEmpty(context.getBeanFactory().getBeanNamesForAnnotation(clazz)); + return !ObjectUtils.isEmpty(context.getBeanFactory().getBeanNamesForAnnotation(clazz)); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceWebSocketAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceWebSocketAutoConfiguration.java index 90be737b3..1b2de82d7 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceWebSocketAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TraceWebSocketAutoConfiguration.java @@ -40,8 +40,7 @@ import org.springframework.web.socket.config.annotation.StompEndpointRegistry; @Configuration(proxyBeanMethods = false) @ConditionalOnClass(DelegatingWebSocketMessageBrokerConfiguration.class) @ConditionalOnBean(Tracing.class) -@ConditionalOnProperty(value = "spring.sleuth.integration.websockets.enabled", - matchIfMissing = true) +@ConditionalOnProperty(value = "spring.sleuth.integration.websockets.enabled", matchIfMissing = true) class TraceWebSocketAutoConfiguration extends AbstractWebSocketMessageBrokerConfigurer { @Autowired @@ -57,20 +56,18 @@ class TraceWebSocketAutoConfiguration extends AbstractWebSocketMessageBrokerConf @Override public void configureMessageBroker(MessageBrokerRegistry registry) { - registry.configureBrokerChannel().setInterceptors( - TracingChannelInterceptor.create(this.tracing, this.properties)); + registry.configureBrokerChannel() + .setInterceptors(TracingChannelInterceptor.create(this.tracing, this.properties)); } @Override public void configureClientOutboundChannel(ChannelRegistration registration) { - registration.setInterceptors( - TracingChannelInterceptor.create(this.tracing, this.properties)); + registration.setInterceptors(TracingChannelInterceptor.create(this.tracing, this.properties)); } @Override public void configureClientInboundChannel(ChannelRegistration registration) { - registration.setInterceptors( - TracingChannelInterceptor.create(this.tracing, this.properties)); + registration.setInterceptors(TracingChannelInterceptor.create(this.tracing, this.properties)); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingChannelInterceptor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingChannelInterceptor.java index 9a47743f1..527631cf7 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingChannelInterceptor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingChannelInterceptor.java @@ -57,8 +57,7 @@ import org.springframework.util.ClassUtils; * * @author Marcin Grzejszczak */ -final class TracingChannelInterceptor extends ChannelInterceptorAdapter - implements ExecutorChannelInterceptor { +final class TracingChannelInterceptor extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { /** * Name of the class in Spring Cloud Stream that is a direct channel. @@ -109,8 +108,7 @@ final class TracingChannelInterceptor extends ChannelInterceptorAdapter @Autowired TracingChannelInterceptor(Tracing tracing, SleuthMessagingProperties properties) { - this(tracing, properties, MessageHeaderPropagation.INSTANCE, - MessageHeaderPropagation.INSTANCE); + this(tracing, properties, MessageHeaderPropagation.INSTANCE, MessageHeaderPropagation.INSTANCE); } TracingChannelInterceptor(Tracing tracing, SleuthMessagingProperties properties, @@ -122,17 +120,15 @@ final class TracingChannelInterceptor extends ChannelInterceptorAdapter this.threadLocalSpan = ThreadLocalSpan.create(this.tracer); this.injector = tracing.propagation().injector(setter); this.extractor = tracing.propagation().extractor(getter); - this.integrationObjectSupportPresent = ClassUtils.isPresent( - "org.springframework.integration.context.IntegrationObjectSupport", null); - this.hasDirectChannelClass = ClassUtils - .isPresent("org.springframework.integration.channel.DirectChannel", null); - this.directWithAttributesChannelClass = ClassUtils - .isPresent(STREAM_DIRECT_CHANNEL, null) - ? ClassUtils.resolveClassName(STREAM_DIRECT_CHANNEL, null) : null; + this.integrationObjectSupportPresent = ClassUtils + .isPresent("org.springframework.integration.context.IntegrationObjectSupport", null); + this.hasDirectChannelClass = ClassUtils.isPresent("org.springframework.integration.channel.DirectChannel", + null); + this.directWithAttributesChannelClass = ClassUtils.isPresent(STREAM_DIRECT_CHANNEL, null) + ? ClassUtils.resolveClassName(STREAM_DIRECT_CHANNEL, null) : null; } - public static TracingChannelInterceptor create(Tracing tracing, - SleuthMessagingProperties properties) { + public static TracingChannelInterceptor create(Tracing tracing, SleuthMessagingProperties properties) { return new TracingChannelInterceptor(tracing, properties); } @@ -169,8 +165,7 @@ final class TracingChannelInterceptor extends ChannelInterceptorAdapter MessageHeaderAccessor headers = mutableHeaderAccessor(retrievedMessage); TraceContextOrSamplingFlags extracted = this.extractor.extract(headers); Span span = this.threadLocalSpan.next(extracted); - MessageHeaderPropagation.removeAnyTraceHeaders(headers, - this.tracing.propagation().keys()); + MessageHeaderPropagation.removeAnyTraceHeaders(headers, this.tracing.propagation().keys()); this.injector.inject(span.context(), headers); if (!span.isNoop()) { span.kind(Span.Kind.PRODUCER).name("send").start(); @@ -199,24 +194,19 @@ final class TracingChannelInterceptor extends ChannelInterceptorAdapter return REMOTE_SERVICE_NAME; } - private Message outputMessage(Message originalMessage, - Message retrievedMessage, MessageHeaderAccessor additionalHeaders) { - MessageHeaderAccessor headers = MessageHeaderAccessor - .getMutableAccessor(originalMessage); + private Message outputMessage(Message originalMessage, Message retrievedMessage, + MessageHeaderAccessor additionalHeaders) { + MessageHeaderAccessor headers = MessageHeaderAccessor.getMutableAccessor(originalMessage); if (originalMessage instanceof ErrorMessage) { ErrorMessage errorMessage = (ErrorMessage) originalMessage; - headers.copyHeaders(MessageHeaderPropagation.propagationHeaders( - additionalHeaders.getMessageHeaders(), + headers.copyHeaders(MessageHeaderPropagation.propagationHeaders(additionalHeaders.getMessageHeaders(), this.tracing.propagation().keys())); - return new ErrorMessage(errorMessage.getPayload(), - isWebSockets(headers) ? headers.getMessageHeaders() - : new MessageHeaders(headers.getMessageHeaders()), - errorMessage.getOriginalMessage()); + return new ErrorMessage(errorMessage.getPayload(), isWebSockets(headers) ? headers.getMessageHeaders() + : new MessageHeaders(headers.getMessageHeaders()), errorMessage.getOriginalMessage()); } headers.copyHeaders(additionalHeaders.getMessageHeaders()); return new GenericMessage<>(retrievedMessage.getPayload(), - isWebSockets(headers) ? headers.getMessageHeaders() - : new MessageHeaders(headers.getMessageHeaders())); + isWebSockets(headers) ? headers.getMessageHeaders() : new MessageHeaders(headers.getMessageHeaders())); } private boolean isWebSockets(MessageHeaderAccessor headerAccessor) { @@ -226,8 +216,7 @@ final class TracingChannelInterceptor extends ChannelInterceptorAdapter private boolean isDirectChannel(MessageChannel channel) { Class targetClass = AopUtils.getTargetClass(channel); - boolean directChannel = this.hasDirectChannelClass - && DirectChannel.class.isAssignableFrom(targetClass); + boolean directChannel = this.hasDirectChannelClass && DirectChannel.class.isAssignableFrom(targetClass); if (!directChannel) { return false; } @@ -242,8 +231,7 @@ final class TracingChannelInterceptor extends ChannelInterceptorAdapter } @Override - public void afterSendCompletion(Message message, MessageChannel channel, - boolean sent, Exception ex) { + public void afterSendCompletion(Message message, MessageChannel channel, boolean sent, Exception ex) { if (emptyMessage(message)) { return; } @@ -251,8 +239,7 @@ final class TracingChannelInterceptor extends ChannelInterceptorAdapter afterMessageHandled(message, channel, null, ex); } if (log.isDebugEnabled()) { - log.debug("Will finish the current span after completion " - + this.tracer.currentSpan()); + log.debug("Will finish the current span after completion " + this.tracer.currentSpan()); } finishSpan(ex); } @@ -269,8 +256,7 @@ final class TracingChannelInterceptor extends ChannelInterceptorAdapter MessageHeaderAccessor headers = mutableHeaderAccessor(message); TraceContextOrSamplingFlags extracted = this.extractor.extract(headers); Span span = this.threadLocalSpan.next(extracted); - MessageHeaderPropagation.removeAnyTraceHeaders(headers, - this.tracing.propagation().keys()); + MessageHeaderPropagation.removeAnyTraceHeaders(headers, this.tracing.propagation().keys()); this.injector.inject(span.context(), headers); if (!span.isNoop()) { span.kind(Span.Kind.CONSUMER).name("receive").start(); @@ -283,21 +269,19 @@ final class TracingChannelInterceptor extends ChannelInterceptorAdapter headers.setImmutable(); if (message instanceof ErrorMessage) { ErrorMessage errorMessage = (ErrorMessage) message; - return new ErrorMessage(errorMessage.getPayload(), - headers.getMessageHeaders(), errorMessage.getOriginalMessage()); + return new ErrorMessage(errorMessage.getPayload(), headers.getMessageHeaders(), + errorMessage.getOriginalMessage()); } return new GenericMessage<>(message.getPayload(), headers.getMessageHeaders()); } @Override - public void afterReceiveCompletion(Message message, MessageChannel channel, - Exception ex) { + public void afterReceiveCompletion(Message message, MessageChannel channel, Exception ex) { if (emptyMessage(message)) { return; } if (log.isDebugEnabled()) { - log.debug("Will finish the current span after receive completion " - + this.tracer.currentSpan()); + log.debug("Will finish the current span after receive completion " + this.tracer.currentSpan()); } finishSpan(ex); } @@ -307,8 +291,7 @@ final class TracingChannelInterceptor extends ChannelInterceptorAdapter * context. It then creates a span for the handler, placing it in scope. */ @Override - public Message beforeHandle(Message message, MessageChannel channel, - MessageHandler handler) { + public Message beforeHandle(Message message, MessageChannel channel, MessageHandler handler) { if (emptyMessage(message)) { return message; } @@ -323,34 +306,28 @@ final class TracingChannelInterceptor extends ChannelInterceptorAdapter consumerSpan.finish(); } // create and scope a span for the message processor - this.threadLocalSpan - .next(TraceContextOrSamplingFlags.create(consumerSpan.context())) - .name("handle").start(); + this.threadLocalSpan.next(TraceContextOrSamplingFlags.create(consumerSpan.context())).name("handle").start(); // remove any trace headers, but don't re-inject as we are synchronously // processing the // message and can rely on scoping to access this span later. - MessageHeaderPropagation.removeAnyTraceHeaders(headers, - this.tracing.propagation().keys()); + MessageHeaderPropagation.removeAnyTraceHeaders(headers, this.tracing.propagation().keys()); if (log.isDebugEnabled()) { log.debug("Created a new span in before handle" + consumerSpan); } if (message instanceof ErrorMessage) { - return new ErrorMessage((Throwable) message.getPayload(), - headers.getMessageHeaders()); + return new ErrorMessage((Throwable) message.getPayload(), headers.getMessageHeaders()); } headers.setImmutable(); return new GenericMessage<>(message.getPayload(), headers.getMessageHeaders()); } @Override - public void afterMessageHandled(Message message, MessageChannel channel, - MessageHandler handler, Exception ex) { + public void afterMessageHandled(Message message, MessageChannel channel, MessageHandler handler, Exception ex) { if (emptyMessage(message)) { return; } if (log.isDebugEnabled()) { - log.debug("Will finish the current span after message handled " - + this.tracer.currentSpan()); + log.debug("Will finish the current span after message handled " + this.tracer.currentSpan()); } finishSpan(ex); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingConnectionFactoryBeanPostProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingConnectionFactoryBeanPostProcessor.java index 738ae3b61..100252c60 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingConnectionFactoryBeanPostProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingConnectionFactoryBeanPostProcessor.java @@ -51,38 +51,33 @@ class TracingConnectionFactoryBeanPostProcessor implements BeanPostProcessor { } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { // Wrap the caching connection factories instead of its target, because it catches // callbacks // such as ExceptionListener. If we don't wrap, cached callbacks like this won't // be traced. if (bean instanceof CachingConnectionFactory) { - return new LazyConnectionFactory(this.beanFactory, - (CachingConnectionFactory) bean); + return new LazyConnectionFactory(this.beanFactory, (CachingConnectionFactory) bean); } if (bean instanceof JmsMessageEndpointManager) { JmsMessageEndpointManager manager = (JmsMessageEndpointManager) bean; MessageListener listener = manager.getMessageListener(); if (listener != null) { - manager.setMessageListener( - new LazyMessageListener(this.beanFactory, listener)); + manager.setMessageListener(new LazyMessageListener(this.beanFactory, listener)); } return bean; } if (bean instanceof XAConnectionFactory && bean instanceof ConnectionFactory) { - return new LazyConnectionAndXaConnectionFactory(this.beanFactory, - (ConnectionFactory) bean, (XAConnectionFactory) bean); + return new LazyConnectionAndXaConnectionFactory(this.beanFactory, (ConnectionFactory) bean, + (XAConnectionFactory) bean); } // We check XA first in case the ConnectionFactory also implements // XAConnectionFactory else if (bean instanceof XAConnectionFactory) { - return new LazyXAConnectionFactory(this.beanFactory, - (XAConnectionFactory) bean); + return new LazyXAConnectionFactory(this.beanFactory, (XAConnectionFactory) bean); } else if (bean instanceof TopicConnectionFactory) { - return new LazyTopicConnectionFactory(this.beanFactory, - (TopicConnectionFactory) bean); + return new LazyTopicConnectionFactory(this.beanFactory, (TopicConnectionFactory) bean); } else if (bean instanceof ConnectionFactory) { return new LazyConnectionFactory(this.beanFactory, (ConnectionFactory) bean); @@ -167,8 +162,7 @@ class LazyTopicConnectionFactory implements TopicConnectionFactory { } @Override - public TopicConnection createTopicConnection(String s, String s1) - throws JMSException { + public TopicConnection createTopicConnection(String s, String s1) throws JMSException { return jmsTracing().topicConnection(this.delegate.createTopicConnection(s, s1)); } @@ -275,20 +269,16 @@ class LazyConnectionFactory implements ConnectionFactory { } -class LazyConnectionAndXaConnectionFactory - implements ConnectionFactory, XAConnectionFactory { +class LazyConnectionAndXaConnectionFactory implements ConnectionFactory, XAConnectionFactory { private final ConnectionFactory connectionFactoryDelegate; private final XAConnectionFactory xaConnectionFactoryDelegate; - LazyConnectionAndXaConnectionFactory(BeanFactory beanFactory, - ConnectionFactory connectionFactoryDelegate, + LazyConnectionAndXaConnectionFactory(BeanFactory beanFactory, ConnectionFactory connectionFactoryDelegate, XAConnectionFactory xaConnectionFactoryDelegate) { - this.connectionFactoryDelegate = new LazyConnectionFactory(beanFactory, - connectionFactoryDelegate); - this.xaConnectionFactoryDelegate = new LazyXAConnectionFactory(beanFactory, - xaConnectionFactoryDelegate); + this.connectionFactoryDelegate = new LazyConnectionFactory(beanFactory, connectionFactoryDelegate); + this.xaConnectionFactoryDelegate = new LazyXAConnectionFactory(beanFactory, xaConnectionFactoryDelegate); } @Override @@ -297,8 +287,7 @@ class LazyConnectionAndXaConnectionFactory } @Override - public Connection createConnection(String userName, String password) - throws JMSException { + public Connection createConnection(String userName, String password) throws JMSException { return this.connectionFactoryDelegate.createConnection(userName, password); } @@ -314,8 +303,7 @@ class LazyConnectionAndXaConnectionFactory @Override public JMSContext createContext(String userName, String password, int sessionMode) { - return this.connectionFactoryDelegate.createContext(userName, password, - sessionMode); + return this.connectionFactoryDelegate.createContext(userName, password, sessionMode); } @Override @@ -329,8 +317,7 @@ class LazyConnectionAndXaConnectionFactory } @Override - public XAConnection createXAConnection(String userName, String password) - throws JMSException { + public XAConnection createXAConnection(String userName, String password) throws JMSException { return this.xaConnectionFactoryDelegate.createXAConnection(userName, password); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingMethodMessageHandlerAdapter.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingMethodMessageHandlerAdapter.java index 2e1c34f9e..7bae20f77 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingMethodMessageHandlerAdapter.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/messaging/TracingMethodMessageHandlerAdapter.java @@ -77,8 +77,7 @@ class TracingMethodMessageHandlerAdapter { } // incur timestamp overhead only once - long timestamp = tracing.clock(consumerSpan.context()) - .currentTimeMicroseconds(); + long timestamp = tracing.clock(consumerSpan.context()).currentTimeMicroseconds(); consumerSpan.start(timestamp); long consumerFinish = timestamp + 1L; // save a clock reading consumerSpan.finish(consumerFinish); @@ -99,8 +98,7 @@ class TracingMethodMessageHandlerAdapter { } } - private TraceContextOrSamplingFlags extractAndClearHeaders( - MessageConsumerRequest request) { + private TraceContextOrSamplingFlags extractAndClearHeaders(MessageConsumerRequest request) { TraceContextOrSamplingFlags extracted = extractor.extract(request); for (String propagationKey : tracing.propagation().keys()) { @@ -134,8 +132,7 @@ final class MessageConsumerRequest extends ConsumerRequest { final Getter getter; - MessageConsumerRequest(Message delegate, - Getter getter) { + MessageConsumerRequest(Message delegate, Getter getter) { this.delegate = delegate; this.mutableHeaders = MessageHeaderAccessor.getMutableAccessor(delegate); this.getter = getter; diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/mongodb/TraceMongoDbAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/mongodb/TraceMongoDbAutoConfiguration.java index b00733e36..eb069553d 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/mongodb/TraceMongoDbAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/mongodb/TraceMongoDbAutoConfiguration.java @@ -50,15 +50,13 @@ class TraceMongoDbAutoConfiguration { @Bean // for tests @ConditionalOnMissingBean(TraceMongoClientSettingsBuilderCustomizer.class) - MongoClientSettingsBuilderCustomizer traceMongoClientSettingsBuilderCustomizer( - Tracing tracing) { + MongoClientSettingsBuilderCustomizer traceMongoClientSettingsBuilderCustomizer(Tracing tracing) { return new TraceMongoClientSettingsBuilderCustomizer(tracing); } } -class TraceMongoClientSettingsBuilderCustomizer - implements MongoClientSettingsBuilderCustomizer { +class TraceMongoClientSettingsBuilderCustomizer implements MongoClientSettingsBuilderCustomizer { private final Tracing tracing; @@ -68,8 +66,7 @@ class TraceMongoClientSettingsBuilderCustomizer @Override public void customize(MongoClientSettings.Builder clientSettingsBuilder) { - clientSettingsBuilder.addCommandListener( - MongoDBTracing.create(this.tracing).commandListener()); + clientSettingsBuilder.addCommandListener(MongoDBTracing.create(this.tracing).commandListener()); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/quartz/TraceQuartzAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/quartz/TraceQuartzAutoConfiguration.java index 825aacf0c..78389bebf 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/quartz/TraceQuartzAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/quartz/TraceQuartzAutoConfiguration.java @@ -62,8 +62,7 @@ class TraceQuartzAutoConfiguration implements InitializingBean { @Override public void afterPropertiesSet() throws Exception { - TracingJobListener tracingJobListener = beanFactory - .getBean(TracingJobListener.class); + TracingJobListener tracingJobListener = beanFactory.getBean(TracingJobListener.class); scheduler.getListenerManager().addTriggerListener(tracingJobListener); scheduler.getListenerManager().addJobListener(tracingJobListener); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/quartz/TracingJobListener.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/quartz/TracingJobListener.java index 7612c0fa5..d3dcd2743 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/quartz/TracingJobListener.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/quartz/TracingJobListener.java @@ -67,12 +67,10 @@ class TracingJobListener implements JobListener, TriggerListener { public void triggerFired(Trigger trigger, JobExecutionContext context) { TraceContextOrSamplingFlags extracted = tracing.propagation().extractor(GETTER) .extract(context.getMergedJobDataMap()); - Span span = tracing.tracer().nextSpan(extracted) - .name(context.getTrigger().getJobKey().toString()) + Span span = tracing.tracer().nextSpan(extracted).name(context.getTrigger().getJobKey().toString()) .tag(TRIGGER_TAG_KEY, context.getTrigger().getKey().toString()); context.put(CONTEXT_SPAN_KEY, span); - context.put(CONTEXT_SPAN_IN_SCOPE_KEY, - tracing.tracer().withSpanInScope(span.start())); + context.put(CONTEXT_SPAN_IN_SCOPE_KEY, tracing.tracer().withSpanInScope(span.start())); } @Override @@ -102,8 +100,7 @@ class TracingJobListener implements JobListener, TriggerListener { } @Override - public void jobWasExecuted(JobExecutionContext context, - JobExecutionException jobException) { + public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) { } private void closeTrace(JobExecutionContext context) { diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/ReactorSleuth.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/ReactorSleuth.java index d42cfe056..20a2259d3 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/ReactorSleuth.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/ReactorSleuth.java @@ -75,8 +75,8 @@ public abstract class ReactorSleuth { // keep a reference outside the lambda so that any caching will be visible to // all publishers - LazyBean lazyCurrentTraceContext = LazyBean - .create(springContext, CurrentTraceContext.class); + LazyBean lazyCurrentTraceContext = LazyBean.create(springContext, + CurrentTraceContext.class); return Operators.liftPublisher((p, sub) -> { // We don't scope scalar results as they happen in an instant. This prevents @@ -90,8 +90,8 @@ public abstract class ReactorSleuth { assert assertOn = true; // gives a message in unit test failures if (log.isTraceEnabled() || assertOn) { String message = "Spring Context [" + springContext - + "] is not yet refreshed. This is unexpected. Reactor Context is [" - + sub.currentContext() + "] and name is [" + name(sub) + "]"; + + "] is not yet refreshed. This is unexpected. Reactor Context is [" + sub.currentContext() + + "] and name is [" + name(sub) + "]"; log.trace(message); assert false : message; // should never happen, but don't break. } @@ -105,8 +105,8 @@ public abstract class ReactorSleuth { assert assertOn = true; // gives a message in unit test failures if (log.isTraceEnabled() || assertOn) { String message = "Spring Context [" + springContext - + "] did not return a CurrentTraceContext. Reactor Context is [" - + sub.currentContext() + "] and name is [" + name(sub) + "]"; + + "] did not return a CurrentTraceContext. Reactor Context is [" + sub.currentContext() + + "] and name is [" + name(sub) + "]"; log.trace(message); assert false : message; // should never happen, but don't break. } @@ -115,8 +115,8 @@ public abstract class ReactorSleuth { Context context = contextWithBeans(springContext, sub); if (log.isTraceEnabled()) { - log.trace("Spring context [" + springContext + "], Reactor context [" - + context + "], name [" + name(sub) + "]"); + log.trace("Spring context [" + springContext + "], Reactor context [" + context + "], name [" + + name(sub) + "]"); } TraceContext parent = traceContext(context, currentTraceContext); @@ -125,26 +125,24 @@ public abstract class ReactorSleuth { } if (log.isTraceEnabled()) { - log.trace("Creating a scope passing span subscriber with Reactor Context " - + "[" + context + "] and name [" + name(sub) + "]"); + log.trace("Creating a scope passing span subscriber with Reactor Context " + "[" + context + + "] and name [" + name(sub) + "]"); } // if (runStyle == Scannable.Attr.RunStyle.SYNC) { // return sub; // } - return new ScopePassingSpanSubscriber<>(sub, context, currentTraceContext, - parent); + return new ScopePassingSpanSubscriber<>(sub, context, currentTraceContext, parent); }); } - private static Context contextWithBeans( - ConfigurableApplicationContext springContext, CoreSubscriber sub) { + private static Context contextWithBeans(ConfigurableApplicationContext springContext, + CoreSubscriber sub) { Context context = sub.currentContext(); if (!context.hasKey(Tracing.class)) { context = context.put(Tracing.class, springContext.getBean(Tracing.class)); } if (!context.hasKey(CurrentTraceContext.class)) { - context = context.put(CurrentTraceContext.class, - springContext.getBean(CurrentTraceContext.class)); + context = context.put(CurrentTraceContext.class, springContext.getBean(CurrentTraceContext.class)); } return context; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriber.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriber.java index edb930e2e..ce10ab56f 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriber.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriber.java @@ -49,14 +49,13 @@ final class ScopePassingSpanSubscriber implements SpanSubscription, Scanna private Subscription s; - ScopePassingSpanSubscriber(Subscriber subscriber, Context ctx, - CurrentTraceContext currentTraceContext, @Nullable TraceContext parent) { + ScopePassingSpanSubscriber(Subscriber subscriber, Context ctx, CurrentTraceContext currentTraceContext, + @Nullable TraceContext parent) { this.subscriber = subscriber; this.currentTraceContext = currentTraceContext; this.parent = parent; - this.context = parent != null - && !parent.equals(ctx.getOrDefault(TraceContext.class, null)) - ? ctx.put(TraceContext.class, parent) : ctx; + this.context = parent != null && !parent.equals(ctx.getOrDefault(TraceContext.class, null)) + ? ctx.put(TraceContext.class, parent) : ctx; if (log.isTraceEnabled()) { log.trace("Parent span [" + parent + "], context [" + this.context + "]"); } @@ -122,8 +121,7 @@ final class ScopePassingSpanSubscriber implements SpanSubscription, Scanna @Override public String toString() { - return "ScopePassingSpanSubscriber{" + "subscriber=" + this.subscriber - + ", parent=" + this.parent + "}"; + return "ScopePassingSpanSubscriber{" + "subscriber=" + this.subscriber + ", parent=" + this.parent + "}"; } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/SpanSubscription.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/SpanSubscription.java index ea4ec0873..a546e1ab5 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/SpanSubscription.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/SpanSubscription.java @@ -28,8 +28,7 @@ import reactor.core.Fuseable; * @param - type of the subscription * @author Marcin Grzejszczak */ -interface SpanSubscription - extends Subscription, CoreSubscriber, Fuseable.QueueSubscription { +interface SpanSubscription extends Subscription, CoreSubscriber, Fuseable.QueueSubscription { @Override default T poll() { diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfiguration.java index 43ff35dd2..660dcff0d 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfiguration.java @@ -62,8 +62,7 @@ import static org.springframework.cloud.sleuth.instrument.reactor.TraceReactorAu @Configuration(proxyBeanMethods = false) @ConditionalOnProperty(value = "spring.sleuth.reactor.enabled", matchIfMissing = true) @ConditionalOnClass(Mono.class) -@AutoConfigureAfter( - name = "org.springframework.cloud.sleuth.instrument.web.TraceWebFluxAutoConfiguration") +@AutoConfigureAfter(name = "org.springframework.cloud.sleuth.instrument.web.TraceWebFluxAutoConfiguration") @EnableConfigurationProperties(SleuthReactorProperties.class) class TraceReactorAutoConfiguration { @@ -73,8 +72,7 @@ class TraceReactorAutoConfiguration { @ConditionalOnBean(Tracing.class) static class TraceReactorConfiguration { - static final String SLEUTH_TRACE_REACTOR_KEY = TraceReactorConfiguration.class - .getName(); + static final String SLEUTH_TRACE_REACTOR_KEY = TraceReactorConfiguration.class.getName(); private static final Log log = LogFactory.getLog(TraceReactorConfiguration.class); @@ -86,9 +84,7 @@ class TraceReactorAutoConfiguration { HookRegisteringBeanDefinitionRegistryPostProcessor traceHookRegisteringBeanDefinitionRegistryPostProcessor( ConfigurableApplicationContext context) { if (log.isTraceEnabled()) { - log.trace( - "Registering bean definition registry post processor for context [" - + context + "]"); + log.trace("Registering bean definition registry post processor for context [" + context + "]"); } return new HookRegisteringBeanDefinitionRegistryPostProcessor(context); } @@ -117,8 +113,7 @@ class HooksRefresher implements ApplicationListener private final ConfigurableApplicationContext context; - HooksRefresher(SleuthReactorProperties reactorProperties, - ConfigurableApplicationContext context) { + HooksRefresher(SleuthReactorProperties reactorProperties, ConfigurableApplicationContext context) { this.reactorProperties = reactorProperties; this.context = context; } @@ -135,35 +130,29 @@ class HooksRefresher implements ApplicationListener if (log.isTraceEnabled()) { log.trace("Decorating onEach operator instrumentation"); } - Hooks.onEachOperator(SLEUTH_TRACE_REACTOR_KEY, - scopePassingSpanOperator(this.context)); + Hooks.onEachOperator(SLEUTH_TRACE_REACTOR_KEY, scopePassingSpanOperator(this.context)); break; case DECORATE_ON_LAST: if (log.isTraceEnabled()) { log.trace("Decorating onLast operator instrumentation"); } - Hooks.onLastOperator(SLEUTH_TRACE_REACTOR_KEY, - scopePassingSpanOperator(this.context)); + Hooks.onLastOperator(SLEUTH_TRACE_REACTOR_KEY, scopePassingSpanOperator(this.context)); break; case MANUAL: - Hooks.onLastOperator(SLEUTH_TRACE_REACTOR_KEY, - springContextSpanOperator(this.context)); + Hooks.onLastOperator(SLEUTH_TRACE_REACTOR_KEY, springContextSpanOperator(this.context)); break; } } } -class HookRegisteringBeanDefinitionRegistryPostProcessor - implements BeanDefinitionRegistryPostProcessor, Closeable { +class HookRegisteringBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor, Closeable { - private static final Log log = LogFactory - .getLog(HookRegisteringBeanDefinitionRegistryPostProcessor.class); + private static final Log log = LogFactory.getLog(HookRegisteringBeanDefinitionRegistryPostProcessor.class); final ConfigurableApplicationContext springContext; - HookRegisteringBeanDefinitionRegistryPostProcessor( - ConfigurableApplicationContext springContext) { + HookRegisteringBeanDefinitionRegistryPostProcessor(ConfigurableApplicationContext springContext) { this.springContext = springContext; } @@ -179,11 +168,9 @@ class HookRegisteringBeanDefinitionRegistryPostProcessor static void setupHooks(ConfigurableApplicationContext springContext) { ConfigurableEnvironment environment = springContext.getEnvironment(); SleuthReactorProperties.InstrumentationType property = environment.getProperty( - "spring.sleuth.reactor.instrumentation-type", - SleuthReactorProperties.InstrumentationType.class, + "spring.sleuth.reactor.instrumentation-type", SleuthReactorProperties.InstrumentationType.class, SleuthReactorProperties.InstrumentationType.DECORATE_ON_EACH); - Boolean decorateOnEach = environment.getProperty( - "spring.sleuth.reactor.decorate-on-each", Boolean.class, true); + Boolean decorateOnEach = environment.getProperty("spring.sleuth.reactor.decorate-on-each", Boolean.class, true); if (!decorateOnEach) { log.warn( "You're using the deprecated [spring.sleuth.reactor.decorate-on-each] property. Please use the [spring.sleuth.reactor.instrumentation-type] one instead."); @@ -198,15 +185,12 @@ class HookRegisteringBeanDefinitionRegistryPostProcessor else if (property == SleuthReactorProperties.InstrumentationType.MANUAL) { decorateOnLast(springContextSpanOperator(springContext)); } - Schedulers.setExecutorServiceDecorator( - TraceReactorAutoConfiguration.SLEUTH_REACTOR_EXECUTOR_SERVICE_KEY, - (scheduler, - scheduledExecutorService) -> new TraceableScheduledExecutorService( - springContext, scheduledExecutorService)); + Schedulers.setExecutorServiceDecorator(TraceReactorAutoConfiguration.SLEUTH_REACTOR_EXECUTOR_SERVICE_KEY, + (scheduler, scheduledExecutorService) -> new TraceableScheduledExecutorService(springContext, + scheduledExecutorService)); } - private static void decorateOnLast( - Function, ? extends Publisher> function) { + private static void decorateOnLast(Function, ? extends Publisher> function) { if (log.isTraceEnabled()) { log.trace("Decorating onLast operator instrumentation"); } @@ -217,8 +201,7 @@ class HookRegisteringBeanDefinitionRegistryPostProcessor if (log.isTraceEnabled()) { log.trace("Decorating onEach operator instrumentation"); } - Hooks.onEachOperator(SLEUTH_TRACE_REACTOR_KEY, - scopePassingSpanOperator(springContext)); + Hooks.onEachOperator(SLEUTH_TRACE_REACTOR_KEY, scopePassingSpanOperator(springContext)); } @Override @@ -228,8 +211,7 @@ class HookRegisteringBeanDefinitionRegistryPostProcessor } Hooks.resetOnEachOperator(SLEUTH_TRACE_REACTOR_KEY); Hooks.resetOnLastOperator(SLEUTH_TRACE_REACTOR_KEY); - Schedulers.removeExecutorServiceDecorator( - TraceReactorAutoConfiguration.SLEUTH_REACTOR_EXECUTOR_SERVICE_KEY); + Schedulers.removeExecutorServiceDecorator(TraceReactorAutoConfiguration.SLEUTH_REACTOR_EXECUTOR_SERVICE_KEY); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/redis/TraceRedisAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/redis/TraceRedisAutoConfiguration.java index 8365e6cbd..d170f12d5 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/redis/TraceRedisAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/redis/TraceRedisAutoConfiguration.java @@ -53,8 +53,7 @@ class TraceRedisAutoConfiguration { @Bean static TraceLettuceClientResourcesBeanPostProcessor traceLettuceClientResourcesBeanPostProcessor( BeanFactory beanFactory, TraceRedisProperties traceRedisProperties) { - return new TraceLettuceClientResourcesBeanPostProcessor(beanFactory, - traceRedisProperties); + return new TraceLettuceClientResourcesBeanPostProcessor(beanFactory, traceRedisProperties); } } @@ -63,8 +62,7 @@ class TraceRedisAutoConfiguration { class TraceLettuceClientResourcesBeanPostProcessor implements BeanPostProcessor { - private static final Log log = LogFactory - .getLog(TraceLettuceClientResourcesBeanPostProcessor.class); + private static final Log log = LogFactory.getLog(TraceLettuceClientResourcesBeanPostProcessor.class); private final BeanFactory beanFactory; @@ -72,30 +70,25 @@ class TraceLettuceClientResourcesBeanPostProcessor implements BeanPostProcessor private Tracing tracing; - TraceLettuceClientResourcesBeanPostProcessor(BeanFactory beanFactory, - TraceRedisProperties traceRedisProperties) { + TraceLettuceClientResourcesBeanPostProcessor(BeanFactory beanFactory, TraceRedisProperties traceRedisProperties) { this.beanFactory = beanFactory; this.traceRedisProperties = traceRedisProperties; } @Override - public Object postProcessBeforeInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof ClientResources) { ClientResources cr = (ClientResources) bean; if (!cr.tracing().isEnabled()) { if (log.isDebugEnabled()) { - log.debug( - "Lettuce ClientResources bean is auto-configured to enable tracing."); + log.debug("Lettuce ClientResources bean is auto-configured to enable tracing."); } - BraveTracing lettuceTracing = BraveTracing.builder().tracing(tracing()) - .excludeCommandArgsFromSpanTags() + BraveTracing lettuceTracing = BraveTracing.builder().tracing(tracing()).excludeCommandArgsFromSpanTags() .serviceName(traceRedisProperties.getRemoteServiceName()).build(); return cr.mutate().tracing(lettuceTracing).build(); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/RpcClientSampler.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/RpcClientSampler.java index bded8c0db..0c823f444 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/RpcClientSampler.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/RpcClientSampler.java @@ -34,8 +34,7 @@ import org.springframework.beans.factory.annotation.Qualifier; * @since 2.2.0 * @see Qualifier */ -@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, - ElementType.ANNOTATION_TYPE }) +@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE }) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/RpcServerSampler.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/RpcServerSampler.java index 006090d20..a36bec711 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/RpcServerSampler.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/RpcServerSampler.java @@ -34,8 +34,7 @@ import org.springframework.beans.factory.annotation.Qualifier; * @since 2.2.0 * @see Qualifier */ -@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, - ElementType.ANNOTATION_TYPE }) +@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE }) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfiguration.java index 811843e64..5cba9ee12 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfiguration.java @@ -41,8 +41,7 @@ import org.springframework.lang.Nullable; * @since 2.2.0 */ @Configuration(proxyBeanMethods = false) -@ConditionalOnProperty(name = "spring.sleuth.rpc.enabled", havingValue = "true", - matchIfMissing = true) +@ConditionalOnProperty(name = "spring.sleuth.rpc.enabled", havingValue = "true", matchIfMissing = true) @ConditionalOnBean(Tracing.class) @ConditionalOnClass(RpcTracing.class) @AutoConfigureAfter(TraceAutoConfiguration.class) @@ -53,8 +52,7 @@ public class TraceRpcAutoConfiguration { @Bean @ConditionalOnMissingBean // NOTE: stable bean name as might be used outside sleuth - RpcTracing rpcTracing(Tracing tracing, - @Nullable @RpcClientSampler SamplerFunction clientSampler, + RpcTracing rpcTracing(Tracing tracing, @Nullable @RpcClientSampler SamplerFunction clientSampler, @Nullable @RpcServerSampler SamplerFunction serverSampler, @Nullable List rpcTracingCustomizers) { diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rxjava/RxJavaAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rxjava/RxJavaAutoConfiguration.java index f6d422a2b..c635ebee3 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rxjava/RxJavaAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rxjava/RxJavaAutoConfiguration.java @@ -42,8 +42,7 @@ import org.springframework.context.annotation.Configuration; @AutoConfigureAfter(TraceAutoConfiguration.class) @ConditionalOnBean(Tracing.class) @ConditionalOnClass(RxJavaSchedulersHook.class) -@ConditionalOnProperty(value = "spring.sleuth.rxjava.schedulers.hook.enabled", - matchIfMissing = true) +@ConditionalOnProperty(value = "spring.sleuth.rxjava.schedulers.hook.enabled", matchIfMissing = true) @EnableConfigurationProperties(SleuthRxJavaSchedulersProperties.class) class RxJavaAutoConfiguration { diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaSchedulersHook.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaSchedulersHook.java index f3454b7b3..281987ecc 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaSchedulersHook.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaSchedulersHook.java @@ -55,16 +55,14 @@ class SleuthRxJavaSchedulersHook extends RxJavaSchedulersHook { if (this.delegate instanceof SleuthRxJavaSchedulersHook) { return; } - RxJavaErrorHandler errorHandler = RxJavaPlugins.getInstance() - .getErrorHandler(); - RxJavaObservableExecutionHook observableExecutionHook = RxJavaPlugins - .getInstance().getObservableExecutionHook(); + RxJavaErrorHandler errorHandler = RxJavaPlugins.getInstance().getErrorHandler(); + RxJavaObservableExecutionHook observableExecutionHook = RxJavaPlugins.getInstance() + .getObservableExecutionHook(); logCurrentStateOfRxJavaPlugins(errorHandler, observableExecutionHook); RxJavaPlugins.getInstance().reset(); RxJavaPlugins.getInstance().registerSchedulersHook(this); RxJavaPlugins.getInstance().registerErrorHandler(errorHandler); - RxJavaPlugins.getInstance() - .registerObservableExecutionHook(observableExecutionHook); + RxJavaPlugins.getInstance().registerObservableExecutionHook(observableExecutionHook); } catch (Exception ex) { log.error("Failed to register Sleuth RxJava SchedulersHook", ex); @@ -74,9 +72,9 @@ class SleuthRxJavaSchedulersHook extends RxJavaSchedulersHook { private void logCurrentStateOfRxJavaPlugins(RxJavaErrorHandler errorHandler, RxJavaObservableExecutionHook observableExecutionHook) { if (log.isDebugEnabled()) { - log.debug("Current RxJava plugins configuration is [" + "schedulersHook [" - + this.delegate + "]," + "errorHandler [" + errorHandler + "]," - + "observableExecutionHook [" + observableExecutionHook + "]," + "]"); + log.debug("Current RxJava plugins configuration is [" + "schedulersHook [" + this.delegate + "]," + + "errorHandler [" + errorHandler + "]," + "observableExecutionHook [" + observableExecutionHook + + "]," + "]"); log.debug("Registering Sleuth RxJava Schedulers Hook."); } } @@ -86,13 +84,11 @@ class SleuthRxJavaSchedulersHook extends RxJavaSchedulersHook { if (action instanceof TraceAction) { return action; } - Action0 wrappedAction = this.delegate != null ? this.delegate.onSchedule(action) - : action; + Action0 wrappedAction = this.delegate != null ? this.delegate.onSchedule(action) : action; if (wrappedAction instanceof TraceAction) { return action; } - return super.onSchedule( - new TraceAction(this.tracer, wrappedAction, this.threadsToSample)); + return super.onSchedule(new TraceAction(this.tracer, wrappedAction, this.threadsToSample)); } /** diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAspect.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAspect.java index 4495176e3..1175ad2db 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAspect.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAspect.java @@ -61,8 +61,7 @@ class TraceSchedulingAspect { @Around("execution (@org.springframework.scheduling.annotation.Scheduled * *.*(..))") public Object traceBackgroundThread(final ProceedingJoinPoint pjp) throws Throwable { - if (this.skipPattern != null && this.skipPattern - .matcher(pjp.getTarget().getClass().getName()).matches()) { + if (this.skipPattern != null && this.skipPattern.matcher(pjp.getTarget().getClass().getName()).matches()) { // we might have a span in context due to wrapping of runnables // we want to clear that context this.tracer.withSpanInScope(null); @@ -76,8 +75,7 @@ class TraceSchedulingAspect { return pjp.proceed(); } catch (Throwable ex) { - String message = ex.getMessage() == null ? ex.getClass().getSimpleName() - : ex.getMessage(); + String message = ex.getMessage() == null ? ex.getClass().getSimpleName() : ex.getMessage(); span.tag("error", message); throw ex; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAutoConfiguration.java index 3981f046e..ab9fb1a4d 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAutoConfiguration.java @@ -50,8 +50,7 @@ class TraceSchedulingAutoConfiguration { public TraceSchedulingAspect traceSchedulingAspect(Tracer tracer, SleuthSchedulingProperties sleuthSchedulingProperties) { String skipPatternString = sleuthSchedulingProperties.getSkipPattern(); - Pattern skipPattern = skipPatternString != null - ? Pattern.compile(skipPatternString) : null; + Pattern skipPattern = skipPatternString != null ? Pattern.compile(skipPatternString) : null; return new TraceSchedulingAspect(tracer, skipPattern); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientRequestParser.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientRequestParser.java index 794208129..7b612b7a7 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientRequestParser.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientRequestParser.java @@ -35,8 +35,7 @@ import org.springframework.beans.factory.annotation.Qualifier; * @see Qualifier * @since 2.2.2 */ -@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, - ElementType.ANNOTATION_TYPE }) +@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE }) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientResponseParser.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientResponseParser.java index e1db8cd77..600af21e8 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientResponseParser.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientResponseParser.java @@ -35,8 +35,7 @@ import org.springframework.beans.factory.annotation.Qualifier; * @see Qualifier * @since 2.2.2 */ -@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, - ElementType.ANNOTATION_TYPE }) +@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE }) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientSampler.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientSampler.java index 780780a02..559b892a3 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientSampler.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpClientSampler.java @@ -34,8 +34,7 @@ import org.springframework.beans.factory.annotation.Qualifier; * @since 2.2.0 * @see Qualifier */ -@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, - ElementType.ANNOTATION_TYPE }) +@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE }) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerRequestParser.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerRequestParser.java index b5e49214a..87216a1f5 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerRequestParser.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerRequestParser.java @@ -35,8 +35,7 @@ import org.springframework.beans.factory.annotation.Qualifier; * @see Qualifier * @since 2.2.2 */ -@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, - ElementType.ANNOTATION_TYPE }) +@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE }) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerResponseParser.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerResponseParser.java index 7ccee7ed1..1aa5940a8 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerResponseParser.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerResponseParser.java @@ -35,8 +35,7 @@ import org.springframework.beans.factory.annotation.Qualifier; * @see Qualifier * @since 2.2.2 */ -@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, - ElementType.ANNOTATION_TYPE }) +@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE }) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerSampler.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerSampler.java index 0e3c5f7b4..188e2d65d 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerSampler.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/HttpServerSampler.java @@ -34,8 +34,7 @@ import org.springframework.beans.factory.annotation.Qualifier; * @since 2.2.0 * @see Qualifier */ -@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, - ElementType.ANNOTATION_TYPE }) +@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE }) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/ServletUtils.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/ServletUtils.java index 35f79a35a..72cc4b573 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/ServletUtils.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/ServletUtils.java @@ -31,8 +31,7 @@ final class ServletUtils { } - static String getHeader(HttpServletRequest request, HttpServletResponse response, - String name) { + static String getHeader(HttpServletRequest request, HttpServletResponse response, String name) { String value = request.getHeader(name); return value != null ? value : response.getHeader(name); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/SkipPatternConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/SkipPatternConfiguration.java index 6165c101c..5f3914a27 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/SkipPatternConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/SkipPatternConfiguration.java @@ -64,8 +64,7 @@ class SkipPatternConfiguration { @Bean @ConditionalOnMissingBean - SkipPatternProvider sleuthSkipPatternProvider( - @Nullable List patterns) { + SkipPatternProvider sleuthSkipPatternProvider(@Nullable List patterns) { if (patterns == null || patterns.isEmpty()) { return null; } @@ -96,9 +95,8 @@ class SkipPatternConfiguration { @Nullable static Pattern consolidateSkipPatterns(List patterns) { - List presentPatterns = patterns.stream() - .map(SingleSkipPattern::skipPattern).filter(Optional::isPresent) - .map(Optional::get).collect(Collectors.toList()); + List presentPatterns = patterns.stream().map(SingleSkipPattern::skipPattern) + .filter(Optional::isPresent).map(Optional::get).collect(Collectors.toList()); if (presentPatterns.isEmpty()) { return null; } @@ -116,8 +114,8 @@ class SkipPatternConfiguration { @Configuration(proxyBeanMethods = false) @ConditionalOnClass(ManagementServerProperties.class) - @ConditionalOnProperty(value = "spring.sleuth.web.ignoreAutoConfiguredSkipPatterns", - havingValue = "false", matchIfMissing = true) + @ConditionalOnProperty(value = "spring.sleuth.web.ignoreAutoConfiguredSkipPatterns", havingValue = "false", + matchIfMissing = true) protected static class ManagementSkipPatternProviderConfig { /** @@ -126,38 +124,33 @@ class SkipPatternConfiguration { * @param managementServerProperties properties * @return optional skip pattern */ - static Optional getPatternForManagementServerProperties( - Environment environment, + static Optional getPatternForManagementServerProperties(Environment environment, ManagementServerProperties managementServerProperties) { String contextPath = managementServerProperties.getServlet().getContextPath(); if (StringUtils.hasText(contextPath)) { - return Optional.of(Pattern - .compile(environment.resolvePlaceholders(contextPath) + ".*")); + return Optional.of(Pattern.compile(environment.resolvePlaceholders(contextPath) + ".*")); } return Optional.empty(); } @Bean @ConditionalOnBean(ManagementServerProperties.class) - public SingleSkipPattern skipPatternForManagementServerProperties( - Environment environment, + public SingleSkipPattern skipPatternForManagementServerProperties(Environment environment, final ManagementServerProperties managementServerProperties) { - return () -> getPatternForManagementServerProperties(environment, - managementServerProperties); + return () -> getPatternForManagementServerProperties(environment, managementServerProperties); } } @Configuration(proxyBeanMethods = false) - @ConditionalOnClass({ ServerProperties.class, EndpointsSupplier.class, - ExposableWebEndpoint.class }) + @ConditionalOnClass({ ServerProperties.class, EndpointsSupplier.class, ExposableWebEndpoint.class }) @ConditionalOnBean(ServerProperties.class) - @ConditionalOnProperty(value = "spring.sleuth.web.ignoreAutoConfiguredSkipPatterns", - havingValue = "false", matchIfMissing = true) + @ConditionalOnProperty(value = "spring.sleuth.web.ignoreAutoConfiguredSkipPatterns", havingValue = "false", + matchIfMissing = true) protected static class ActuatorSkipPatternProviderConfig { - static Optional getEndpointsPatterns(Environment environment, - String contextPath, WebEndpointProperties webEndpointProperties, + static Optional getEndpointsPatterns(Environment environment, String contextPath, + WebEndpointProperties webEndpointProperties, EndpointsSupplier endpointsSupplier) { Collection endpoints = endpointsSupplier.getEndpoints(); if (endpoints.isEmpty()) { @@ -166,16 +159,14 @@ class SkipPatternConfiguration { String basePath = webEndpointProperties.getBasePath(); String pattern = patternFromEndpoints(contextPath, endpoints, basePath); if (StringUtils.hasText(pattern)) { - return Optional - .of(Pattern.compile(environment.resolvePlaceholders(pattern))); + return Optional.of(Pattern.compile(environment.resolvePlaceholders(pattern))); } return Optional.empty(); } - private static String patternFromEndpoints(String contextPath, - Collection endpoints, String basePath) { - StringJoiner joiner = new StringJoiner("|", - getPathPrefix(contextPath, basePath), + private static String patternFromEndpoints(String contextPath, Collection endpoints, + String basePath) { + StringJoiner joiner = new StringJoiner("|", getPathPrefix(contextPath, basePath), getPathSuffix(contextPath, basePath)); for (ExposableWebEndpoint endpoint : endpoints) { String path = endpoint.getRootPath(); @@ -203,8 +194,8 @@ class SkipPatternConfiguration { private static String getPathSuffix(String contextPath, String actuatorBasePath) { String result = ")"; - if (StringUtils.hasText(contextPath) || (StringUtils.hasText(actuatorBasePath) - && !"/".equals(actuatorBasePath))) { + if (StringUtils.hasText(contextPath) + || (StringUtils.hasText(actuatorBasePath) && !"/".equals(actuatorBasePath))) { result += ")?"; } return result; @@ -212,25 +203,21 @@ class SkipPatternConfiguration { @Bean @ConditionalOnManagementPort(ManagementPortType.SAME) - public SingleSkipPattern skipPatternForActuatorEndpointsSamePort( - Environment environment, final ServerProperties serverProperties, - final WebEndpointProperties webEndpointProperties, + public SingleSkipPattern skipPatternForActuatorEndpointsSamePort(Environment environment, + final ServerProperties serverProperties, final WebEndpointProperties webEndpointProperties, final EndpointsSupplier endpointsSupplier) { - return () -> getEndpointsPatterns(environment, - serverProperties.getServlet().getContextPath(), webEndpointProperties, - endpointsSupplier); + return () -> getEndpointsPatterns(environment, serverProperties.getServlet().getContextPath(), + webEndpointProperties, endpointsSupplier); } @Bean @ConditionalOnManagementPort(ManagementPortType.DIFFERENT) - @ConditionalOnProperty(name = "management.server.servlet.context-path", - havingValue = "/", matchIfMissing = true) - public SingleSkipPattern skipPatternForActuatorEndpointsDifferentPort( - Environment environment, final ServerProperties serverProperties, - final WebEndpointProperties webEndpointProperties, + @ConditionalOnProperty(name = "management.server.servlet.context-path", havingValue = "/", + matchIfMissing = true) + public SingleSkipPattern skipPatternForActuatorEndpointsDifferentPort(Environment environment, + final ServerProperties serverProperties, final WebEndpointProperties webEndpointProperties, final EndpointsSupplier endpointsSupplier) { - return () -> getEndpointsPatterns(environment, null, webEndpointProperties, - endpointsSupplier); + return () -> getEndpointsPatterns(environment, null, webEndpointProperties, endpointsSupplier); } } @@ -239,15 +226,12 @@ class SkipPatternConfiguration { static class DefaultSkipPatternConfig { @Bean - SingleSkipPattern defaultSkipPatternBean(Environment environment, - SleuthWebProperties sleuthWebProperties) { + SingleSkipPattern defaultSkipPatternBean(Environment environment, SleuthWebProperties sleuthWebProperties) { String skipPattern = sleuthWebProperties.getSkipPattern(); - String left = StringUtils.hasText(skipPattern) - ? environment.resolvePlaceholders(skipPattern) : skipPattern; + String left = StringUtils.hasText(skipPattern) ? environment.resolvePlaceholders(skipPattern) : skipPattern; String additionalSkipPattern = sleuthWebProperties.getAdditionalSkipPattern(); String right = StringUtils.hasText(additionalSkipPattern) - ? environment.resolvePlaceholders(additionalSkipPattern) - : additionalSkipPattern; + ? environment.resolvePlaceholders(additionalSkipPattern) : additionalSkipPattern; Pattern pattern = combinePatterns(left, right); return () -> Optional.ofNullable(pattern); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/SleuthWebProperties.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/SleuthWebProperties.java index 1bf866946..335ff3868 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/SleuthWebProperties.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/SleuthWebProperties.java @@ -107,8 +107,7 @@ class SleuthWebProperties { return ignoreAutoConfiguredSkipPatterns; } - public void setIgnoreAutoConfiguredSkipPatterns( - boolean ignoreAutoConfiguredSkipPatterns) { + public void setIgnoreAutoConfiguredSkipPatterns(boolean ignoreAutoConfiguredSkipPatterns) { this.ignoreAutoConfiguredSkipPatterns = ignoreAutoConfiguredSkipPatterns; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceHttpAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceHttpAutoConfiguration.java index f61d0410d..9d5577bb7 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceHttpAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceHttpAutoConfiguration.java @@ -52,9 +52,8 @@ import org.springframework.lang.Nullable; // conditional on "spring.sleuth.web.enabled". As this is conditional on // "spring.sleuth.http.enabled", to be compatible with old behavior we have // to be conditional on two properties. -@ConditionalOnProperty( - name = { "spring.sleuth.http.enabled", "spring.sleuth.web.enabled" }, - havingValue = "true", matchIfMissing = true) +@ConditionalOnProperty(name = { "spring.sleuth.http.enabled", "spring.sleuth.web.enabled" }, havingValue = "true", + matchIfMissing = true) @ConditionalOnBean(Tracing.class) @ConditionalOnClass(HttpTracing.class) @AutoConfigureAfter(TraceAutoConfiguration.class) @@ -80,8 +79,8 @@ public class TraceHttpAutoConfiguration { @Nullable List httpTracingCustomizers) { SamplerFunction combinedSampler = combineUserProvidedSamplerWithSkipPatternSampler( httpServerSampler, provider); - HttpTracing.Builder builder = HttpTracing.newBuilder(tracing) - .clientSampler(httpClientSampler).serverSampler(combinedSampler); + HttpTracing.Builder builder = HttpTracing.newBuilder(tracing).clientSampler(httpClientSampler) + .serverSampler(combinedSampler); if (httpClientRequestParser != null || httpClientResponseParser != null) { if (httpClientRequestParser != null) { @@ -116,10 +115,9 @@ public class TraceHttpAutoConfiguration { } private SamplerFunction combineUserProvidedSamplerWithSkipPatternSampler( - @Nullable SamplerFunction serverSampler, - @Nullable SkipPatternProvider provider) { - SamplerFunction skipPatternSampler = provider != null - ? new SkipPatternHttpServerSampler(provider) : null; + @Nullable SamplerFunction serverSampler, @Nullable SkipPatternProvider provider) { + SamplerFunction skipPatternSampler = provider != null ? new SkipPatternHttpServerSampler(provider) + : null; if (serverSampler == null && skipPatternSampler == null) { return SamplerFunctions.deferDecision(); } @@ -134,8 +132,7 @@ public class TraceHttpAutoConfiguration { @Bean @ConditionalOnMissingBean(name = HttpClientSampler.NAME) - SamplerFunction sleuthHttpClientSampler( - SleuthWebProperties sleuthWebProperties) { + SamplerFunction sleuthHttpClientSampler(SleuthWebProperties sleuthWebProperties) { String skipPattern = sleuthWebProperties.getClient().getSkipPattern(); if (skipPattern == null) { return SamplerFunctions.deferDecision(); @@ -157,8 +154,7 @@ final class CompositeHttpSampler implements SamplerFunction { final SamplerFunction right; - CompositeHttpSampler(SamplerFunction left, - SamplerFunction right) { + CompositeHttpSampler(SamplerFunction left, SamplerFunction right) { this.left = left; this.right = right; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebAspect.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebAspect.java index 99ddf0768..392294a57 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebAspect.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebAspect.java @@ -56,8 +56,7 @@ import org.springframework.web.context.request.async.WebAsyncTask; @Aspect class TraceWebAspect { - private static final Log log = org.apache.commons.logging.LogFactory - .getLog(TraceWebAspect.class); + private static final Log log = org.apache.commons.logging.LogFactory.getLog(TraceWebAspect.class); private final Tracing tracing; @@ -107,8 +106,7 @@ class TraceWebAspect { } @Around("anyControllerOrRestControllerWithPublicWebAsyncTaskMethod()") - public Object wrapWebAsyncTaskWithCorrelationId(ProceedingJoinPoint pjp) - throws Throwable { + public Object wrapWebAsyncTaskWithCorrelationId(ProceedingJoinPoint pjp) throws Throwable { final WebAsyncTask webAsyncTask = (WebAsyncTask) pjp.proceed(); TraceContext currentSpan = this.tracing.currentTraceContext().get(); if (currentSpan == null) { @@ -120,8 +118,8 @@ class TraceWebAspect { } Field callableField = WebAsyncTask.class.getDeclaredField("callable"); callableField.setAccessible(true); - callableField.set(webAsyncTask, new TraceCallable<>(this.tracing, - this.spanNamer, webAsyncTask.getCallable())); + callableField.set(webAsyncTask, + new TraceCallable<>(this.tracing, this.spanNamer, webAsyncTask.getCallable())); } catch (NoSuchFieldException ex) { log.warn("Cannot wrap webAsyncTask's callable with TraceCallable", ex); diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebFilter.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebFilter.java index d3bba36ad..2774adec7 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebFilter.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebFilter.java @@ -74,8 +74,7 @@ final class TraceWebFilter implements WebFilter, Ordered { private static final String STATUS_CODE_KEY = "http.status_code"; - private static final String TRACE_SPAN_WITHOUT_PARENT = TraceWebFilter.class.getName() - + ".SPAN_WITH_NO_PARENT"; + private static final String TRACE_SPAN_WITHOUT_PARENT = TraceWebFilter.class.getName() + ".SPAN_WITH_NO_PARENT"; private final BeanFactory beanFactory; @@ -98,8 +97,7 @@ final class TraceWebFilter implements WebFilter, Ordered { @SuppressWarnings("unchecked") HttpServerHandler handler() { if (this.handler == null) { - this.handler = HttpServerHandler - .create(this.beanFactory.getBean(HttpTracing.class)); + this.handler = HttpServerHandler.create(this.beanFactory.getBean(HttpTracing.class)); } return this.handler; } @@ -120,8 +118,7 @@ final class TraceWebFilter implements WebFilter, Ordered { SleuthReactorProperties sleuthReactorProperties() { if (this.sleuthReactorProperties == null) { - this.sleuthReactorProperties = this.beanFactory - .getBean(SleuthReactorProperties.class); + this.sleuthReactorProperties = this.beanFactory.getBean(SleuthReactorProperties.class); } return this.sleuthReactorProperties; } @@ -138,8 +135,7 @@ final class TraceWebFilter implements WebFilter, Ordered { } private boolean isTracePresent() { - if (sleuthReactorProperties() - .getInstrumentationType() == SleuthReactorProperties.InstrumentationType.MANUAL) { + if (sleuthReactorProperties().getInstrumentationType() == SleuthReactorProperties.InstrumentationType.MANUAL) { return false; } boolean tracePresent = tracer().currentSpan() != null; @@ -169,8 +165,8 @@ final class TraceWebFilter implements WebFilter, Ordered { final boolean initialTracePresent; - MonoWebFilterTrace(Mono source, ServerWebExchange exchange, - boolean initialTracePresent, TraceWebFilter parent) { + MonoWebFilterTrace(Mono source, ServerWebExchange exchange, boolean initialTracePresent, + TraceWebFilter parent) { super(source); this.tracer = parent.tracer(); this.handler = parent.handler(); @@ -182,8 +178,7 @@ final class TraceWebFilter implements WebFilter, Ordered { @Override public void subscribe(CoreSubscriber subscriber) { Context context = contextWithoutInitialSpan(subscriber.currentContext()); - this.source.subscribe(new WebFilterTraceSubscriber(subscriber, context, - findOrCreateSpan(context), this)); + this.source.subscribe(new WebFilterTraceSubscriber(subscriber, context, findOrCreateSpan(context), this)); } private Context contextWithoutInitialSpan(Context context) { @@ -205,15 +200,13 @@ final class TraceWebFilter implements WebFilter, Ordered { } else { if (this.traceContext != null) { - span = this.tracer.nextSpan( - TraceContextOrSamplingFlags.create(this.traceContext)); + span = this.tracer.nextSpan(TraceContextOrSamplingFlags.create(this.traceContext)); if (log.isDebugEnabled()) { log.debug("Found span in attribute " + span); } } else { - span = this.handler.handleReceive( - new WrappedRequest(this.exchange.getRequest())); + span = this.handler.handleReceive(new WrappedRequest(this.exchange.getRequest())); if (log.isDebugEnabled()) { log.debug("Handled receive of span " + span); } @@ -235,8 +228,8 @@ final class TraceWebFilter implements WebFilter, Ordered { final HttpServerHandler handler; - WebFilterTraceSubscriber(CoreSubscriber actual, Context context, - Span span, MonoWebFilterTrace parent) { + WebFilterTraceSubscriber(CoreSubscriber actual, Context context, Span span, + MonoWebFilterTrace parent) { this.actual = actual; this.span = span; this.context = context.put(TraceContext.class, span.context()); @@ -272,17 +265,13 @@ final class TraceWebFilter implements WebFilter, Ordered { } private void terminateSpan(@Nullable Throwable t) { - Object attribute = this.exchange - .getAttribute(HandlerMapping.BEST_MATCHING_HANDLER_ATTRIBUTE); + Object attribute = this.exchange.getAttribute(HandlerMapping.BEST_MATCHING_HANDLER_ATTRIBUTE); addClassMethodTag(attribute, this.span); addClassNameTag(attribute, this.span); - Object pattern = this.exchange - .getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE); + Object pattern = this.exchange.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE); String httpRoute = pattern != null ? pattern.toString() : ""; - addResponseTagsForSpanWithoutParent(this.exchange, - this.exchange.getResponse(), this.span); - WrappedResponse response = new WrappedResponse( - this.exchange.getResponse(), + addResponseTagsForSpanWithoutParent(this.exchange, this.exchange.getResponse(), this.span); + WrappedResponse response = new WrappedResponse(this.exchange.getResponse(), this.exchange.getRequest().getMethodValue(), httpRoute); this.handler.handleSend(response, t, this.span); if (log.isDebugEnabled()) { @@ -295,8 +284,7 @@ final class TraceWebFilter implements WebFilter, Ordered { String methodName = ((HandlerMethod) handler).getMethod().getName(); span.tag(MVC_CONTROLLER_METHOD_KEY, methodName); if (log.isDebugEnabled()) { - log.debug("Adding a method tag with value [" + methodName - + "] to a span " + span); + log.debug("Adding a method tag with value [" + methodName + "] to a span " + span); } } } @@ -313,18 +301,15 @@ final class TraceWebFilter implements WebFilter, Ordered { className = handler.getClass().getSimpleName(); } if (log.isDebugEnabled()) { - log.debug("Adding a class tag with value [" + className - + "] to a span " + span); + log.debug("Adding a class tag with value [" + className + "] to a span " + span); } span.tag(MVC_CONTROLLER_CLASS_KEY, className); } - private void addResponseTagsForSpanWithoutParent(ServerWebExchange exchange, - ServerHttpResponse response, Span span) { - if (spanWithoutParent(exchange) && response.getStatusCode() != null - && span != null) { - span.tag(STATUS_CODE_KEY, - String.valueOf(response.getStatusCode().value())); + private void addResponseTagsForSpanWithoutParent(ServerWebExchange exchange, ServerHttpResponse response, + Span span) { + if (spanWithoutParent(exchange) && response.getStatusCode() != null && span != null) { + span.tag(STATUS_CODE_KEY, String.valueOf(response.getStatusCode().value())); } } @@ -363,8 +348,7 @@ final class TraceWebFilter implements WebFilter, Ordered { if (addr == null) { return false; } - return span.remoteIpAndPort(addr.getAddress().getHostAddress(), - addr.getPort()); + return span.remoteIpAndPort(addr.getAddress().getHostAddress(), addr.getPort()); } @Override diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebMvcConfigurer.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebMvcConfigurer.java index 927b2d80e..5d67ff5ef 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebMvcConfigurer.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebMvcConfigurer.java @@ -40,8 +40,7 @@ class TraceWebMvcConfigurer implements WebMvcConfigurer { @Override public void addInterceptors(InterceptorRegistry registry) { - registry.addInterceptor(this.applicationContext - .getBean(SpanCustomizingAsyncHandlerInterceptor.class)); + registry.addInterceptor(this.applicationContext.getBean(SpanCustomizingAsyncHandlerInterceptor.class)); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebServletAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebServletAutoConfiguration.java index 4d007b4ea..a448b1fe0 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebServletAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/TraceWebServletAutoConfiguration.java @@ -74,13 +74,10 @@ class TraceWebServletAutoConfiguration { } @Bean - public FilterRegistrationBean traceWebFilter(BeanFactory beanFactory, - SleuthWebProperties webProperties) { - FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean( - new LazyTracingFilter(beanFactory)); - filterRegistrationBean.setDispatcherTypes(DispatcherType.ASYNC, - DispatcherType.ERROR, DispatcherType.FORWARD, DispatcherType.INCLUDE, - DispatcherType.REQUEST); + public FilterRegistrationBean traceWebFilter(BeanFactory beanFactory, SleuthWebProperties webProperties) { + FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new LazyTracingFilter(beanFactory)); + filterRegistrationBean.setDispatcherTypes(DispatcherType.ASYNC, DispatcherType.ERROR, DispatcherType.FORWARD, + DispatcherType.INCLUDE, DispatcherType.REQUEST); filterRegistrationBean.setOrder(webProperties.getFilterOrder()); return filterRegistrationBean; } @@ -120,8 +117,8 @@ final class LazyTracingFilter implements Filter { } @Override - public void doFilter(ServletRequest request, ServletResponse response, - FilterChain chain) throws IOException, ServletException { + public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) + throws IOException, ServletException { tracingFilter().doFilter(request, response, chain); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/WebFluxSleuthOperators.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/WebFluxSleuthOperators.java index 136296799..b0684c025 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/WebFluxSleuthOperators.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/WebFluxSleuthOperators.java @@ -51,8 +51,7 @@ public final class WebFluxSleuthOperators { * @param runnable - lambda to execute within the tracing context * @return consumer of a signal */ - public static Consumer withSpanInScope(SignalType signalType, - Runnable runnable) { + public static Consumer withSpanInScope(SignalType signalType, Runnable runnable) { return signal -> { if (signalType != signal.getType()) { return; @@ -67,8 +66,7 @@ public final class WebFluxSleuthOperators { * @param consumer - lambda to execute within the tracing context * @return consumer of a signal */ - public static Consumer withSpanInScope(SignalType signalType, - Consumer consumer) { + public static Consumer withSpanInScope(SignalType signalType, Consumer consumer) { return signal -> { if (signalType != signal.getType()) { return; @@ -97,8 +95,7 @@ public final class WebFluxSleuthOperators { public static void withSpanInScope(Context context, Runnable runnable) { CurrentTraceContext currentTraceContext = context.get(CurrentTraceContext.class); TraceContext traceContext = traceContextOrNew(context); - try (CurrentTraceContext.Scope scope = currentTraceContext - .maybeScope(traceContext)) { + try (CurrentTraceContext.Scope scope = currentTraceContext.maybeScope(traceContext)) { runnable.run(); } } @@ -134,12 +131,10 @@ public final class WebFluxSleuthOperators { * its attribute * @param runnable - lambda to execute within the tracing context */ - public static void withSpanInScope(Tracing tracing, ServerWebExchange exchange, - Runnable runnable) { + public static void withSpanInScope(Tracing tracing, ServerWebExchange exchange, Runnable runnable) { CurrentTraceContext currentTraceContext = tracing.currentTraceContext(); TraceContext traceContext = traceContextFromExchangeOrNew(tracing, exchange); - try (CurrentTraceContext.Scope scope = currentTraceContext - .maybeScope(traceContext)) { + try (CurrentTraceContext.Scope scope = currentTraceContext.maybeScope(traceContext)) { runnable.run(); } } @@ -153,8 +148,7 @@ public final class WebFluxSleuthOperators { * @param callable's return type * @return value from the callable */ - public static T withSpanInScope(Tracing tracing, ServerWebExchange exchange, - Callable callable) { + public static T withSpanInScope(Tracing tracing, ServerWebExchange exchange, Callable callable) { CurrentTraceContext currentTraceContext = tracing.currentTraceContext(); TraceContext traceContext = traceContextFromExchangeOrNew(tracing, exchange); return withContext(callable, currentTraceContext, traceContext); @@ -189,10 +183,9 @@ public final class WebFluxSleuthOperators { return currentTraceContext(signal.getContext()); } - private static T withContext(Callable callable, - CurrentTraceContext currentTraceContext, TraceContext traceContext) { - try (CurrentTraceContext.Scope scope = currentTraceContext - .maybeScope(traceContext)) { + private static T withContext(Callable callable, CurrentTraceContext currentTraceContext, + TraceContext traceContext) { + try (CurrentTraceContext.Scope scope = currentTraceContext.maybeScope(traceContext)) { try { return callable.call(); } @@ -202,8 +195,7 @@ public final class WebFluxSleuthOperators { } } - private static TraceContext traceContextFromExchangeOrNew(Tracing tracing, - ServerWebExchange exchange) { + private static TraceContext traceContextFromExchangeOrNew(Tracing tracing, ServerWebExchange exchange) { TraceContext traceContext = exchange.getAttribute(TraceContext.class.getName()); if (traceContext == null) { if (log.isDebugEnabled()) { diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/HttpClientBeanPostProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/HttpClientBeanPostProcessor.java index 4aa240768..74d8b1b6c 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/HttpClientBeanPostProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/HttpClientBeanPostProcessor.java @@ -50,10 +50,8 @@ class HttpClientBeanPostProcessor implements BeanPostProcessor { } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { - LazyBean httpTracing = LazyBean.create(this.springContext, - HttpTracing.class); + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { + LazyBean httpTracing = LazyBean.create(this.springContext, HttpTracing.class); if (bean instanceof HttpClient) { // This adds handlers to manage the span lifecycle. All require explicit // propagation of the current span as a reactor context property. @@ -63,15 +61,12 @@ class HttpClientBeanPostProcessor implements BeanPostProcessor { // In our case, we treat a normal response no differently than one in // preparation of a redirect follow-up. TracingDoOnResponse doOnResponse = new TracingDoOnResponse(httpTracing); - return ((HttpClient) bean) - .doOnResponseError(new TracingDoOnErrorResponse(httpTracing)) + return ((HttpClient) bean).doOnResponseError(new TracingDoOnErrorResponse(httpTracing)) .doOnRedirect(doOnResponse).doOnResponse(doOnResponse) .doOnRequestError(new TracingDoOnErrorRequest(httpTracing)) - .doOnRequest(new TracingDoOnRequest(httpTracing)) - .mapConnect(new TracingMapConnect(() -> { + .doOnRequest(new TracingDoOnRequest(httpTracing)).mapConnect(new TracingMapConnect(() -> { HttpTracing ref = httpTracing.get(); - return ref != null ? ref.tracing().currentTraceContext().get() - : null; + return ref != null ? ref.tracing().currentTraceContext().get() : null; })); } return bean; @@ -82,8 +77,7 @@ class HttpClientBeanPostProcessor implements BeanPostProcessor { } - static class TracingMapConnect - implements Function, Mono> { + static class TracingMapConnect implements Function, Mono> { static final Exception CANCELLED_ERROR = new CancellationException("CANCELLED") { @Override @@ -123,8 +117,7 @@ class HttpClientBeanPostProcessor implements BeanPostProcessor { } - private static class TracingDoOnRequest - implements BiConsumer { + private static class TracingDoOnRequest implements BiConsumer { final LazyBean httpTracing; @@ -143,8 +136,7 @@ class HttpClientBeanPostProcessor implements BeanPostProcessor { @Override public void accept(HttpClientRequest req, Connection connection) { - PendingSpan pendingSpan = req.currentContext().getOrDefault(PendingSpan.class, - null); + PendingSpan pendingSpan = req.currentContext().getOrDefault(PendingSpan.class, null); if (pendingSpan == null) { return; // Somehow TracingMapConnect was not invoked.. skip out } @@ -159,8 +151,7 @@ class HttpClientBeanPostProcessor implements BeanPostProcessor { } // Start a new client span with the appropriate parent - TraceContext parent = req.currentContext().getOrDefault(TraceContext.class, - null); + TraceContext parent = req.currentContext().getOrDefault(TraceContext.class, null); HttpClientRequestWrapper request = new HttpClientRequestWrapper(req); span = handler().handleSendWithParent(request, parent); @@ -175,8 +166,7 @@ class HttpClientBeanPostProcessor implements BeanPostProcessor { SocketAddress socketAddress = connection.address(); if (socketAddress instanceof InetSocketAddress) { InetSocketAddress inetSocketAddress = (InetSocketAddress) socketAddress; - span.remoteIpAndPort(inetSocketAddress.getHostString(), - inetSocketAddress.getPort()); + span.remoteIpAndPort(inetSocketAddress.getHostString(), inetSocketAddress.getPort()); } } @@ -241,8 +231,7 @@ class HttpClientBeanPostProcessor implements BeanPostProcessor { return this.handler; } - void handle(Context context, @Nullable HttpClientResponse resp, - @Nullable Throwable error) { + void handle(Context context, @Nullable HttpClientResponse resp, @Nullable Throwable error) { PendingSpan pendingSpan = context.getOrDefault(PendingSpan.class, null); if (pendingSpan == null) { return; // Somehow TracingMapConnect was not invoked.. skip out @@ -252,8 +241,7 @@ class HttpClientBeanPostProcessor implements BeanPostProcessor { if (span == null) { return; // Unexpected. In the handle method, without a span to finish! } - HttpClientResponseWrapper response = resp != null - ? new HttpClientResponseWrapper(resp) : null; + HttpClientResponseWrapper response = resp != null ? new HttpClientResponseWrapper(resp) : null; handler().handleReceive(response, error, span); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceGatewayEnvironmentPostProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceGatewayEnvironmentPostProcessor.java index 2f656651d..bc68f9a03 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceGatewayEnvironmentPostProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceGatewayEnvironmentPostProcessor.java @@ -39,27 +39,22 @@ import org.springframework.util.StringUtils; */ class TraceGatewayEnvironmentPostProcessor implements EnvironmentPostProcessor { - private static final Log log = LogFactory - .getLog(TraceGatewayEnvironmentPostProcessor.class); + private static final Log log = LogFactory.getLog(TraceGatewayEnvironmentPostProcessor.class); private static final String PROPERTY_SOURCE_NAME = "defaultProperties"; @Override - public void postProcessEnvironment(ConfigurableEnvironment environment, - SpringApplication application) { + public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) { Map map = new HashMap<>(); if (sleuthEnabled(environment) && isGatewayOnTheClasspath()) { - String instrumentationType = environment - .getProperty("spring.sleuth.reactor.instrumentation-type"); + String instrumentationType = environment.getProperty("spring.sleuth.reactor.instrumentation-type"); if (log.isDebugEnabled()) { - log.debug("Found the following instrumentation type [" - + instrumentationType + "]"); + log.debug("Found the following instrumentation type [" + instrumentationType + "]"); } if (StringUtils.isEmpty(instrumentationType)) { instrumentationType = "manual"; if (log.isDebugEnabled()) { - log.debug("No instrumentation type passed, will force it to [" - + instrumentationType + "]"); + log.debug("No instrumentation type passed, will force it to [" + instrumentationType + "]"); } } map.put("spring.sleuth.reactor.instrumentation-type", instrumentationType); @@ -68,14 +63,12 @@ class TraceGatewayEnvironmentPostProcessor implements EnvironmentPostProcessor { } private boolean sleuthEnabled(ConfigurableEnvironment environment) { - return Boolean - .parseBoolean(environment.getProperty("spring.sleuth.enabled", "true")); + return Boolean.parseBoolean(environment.getProperty("spring.sleuth.enabled", "true")); } private boolean isGatewayOnTheClasspath() { try { - ClassUtils.forName("org.springframework.cloud.gateway.filter.GatewayFilter", - null); + ClassUtils.forName("org.springframework.cloud.gateway.filter.GatewayFilter", null); return true; } catch (ClassNotFoundException e) { @@ -83,8 +76,7 @@ class TraceGatewayEnvironmentPostProcessor implements EnvironmentPostProcessor { } } - private void addOrReplace(MutablePropertySources propertySources, - Map map) { + private void addOrReplace(MutablePropertySources propertySources, Map map) { MapPropertySource target = null; if (propertySources.contains(PROPERTY_SOURCE_NAME)) { PropertySource source = propertySources.get(PROPERTY_SOURCE_NAME); diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRequestHttpHeadersFilter.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRequestHttpHeadersFilter.java index 83abb19c4..67d800e15 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRequestHttpHeadersFilter.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRequestHttpHeadersFilter.java @@ -52,16 +52,14 @@ final class TraceRequestHttpHeadersFilter extends AbstractHttpHeadersFilter { @Override public HttpHeaders filter(HttpHeaders input, ServerWebExchange exchange) { if (log.isDebugEnabled()) { - log.debug("Will instrument the HTTP request headers [" - + exchange.getRequest().getHeaders() + "]"); + log.debug("Will instrument the HTTP request headers [" + exchange.getRequest().getHeaders() + "]"); } HttpClientRequest request = new HttpClientRequest(exchange.getRequest(), input); Span currentSpan = currentSpan(exchange, request); Span span = injectedSpan(request, currentSpan); if (log.isDebugEnabled()) { - log.debug( - "Client span " + span + " created for the request. New headers are " - + request.filteredHeaders.toSingleValueMap()); + log.debug("Client span " + span + " created for the request. New headers are " + + request.filteredHeaders.toSingleValueMap()); } exchange.getAttributes().put(SPAN_ATTRIBUTE, span); HttpHeaders headersWithInput = new HttpHeaders(); @@ -90,8 +88,7 @@ final class TraceRequestHttpHeadersFilter extends AbstractHttpHeadersFilter { Object attribute = exchange.getAttribute(TRACE_REQUEST_ATTR); if (attribute instanceof Span) { if (log.isDebugEnabled()) { - log.debug("Found trace request attribute in the server web exchange [" - + attribute + "]"); + log.debug("Found trace request attribute in the server web exchange [" + attribute + "]"); } return (Span) attribute; } @@ -106,8 +103,7 @@ final class TraceRequestHttpHeadersFilter extends AbstractHttpHeadersFilter { return this.handler.handleSend(request, clientSpan); } - private void addHeadersWithInput(HttpHeaders filteredHeaders, - HttpHeaders headersWithInput) { + private void addHeadersWithInput(HttpHeaders filteredHeaders, HttpHeaders headersWithInput) { for (Map.Entry> entry : filteredHeaders.entrySet()) { String key = entry.getKey(); List value = entry.getValue(); @@ -124,8 +120,7 @@ final class TraceRequestHttpHeadersFilter extends AbstractHttpHeadersFilter { final class TraceResponseHttpHeadersFilter extends AbstractHttpHeadersFilter { - private static final Log log = LogFactory - .getLog(TraceResponseHttpHeadersFilter.class); + private static final Log log = LogFactory.getLog(TraceResponseHttpHeadersFilter.class); private TraceResponseHttpHeadersFilter(HttpTracing httpTracing) { super(httpTracing); @@ -173,8 +168,7 @@ abstract class AbstractHttpHeadersFilter implements HttpHeadersFilter { AbstractHttpHeadersFilter(HttpTracing httpTracing) { this.tracer = httpTracing.tracing().tracer(); - this.extractor = httpTracing.tracing().propagation() - .extractor(HttpClientRequest::header); + this.extractor = httpTracing.tracing().propagation().extractor(HttpClientRequest::header); this.handler = HttpClientHandler.create(httpTracing); this.httpTracing = httpTracing; } @@ -237,8 +231,7 @@ abstract class AbstractHttpHeadersFilter implements HttpHeadersFilter { @Override public int statusCode() { - return delegate.getStatusCode() != null ? delegate.getStatusCode().value() - : 0; + return delegate.getStatusCode() != null ? delegate.getStatusCode().value() : 0; } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebAsyncClientAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebAsyncClientAutoConfiguration.java index 11b9b6c50..49733f1f1 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebAsyncClientAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebAsyncClientAutoConfiguration.java @@ -47,8 +47,7 @@ import org.springframework.web.client.AsyncRestTemplate; */ @Configuration(proxyBeanMethods = false) @SleuthWebClientEnabled -@ConditionalOnProperty(value = "spring.sleuth.web.async.client.enabled", - matchIfMissing = true) +@ConditionalOnProperty(value = "spring.sleuth.web.async.client.enabled", matchIfMissing = true) @ConditionalOnClass(AsyncRestTemplate.class) @ConditionalOnBean(HttpTracing.class) @AutoConfigureAfter(TraceHttpAutoConfiguration.class) diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientAutoConfiguration.java index 201811dc7..5f93b6c95 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientAutoConfiguration.java @@ -75,10 +75,8 @@ class TraceWebClientAutoConfiguration { static class RestTemplateConfig { @Bean - public TracingClientHttpRequestInterceptor tracingClientHttpRequestInterceptor( - HttpTracing httpTracing) { - return (TracingClientHttpRequestInterceptor) TracingClientHttpRequestInterceptor - .create(httpTracing); + public TracingClientHttpRequestInterceptor tracingClientHttpRequestInterceptor(HttpTracing httpTracing) { + return (TracingClientHttpRequestInterceptor) TracingClientHttpRequestInterceptor.create(httpTracing); } @Configuration(proxyBeanMethods = false) @@ -96,8 +94,7 @@ class TraceWebClientAutoConfiguration { @Bean @Order RestTemplateCustomizer traceRestTemplateCustomizer() { - return new TraceRestTemplateCustomizer( - new LazyTracingClientHttpRequestInterceptor(this.beanFactory)); + return new TraceRestTemplateCustomizer(new LazyTracingClientHttpRequestInterceptor(this.beanFactory)); } } @@ -161,16 +158,14 @@ class TraceWebClientAutoConfiguration { static class NettyConfiguration { @Bean - static HttpClientBeanPostProcessor httpClientBeanPostProcessor( - ConfigurableApplicationContext springContext) { + static HttpClientBeanPostProcessor httpClientBeanPostProcessor(ConfigurableApplicationContext springContext) { return new HttpClientBeanPostProcessor(springContext); } } @Configuration(proxyBeanMethods = false) - @ConditionalOnClass({ UserInfoRestTemplateCustomizer.class, - OAuth2RestTemplate.class }) + @ConditionalOnClass({ UserInfoRestTemplateCustomizer.class, OAuth2RestTemplate.class }) protected static class TraceOAuthConfiguration { @Bean @@ -181,13 +176,11 @@ class TraceWebClientAutoConfiguration { @Bean @ConditionalOnMissingBean - static UserInfoRestTemplateCustomizer traceUserInfoRestTemplateCustomizer( - BeanFactory beanFactory) { + static UserInfoRestTemplateCustomizer traceUserInfoRestTemplateCustomizer(BeanFactory beanFactory) { return new TraceUserInfoRestTemplateCustomizer(beanFactory); } - private static class UserInfoRestTemplateCustomizerBPP - implements BeanPostProcessor { + private static class UserInfoRestTemplateCustomizerBPP implements BeanPostProcessor { private final BeanFactory beanFactory; @@ -196,14 +189,12 @@ class TraceWebClientAutoConfiguration { } @Override - public Object postProcessBeforeInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override - public Object postProcessAfterInitialization(final Object bean, - String beanName) throws BeansException { + public Object postProcessAfterInitialization(final Object bean, String beanName) throws BeansException { final BeanFactory beanFactory = this.beanFactory; if (bean instanceof UserInfoRestTemplateCustomizer && !(bean instanceof TraceUserInfoRestTemplateCustomizer)) { @@ -272,14 +263,12 @@ class TraceRestTemplateBeanPostProcessor implements BeanPostProcessor { } @Override - public Object postProcessBeforeInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof RestTemplate) { RestTemplate rt = (RestTemplate) bean; new RestTemplateInterceptorInjector(interceptor()).inject(rt); @@ -304,15 +293,14 @@ class LazyTracingClientHttpRequestInterceptor implements ClientHttpRequestInterc } @Override - public ClientHttpResponse intercept(HttpRequest request, byte[] body, - ClientHttpRequestExecution execution) throws IOException { + public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) + throws IOException { return interceptor().intercept(request, body, execution); } private TracingClientHttpRequestInterceptor interceptor() { if (this.interceptor == null) { - this.interceptor = this.beanFactory - .getBean(TracingClientHttpRequestInterceptor.class); + this.interceptor = this.beanFactory.getBean(TracingClientHttpRequestInterceptor.class); } return this.interceptor; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientBeanPostProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientBeanPostProcessor.java index c537ba7be..0cce3641f 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientBeanPostProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientBeanPostProcessor.java @@ -97,8 +97,7 @@ final class TraceWebClientBeanPostProcessor implements BeanPostProcessor { }; } - private boolean noneMatchTraceExchangeFunction( - List functions) { + private boolean noneMatchTraceExchangeFunction(List functions) { for (ExchangeFilterFunction function : functions) { if (function instanceof TraceExchangeFilterFunction) { return false; @@ -127,8 +126,7 @@ final class TraceExchangeFilterFunction implements ExchangeFilterFunction { this.scopePassingTransformer = scopePassingSpanOperator(springContext); } - public static ExchangeFilterFunction create( - ConfigurableApplicationContext springContext) { + public static ExchangeFilterFunction create(ConfigurableApplicationContext springContext) { return new TraceExchangeFilterFunction(springContext); } @@ -161,8 +159,7 @@ final class TraceExchangeFilterFunction implements ExchangeFilterFunction { final CurrentTraceContext currentTraceContext; - MonoWebClientTrace(ExchangeFunction next, ClientRequest request, - TraceExchangeFilterFunction filterFunction) { + MonoWebClientTrace(ExchangeFunction next, ClientRequest request, TraceExchangeFilterFunction filterFunction) { this.next = next; this.request = request; this.handler = filterFunction.handler(); @@ -176,8 +173,7 @@ final class TraceExchangeFilterFunction implements ExchangeFilterFunction { log.trace("Got the following context [" + context + "]"); } ClientRequestWrapper wrapper = new ClientRequestWrapper(request); - TraceContext parent = context.hasKey(TraceContext.class) - ? context.get(TraceContext.class) : null; + TraceContext parent = context.hasKey(TraceContext.class) ? context.get(TraceContext.class) : null; Span span = handler.handleSendWithParent(wrapper, parent); if (log.isDebugEnabled()) { log.debug("HttpClientHandler::handleSend: " + span); @@ -186,8 +182,7 @@ final class TraceExchangeFilterFunction implements ExchangeFilterFunction { // canceled prior to actually being invoked. TraceWebClientSubscription will // abandon this span, if cancel() happens before request(). this.next.exchange(wrapper.buildRequest()) - .subscribe(new TraceWebClientSubscriber(subscriber, context, span, - parent, this)); + .subscribe(new TraceWebClientSubscriber(subscriber, context, span, parent, this)); } } @@ -206,16 +201,14 @@ final class TraceExchangeFilterFunction implements ExchangeFilterFunction { final CurrentTraceContext currentTraceContext; - TraceWebClientSubscriber(CoreSubscriber actual, - Context ctx, Span clientSpan, TraceContext parent, - MonoWebClientTrace mono) { + TraceWebClientSubscriber(CoreSubscriber actual, Context ctx, Span clientSpan, + TraceContext parent, MonoWebClientTrace mono) { this.actual = actual; this.parent = parent; this.handler = mono.handler; this.currentTraceContext = mono.currentTraceContext; - this.context = this.parent != null - && !this.parent.equals(ctx.getOrDefault(TraceContext.class, null)) - ? ctx.put(TraceContext.class, this.parent) : ctx; + this.context = this.parent != null && !this.parent.equals(ctx.getOrDefault(TraceContext.class, null)) + ? ctx.put(TraceContext.class, this.parent) : ctx; set(clientSpan); } @@ -234,8 +227,7 @@ final class TraceExchangeFilterFunction implements ExchangeFilterFunction { Span span = getAndSet(null); if (span != null) { // TODO: is there a way to read the request at response time? - this.handler.handleReceive(new ClientResponseWrapper(response), null, - span); + this.handler.handleReceive(new ClientResponseWrapper(response), null, span); } } } @@ -294,8 +286,7 @@ final class TraceExchangeFilterFunction implements ExchangeFilterFunction { volatile boolean requested; - TraceWebClientSubscription(Subscription delegate, - AtomicReference pendingSpan) { + TraceWebClientSubscription(Subscription delegate, AtomicReference pendingSpan) { this.delegate = delegate; this.pendingSpan = pendingSpan; } @@ -315,9 +306,8 @@ final class TraceExchangeFilterFunction implements ExchangeFilterFunction { Span span = pendingSpan.getAndSet(null); if (span != null) { if (log.isDebugEnabled()) { - log.debug( - "Subscription was cancelled. TraceWebClientBeanPostProcessor Will close the span [" - + span + "]"); + log.debug("Subscription was cancelled. TraceWebClientBeanPostProcessor Will close the span [" + span + + "]"); } if (!requested) { // Abandon the span. diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/FeignContextBeanPostProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/FeignContextBeanPostProcessor.java index 560446f4b..7155818a1 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/FeignContextBeanPostProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/FeignContextBeanPostProcessor.java @@ -36,14 +36,12 @@ final class FeignContextBeanPostProcessor implements BeanPostProcessor { } @Override - public Object postProcessBeforeInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof FeignContext && !(bean instanceof TraceFeignContext)) { return new TraceFeignContext(traceFeignObjectWrapper(), (FeignContext) bean); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/LazyClient.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/LazyClient.java index e62169ef4..c7ca6436a 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/LazyClient.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/LazyClient.java @@ -59,8 +59,7 @@ class LazyClient implements Client { this.delegate = this.beanFactory.getBean(Client.class); } catch (BeansException ex) { - this.delegate = TracingFeignClient.create( - beanFactory.getBean(HttpTracing.class), + this.delegate = TracingFeignClient.create(beanFactory.getBean(HttpTracing.class), new Client.Default(null, null)); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/LazyTracingFeignClient.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/LazyTracingFeignClient.java index 71bdba0b4..f79c4894b 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/LazyTracingFeignClient.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/LazyTracingFeignClient.java @@ -53,17 +53,15 @@ class LazyTracingFeignClient implements Client { @Override public Response execute(Request request, Request.Options options) throws IOException { if (log.isDebugEnabled()) { - log.debug( - "Sending a request via tracing feign client [" + tracingFeignClient() - + "] " + "and the delegate [" + this.delegate + "]"); + log.debug("Sending a request via tracing feign client [" + tracingFeignClient() + "] " + + "and the delegate [" + this.delegate + "]"); } return tracingFeignClient().execute(request, options); } private Client tracingFeignClient() { if (this.tracingFeignClient == null) { - this.tracingFeignClient = TracingFeignClient.create(httpTracing(), - this.delegate); + this.tracingFeignClient = TracingFeignClient.create(httpTracing(), this.delegate); } return this.tracingFeignClient; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/OkHttpFeignClientBeanPostProcessor.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/OkHttpFeignClientBeanPostProcessor.java index cf8f2cec3..c4193066d 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/OkHttpFeignClientBeanPostProcessor.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/OkHttpFeignClientBeanPostProcessor.java @@ -38,8 +38,7 @@ final class OkHttpFeignClientBeanPostProcessor implements BeanPostProcessor { } @Override - public Object postProcessBeforeInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if (bean instanceof OkHttpClient && !(bean instanceof LazyClient)) { return new LazyClient(this.beanFactory, (Client) bean); } @@ -47,8 +46,7 @@ final class OkHttpFeignClientBeanPostProcessor implements BeanPostProcessor { } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return bean; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignAspect.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignAspect.java index eaafe6c72..038b5af1e 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignAspect.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignAspect.java @@ -58,8 +58,7 @@ class TraceFeignAspect { return pjp.proceed(); } - Object executeTraceFeignClient(Object bean, ProceedingJoinPoint pjp) - throws IOException { + Object executeTraceFeignClient(Object bean, ProceedingJoinPoint pjp) throws IOException { Object[] args = pjp.getArgs(); Request request = (Request) args[0]; Request.Options options = (Request.Options) args[1]; diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignBlockingLoadBalancerClient.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignBlockingLoadBalancerClient.java index e64c8cd2b..f6bc1fcf1 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignBlockingLoadBalancerClient.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignBlockingLoadBalancerClient.java @@ -40,8 +40,7 @@ import org.springframework.cloud.openfeign.loadbalancer.FeignBlockingLoadBalance */ class TraceFeignBlockingLoadBalancerClient extends FeignBlockingLoadBalancerClient { - private static final Log LOG = LogFactory - .getLog(TraceFeignBlockingLoadBalancerClient.class); + private static final Log LOG = LogFactory.getLog(TraceFeignBlockingLoadBalancerClient.class); private final BeanFactory beanFactory; @@ -51,8 +50,8 @@ class TraceFeignBlockingLoadBalancerClient extends FeignBlockingLoadBalancerClie TracingFeignClient tracingFeignClient; - TraceFeignBlockingLoadBalancerClient(Client delegate, - LoadBalancerClient loadBalancerClient, BeanFactory beanFactory) { + TraceFeignBlockingLoadBalancerClient(Client delegate, LoadBalancerClient loadBalancerClient, + BeanFactory beanFactory) { super(delegate, loadBalancerClient); this.beanFactory = beanFactory; } @@ -91,8 +90,7 @@ class TraceFeignBlockingLoadBalancerClient extends FeignBlockingLoadBalancerClie LOG.debug( "General exception was thrown, so most likely the traced client wasn't called. Falling back to a manual span"); } - tracingFeignClient().handleSendAndReceive(fallbackSpan, request, response, - e); + tracingFeignClient().handleSendAndReceive(fallbackSpan, request, response, e); } throw e; } @@ -121,8 +119,7 @@ class TraceFeignBlockingLoadBalancerClient extends FeignBlockingLoadBalancerClie private TracingFeignClient tracingFeignClient() { if (tracingFeignClient == null) { - tracingFeignClient = (TracingFeignClient) TracingFeignClient - .create(httpTracing(), getDelegate()); + tracingFeignClient = (TracingFeignClient) TracingFeignClient.create(httpTracing(), getDelegate()); } return tracingFeignClient; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignClientAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignClientAutoConfiguration.java index cb6c8b291..397458a93 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignClientAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignClientAutoConfiguration.java @@ -68,13 +68,11 @@ class TraceFeignClientAutoConfiguration { } @Configuration(proxyBeanMethods = false) - @ConditionalOnProperty(name = "spring.sleuth.feign.processor.enabled", - matchIfMissing = true) + @ConditionalOnProperty(name = "spring.sleuth.feign.processor.enabled", matchIfMissing = true) protected static class FeignBeanPostProcessorConfiguration { @Bean - static FeignContextBeanPostProcessor feignContextBeanPostProcessor( - BeanFactory beanFactory) { + static FeignContextBeanPostProcessor feignContextBeanPostProcessor(BeanFactory beanFactory) { return new FeignContextBeanPostProcessor(beanFactory); } @@ -85,8 +83,7 @@ class TraceFeignClientAutoConfiguration { protected static class OkHttpClientFeignBeanPostProcessorConfiguration { @Bean - static OkHttpFeignClientBeanPostProcessor okHttpFeignClientBeanPostProcessor( - BeanFactory beanFactory) { + static OkHttpFeignClientBeanPostProcessor okHttpFeignClientBeanPostProcessor(BeanFactory beanFactory) { return new OkHttpFeignClientBeanPostProcessor(beanFactory); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignContext.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignContext.java index 7a54ed4c6..33eba5489 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignContext.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignContext.java @@ -34,8 +34,7 @@ class TraceFeignContext extends FeignContext { private final FeignContext delegate; - TraceFeignContext(TraceFeignObjectWrapper traceFeignObjectWrapper, - FeignContext delegate) { + TraceFeignContext(TraceFeignObjectWrapper traceFeignObjectWrapper, FeignContext delegate) { this.traceFeignObjectWrapper = traceFeignObjectWrapper; this.delegate = delegate; } @@ -59,8 +58,7 @@ class TraceFeignContext extends FeignContext { } Map convertedInstances = new HashMap<>(); for (Map.Entry entry : instances.entrySet()) { - convertedInstances.put(entry.getKey(), - (T) this.traceFeignObjectWrapper.wrap(entry.getValue())); + convertedInstances.put(entry.getKey(), (T) this.traceFeignObjectWrapper.wrap(entry.getValue())); } return convertedInstances; } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignObjectWrapper.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignObjectWrapper.java index e27043dd0..3f270f6ea 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignObjectWrapper.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignObjectWrapper.java @@ -47,12 +47,10 @@ final class TraceFeignObjectWrapper { private static final String DELEGATE = "delegate"; static { - loadBalancerPresent = ClassUtils.isPresent( - "org.springframework.cloud.openfeign.loadbalancer.FeignBlockingLoadBalancerClient", - null) + loadBalancerPresent = ClassUtils + .isPresent("org.springframework.cloud.openfeign.loadbalancer.FeignBlockingLoadBalancerClient", null) && ClassUtils.isPresent( - "org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient", - null); + "org.springframework.cloud.loadbalancer.blocking.client.BlockingLoadBalancerClient", null); } private final BeanFactory beanFactory; @@ -78,25 +76,21 @@ final class TraceFeignObjectWrapper { if (AopUtils.getTargetClass(bean).equals(FeignBlockingLoadBalancerClient.class)) { FeignBlockingLoadBalancerClient client = ProxyUtils.getTargetObject(bean); return new TraceFeignBlockingLoadBalancerClient( - (Client) new TraceFeignObjectWrapper(this.beanFactory) - .wrap(client.getDelegate()), + (Client) new TraceFeignObjectWrapper(this.beanFactory).wrap(client.getDelegate()), (LoadBalancerClient) loadBalancerClient(), this.beanFactory); } else { FeignBlockingLoadBalancerClient client = ProxyUtils.getTargetObject(bean); try { - Field delegate = FeignBlockingLoadBalancerClient.class - .getDeclaredField(DELEGATE); + Field delegate = FeignBlockingLoadBalancerClient.class.getDeclaredField(DELEGATE); delegate.setAccessible(true); - delegate.set(client, new TraceFeignObjectWrapper(this.beanFactory) - .wrap(client.getDelegate())); + delegate.set(client, new TraceFeignObjectWrapper(this.beanFactory).wrap(client.getDelegate())); } - catch (NoSuchFieldException | IllegalArgumentException - | IllegalAccessException | SecurityException e) { + catch (NoSuchFieldException | IllegalArgumentException | IllegalAccessException | SecurityException e) { log.warn(EXCEPTION_WARNING, e); } - return new TraceFeignBlockingLoadBalancerClient(client, - (LoadBalancerClient) loadBalancerClient(), this.beanFactory); + return new TraceFeignBlockingLoadBalancerClient(client, (LoadBalancerClient) loadBalancerClient(), + this.beanFactory); } } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignClient.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignClient.java index 3039ecb54..6e81a8370 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignClient.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignClient.java @@ -60,8 +60,8 @@ final class TracingFeignClient implements Client { this.currentTraceContext = httpTracing.tracing().currentTraceContext(); this.handler = HttpClientHandler.create(httpTracing); Client delegateTarget = ProxyUtils.getTargetObject(delegate); - this.delegate = delegateTarget instanceof TracingFeignClient - ? ((TracingFeignClient) delegateTarget).delegate : delegateTarget; + this.delegate = delegateTarget instanceof TracingFeignClient ? ((TracingFeignClient) delegateTarget).delegate + : delegateTarget; } static Client create(HttpTracing httpTracing, Client delegate) { @@ -89,8 +89,7 @@ final class TracingFeignClient implements Client { throw e; } finally { - ResponseWrapper response = res != null - ? new ResponseWrapper(request, res, error) : null; + ResponseWrapper response = res != null ? new ResponseWrapper(request, res, error) : null; this.handler.handleReceive(response, error, span); if (log.isDebugEnabled()) { @@ -99,12 +98,10 @@ final class TracingFeignClient implements Client { } } - void handleSendAndReceive(Span span, Request req, @Nullable Response res, - @Nullable Throwable error) { + void handleSendAndReceive(Span span, Request req, @Nullable Response res, @Nullable Throwable error) { RequestWrapper request = new RequestWrapper(req); this.handler.handleSend(request, span); - ResponseWrapper response = res != null ? new ResponseWrapper(request, res, error) - : null; + ResponseWrapper response = res != null ? new ResponseWrapper(request, res, error) : null; this.handler.handleReceive(response, error, span); } @@ -145,8 +142,7 @@ final class TracingFeignClient implements Client { @Override public String header(String name) { Collection result = delegate.headers().get(name); - return result != null && result.iterator().hasNext() - ? result.iterator().next() : null; + return result != null && result.iterator().hasNext() ? result.iterator().next() : null; } @Override @@ -157,8 +153,7 @@ final class TracingFeignClient implements Client { if (!headers.containsKey(name)) { headers.put(name, Collections.singletonList(value)); if (log.isTraceEnabled()) { - log.trace( - "Added key [" + name + "] and header value [" + value + "]"); + log.trace("Added key [" + name + "] and header value [" + value + "]"); } } else { @@ -176,8 +171,7 @@ final class TracingFeignClient implements Client { String url = delegate.url(); byte[] body = delegate.body(); Charset charset = delegate.charset(); - return Request.create(delegate.httpMethod(), url, headers, body, charset, - delegate.requestTemplate()); + return Request.create(delegate.httpMethod(), url, headers, body, charset, delegate.requestTemplate()); } } @@ -191,8 +185,7 @@ final class TracingFeignClient implements Client { @Nullable final Throwable error; - ResponseWrapper(RequestWrapper request, Response response, - @Nullable Throwable error) { + ResponseWrapper(RequestWrapper request, Response response, @Nullable Throwable error) { this.request = request; this.response = response; this.error = error; diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/DefaultSpanNamer.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/DefaultSpanNamer.java index 80bf2e27a..04a8588ce 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/DefaultSpanNamer.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/DefaultSpanNamer.java @@ -45,8 +45,7 @@ public class DefaultSpanNamer implements SpanNamer { if (delegate instanceof Method) { return delegate.toString().equals(spanName); } - return (delegate.getClass().getName() + "@" - + Integer.toHexString(delegate.hashCode())).equals(spanName); + return (delegate.getClass().getName() + "@" + Integer.toHexString(delegate.hashCode())).equals(spanName); } @Override diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/LazyBean.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/LazyBean.java index 4b949fc1d..845f5a4f5 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/LazyBean.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/LazyBean.java @@ -31,8 +31,7 @@ import org.springframework.lang.Nullable; */ public final class LazyBean { - public static LazyBean create(ConfigurableApplicationContext springContext, - Class requiredType) { + public static LazyBean create(ConfigurableApplicationContext springContext, Class requiredType) { return new LazyBean<>(springContext, requiredType); } @@ -65,8 +64,7 @@ public final class LazyBean { } catch (Exception ex) { if (log.isDebugEnabled()) { - log.debug("Spring context [" + springContext + "] error getting [" - + requiredType + "].", ex); + log.debug("Spring context [" + springContext + "] error getting [" + requiredType + "].", ex); } } return this.value; diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/SpanNameUtil.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/SpanNameUtil.java index b99933235..9b07b3751 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/SpanNameUtil.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/internal/SpanNameUtil.java @@ -36,8 +36,7 @@ public final class SpanNameUtil { if (StringUtils.isEmpty(name)) { return name; } - int maxLength = name.length() > MAX_NAME_LENGTH ? (MAX_NAME_LENGTH) - : (name.length()); + int maxLength = name.length() > MAX_NAME_LENGTH ? (MAX_NAME_LENGTH) : (name.length()); return name.substring(0, maxLength); } diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/sampler/ProbabilityBasedSampler.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/sampler/ProbabilityBasedSampler.java index 8aa1499a2..ed030e4b2 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/sampler/ProbabilityBasedSampler.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/sampler/ProbabilityBasedSampler.java @@ -52,8 +52,7 @@ class ProbabilityBasedSampler extends Sampler { private final SamplerProperties configuration; ProbabilityBasedSampler(SamplerProperties configuration) { - Assert.notNull(configuration.getProbability(), - "probability property is required for ProbabilityBasedSampler"); + Assert.notNull(configuration.getProbability(), "probability property is required for ProbabilityBasedSampler"); int outOf100 = (int) (configuration.getProbability() * 100.0f); this.sampleDecisions = randomBitSet(100, outOf100, new Random()); this.configuration = configuration; diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/sampler/SamplerAutoConfiguration.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/sampler/SamplerAutoConfiguration.java index eeb451160..ca7cecaf9 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/sampler/SamplerAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/cloud/sleuth/sampler/SamplerAutoConfiguration.java @@ -60,23 +60,20 @@ public class SamplerAutoConfiguration { @Configuration(proxyBeanMethods = false) @Conditional(SamplerCondition.class) - @ConditionalOnBean( - type = "org.springframework.cloud.context.scope.refresh.RefreshScope") + @ConditionalOnBean(type = "org.springframework.cloud.context.scope.refresh.RefreshScope") protected static class RefreshScopedSamplerConfiguration { @Bean @RefreshScope @ConditionalOnMissingBean - @ConditionalOnProperty(value = "spring.sleuth.sampler.refresh.enabled", - matchIfMissing = true) + @ConditionalOnProperty(value = "spring.sleuth.sampler.refresh.enabled", matchIfMissing = true) public Sampler defaultTraceSampler(SamplerProperties config) { return sampler(config); } @Bean @ConditionalOnMissingBean - @ConditionalOnProperty(value = "spring.sleuth.sampler.refresh.enabled", - havingValue = "false") + @ConditionalOnProperty(value = "spring.sleuth.sampler.refresh.enabled", havingValue = "false") public Sampler defaultNonRefreshScopeTraceSampler(SamplerProperties config) { return sampler(config); } @@ -95,8 +92,7 @@ public class SamplerAutoConfiguration { @Configuration(proxyBeanMethods = false) @Conditional(SamplerCondition.class) - @ConditionalOnMissingBean( - type = "org.springframework.cloud.context.scope.refresh.RefreshScope") + @ConditionalOnMissingBean(type = "org.springframework.cloud.context.scope.refresh.RefreshScope") protected static class NonRefreshScopeSamplerConfiguration { @Bean diff --git a/spring-cloud-sleuth-core/src/main/java/org/springframework/jms/config/TracingJmsListenerEndpointRegistry.java b/spring-cloud-sleuth-core/src/main/java/org/springframework/jms/config/TracingJmsListenerEndpointRegistry.java index 4b8c3f7d3..cd13b82b9 100644 --- a/spring-cloud-sleuth-core/src/main/java/org/springframework/jms/config/TracingJmsListenerEndpointRegistry.java +++ b/spring-cloud-sleuth-core/src/main/java/org/springframework/jms/config/TracingJmsListenerEndpointRegistry.java @@ -47,8 +47,7 @@ import org.springframework.lang.Nullable; * @author Marcin Grzejszczak * @since 2.1.1 */ -public final class TracingJmsListenerEndpointRegistry - extends JmsListenerEndpointRegistry { +public final class TracingJmsListenerEndpointRegistry extends JmsListenerEndpointRegistry { private final BeanFactory beanFactory; @@ -63,8 +62,7 @@ public final class TracingJmsListenerEndpointRegistry final Field embeddedValueResolverField; - public TracingJmsListenerEndpointRegistry(JmsListenerEndpointRegistry registry, - BeanFactory beanFactory) { + public TracingJmsListenerEndpointRegistry(JmsListenerEndpointRegistry registry, BeanFactory beanFactory) { this.delegate = registry; this.beanFactory = beanFactory; this.messageHandlerMethodFactoryField = tryField("messageHandlerMethodFactory"); @@ -80,8 +78,7 @@ public final class TracingJmsListenerEndpointRegistry private CurrentTraceContext currentTraceContext() { if (this.currentTraceContext == null) { - this.currentTraceContext = this.beanFactory - .getBean(CurrentTraceContext.class); + this.currentTraceContext = this.beanFactory.getBean(CurrentTraceContext.class); } return this.currentTraceContext; } @@ -112,14 +109,13 @@ public final class TracingJmsListenerEndpointRegistry } @Override - public void registerListenerContainer(JmsListenerEndpoint endpoint, - JmsListenerContainerFactory factory) { + public void registerListenerContainer(JmsListenerEndpoint endpoint, JmsListenerContainerFactory factory) { this.delegate.registerListenerContainer(wrapEndpoint(endpoint), factory); } @Override - protected MessageListenerContainer createListenerContainer( - JmsListenerEndpoint endpoint, JmsListenerContainerFactory factory) { + protected MessageListenerContainer createListenerContainer(JmsListenerEndpoint endpoint, + JmsListenerContainerFactory factory) { return this.delegate.createListenerContainer(wrapEndpoint(endpoint), factory); } @@ -176,10 +172,9 @@ public final class TracingJmsListenerEndpointRegistry } @Override - public void registerListenerContainer(JmsListenerEndpoint endpoint, - JmsListenerContainerFactory factory, boolean startImmediately) { - this.delegate.registerListenerContainer(wrapEndpoint(endpoint), factory, - startImmediately); + public void registerListenerContainer(JmsListenerEndpoint endpoint, JmsListenerContainerFactory factory, + boolean startImmediately) { + this.delegate.registerListenerContainer(wrapEndpoint(endpoint), factory, startImmediately); } private JmsListenerEndpoint wrapEndpoint(JmsListenerEndpoint endpoint) { @@ -223,8 +218,7 @@ public final class TracingJmsListenerEndpointRegistry */ MethodJmsListenerEndpoint trace(MethodJmsListenerEndpoint source) { // Skip out rather than incompletely copying the source - if (this.messageHandlerMethodFactoryField == null - || this.embeddedValueResolverField == null) { + if (this.messageHandlerMethodFactoryField == null || this.embeddedValueResolverField == null) { return source; } // We want the stock implementation, except we want to wrap the message listener @@ -232,8 +226,7 @@ public final class TracingJmsListenerEndpointRegistry MethodJmsListenerEndpoint dest = new MethodJmsListenerEndpoint() { @Override protected MessagingMessageListenerAdapter createMessageListenerInstance() { - return new TracingMessagingMessageListenerAdapter(jmsTracing(), - currentTraceContext()); + return new TracingMessagingMessageListenerAdapter(jmsTracing(), currentTraceContext()); } }; // set state from AbstractJmsListenerEndpoint @@ -247,8 +240,7 @@ public final class TracingJmsListenerEndpointRegistry dest.setMethod(source.getMethod()); dest.setMostSpecificMethod(source.getMostSpecificMethod()); try { - dest.setMessageHandlerMethodFactory( - get(source, this.messageHandlerMethodFactoryField)); + dest.setMessageHandlerMethodFactory(get(source, this.messageHandlerMethodFactoryField)); dest.setEmbeddedValueResolver(get(source, this.embeddedValueResolverField)); } catch (IllegalAccessException e) { @@ -266,15 +258,13 @@ final class TracingMethodJmsListenerEndpoint extends MethodJmsListenerEndpoint { /** * This wraps the message listener in a child span. */ -final class TracingMessagingMessageListenerAdapter - extends MessagingMessageListenerAdapter { +final class TracingMessagingMessageListenerAdapter extends MessagingMessageListenerAdapter { final JmsTracing jmsTracing; final CurrentTraceContext current; - TracingMessagingMessageListenerAdapter(JmsTracing jmsTracing, - CurrentTraceContext current) { + TracingMessagingMessageListenerAdapter(JmsTracing jmsTracing, CurrentTraceContext current) { this.jmsTracing = jmsTracing; this.current = current; } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/PermitAllWebFluxSecurityConfiguration.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/PermitAllWebFluxSecurityConfiguration.java index efa117b95..59e4f0e57 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/PermitAllWebFluxSecurityConfiguration.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/PermitAllWebFluxSecurityConfiguration.java @@ -25,10 +25,8 @@ import org.springframework.security.web.server.SecurityWebFilterChain; class PermitAllWebFluxSecurityConfiguration { @Bean - SecurityWebFilterChain springWebFilterChain(ServerHttpSecurity http) - throws Exception { - return http.authorizeExchange().anyExchange().permitAll().and().csrf().disable() - .build(); + SecurityWebFilterChain springWebFilterChain(ServerHttpSecurity http) throws Exception { + return http.authorizeExchange().anyExchange().permitAll().and().csrf().disable().build(); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/SpanHandlerTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/SpanHandlerTests.java index 51b80703b..819171464 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/SpanHandlerTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/SpanHandlerTests.java @@ -39,8 +39,7 @@ import static org.springframework.boot.test.context.SpringBootTest.WebEnvironmen /** * @author Marcin Grzejszczak */ -@SpringBootTest(classes = SpanHandlerTests.SpanHandlerAspectTestsConfig.class, - webEnvironment = NONE) +@SpringBootTest(classes = SpanHandlerTests.SpanHandlerAspectTestsConfig.class, webEnvironment = NONE) public class SpanHandlerTests { @Autowired @@ -83,8 +82,7 @@ public class SpanHandlerTests { SpanHandler handlerOne() { return new SpanHandler() { @Override - public boolean end(TraceContext traceContext, MutableSpan span, - Cause cause) { + public boolean end(TraceContext traceContext, MutableSpan span, Cause cause) { span.name("foo"); return true; // keep this span } @@ -95,8 +93,7 @@ public class SpanHandlerTests { SpanHandler handlerTwo() { return new SpanHandler() { @Override - public boolean end(TraceContext traceContext, MutableSpan span, - Cause cause) { + public boolean end(TraceContext traceContext, MutableSpan span, Cause cause) { span.name(span.name() + " bar"); return true; // keep this span } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/NullSpanTagAnnotationHandlerTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/NullSpanTagAnnotationHandlerTests.java index 6af9e924b..c79f64b5a 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/NullSpanTagAnnotationHandlerTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/NullSpanTagAnnotationHandlerTests.java @@ -53,12 +53,10 @@ public class NullSpanTagAnnotationHandlerTests { @Test public void shouldUseEmptyStringWheCustomTagValueResolverReturnsNull() throws NoSuchMethodException, SecurityException { - Method method = AnnotationMockClass.class - .getMethod("getAnnotationForTagValueResolver", String.class); + Method method = AnnotationMockClass.class.getMethod("getAnnotationForTagValueResolver", String.class); Annotation annotation = method.getParameterAnnotations()[0][0]; if (annotation instanceof SpanTag) { - String resolvedValue = this.handler.resolveTagValue((SpanTag) annotation, - "test"); + String resolvedValue = this.handler.resolveTagValue((SpanTag) annotation, "test"); assertThat(resolvedValue).isEqualTo(""); } else { @@ -67,14 +65,11 @@ public class NullSpanTagAnnotationHandlerTests { } @Test - public void shouldUseEmptyStringWhenTagValueExpressionReturnNull() - throws NoSuchMethodException, SecurityException { - Method method = AnnotationMockClass.class - .getMethod("getAnnotationForTagValueExpression", String.class); + public void shouldUseEmptyStringWhenTagValueExpressionReturnNull() throws NoSuchMethodException, SecurityException { + Method method = AnnotationMockClass.class.getMethod("getAnnotationForTagValueExpression", String.class); Annotation annotation = method.getParameterAnnotations()[0][0]; if (annotation instanceof SpanTag) { - String resolvedValue = this.handler.resolveTagValue((SpanTag) annotation, - "test"); + String resolvedValue = this.handler.resolveTagValue((SpanTag) annotation, "test"); assertThat(resolvedValue).isEqualTo(""); } @@ -84,14 +79,11 @@ public class NullSpanTagAnnotationHandlerTests { } @Test - public void shouldUseEmptyStringWhenArgumentIsNull() - throws NoSuchMethodException, SecurityException { - Method method = AnnotationMockClass.class - .getMethod("getAnnotationForArgumentToString", Long.class); + public void shouldUseEmptyStringWhenArgumentIsNull() throws NoSuchMethodException, SecurityException { + Method method = AnnotationMockClass.class.getMethod("getAnnotationForArgumentToString", Long.class); Annotation annotation = method.getParameterAnnotations()[0][0]; if (annotation instanceof SpanTag) { - String resolvedValue = this.handler.resolveTagValue((SpanTag) annotation, - null); + String resolvedValue = this.handler.resolveTagValue((SpanTag) annotation, null); assertThat(resolvedValue).isEqualTo(""); } else { @@ -123,8 +115,7 @@ public class NullSpanTagAnnotationHandlerTests { } @NewSpan - public void getAnnotationForTagValueExpression( - @SpanTag(key = "test", expression = "null") String test) { + public void getAnnotationForTagValueExpression(@SpanTag(key = "test", expression = "null") String test) { } @NewSpan diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthNewSpanParserAnnotationNoSleuthTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthNewSpanParserAnnotationNoSleuthTests.java index 04269e61f..471fc919b 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthNewSpanParserAnnotationNoSleuthTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthNewSpanParserAnnotationNoSleuthTests.java @@ -24,8 +24,7 @@ import org.springframework.boot.test.context.SpringBootTest; import static org.assertj.core.api.Assertions.assertThat; -@SpringBootTest(classes = SleuthAnnotationAutoConfiguration.class, - properties = "spring.sleuth.enabled=false") +@SpringBootTest(classes = SleuthAnnotationAutoConfiguration.class, properties = "spring.sleuth.enabled=false") public class SleuthNewSpanParserAnnotationNoSleuthTests { @Autowired(required = false) diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectFluxTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectFluxTests.java index f69480719..f6cf112b6 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectFluxTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectFluxTests.java @@ -64,8 +64,7 @@ public class SleuthSpanCreatorAspectFluxTests { @Autowired TestSpanHandler spans; - TraceContext context = TraceContext.newBuilder().traceId(1).spanId(1).sampled(true) - .build(); + TraceContext context = TraceContext.newBuilder().traceId(1).spanId(1).sampled(true).build(); private static String toHexString(Long value) { then(value).isNotNull(); @@ -217,8 +216,7 @@ public class SleuthSpanCreatorAspectFluxTests { Awaitility.await().untilAsserted(() -> { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("custom-name-on-test-method9"); - then(this.spans.get(0).tags()).containsEntry("class", "TestBean") - .containsEntry("method", "testMethod9"); + then(this.spans.get(0).tags()).containsEntry("class", "TestBean").containsEntry("method", "testMethod9"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -241,9 +239,8 @@ public class SleuthSpanCreatorAspectFluxTests { then(spans).hasSize(1); then(spans.get(0).name()).isEqualTo("foo"); then(spans.get(0).tags()).containsEntry("customTestTag10", "test"); - then(spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -258,9 +255,8 @@ public class SleuthSpanCreatorAspectFluxTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("test-method10"); then(this.spans.get(0).tags()).containsEntry("customTestTag10", "test"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -283,9 +279,8 @@ public class SleuthSpanCreatorAspectFluxTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("foo"); then(this.spans.get(0).tags()).containsEntry("customTestTag10", "test"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -308,12 +303,10 @@ public class SleuthSpanCreatorAspectFluxTests { Awaitility.await().untilAsserted(() -> { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("foo"); - then(this.spans.get(0).tags()).containsEntry("class", "TestBean") - .containsEntry("method", "testMethod11") + then(this.spans.get(0).tags()).containsEntry("class", "TestBean").containsEntry("method", "testMethod11") .containsEntry("customTestTag11", "test"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -364,9 +357,8 @@ public class SleuthSpanCreatorAspectFluxTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("foo"); then(this.spans.get(0).error()).hasMessageContaining("test exception 13"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("testMethod13.before", - "testMethod13.afterFailure", "testMethod13.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("testMethod13.before", "testMethod13.afterFailure", "testMethod13.after"); then(spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -497,11 +489,9 @@ public class SleuthSpanCreatorAspectFluxTests { private final Tracer tracer; - private AtomicReference> proceed = new AtomicReference<>( - new CompletableFuture<>()); + private AtomicReference> proceed = new AtomicReference<>(new CompletableFuture<>()); - private Flux testFlux = Flux - .defer(() -> Flux.just(TEST_STRING1, TEST_STRING2)) + private Flux testFlux = Flux.defer(() -> Flux.just(TEST_STRING1, TEST_STRING2)) .delayUntil(s -> Mono.fromFuture(this.proceed.get())) .doOnNext(s -> this.proceed.set(new CompletableFuture<>())); @@ -575,8 +565,7 @@ public class SleuthSpanCreatorAspectFluxTests { } @Override - public Flux testMethod10_v2( - @SpanTag(key = "customTestTag10") String param) { + public Flux testMethod10_v2(@SpanTag(key = "customTestTag10") String param) { return this.testFlux; } @@ -588,14 +577,12 @@ public class SleuthSpanCreatorAspectFluxTests { @Override public Flux testMethod12(String param) { - return Flux - .defer(() -> Flux.error(new RuntimeException("test exception 12"))); + return Flux.defer(() -> Flux.error(new RuntimeException("test exception 12"))); } @Override public Flux testMethod13() { - return Flux - .defer(() -> Flux.error(new RuntimeException("test exception 13"))); + return Flux.defer(() -> Flux.error(new RuntimeException("test exception 13"))); } @Override @@ -610,8 +597,7 @@ public class SleuthSpanCreatorAspectFluxTests { @Override public Flux newSpanInSubscriberContext() { - return Mono.subscriberContext() - .flatMapMany(context -> Flux.just(id(context, this.tracer))); + return Mono.subscriberContext().flatMapMany(context -> Flux.just(id(context, this.tracer))); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectMonoTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectMonoTests.java index cc612d8fd..11966a9b1 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectMonoTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectMonoTests.java @@ -203,8 +203,7 @@ public class SleuthSpanCreatorAspectMonoTests { Awaitility.await().untilAsserted(() -> { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("custom-name-on-test-method9"); - then(this.spans.get(0).tags()).containsEntry("class", "TestBean") - .containsEntry("method", "testMethod9"); + then(this.spans.get(0).tags()).containsEntry("class", "TestBean").containsEntry("method", "testMethod9"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -229,9 +228,8 @@ public class SleuthSpanCreatorAspectMonoTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("foo"); then(this.spans.get(0).tags()).containsEntry("customTestTag10", "test"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -245,9 +243,8 @@ public class SleuthSpanCreatorAspectMonoTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("test-method10"); then(this.spans.get(0).tags()).containsEntry("customTestTag10", "test"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -272,9 +269,8 @@ public class SleuthSpanCreatorAspectMonoTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("foo"); then(this.spans.get(0).tags()).containsEntry("customTestTag10", "test"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -299,12 +295,10 @@ public class SleuthSpanCreatorAspectMonoTests { Awaitility.await().untilAsserted(() -> { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("foo"); - then(this.spans.get(0).tags()).containsEntry("class", "TestBean") - .containsEntry("method", "testMethod11") + then(this.spans.get(0).tags()).containsEntry("class", "TestBean").containsEntry("method", "testMethod11") .containsEntry("customTestTag11", "test"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -355,9 +349,8 @@ public class SleuthSpanCreatorAspectMonoTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("foo"); then(this.spans.get(0).error()).hasMessageContaining("test exception 13"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("testMethod13.before", - "testMethod13.afterFailure", "testMethod13.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("testMethod13.before", "testMethod13.afterFailure", "testMethod13.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); }); @@ -392,8 +385,7 @@ public class SleuthSpanCreatorAspectMonoTests { @Test public void shouldReturnNewSpanFromTraceContextOuter() { - Mono, String>> mono = this.testBeanOuter - .outerNewSpanInTraceContext(); + Mono, String>> mono = this.testBeanOuter.outerNewSpanInTraceContext(); then(this.spans).isEmpty(); @@ -405,15 +397,13 @@ public class SleuthSpanCreatorAspectMonoTests { Awaitility.await().untilAsserted(() -> { MutableSpan outerSpan = spans.spans().stream() - .filter(span -> span.name().equals("outer-span-in-trace-context")) - .findFirst().orElseThrow(() -> new AssertionError( - "No span with name [outer-span-in-trace-context] found")); + .filter(span -> span.name().equals("outer-span-in-trace-context")).findFirst() + .orElseThrow(() -> new AssertionError("No span with name [outer-span-in-trace-context] found")); then(outerSpan.name()).isEqualTo("outer-span-in-trace-context"); then(outerSpan.id()).isEqualTo(outerSpanIdBefore); - MutableSpan innerSpan = spans.spans().stream() - .filter(span -> span.name().equals("span-in-trace-context")) - .findFirst().orElseThrow(() -> new AssertionError( - "No span with name [span-in-trace-context] found")); + MutableSpan innerSpan = spans.spans().stream().filter(span -> span.name().equals("span-in-trace-context")) + .findFirst() + .orElseThrow(() -> new AssertionError("No span with name [span-in-trace-context] found")); then(innerSpan.name()).isEqualTo("span-in-trace-context"); then(innerSpan.id()).isEqualTo(innerSpanId); then(this.tracer.currentSpan()).isNull(); @@ -438,8 +428,7 @@ public class SleuthSpanCreatorAspectMonoTests { @Test public void shouldReturnNewSpanFromSubscriberContextOuter() { - Mono, String>> mono = this.testBeanOuter - .outerNewSpanInSubscriberContext(); + Mono, String>> mono = this.testBeanOuter.outerNewSpanInSubscriberContext(); then(this.spans).isEmpty(); @@ -450,16 +439,14 @@ public class SleuthSpanCreatorAspectMonoTests { then(outerSpanIdBefore).isNotEqualTo(innerSpanId); Awaitility.await().untilAsserted(() -> { - MutableSpan outerSpan = spans.spans().stream().filter( - span -> span.name().equals("outer-span-in-subscriber-context")) - .findFirst().orElseThrow(() -> new AssertionError( - "No span with name [outer-span-in-subscriber-context] found")); + MutableSpan outerSpan = spans.spans().stream() + .filter(span -> span.name().equals("outer-span-in-subscriber-context")).findFirst().orElseThrow( + () -> new AssertionError("No span with name [outer-span-in-subscriber-context] found")); then(outerSpan.name()).isEqualTo("outer-span-in-subscriber-context"); then(outerSpan.id()).isEqualTo(outerSpanIdBefore); MutableSpan innerSpan = spans.spans().stream() - .filter(span -> span.name().equals("span-in-subscriber-context")) - .findFirst().orElseThrow(() -> new AssertionError( - "No span with name [span-in-subscriber-context] found")); + .filter(span -> span.name().equals("span-in-subscriber-context")).findFirst() + .orElseThrow(() -> new AssertionError("No span with name [span-in-subscriber-context] found")); then(innerSpan.name()).isEqualTo("span-in-subscriber-context"); then(innerSpan.id()).isEqualTo(innerSpanId); then(this.tracer.currentSpan()).isNull(); @@ -592,8 +579,7 @@ public class SleuthSpanCreatorAspectMonoTests { } @Override - public Mono testMethod10_v2( - @SpanTag(key = "customTestTag10") String param) { + public Mono testMethod10_v2(@SpanTag(key = "customTestTag10") String param) { return TEST_MONO; } @@ -605,14 +591,12 @@ public class SleuthSpanCreatorAspectMonoTests { @Override public Mono testMethod12(String param) { - return Mono - .defer(() -> Mono.error(new RuntimeException("test exception 12"))); + return Mono.defer(() -> Mono.error(new RuntimeException("test exception 12"))); } @Override public Mono testMethod13() { - return Mono - .defer(() -> Mono.error(new RuntimeException("test exception 13"))); + return Mono.defer(() -> Mono.error(new RuntimeException("test exception 13"))); } @Override @@ -622,8 +606,7 @@ public class SleuthSpanCreatorAspectMonoTests { @Override public Mono newSpanInSubscriberContext() { - return Mono.subscriberContext() - .flatMap(context -> Mono.just(id(this.tracer))); + return Mono.subscriberContext().flatMap(context -> Mono.just(id(this.tracer))); } } @@ -641,10 +624,8 @@ public class SleuthSpanCreatorAspectMonoTests { @NewSpan(name = "outerSpanInTraceContext") public Mono, String>> outerNewSpanInTraceContext() { - return Mono.defer(() -> Mono.just(id(this.tracer)) - .zipWith(this.testBeanInterface.newSpanInTraceContext()) - .map(pair -> Pair.of(Pair.of(pair.getT1(), id(this.tracer)), - pair.getT2()))); + return Mono.defer(() -> Mono.just(id(this.tracer)).zipWith(this.testBeanInterface.newSpanInTraceContext()) + .map(pair -> Pair.of(Pair.of(pair.getT1(), id(this.tracer)), pair.getT2()))); } @NewSpan(name = "outerSpanInSubscriberContext") @@ -652,8 +633,7 @@ public class SleuthSpanCreatorAspectMonoTests { return Mono.subscriberContext() .flatMap(context -> Mono.just(id(this.tracer)) .zipWith(this.testBeanInterface.newSpanInSubscriberContext()) - .map(pair -> Pair.of(Pair.of(pair.getT1(), id(this.tracer)), - pair.getT2()))); + .map(pair -> Pair.of(Pair.of(pair.getT1(), id(this.tracer)), pair.getT2()))); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectTests.java index 2d88c6b95..c9465e894 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorAspectTests.java @@ -136,8 +136,7 @@ public class SleuthSpanCreatorAspectTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("custom-name-on-test-method9"); - then(this.spans.get(0).tags()).containsEntry("class", "TestBean") - .containsEntry("method", "testMethod9"); + then(this.spans.get(0).tags()).containsEntry("class", "TestBean").containsEntry("method", "testMethod9"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); } @@ -156,9 +155,8 @@ public class SleuthSpanCreatorAspectTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("foo"); then(this.spans.get(0).tags()).containsEntry("customTestTag10", "test"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); } @@ -170,9 +168,8 @@ public class SleuthSpanCreatorAspectTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("test-method10"); then(this.spans.get(0).tags()).containsEntry("customTestTag10", "test"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); } @@ -191,9 +188,8 @@ public class SleuthSpanCreatorAspectTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("foo"); then(this.spans.get(0).tags()).containsEntry("customTestTag10", "test"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); } @@ -213,12 +209,10 @@ public class SleuthSpanCreatorAspectTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("foo"); - then(this.spans.get(0).tags()).containsEntry("class", "TestBean") - .containsEntry("method", "testMethod11") + then(this.spans.get(0).tags()).containsEntry("class", "TestBean").containsEntry("method", "testMethod11") .containsEntry("customTestTag11", "test"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("customTest.before", - "customTest.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("customTest.before", "customTest.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); } @@ -257,9 +251,8 @@ public class SleuthSpanCreatorAspectTests { then(this.spans).hasSize(1); then(this.spans.get(0).name()).isEqualTo("foo"); then(this.spans.get(0).error()).hasMessageContaining("test exception 13"); - then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue) - .collect(Collectors.toList())).contains("testMethod13.before", - "testMethod13.afterFailure", "testMethod13.after"); + then(this.spans.get(0).annotations().stream().map(Map.Entry::getValue).collect(Collectors.toList())) + .contains("testMethod13.before", "testMethod13.afterFailure", "testMethod13.after"); then(this.spans.get(0).finishTimestamp()).isNotZero(); then(this.tracer.currentSpan()).isNull(); } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorCircularDependencyTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorCircularDependencyTests.java index 29cb995eb..e4e38f703 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorCircularDependencyTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SleuthSpanCreatorCircularDependencyTests.java @@ -26,8 +26,7 @@ import org.springframework.boot.test.context.SpringBootTest; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; -@SpringBootTest( - classes = SleuthSpanCreatorCircularDependencyTests.TestConfiguration.class) +@SpringBootTest(classes = SleuthSpanCreatorCircularDependencyTests.TestConfiguration.class) public class SleuthSpanCreatorCircularDependencyTests { @Test diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SpanTagAnnotationHandlerTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SpanTagAnnotationHandlerTests.java index 8a597759b..7b7a396e5 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SpanTagAnnotationHandlerTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SpanTagAnnotationHandlerTests.java @@ -51,14 +51,11 @@ public class SpanTagAnnotationHandlerTests { } @Test - public void shouldUseCustomTagValueResolver() - throws NoSuchMethodException, SecurityException { - Method method = AnnotationMockClass.class - .getMethod("getAnnotationForTagValueResolver", String.class); + public void shouldUseCustomTagValueResolver() throws NoSuchMethodException, SecurityException { + Method method = AnnotationMockClass.class.getMethod("getAnnotationForTagValueResolver", String.class); Annotation annotation = method.getParameterAnnotations()[0][0]; if (annotation instanceof SpanTag) { - String resolvedValue = this.handler.resolveTagValue((SpanTag) annotation, - "test"); + String resolvedValue = this.handler.resolveTagValue((SpanTag) annotation, "test"); assertThat(resolvedValue).isEqualTo("Value from myCustomTagValueResolver"); } else { @@ -67,14 +64,11 @@ public class SpanTagAnnotationHandlerTests { } @Test - public void shouldUseTagValueExpression() - throws NoSuchMethodException, SecurityException { - Method method = AnnotationMockClass.class - .getMethod("getAnnotationForTagValueExpression", String.class); + public void shouldUseTagValueExpression() throws NoSuchMethodException, SecurityException { + Method method = AnnotationMockClass.class.getMethod("getAnnotationForTagValueExpression", String.class); Annotation annotation = method.getParameterAnnotations()[0][0]; if (annotation instanceof SpanTag) { - String resolvedValue = this.handler.resolveTagValue((SpanTag) annotation, - "test"); + String resolvedValue = this.handler.resolveTagValue((SpanTag) annotation, "test"); assertThat(resolvedValue).isEqualTo("hello characters"); } @@ -84,10 +78,8 @@ public class SpanTagAnnotationHandlerTests { } @Test - public void shouldReturnArgumentToString() - throws NoSuchMethodException, SecurityException { - Method method = AnnotationMockClass.class - .getMethod("getAnnotationForArgumentToString", Long.class); + public void shouldReturnArgumentToString() throws NoSuchMethodException, SecurityException { + Method method = AnnotationMockClass.class.getMethod("getAnnotationForArgumentToString", Long.class); Annotation annotation = method.getParameterAnnotations()[0][0]; if (annotation instanceof SpanTag) { String resolvedValue = this.handler.resolveTagValue((SpanTag) annotation, 15); @@ -127,8 +119,8 @@ public class SpanTagAnnotationHandlerTests { // tag::spel[] @NewSpan - public void getAnnotationForTagValueExpression(@SpanTag(key = "test", - expression = "'hello' + ' characters'") String test) { + public void getAnnotationForTagValueExpression( + @SpanTag(key = "test", expression = "'hello' + ' characters'") String test) { } // end::spel[] diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SpelTagValueExpressionResolverTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SpelTagValueExpressionResolverTests.java index 017155d30..1b47e90b9 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SpelTagValueExpressionResolverTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/annotation/SpelTagValueExpressionResolverTests.java @@ -37,8 +37,7 @@ public class SpelTagValueExpressionResolverTests { } @Test - public void should_use_to_string_if_expression_is_not_analyzed_properly() - throws Exception { + public void should_use_to_string_if_expression_is_not_analyzed_properly() throws Exception { SpelTagValueExpressionResolver resolver = new SpelTagValueExpressionResolver(); String resolved = resolver.resolve("invalid() structure + 1", new Foo()); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/SpanIgnoringSpanHandlerTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/SpanIgnoringSpanHandlerTests.java index a94ee1764..4e19d9450 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/SpanIgnoringSpanHandlerTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/SpanIgnoringSpanHandlerTests.java @@ -33,24 +33,21 @@ class SpanIgnoringSpanHandlerTests { @Test void should_handle_span_when_not_yet_finished() { - SpanIgnoringSpanHandler handler = new SpanIgnoringSpanHandler( - new SleuthProperties()); + SpanIgnoringSpanHandler handler = new SpanIgnoringSpanHandler(new SleuthProperties()); then(handler.end(null, null, SpanHandler.Cause.ABANDONED)).isTrue(); } @Test void should_handle_span_when_name_null() { - SpanIgnoringSpanHandler handler = new SpanIgnoringSpanHandler( - new SleuthProperties()); + SpanIgnoringSpanHandler handler = new SpanIgnoringSpanHandler(new SleuthProperties()); then(handler.end(null, new MutableSpan(), SpanHandler.Cause.FINISHED)).isTrue(); } @Test void should_handle_span_when_not_present_in_main_list_of_spans_to_skip() { - SpanIgnoringSpanHandler handler = new SpanIgnoringSpanHandler( - new SleuthProperties()); + SpanIgnoringSpanHandler handler = new SpanIgnoringSpanHandler(new SleuthProperties()); then(handler.end(null, namedSpan(), SpanHandler.Cause.FINISHED)).isTrue(); } @@ -64,8 +61,7 @@ class SpanIgnoringSpanHandlerTests { @Test void should_not_handle_span_when_present_in_main_list_of_spans_to_skip() { SleuthProperties sleuthProperties = new SleuthProperties(); - sleuthProperties.getSpanHandler() - .setSpanNamePatternsToSkip(Collections.singletonList("someName")); + sleuthProperties.getSpanHandler().setSpanNamePatternsToSkip(Collections.singletonList("someName")); SpanIgnoringSpanHandler handler = new SpanIgnoringSpanHandler(sleuthProperties); then(handler.end(null, namedSpan(), SpanHandler.Cause.FINISHED)).isFalse(); @@ -91,8 +87,8 @@ class SpanIgnoringSpanHandlerTests { end(handler(sleuthPropertiesWithAdditionalEntries("b"))); end(handler(sleuthPropertiesWithAdditionalEntries("c"))); - then(SpanIgnoringSpanHandler.cache).containsKey("someOtherName").containsKey("a") - .containsKey("b").containsKey("c"); + then(SpanIgnoringSpanHandler.cache).containsKey("someOtherName").containsKey("a").containsKey("b") + .containsKey("c"); } private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() @@ -101,16 +97,13 @@ class SpanIgnoringSpanHandlerTests { @Test void should_not_register_span_handler_when_property_passed() { this.contextRunner.withPropertyValues("spring.sleuth.span-handler.enabled=false") - .run((context) -> BDDAssertions - .thenThrownBy( - () -> context.getBean(SpanIgnoringSpanHandler.class)) + .run((context) -> BDDAssertions.thenThrownBy(() -> context.getBean(SpanIgnoringSpanHandler.class)) .isInstanceOf(NoSuchBeanDefinitionException.class)); } @Test void should_register_span_handler_by_default() { - this.contextRunner - .run((context) -> context.getBean(SpanIgnoringSpanHandler.class)); + this.contextRunner.run((context) -> context.getBean(SpanIgnoringSpanHandler.class)); } private SleuthProperties sleuthPropertiesWithAdditionalEntries() { @@ -119,8 +112,7 @@ class SpanIgnoringSpanHandlerTests { private SleuthProperties sleuthPropertiesWithAdditionalEntries(String name) { SleuthProperties sleuthProperties = new SleuthProperties(); - sleuthProperties.getSpanHandler() - .setAdditionalSpanNamePatternsToIgnore(Collections.singletonList(name)); + sleuthProperties.getSpanHandler().setAdditionalSpanNamePatternsToIgnore(Collections.singletonList(name)); return sleuthProperties; } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationCustomizersTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationCustomizersTests.java index ef710f3db..2b4fdf7a1 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationCustomizersTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationCustomizersTests.java @@ -41,22 +41,19 @@ import static org.assertj.core.api.BDDAssertions.then; public class TraceAutoConfigurationCustomizersTests { private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() - .withConfiguration(AutoConfigurations.of(TraceAutoConfiguration.class, - TraceHttpAutoConfiguration.class, TraceRpcAutoConfiguration.class, - TraceMessagingAutoConfiguration.class, + .withConfiguration(AutoConfigurations.of(TraceAutoConfiguration.class, TraceHttpAutoConfiguration.class, + TraceRpcAutoConfiguration.class, TraceMessagingAutoConfiguration.class, FakeSpringMessagingAutoConfiguration.class)) .withUserConfiguration(Customizers.class); @Test public void should_apply_customizers() { - this.contextRunner - .withPropertyValues("spring.sleuth.baggage.remote-fields=country-code") - .run((context) -> { - Customizers bean = context.getBean(Customizers.class); + this.contextRunner.withPropertyValues("spring.sleuth.baggage.remote-fields=country-code").run((context) -> { + Customizers bean = context.getBean(Customizers.class); - shouldApplyCustomizations(bean); - shouldNotOverrideTheDefaults(context); - }); + shouldApplyCustomizations(bean); + shouldNotOverrideTheDefaults(context); + }); } @Test diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationPropagationCustomizationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationPropagationCustomizationTests.java index e0aa9b192..0ed193699 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationPropagationCustomizationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationPropagationCustomizationTests.java @@ -42,32 +42,26 @@ public class TraceAutoConfigurationPropagationCustomizationTests { @Test public void allowsCustomization() { - this.contextRunner - .withPropertyValues("spring.sleuth.baggage.remote-fields=country-code") - .run((context) -> { - BDDAssertions.then(context.getBean(Propagation.Factory.class)) - .extracting("delegate") - .isEqualTo(TraceBaggageConfiguration.B3_FACTORY); - }); + this.contextRunner.withPropertyValues("spring.sleuth.baggage.remote-fields=country-code").run((context) -> { + BDDAssertions.then(context.getBean(Propagation.Factory.class)).extracting("delegate") + .isEqualTo(TraceBaggageConfiguration.B3_FACTORY); + }); } @Test public void defaultValueUsedWhenApplicationNameNotSet() { - this.contextRunner.withPropertyValues("spring.application.name=") - .run((context) -> { - BDDAssertions.then(context.getBean(Propagation.Factory.class)) - .isEqualTo(TraceBaggageConfiguration.B3_FACTORY); - }); + this.contextRunner.withPropertyValues("spring.application.name=").run((context) -> { + BDDAssertions.then(context.getBean(Propagation.Factory.class)) + .isEqualTo(TraceBaggageConfiguration.B3_FACTORY); + }); } @Test public void allowsCustomizationOfBuilder() { - this.contextRunner - .withPropertyValues("spring.sleuth.baggage.remote-fields=country-code") + this.contextRunner.withPropertyValues("spring.sleuth.baggage.remote-fields=country-code") .withUserConfiguration(CustomPropagationFactoryBuilderConfig.class) - .run((context) -> BDDAssertions - .then(context.getBean(Propagation.Factory.class)) - .extracting("delegate").isSameAs(B3SinglePropagation.FACTORY)); + .run((context) -> BDDAssertions.then(context.getBean(Propagation.Factory.class)).extracting("delegate") + .isSameAs(B3SinglePropagation.FACTORY)); } @Configuration diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationTests.java index 3b49f2a11..bdb5df4e0 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationTests.java @@ -96,13 +96,11 @@ public class TraceAutoConfigurationTests { @Test void should_use_baggageBean() { - this.contextRunner.withUserConfiguration(WithBaggageBeans.class, Baggage.class) - .run((context -> { - final Baggage bean = context.getBean(Baggage.class); - BDDAssertions.then(bean.fields).containsOnly( - BaggageField.create("country-code"), - BaggageField.create("x-vcap-request-id")); - })); + this.contextRunner.withUserConfiguration(WithBaggageBeans.class, Baggage.class).run((context -> { + final Baggage bean = context.getBean(Baggage.class); + BDDAssertions.then(bean.fields).containsOnly(BaggageField.create("country-code"), + BaggageField.create("x-vcap-request-id")); + })); } @Test @@ -110,21 +108,17 @@ public class TraceAutoConfigurationTests { this.contextRunner.withPropertyValues("spring.sleuth.baggage.local-fields=bp") .withUserConfiguration(Baggage.class).run((context -> { final Baggage bean = context.getBean(Baggage.class); - BDDAssertions.then(bean.fields) - .containsExactly(BaggageField.create("bp")); + BDDAssertions.then(bean.fields).containsExactly(BaggageField.create("bp")); })); } @Test void should_combine_baggage_beans_and_properties() { this.contextRunner.withPropertyValues("spring.sleuth.baggage.local-fields=bp") - .withUserConfiguration(WithBaggageBeans.class, Baggage.class) - .run((context -> { + .withUserConfiguration(WithBaggageBeans.class, Baggage.class).run((context -> { final Baggage bean = context.getBean(Baggage.class); - BDDAssertions.then(bean.fields).containsOnly( - BaggageField.create("country-code"), - BaggageField.create("x-vcap-request-id"), - BaggageField.create("bp")); + BDDAssertions.then(bean.fields).containsOnly(BaggageField.create("country-code"), + BaggageField.create("x-vcap-request-id"), BaggageField.create("bp")); })); } @@ -132,10 +126,8 @@ public class TraceAutoConfigurationTests { void should_use_baggagePropagationFactoryBuilder_bean() { // BaggagePropagation.FactoryBuilder unwraps itself if there are no baggage fields // defined - this.contextRunner - .withUserConfiguration(WithBaggagePropagationFactoryBuilderBean.class) - .run((context -> BDDAssertions - .then(context.getBean(Propagation.Factory.class)) + this.contextRunner.withUserConfiguration(WithBaggagePropagationFactoryBuilderBean.class) + .run((context -> BDDAssertions.then(context.getBean(Propagation.Factory.class)) .isSameAs(B3SinglePropagation.FACTORY))); } @@ -148,8 +140,8 @@ public class TraceAutoConfigurationTests { Baggage(Tracing tracing) { // When predefined baggage fields exist, the result != // TraceContextOrSamplingFlags.EMPTY - TraceContextOrSamplingFlags emptyExtraction = tracing.propagation() - .extractor((c, k) -> null).extract(Boolean.TRUE); + TraceContextOrSamplingFlags emptyExtraction = tracing.propagation().extractor((c, k) -> null) + .extract(Boolean.TRUE); fields = BaggageField.getAll(emptyExtraction); } @@ -160,14 +152,12 @@ public class TraceAutoConfigurationTests { @Bean BaggagePropagationCustomizer countryCode() { - return fb -> fb - .add(SingleBaggageField.remote(BaggageField.create("country-code"))); + return fb -> fb.add(SingleBaggageField.remote(BaggageField.create("country-code"))); } @Bean BaggagePropagationCustomizer requestId() { - return fb -> fb.add( - SingleBaggageField.remote(BaggageField.create("x-vcap-request-id"))); + return fb -> fb.add(SingleBaggageField.remote(BaggageField.create("x-vcap-request-id"))); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationWithDisabledSleuthTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationWithDisabledSleuthTests.java index 3da93c116..4e51f84c5 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationWithDisabledSleuthTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceAutoConfigurationWithDisabledSleuthTests.java @@ -43,8 +43,7 @@ import static org.assertj.core.api.Assertions.assertThat; @ExtendWith(OutputCaptureExtension.class) public class TraceAutoConfigurationWithDisabledSleuthTests { - private static final Log log = LogFactory - .getLog(TraceAutoConfigurationWithDisabledSleuthTests.class); + private static final Log log = LogFactory.getLog(TraceAutoConfigurationWithDisabledSleuthTests.class); @Autowired(required = false) Tracing tracing; diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceBaggageConfigurationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceBaggageConfigurationTests.java index 4283812b1..0e0a57fd3 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceBaggageConfigurationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/autoconfig/TraceBaggageConfigurationTests.java @@ -57,143 +57,108 @@ public class TraceBaggageConfigurationTests { @Test public void shouldCreateLocalFields() { this.contextRunner.withPropertyValues("spring.sleuth.baggage.local-fields=bp") - .run((context) -> assertThatBaggageFieldNameToKeyNames(context) - .containsOnly(tuple("bp", EMPTY_ARRAY))); + .run((context) -> assertThatBaggageFieldNameToKeyNames(context).containsOnly(tuple("bp", EMPTY_ARRAY))); } @Test public void shouldCreateLocalFields_oldName() { this.contextRunner.withPropertyValues("spring.sleuth.local-keys=bp") - .run((context) -> assertThatBaggageFieldNameToKeyNames(context) - .containsOnly(tuple("bp", EMPTY_ARRAY))); + .run((context) -> assertThatBaggageFieldNameToKeyNames(context).containsOnly(tuple("bp", EMPTY_ARRAY))); } - static ListAssert assertThatBaggageFieldNameToKeyNames( - AssertableApplicationContext context) { - return assertThat(context.getBean(Propagation.Factory.class)) - .extracting("configs").asInstanceOf(InstanceOfAssertFactories.ARRAY) - .extracting("field.name", "keyNames.toArray") + static ListAssert assertThatBaggageFieldNameToKeyNames(AssertableApplicationContext context) { + return assertThat(context.getBean(Propagation.Factory.class)).extracting("configs") + .asInstanceOf(InstanceOfAssertFactories.ARRAY).extracting("field.name", "keyNames.toArray") .asInstanceOf(InstanceOfAssertFactories.list(Tuple.class)); } @Test public void shouldCreateRemoteFields() { - this.contextRunner.withPropertyValues( - "spring.sleuth.baggage.remote-fields=x-vcap-request-id,country-code") - .run((context) -> assertThatBaggageFieldNameToKeyNames(context) - .containsOnly( - tuple("x-vcap-request-id", - new String[] { "x-vcap-request-id" }), - tuple("country-code", new String[] { "country-code" }))); + this.contextRunner.withPropertyValues("spring.sleuth.baggage.remote-fields=x-vcap-request-id,country-code") + .run((context) -> assertThatBaggageFieldNameToKeyNames(context).containsOnly( + tuple("x-vcap-request-id", new String[] { "x-vcap-request-id" }), + tuple("country-code", new String[] { "country-code" }))); } @Test public void shouldCreateRemoteFields_oldName() { - this.contextRunner - .withPropertyValues( - "spring.sleuth.propagation-keys=x-vcap-request-id,country-code") - .run((context) -> assertThatBaggageFieldNameToKeyNames(context) - .containsOnly( - tuple("x-vcap-request-id", - new String[] { "x-vcap-request-id" }), - tuple("country-code", new String[] { "country-code" }))); + this.contextRunner.withPropertyValues("spring.sleuth.propagation-keys=x-vcap-request-id,country-code") + .run((context) -> assertThatBaggageFieldNameToKeyNames(context).containsOnly( + tuple("x-vcap-request-id", new String[] { "x-vcap-request-id" }), + tuple("country-code", new String[] { "country-code" }))); } @Test public void shouldCreateDeprecatedBaggageFields() { this.contextRunner.withPropertyValues("spring.sleuth.baggage-keys=country-code") - .run((context) -> assertThatBaggageFieldNameToKeyNames(context) - .containsOnly(tuple("country-code", new String[] { - "baggage-country-code", "baggage_country-code" }))); + .run((context) -> assertThatBaggageFieldNameToKeyNames(context).containsOnly( + tuple("country-code", new String[] { "baggage-country-code", "baggage_country-code" }))); } @Test public void canCreateDeprecatedBaggageFieldsWithJavaConfig() { this.contextRunner.withUserConfiguration(CustomBaggageConfiguration.class) - .run((context) -> assertThatBaggageFieldNameToKeyNames(context) - .containsOnly(tuple("country-code", new String[] { - "baggage-country-code", "baggage_country-code" }))); + .run((context) -> assertThatBaggageFieldNameToKeyNames(context).containsOnly( + tuple("country-code", new String[] { "baggage-country-code", "baggage_country-code" }))); } @Test public void shouldCreateTagHandler() { - this.contextRunner - .withPropertyValues( - "spring.sleuth.baggage.tag-fields=x-vcap-request-id,country-code") - .run((context) -> assertThatFieldNamesToTag(context) - .containsOnly("x-vcap-request-id", "country-code")); + this.contextRunner.withPropertyValues("spring.sleuth.baggage.tag-fields=x-vcap-request-id,country-code") + .run((context) -> assertThatFieldNamesToTag(context).containsOnly("x-vcap-request-id", "country-code")); } @Test public void shouldCreateTagHandler_yaml() { this.contextRunner - .withPropertyValues( - "spring.sleuth.baggage.tag-fields[0]=x-vcap-request-id", + .withPropertyValues("spring.sleuth.baggage.tag-fields[0]=x-vcap-request-id", "spring.sleuth.baggage.tag-fields[1]=country-code") - .run((context) -> assertThatFieldNamesToTag(context) - .containsOnly("x-vcap-request-id", "country-code")); + .run((context) -> assertThatFieldNamesToTag(context).containsOnly("x-vcap-request-id", "country-code")); } @Test public void shouldCreateTagHandler_oldProperty() { - this.contextRunner.withPropertyValues( - "spring.sleuth.propagation.tag.whitelisted-keys=x-vcap-request-id,country-code") - .run((context) -> assertThatFieldNamesToTag(context) - .containsOnly("x-vcap-request-id", "country-code")); + this.contextRunner + .withPropertyValues("spring.sleuth.propagation.tag.whitelisted-keys=x-vcap-request-id,country-code") + .run((context) -> assertThatFieldNamesToTag(context).containsOnly("x-vcap-request-id", "country-code")); } @Test public void shouldCreateTagHandler_oldProperty_yaml() { - this.contextRunner.withPropertyValues( - "spring.sleuth.propagation.tag.whitelisted-keys[0]=x-vcap-request-id", - "spring.sleuth.propagation.tag.whitelisted-keys[1]=country-code") - .run((context) -> assertThatFieldNamesToTag(context) - .containsOnly("x-vcap-request-id", "country-code")); + this.contextRunner + .withPropertyValues("spring.sleuth.propagation.tag.whitelisted-keys[0]=x-vcap-request-id", + "spring.sleuth.propagation.tag.whitelisted-keys[1]=country-code") + .run((context) -> assertThatFieldNamesToTag(context).containsOnly("x-vcap-request-id", "country-code")); } static AbstractListAssert, String, ObjectAssert> assertThatFieldNamesToTag( AssertableApplicationContext context) { - return assertThat(context.getBean(SpanHandler.class)) - .isInstanceOf(BaggageTagSpanHandler.class).extracting("fieldsToTag") - .asInstanceOf(array(BaggageField[].class)).extracting(BaggageField::name); + return assertThat(context.getBean(SpanHandler.class)).isInstanceOf(BaggageTagSpanHandler.class) + .extracting("fieldsToTag").asInstanceOf(array(BaggageField[].class)).extracting(BaggageField::name); } @Test public void noopOnNoTagFields() { - this.contextRunner.withPropertyValues("spring.sleuth.baggage.tag-fields=") - .run((context) -> { - assertThat(context.getBean(SpanHandler.class)) - .isSameAs(SpanHandler.NOOP); - }); + this.contextRunner.withPropertyValues("spring.sleuth.baggage.tag-fields=").run((context) -> { + assertThat(context.getBean(SpanHandler.class)).isSameAs(SpanHandler.NOOP); + }); } @Test public void canAddOldCorrelationFieldsForLogScraping() { - this.contextRunner - .withUserConfiguration( - OldCorrelationFieldsForLogScrapingConfiguration.class) - .run((context) -> assertThat( - context.getBean(CorrelationScopeDecorator.class)) - .extracting("fields") - .asInstanceOf(array(SingleCorrelationField[].class)) - .extracting(SingleCorrelationField::name) - .containsExactly("traceId", "spanId", "parentId", - "spanExportable")); + this.contextRunner.withUserConfiguration(OldCorrelationFieldsForLogScrapingConfiguration.class) + .run((context) -> assertThat(context.getBean(CorrelationScopeDecorator.class)).extracting("fields") + .asInstanceOf(array(SingleCorrelationField[].class)).extracting(SingleCorrelationField::name) + .containsExactly("traceId", "spanId", "parentId", "spanExportable")); } @Test public void canMakeAllCorrelationFieldsDirty() { - this.contextRunner - .withPropertyValues( - "spring.sleuth.baggage.correlation-fields=country-code") + this.contextRunner.withPropertyValues("spring.sleuth.baggage.correlation-fields=country-code") .withUserConfiguration(DirtyCorrelationFieldConfiguration.class) - .run((context) -> assertThat( - context.getBean(CorrelationScopeDecorator.class)) - .extracting("fields") - .asInstanceOf(array(SingleCorrelationField[].class)) - .filteredOn(c -> !c.readOnly()) - .extracting(SingleCorrelationField::dirty) - .containsExactly(true)); + .run((context) -> assertThat(context.getBean(CorrelationScopeDecorator.class)).extracting("fields") + .asInstanceOf(array(SingleCorrelationField[].class)).filteredOn(c -> !c.readOnly()) + .extracting(SingleCorrelationField::dirty).containsExactly(true)); } @Configuration @@ -225,8 +190,7 @@ public class TraceBaggageConfigurationTests { @Bean CorrelationScopeCustomizer addParentAndSpanExportable() { return b -> b.add(SingleCorrelationField.create(BaggageFields.PARENT_ID)) - .add(SingleCorrelationField.newBuilder(BaggageFields.SAMPLED) - .name("spanExportable").build()); + .add(SingleCorrelationField.newBuilder(BaggageFields.SAMPLED).name("spanExportable").build()); } } @@ -236,10 +200,8 @@ public class TraceBaggageConfigurationTests { @Bean BaggagePropagationCustomizer countryCodeBaggageConfig() { - return fb -> fb.add( - SingleBaggageField.newBuilder(BaggageField.create("country-code")) - .addKeyName("baggage-country-code") - .addKeyName("baggage_country-code").build()); + return fb -> fb.add(SingleBaggageField.newBuilder(BaggageField.create("country-code")) + .addKeyName("baggage-country-code").addKeyName("baggage_country-code").build()); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/baggage/BaggageTagSpanHandlerTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/baggage/BaggageTagSpanHandlerTest.java index 705b59227..4de90a0a3 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/baggage/BaggageTagSpanHandlerTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/baggage/BaggageTagSpanHandlerTest.java @@ -39,8 +39,7 @@ import static org.assertj.core.api.Assertions.assertThat; */ @SpringBootTest( // WebEnvironment.NONE will not read a Yaml profile - webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, - classes = BaggageTagSpanHandlerTest.Config.class) + webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, classes = BaggageTagSpanHandlerTest.Config.class) @ActiveProfiles("baggage") // application-baggage.yml public class BaggageTagSpanHandlerTest { diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/baggage/CorrelationScopeDecoratorTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/baggage/CorrelationScopeDecoratorTest.java index 15df18094..8746a9a37 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/baggage/CorrelationScopeDecoratorTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/baggage/CorrelationScopeDecoratorTest.java @@ -40,10 +40,8 @@ import static org.assertj.core.api.Assertions.assertThat; * @author Marcin Grzejszczak */ @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.NONE, - properties = { - "spring.sleuth.baggage.remote-fields=x-vcap-request-id,country-code", - "spring.sleuth.baggage.local-fields=bp", - "spring.sleuth.baggage.correlation-fields=country-code,bp" }) + properties = { "spring.sleuth.baggage.remote-fields=x-vcap-request-id,country-code", + "spring.sleuth.baggage.local-fields=bp", "spring.sleuth.baggage.correlation-fields=country-code,bp" }) @SpringBootConfiguration @EnableAutoConfiguration public class CorrelationScopeDecoratorTest { @@ -95,8 +93,7 @@ public class CorrelationScopeDecoratorTest { public void should_remove_entries_from_mdc_for_null_span() { COUNTRY_CODE.updateValue(this.span.context(), "FO"); - try (Scope scope1 = this.scopeDecorator.decorateScope(this.span.context(), - NOOP)) { + try (Scope scope1 = this.scopeDecorator.decorateScope(this.span.context(), NOOP)) { assertThat(MDC.get(COUNTRY_CODE.name())).isEqualTo("FO"); try (Scope scope2 = this.scopeDecorator.decorateScope(null, NOOP)) { @@ -139,13 +136,13 @@ public class CorrelationScopeDecoratorTest { @Test public void should_only_include_whitelist() { assertThat(this.scopeDecorator).extracting("fields") - .asInstanceOf( - InstanceOfAssertFactories.array(SingleCorrelationField[].class)) - .extracting(SingleCorrelationField::name) - .containsOnly("traceId", "spanId", "bp", COUNTRY_CODE.name()); // x-vcap-request-id - // is not - // in the - // whitelist + .asInstanceOf(InstanceOfAssertFactories.array(SingleCorrelationField[].class)) + .extracting(SingleCorrelationField::name).containsOnly("traceId", "spanId", "bp", COUNTRY_CODE.name()); // x-vcap-request-id + // is + // not + // in + // the + // whitelist } @Test diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/documentation/SpringCloudSleuthDocTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/documentation/SpringCloudSleuthDocTests.java index 0318875ce..878e10901 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/documentation/SpringCloudSleuthDocTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/documentation/SpringCloudSleuthDocTests.java @@ -57,8 +57,8 @@ public class SpringCloudSleuthDocTests { StrictCurrentTraceContext currentTraceContext = StrictCurrentTraceContext.create(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .sampler(Sampler.ALWAYS_SAMPLE).addSpanHandler(this.spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).sampler(Sampler.ALWAYS_SAMPLE) + .addSpanHandler(this.spans).build(); Tracer tracer = this.tracing.tracer(); @@ -74,14 +74,12 @@ public class SpringCloudSleuthDocTests { } @Test - public void should_set_runnable_name_to_annotated_value() - throws ExecutionException, InterruptedException { + public void should_set_runnable_name_to_annotated_value() throws ExecutionException, InterruptedException { ExecutorService executorService = Executors.newSingleThreadExecutor(); SpanNamer spanNamer = new DefaultSpanNamer(); // tag::span_name_annotated_runnable_execution[] - Runnable runnable = new TraceRunnable(this.tracing, spanNamer, - new TaxCountingRunnable()); + Runnable runnable = new TraceRunnable(this.tracing, spanNamer, new TaxCountingRunnable()); Future future = executorService.submit(runnable); // ... some additional logic ... future.get(); @@ -92,8 +90,7 @@ public class SpringCloudSleuthDocTests { } @Test - public void should_set_runnable_name_to_to_string_value() - throws ExecutionException, InterruptedException { + public void should_set_runnable_name_to_to_string_value() throws ExecutionException, InterruptedException { ExecutorService executorService = Executors.newSingleThreadExecutor(); SpanNamer spanNamer = new DefaultSpanNamer(); @@ -221,8 +218,7 @@ public class SpringCloudSleuthDocTests { Optional calculateTax = spans.spans().stream() .filter(span -> span.name().equals("calculateCommission")).findFirst(); BDDAssertions.then(calculateTax).isPresent(); - BDDAssertions.then(calculateTax.get().tags()).containsEntry("commissionValue", - "10"); + BDDAssertions.then(calculateTax.get().tags()).containsEntry("commissionValue", "10"); BDDAssertions.then(calculateTax.get().annotations()).hasSize(1); executorService.shutdown(); } @@ -243,12 +239,10 @@ public class SpringCloudSleuthDocTests { } }; // Manual `TraceRunnable` creation with explicit "calculateTax" Span name - Runnable traceRunnable = new TraceRunnable(this.tracing, spanNamer, runnable, - "calculateTax"); + Runnable traceRunnable = new TraceRunnable(this.tracing, spanNamer, runnable, "calculateTax"); // Wrapping `Runnable` with `Tracing`. That way the current span will be available // in the thread of `Runnable` - Runnable traceRunnableFromTracer = this.tracing.currentTraceContext() - .wrap(runnable); + Runnable traceRunnableFromTracer = this.tracing.currentTraceContext().wrap(runnable); // end::trace_runnable[] then(traceRunnable).isExactlyInstanceOf(TraceRunnable.class); @@ -270,12 +264,10 @@ public class SpringCloudSleuthDocTests { } }; // Manual `TraceCallable` creation with explicit "calculateTax" Span name - Callable traceCallable = new TraceCallable<>(this.tracing, spanNamer, - callable, "calculateTax"); + Callable traceCallable = new TraceCallable<>(this.tracing, spanNamer, callable, "calculateTax"); // Wrapping `Callable` with `Tracing`. That way the current span will be available // in the thread of `Callable` - Callable traceCallableFromTracer = this.tracing.currentTraceContext() - .wrap(callable); + Callable traceCallableFromTracer = this.tracing.currentTraceContext().wrap(callable); // end::trace_callable[] } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/DefaultTestAutoConfiguration.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/DefaultTestAutoConfiguration.java index 5e575ff32..c039967a7 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/DefaultTestAutoConfiguration.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/DefaultTestAutoConfiguration.java @@ -28,8 +28,7 @@ import org.springframework.context.annotation.Configuration; @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) -@EnableAutoConfiguration( - exclude = { LoadBalancerAutoConfiguration.class, JmxAutoConfiguration.class }) +@EnableAutoConfiguration(exclude = { LoadBalancerAutoConfiguration.class, JmxAutoConfiguration.class }) // ,TraceSpringIntegrationAutoConfiguration.class, // TraceWebSocketAutoConfiguration.class }) @Configuration diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncCustomAutoConfigurationTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncCustomAutoConfigurationTest.java index 5cafae117..a0f2642b6 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncCustomAutoConfigurationTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncCustomAutoConfigurationTest.java @@ -32,19 +32,16 @@ public class AsyncCustomAutoConfigurationTest { public void should_return_bean_when_its_not_a_async_configurer() throws Exception { AsyncCustomAutoConfiguration configuration = new AsyncCustomAutoConfiguration(); - Object bean = configuration.postProcessAfterInitialization(new Object(), - "someName"); + Object bean = configuration.postProcessAfterInitialization(new Object(), "someName"); then(bean).isNotInstanceOf(LazyTraceAsyncCustomizer.class); } @Test - public void should_return_lazy_async_configurer_when_bean_is_async_configurer() - throws Exception { + public void should_return_lazy_async_configurer_when_bean_is_async_configurer() throws Exception { AsyncCustomAutoConfiguration configuration = new AsyncCustomAutoConfiguration(); - Object bean = configuration - .postProcessAfterInitialization(mock(AsyncConfigurer.class), "someName"); + Object bean = configuration.postProcessAfterInitialization(mock(AsyncConfigurer.class), "someName"); then(bean).isInstanceOf(LazyTraceAsyncCustomizer.class); } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncDefaultAutoConfigurationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncDefaultAutoConfigurationTests.java index 5fa17d910..865e12c5b 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncDefaultAutoConfigurationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncDefaultAutoConfigurationTests.java @@ -36,8 +36,7 @@ public class AsyncDefaultAutoConfigurationTests { @Test public void should_work_with_proxies() { - BDDAssertions.then(this.executor).isNotNull() - .isInstanceOf(TraceableScheduledExecutorService.class); + BDDAssertions.then(this.executor).isNotNull().isInstanceOf(TraceableScheduledExecutorService.class); } @Configuration diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncDisabledTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncDisabledTests.java index b9cfcb502..8ea379a0f 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncDisabledTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/AsyncDisabledTests.java @@ -36,8 +36,7 @@ import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; import static org.assertj.core.api.BDDAssertions.then; @SpringBootTest(classes = AsyncDisabledTests.ConfigureThreadPoolTaskScheduler.class, - webEnvironment = SpringBootTest.WebEnvironment.NONE, - properties = "spring.sleuth.scheduled.enabled=false") + webEnvironment = SpringBootTest.WebEnvironment.NONE, properties = "spring.sleuth.scheduled.enabled=false") public class AsyncDisabledTests { @Autowired diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/ExecutorBeanPostProcessorTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/ExecutorBeanPostProcessorTests.java index 1421dded2..b86ee9faa 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/ExecutorBeanPostProcessorTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/ExecutorBeanPostProcessorTests.java @@ -75,8 +75,7 @@ public class ExecutorBeanPostProcessorTests { @BeforeEach public void setup() { this.sleuthAsyncProperties = new SleuthAsyncProperties(); - Mockito.when(this.beanFactory.getBean(SleuthAsyncProperties.class)) - .thenReturn(this.sleuthAsyncProperties); + Mockito.when(this.beanFactory.getBean(SleuthAsyncProperties.class)).thenReturn(this.sleuthAsyncProperties); } @AfterEach @@ -86,20 +85,17 @@ public class ExecutorBeanPostProcessorTests { @Test public void should_create_a_cglib_proxy_by_default() throws Exception { - Object o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(new Foo(), "foo"); + Object o = new ExecutorBeanPostProcessor(this.beanFactory).postProcessAfterInitialization(new Foo(), "foo"); then(o).isInstanceOf(Foo.class); then(AopUtils.isCglibProxy(o)).isTrue(); } @Test - public void should_fallback_to_sleuth_implementation_when_cglib_cannot_be_created_for_executor() - throws Exception { + public void should_fallback_to_sleuth_implementation_when_cglib_cannot_be_created_for_executor() throws Exception { ExecutorService service = Executors.newSingleThreadExecutor(); - Object o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(service, "foo"); + Object o = new ExecutorBeanPostProcessor(this.beanFactory).postProcessAfterInitialization(service, "foo"); then(o).isInstanceOf(TraceableExecutorService.class); service.shutdown(); @@ -110,75 +106,59 @@ public class ExecutorBeanPostProcessorTests { throws Exception { ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); - Object o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(service, "foo"); + Object o = new ExecutorBeanPostProcessor(this.beanFactory).postProcessAfterInitialization(service, "foo"); then(o).isInstanceOf(TraceableScheduledExecutorService.class); service.shutdown(); } @Test - public void should_do_nothing_when_bean_is_already_lazy_trace_async_task_executor() - throws Exception { - LazyTraceAsyncTaskExecutor service = BDDMockito - .mock(LazyTraceAsyncTaskExecutor.class); + public void should_do_nothing_when_bean_is_already_lazy_trace_async_task_executor() throws Exception { + LazyTraceAsyncTaskExecutor service = BDDMockito.mock(LazyTraceAsyncTaskExecutor.class); - Object o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(service, "foo"); + Object o = new ExecutorBeanPostProcessor(this.beanFactory).postProcessAfterInitialization(service, "foo"); then(o).isSameAs(service); } @Test - public void should_do_nothing_when_bean_is_already_lazy_trace_executor() - throws Exception { + public void should_do_nothing_when_bean_is_already_lazy_trace_executor() throws Exception { LazyTraceExecutor service = BDDMockito.mock(LazyTraceExecutor.class); - Object o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(service, "foo"); + Object o = new ExecutorBeanPostProcessor(this.beanFactory).postProcessAfterInitialization(service, "foo"); then(o).isSameAs(service); } @Test - public void should_do_nothing_when_bean_is_already_lazy_thread_pool_task_executor() - throws Exception { - LazyTraceThreadPoolTaskExecutor service = BDDMockito - .mock(LazyTraceThreadPoolTaskExecutor.class); + public void should_do_nothing_when_bean_is_already_lazy_thread_pool_task_executor() throws Exception { + LazyTraceThreadPoolTaskExecutor service = BDDMockito.mock(LazyTraceThreadPoolTaskExecutor.class); - Object o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(service, "foo"); + Object o = new ExecutorBeanPostProcessor(this.beanFactory).postProcessAfterInitialization(service, "foo"); then(o).isSameAs(service); } @Test - public void should_do_nothing_when_bean_is_already_traceable_executor() - throws Exception { - TraceableExecutorService service = BDDMockito - .mock(TraceableExecutorService.class); + public void should_do_nothing_when_bean_is_already_traceable_executor() throws Exception { + TraceableExecutorService service = BDDMockito.mock(TraceableExecutorService.class); - Object o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(service, "foo"); + Object o = new ExecutorBeanPostProcessor(this.beanFactory).postProcessAfterInitialization(service, "foo"); then(o).isSameAs(service); } @Test - public void should_do_nothing_when_bean_is_already_traceable_scheduled_executor() - throws Exception { - TraceableScheduledExecutorService service = BDDMockito - .mock(TraceableScheduledExecutorService.class); + public void should_do_nothing_when_bean_is_already_traceable_scheduled_executor() throws Exception { + TraceableScheduledExecutorService service = BDDMockito.mock(TraceableScheduledExecutorService.class); - Object o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(service, "foo"); + Object o = new ExecutorBeanPostProcessor(this.beanFactory).postProcessAfterInitialization(service, "foo"); then(o).isSameAs(service); } @Test - public void should_fallback_to_default_implementation_when_exception_thrown() - throws Exception { + public void should_fallback_to_default_implementation_when_exception_thrown() throws Exception { ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor(); ExecutorBeanPostProcessor bpp = new ExecutorBeanPostProcessor(this.beanFactory) { @@ -196,8 +176,7 @@ public class ExecutorBeanPostProcessorTests { } @Test - public void should_create_a_cglib_proxy_by_default_for_ThreadPoolTaskExecutor() - throws Exception { + public void should_create_a_cglib_proxy_by_default_for_ThreadPoolTaskExecutor() throws Exception { Object o = new ExecutorBeanPostProcessor(this.beanFactory) .postProcessAfterInitialization(new FooThreadPoolTaskExecutor(), "foo"); @@ -211,8 +190,8 @@ public class ExecutorBeanPostProcessorTests { ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor(); ExecutorBeanPostProcessor bpp = new ExecutorBeanPostProcessor(this.beanFactory) { @Override - Object createThreadPoolTaskExecutorProxy(Object bean, boolean cglibProxy, - ThreadPoolTaskExecutor executor, String beanName) { + Object createThreadPoolTaskExecutorProxy(Object bean, boolean cglibProxy, ThreadPoolTaskExecutor executor, + String beanName) { throw new AopConfigException("foo"); } }; @@ -242,8 +221,7 @@ public class ExecutorBeanPostProcessorTests { ExecutorService service = exceptionThrowingExecutorService(); ExecutorBeanPostProcessor bpp = new ExecutorBeanPostProcessor(this.beanFactory); - ExecutorService o = (ExecutorService) bpp.postProcessAfterInitialization(service, - "foo"); + ExecutorService o = (ExecutorService) bpp.postProcessAfterInitialization(service, "foo"); thenThrownBy(() -> o.submit((Callable) () -> "hello")).hasMessage("foo") .isInstanceOf(IllegalStateException.class); @@ -277,8 +255,7 @@ public class ExecutorBeanPostProcessorTests { } @Override - public boolean awaitTermination(long timeout, TimeUnit unit) - throws InterruptedException { + public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { return false; } @@ -298,14 +275,13 @@ public class ExecutorBeanPostProcessorTests { } @Override - public List> invokeAll(Collection> tasks) - throws InterruptedException { + public List> invokeAll(Collection> tasks) throws InterruptedException { return null; } @Override - public List> invokeAll(Collection> tasks, - long timeout, TimeUnit unit) throws InterruptedException { + public List> invokeAll(Collection> tasks, long timeout, TimeUnit unit) + throws InterruptedException { return null; } @@ -316,8 +292,7 @@ public class ExecutorBeanPostProcessorTests { } @Override - public T invokeAny(Collection> tasks, long timeout, - TimeUnit unit) + public T invokeAny(Collection> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return null; } @@ -326,11 +301,9 @@ public class ExecutorBeanPostProcessorTests { @Test public void should_use_jdk_proxy_when_executor_has_final_methods() { - ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor( - this.beanFactory); + ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor(this.beanFactory); Executor executor = Runnable::run; - Executor wrappedExecutor = (Executor) beanPostProcessor - .postProcessAfterInitialization(executor, "executor"); + Executor wrappedExecutor = (Executor) beanPostProcessor.postProcessAfterInitialization(executor, "executor"); then(AopUtils.isJdkDynamicProxy(wrappedExecutor)).isTrue(); then(AopUtils.isCglibProxy(wrappedExecutor)).isFalse(); @@ -344,8 +317,7 @@ public class ExecutorBeanPostProcessorTests { @Test public void should_use_cglib_proxy_when_an_executor_has_a_final_package_protected_method() { - ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor( - this.beanFactory); + ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor(this.beanFactory); ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(10); ScheduledThreadPoolExecutor wrappedExecutor = (ScheduledThreadPoolExecutor) beanPostProcessor .postProcessAfterInitialization(executor, "executor"); @@ -358,10 +330,8 @@ public class ExecutorBeanPostProcessorTests { } @Test - public void should_use_jdk_proxy_when_executor_service_has_final_methods() - throws Exception { - ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor( - this.beanFactory); + public void should_use_jdk_proxy_when_executor_service_has_final_methods() throws Exception { + ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor(this.beanFactory); ExecutorService executorService = new DelegatingSecurityContextExecutorService( Executors.newSingleThreadExecutor()); ExecutorService wrappedExecutor = (ExecutorService) beanPostProcessor @@ -374,10 +344,8 @@ public class ExecutorBeanPostProcessorTests { } @Test - public void should_use_jdk_proxy_when_async_task_executor_has_final_methods() - throws Exception { - ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor( - this.beanFactory); + public void should_use_jdk_proxy_when_async_task_executor_has_final_methods() throws Exception { + ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor(this.beanFactory); AsyncTaskExecutor wrappedExecutor = (AsyncTaskExecutor) beanPostProcessor .postProcessAfterInitialization(new DirectTaskExecutor(), "taskExecutor"); @@ -389,13 +357,11 @@ public class ExecutorBeanPostProcessorTests { @Test public void should_fallback_to_sleuth_impl_when_thread_pool_task_executor_has_final_methods() { - ExecutorBeanPostProcessor postProcessor = new ExecutorBeanPostProcessor( - this.beanFactory); + ExecutorBeanPostProcessor postProcessor = new ExecutorBeanPostProcessor(this.beanFactory); ThreadPoolTaskExecutor threadPoolTaskExecutor = new PoolTaskExecutor(); ThreadPoolTaskExecutor wrappedTaskExecutor = (ThreadPoolTaskExecutor) postProcessor - .postProcessAfterInitialization(threadPoolTaskExecutor, - "threadPoolTaskExecutor"); + .postProcessAfterInitialization(threadPoolTaskExecutor, "threadPoolTaskExecutor"); then(wrappedTaskExecutor).isInstanceOf(LazyTraceThreadPoolTaskExecutor.class); then(AopUtils.isCglibProxy(wrappedTaskExecutor)).isFalse(); @@ -405,31 +371,26 @@ public class ExecutorBeanPostProcessorTests { @Test public void proxy_is_not_needed() throws Exception { - this.sleuthAsyncProperties - .setIgnoredBeans(Collections.singletonList("fooExecutor")); + this.sleuthAsyncProperties.setIgnoredBeans(Collections.singletonList("fooExecutor")); - boolean isProxyNeeded = new ExecutorBeanPostProcessor(this.beanFactory) - .isProxyNeeded("fooExecutor"); + boolean isProxyNeeded = new ExecutorBeanPostProcessor(this.beanFactory).isProxyNeeded("fooExecutor"); then(isProxyNeeded).isFalse(); } @Test public void proxy_is_needed() throws Exception { - boolean isProxyNeeded = new ExecutorBeanPostProcessor(this.beanFactory) - .isProxyNeeded("fooExecutor"); + boolean isProxyNeeded = new ExecutorBeanPostProcessor(this.beanFactory).isProxyNeeded("fooExecutor"); then(isProxyNeeded).isTrue(); } @Test public void should_not_create_proxy() throws Exception { - this.sleuthAsyncProperties - .setIgnoredBeans(Collections.singletonList("fooExecutor")); + this.sleuthAsyncProperties.setIgnoredBeans(Collections.singletonList("fooExecutor")); Object o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(new ThreadPoolTaskExecutor(), - "fooExecutor"); + .postProcessAfterInitialization(new ThreadPoolTaskExecutor(), "fooExecutor"); then(o).isInstanceOf(ThreadPoolTaskExecutor.class); then(AopUtils.isCglibProxy(o)).isFalse(); @@ -438,8 +399,7 @@ public class ExecutorBeanPostProcessorTests { @Test public void should_throw_real_exception_when_using_proxy() throws Exception { Object o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(new RejectedExecutionExecutor(), - "fooExecutor"); + .postProcessAfterInitialization(new RejectedExecutionExecutor(), "fooExecutor"); then(o).isInstanceOf(RejectedExecutionExecutor.class); then(AopUtils.isCglibProxy(o)).isTrue(); @@ -453,25 +413,22 @@ public class ExecutorBeanPostProcessorTests { LazyTraceThreadPoolTaskExecutor lazyTraceThreadPoolTaskExecutor = BDDMockito .mock(LazyTraceThreadPoolTaskExecutor.class); Object o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(lazyTraceThreadPoolTaskExecutor, - "executor"); + .postProcessAfterInitialization(lazyTraceThreadPoolTaskExecutor, "executor"); BDDAssertions.then(o).isSameAs(lazyTraceThreadPoolTaskExecutor); - TraceableExecutorService traceableExecutorService = BDDMockito - .mock(TraceableExecutorService.class); - o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(traceableExecutorService, "executor"); + TraceableExecutorService traceableExecutorService = BDDMockito.mock(TraceableExecutorService.class); + o = new ExecutorBeanPostProcessor(this.beanFactory).postProcessAfterInitialization(traceableExecutorService, + "executor"); BDDAssertions.then(o).isSameAs(traceableExecutorService); - LazyTraceAsyncTaskExecutor lazyTraceAsyncTaskExecutor = BDDMockito - .mock(LazyTraceAsyncTaskExecutor.class); - o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(lazyTraceAsyncTaskExecutor, "executor"); + LazyTraceAsyncTaskExecutor lazyTraceAsyncTaskExecutor = BDDMockito.mock(LazyTraceAsyncTaskExecutor.class); + o = new ExecutorBeanPostProcessor(this.beanFactory).postProcessAfterInitialization(lazyTraceAsyncTaskExecutor, + "executor"); BDDAssertions.then(o).isSameAs(lazyTraceAsyncTaskExecutor); LazyTraceExecutor lazyTraceExecutor = BDDMockito.mock(LazyTraceExecutor.class); - o = new ExecutorBeanPostProcessor(this.beanFactory) - .postProcessAfterInitialization(lazyTraceExecutor, "executor"); + o = new ExecutorBeanPostProcessor(this.beanFactory).postProcessAfterInitialization(lazyTraceExecutor, + "executor"); BDDAssertions.then(o).isSameAs(lazyTraceExecutor); } @@ -479,12 +436,10 @@ public class ExecutorBeanPostProcessorTests { // #1569 @Test public void should_use_jdk_proxy_when_executor_has_any_final_methods() { - ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor( - this.beanFactory); + ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor(this.beanFactory); Executor wrappedExecutor = (Executor) beanPostProcessor - .postProcessAfterInitialization(new ExecutorWithFinalMethod(), - "executorWithFinalMethod"); + .postProcessAfterInitialization(new ExecutorWithFinalMethod(), "executorWithFinalMethod"); then(AopUtils.isJdkDynamicProxy(wrappedExecutor)).isTrue(); then(AopUtils.isCglibProxy(wrappedExecutor)).isFalse(); @@ -498,12 +453,10 @@ public class ExecutorBeanPostProcessorTests { // #1569 @Test public void should_use_jdk_proxy_when_executor_has_an_inherited_final_methods() { - ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor( - this.beanFactory); + ExecutorBeanPostProcessor beanPostProcessor = new ExecutorBeanPostProcessor(this.beanFactory); Executor wrappedExecutor = (Executor) beanPostProcessor - .postProcessAfterInitialization(new ExecutorWithInheritedFinalMethod(), - "executorWithFinalMethod"); + .postProcessAfterInitialization(new ExecutorWithInheritedFinalMethod(), "executorWithFinalMethod"); then(AopUtils.isJdkDynamicProxy(wrappedExecutor)).isTrue(); then(AopUtils.isCglibProxy(wrappedExecutor)).isFalse(); @@ -572,8 +525,7 @@ public class ExecutorBeanPostProcessorTests { } - static class ExecutorWithInheritedFinalMethod extends ExecutorWithFinalMethod - implements Executor { + static class ExecutorWithInheritedFinalMethod extends ExecutorWithFinalMethod implements Executor { @Override public void execute(Runnable command) { diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceScheduledThreadPoolExecutorTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceScheduledThreadPoolExecutorTests.java index 3b6008eed..a5380c353 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceScheduledThreadPoolExecutorTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceScheduledThreadPoolExecutorTests.java @@ -39,8 +39,7 @@ public class LazyTraceScheduledThreadPoolExecutorTests { }; BeanFactory beanFactory = BDDMockito.mock(BeanFactory.class); - new LazyTraceScheduledThreadPoolExecutor(10, beanFactory, executor, null) - .finalize(); + new LazyTraceScheduledThreadPoolExecutor(10, beanFactory, executor, null).finalize(); BDDAssertions.then(wasCalled).isFalse(); BDDAssertions.then(executor.isShutdown()).isFalse(); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskSchedulerTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskSchedulerTests.java index 1ec8b7a26..b3edf3065 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskSchedulerTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/LazyTraceThreadPoolTaskSchedulerTests.java @@ -45,8 +45,7 @@ public class LazyTraceThreadPoolTaskSchedulerTests { StrictCurrentTraceContext currentTraceContext = StrictCurrentTraceContext.create(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(currentTraceContext) - .build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(currentTraceContext).build(); @Mock(lenient = true) BeanFactory beanFactory; @@ -58,8 +57,7 @@ public class LazyTraceThreadPoolTaskSchedulerTests { @BeforeEach public void setup() { - this.executor = new LazyTraceThreadPoolTaskScheduler(beanFactory(), this.delegate, - null); + this.executor = new LazyTraceThreadPoolTaskScheduler(beanFactory(), this.delegate, null); } @AfterEach @@ -70,10 +68,8 @@ public class LazyTraceThreadPoolTaskSchedulerTests { } BeanFactory beanFactory() { - BDDMockito.given(this.beanFactory.getBean(Tracing.class)) - .willReturn(this.tracing); - BDDMockito.given(this.beanFactory.getBean(SpanNamer.class)) - .willReturn(new DefaultSpanNamer()); + BDDMockito.given(this.beanFactory.getBean(Tracing.class)).willReturn(this.tracing); + BDDMockito.given(this.beanFactory.getBean(SpanNamer.class)).willReturn(new DefaultSpanNamer()); SleuthContextListenerAccessor.set(this.beanFactory, true); return this.beanFactory; } @@ -135,8 +131,7 @@ public class LazyTraceThreadPoolTaskSchedulerTests { }; this.executor.execute(r); - BDDMockito.then(this.delegate).should() - .execute(BDDMockito.any(TraceRunnable.class)); + BDDMockito.then(this.delegate).should().execute(BDDMockito.any(TraceRunnable.class)); } @Test @@ -145,8 +140,7 @@ public class LazyTraceThreadPoolTaskSchedulerTests { }; this.executor.execute(r, 10L); - BDDMockito.then(this.delegate).should() - .execute(BDDMockito.any(TraceRunnable.class), BDDMockito.eq(10L)); + BDDMockito.then(this.delegate).should().execute(BDDMockito.any(TraceRunnable.class), BDDMockito.eq(10L)); } @Test @@ -155,8 +149,7 @@ public class LazyTraceThreadPoolTaskSchedulerTests { }; this.executor.submit(c); - BDDMockito.then(this.delegate).should() - .submit(BDDMockito.any(TraceRunnable.class)); + BDDMockito.then(this.delegate).should().submit(BDDMockito.any(TraceRunnable.class)); } @Test @@ -164,8 +157,7 @@ public class LazyTraceThreadPoolTaskSchedulerTests { Callable c = () -> null; this.executor.submit(c); - BDDMockito.then(this.delegate).should() - .submit(BDDMockito.any(TraceCallable.class)); + BDDMockito.then(this.delegate).should().submit(BDDMockito.any(TraceCallable.class)); } @Test @@ -174,8 +166,7 @@ public class LazyTraceThreadPoolTaskSchedulerTests { }; this.executor.submitListenable(c); - BDDMockito.then(this.delegate).should() - .submitListenable(BDDMockito.any(TraceRunnable.class)); + BDDMockito.then(this.delegate).should().submitListenable(BDDMockito.any(TraceRunnable.class)); } @Test @@ -183,8 +174,7 @@ public class LazyTraceThreadPoolTaskSchedulerTests { Callable c = () -> null; this.executor.submitListenable(c); - BDDMockito.then(this.delegate).should() - .submitListenable(BDDMockito.any(TraceCallable.class)); + BDDMockito.then(this.delegate).should().submitListenable(BDDMockito.any(TraceCallable.class)); } @Test @@ -201,8 +191,7 @@ public class LazyTraceThreadPoolTaskSchedulerTests { Trigger trigger = triggerContext -> null; this.executor.schedule(c, trigger); - BDDMockito.then(this.delegate).should() - .schedule(BDDMockito.any(TraceRunnable.class), BDDMockito.eq(trigger)); + BDDMockito.then(this.delegate).should().schedule(BDDMockito.any(TraceRunnable.class), BDDMockito.eq(trigger)); } @Test @@ -212,8 +201,7 @@ public class LazyTraceThreadPoolTaskSchedulerTests { Date date = new Date(); this.executor.schedule(c, date); - BDDMockito.then(this.delegate).should() - .schedule(BDDMockito.any(TraceRunnable.class), BDDMockito.eq(date)); + BDDMockito.then(this.delegate).should().schedule(BDDMockito.any(TraceRunnable.class), BDDMockito.eq(date)); } @Test @@ -223,9 +211,8 @@ public class LazyTraceThreadPoolTaskSchedulerTests { Date date = new Date(); this.executor.scheduleAtFixedRate(c, date, 10L); - BDDMockito.then(this.delegate).should().scheduleAtFixedRate( - BDDMockito.any(TraceRunnable.class), BDDMockito.eq(date), - BDDMockito.eq(10L)); + BDDMockito.then(this.delegate).should().scheduleAtFixedRate(BDDMockito.any(TraceRunnable.class), + BDDMockito.eq(date), BDDMockito.eq(10L)); } @Test @@ -234,8 +221,8 @@ public class LazyTraceThreadPoolTaskSchedulerTests { }; this.executor.scheduleAtFixedRate(c, 10L); - BDDMockito.then(this.delegate).should().scheduleAtFixedRate( - BDDMockito.any(TraceRunnable.class), BDDMockito.eq(10L)); + BDDMockito.then(this.delegate).should().scheduleAtFixedRate(BDDMockito.any(TraceRunnable.class), + BDDMockito.eq(10L)); } @Test @@ -245,9 +232,8 @@ public class LazyTraceThreadPoolTaskSchedulerTests { Date date = new Date(); this.executor.scheduleWithFixedDelay(c, date, 10L); - BDDMockito.then(this.delegate).should().scheduleWithFixedDelay( - BDDMockito.any(TraceRunnable.class), BDDMockito.eq(date), - BDDMockito.eq(10L)); + BDDMockito.then(this.delegate).should().scheduleWithFixedDelay(BDDMockito.any(TraceRunnable.class), + BDDMockito.eq(date), BDDMockito.eq(10L)); } @Test @@ -256,8 +242,8 @@ public class LazyTraceThreadPoolTaskSchedulerTests { }; this.executor.scheduleWithFixedDelay(c, 10L); - BDDMockito.then(this.delegate).should().scheduleWithFixedDelay( - BDDMockito.any(TraceRunnable.class), BDDMockito.eq(10L)); + BDDMockito.then(this.delegate).should().scheduleWithFixedDelay(BDDMockito.any(TraceRunnable.class), + BDDMockito.eq(10L)); } @Test @@ -268,9 +254,8 @@ public class LazyTraceThreadPoolTaskSchedulerTests { Duration duration = Duration.ZERO; this.executor.scheduleWithFixedDelay(c, instant, duration); - BDDMockito.then(this.delegate).should().scheduleWithFixedDelay( - BDDMockito.any(TraceRunnable.class), BDDMockito.eq(instant), - BDDMockito.eq(duration)); + BDDMockito.then(this.delegate).should().scheduleWithFixedDelay(BDDMockito.any(TraceRunnable.class), + BDDMockito.eq(instant), BDDMockito.eq(duration)); } @Test @@ -280,8 +265,8 @@ public class LazyTraceThreadPoolTaskSchedulerTests { Duration duration = Duration.ZERO; this.executor.scheduleWithFixedDelay(c, duration); - BDDMockito.then(this.delegate).should().scheduleWithFixedDelay( - BDDMockito.any(TraceRunnable.class), BDDMockito.eq(duration)); + BDDMockito.then(this.delegate).should().scheduleWithFixedDelay(BDDMockito.any(TraceRunnable.class), + BDDMockito.eq(duration)); } @Test @@ -439,8 +424,7 @@ public class LazyTraceThreadPoolTaskSchedulerTests { Instant instant = Instant.now(); this.executor.schedule(r, instant); - BDDMockito.then(this.delegate).should() - .schedule(BDDMockito.any(TraceRunnable.class), BDDMockito.eq(instant)); + BDDMockito.then(this.delegate).should().schedule(BDDMockito.any(TraceRunnable.class), BDDMockito.eq(instant)); } @Test @@ -451,9 +435,8 @@ public class LazyTraceThreadPoolTaskSchedulerTests { Duration duration = Duration.ZERO; this.executor.scheduleAtFixedRate(r, instant, duration); - BDDMockito.then(this.delegate).should().scheduleAtFixedRate( - BDDMockito.any(TraceRunnable.class), BDDMockito.eq(instant), - BDDMockito.eq(duration)); + BDDMockito.then(this.delegate).should().scheduleAtFixedRate(BDDMockito.any(TraceRunnable.class), + BDDMockito.eq(instant), BDDMockito.eq(duration)); } @Test @@ -463,8 +446,8 @@ public class LazyTraceThreadPoolTaskSchedulerTests { Duration duration = Duration.ZERO; this.executor.scheduleAtFixedRate(r, duration); - BDDMockito.then(this.delegate).should().scheduleAtFixedRate( - BDDMockito.any(TraceRunnable.class), BDDMockito.eq(duration)); + BDDMockito.then(this.delegate).should().scheduleAtFixedRate(BDDMockito.any(TraceRunnable.class), + BDDMockito.eq(duration)); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListenerAccessor.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListenerAccessor.java index 689f2284f..d0b71a319 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListenerAccessor.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListenerAccessor.java @@ -27,8 +27,8 @@ public final class SleuthContextListenerAccessor { } public static void set(BeanFactory beanFactory, boolean refreshed) { - SleuthContextListener.CACHE.put(beanFactory, new SleuthContextListener( - new AtomicBoolean(refreshed), new AtomicBoolean(false))); + SleuthContextListener.CACHE.put(beanFactory, + new SleuthContextListener(new AtomicBoolean(refreshed), new AtomicBoolean(false))); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListenerTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListenerTest.java index 33da47387..12206a2d4 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListenerTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/SleuthContextListenerTest.java @@ -32,8 +32,7 @@ class SleuthContextListenerTest { @Test void should_be_usable_using_context() { - SleuthContextListener listener = SleuthContextListener - .getBean(applicationContext); + SleuthContextListener listener = SleuthContextListener.getBean(applicationContext); then(listener).isNotNull(); then(listener.isUnusable()).isFalse(); @@ -41,8 +40,7 @@ class SleuthContextListenerTest { @Test void should_be_usable_using_beanfactory() { - SleuthContextListener listener = SleuthContextListener - .getBean(applicationContext.getBeanFactory()); + SleuthContextListener listener = SleuthContextListener.getBean(applicationContext.getBeanFactory()); then(listener).isNotNull(); then(listener.isUnusable()).isFalse(); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncAspectTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncAspectTest.java index 5394c7e90..5f88b9f41 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncAspectTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncAspectTest.java @@ -39,8 +39,8 @@ public class TraceAsyncAspectTest { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .build(); ProceedingJoinPoint point = Mockito.mock(ProceedingJoinPoint.class); @@ -48,8 +48,7 @@ public class TraceAsyncAspectTest { public void setup() throws NoSuchMethodException { MethodSignature signature = Mockito.mock(MethodSignature.class); BDDMockito.given(signature.getName()).willReturn("fooBar"); - BDDMockito.given(signature.getMethod()) - .willReturn(TraceAsyncAspectTest.class.getMethod("setup")); + BDDMockito.given(signature.getMethod()).willReturn(TraceAsyncAspectTest.class.getMethod("setup")); BDDMockito.given(this.point.getSignature()).willReturn(signature); BDDMockito.given(this.point.getTarget()).willReturn(""); } @@ -63,8 +62,7 @@ public class TraceAsyncAspectTest { // Issue#926 @Test public void should_work() throws Throwable { - TraceAsyncAspect asyncAspect = new TraceAsyncAspect(this.tracing.tracer(), - new DefaultSpanNamer()) { + TraceAsyncAspect asyncAspect = new TraceAsyncAspect(this.tracing.tracer(), new DefaultSpanNamer()) { @Override String name(ProceedingJoinPoint pjp) { return "foo-bar"; diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncListenableTaskExecutorTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncListenableTaskExecutorTest.java index ad68de319..24dbf480d 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncListenableTaskExecutorTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncListenableTaskExecutorTest.java @@ -41,8 +41,7 @@ public class TraceAsyncListenableTaskExecutorTest { StrictCurrentTraceContext currentTraceContext = StrictCurrentTraceContext.create(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(currentTraceContext) - .build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(currentTraceContext).build(); Tracer tracer = this.tracing.tracer(); @@ -61,8 +60,7 @@ public class TraceAsyncListenableTaskExecutorTest { Span span = this.tracer.nextSpan().name("foo"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { - this.traceAsyncListenableTaskExecutor - .submitListenable(aRunnable(this.tracing, executed)).get(); + this.traceAsyncListenableTaskExecutor.submitListenable(aRunnable(this.tracing, executed)).get(); } finally { span.finish(); @@ -77,8 +75,7 @@ public class TraceAsyncListenableTaskExecutorTest { Span spanFromListenable; try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { - spanFromListenable = this.traceAsyncListenableTaskExecutor - .submitListenable(aCallable(this.tracing)).get(); + spanFromListenable = this.traceAsyncListenableTaskExecutor.submitListenable(aCallable(this.tracing)).get(); } finally { span.finish(); @@ -93,8 +90,7 @@ public class TraceAsyncListenableTaskExecutorTest { Span span = this.tracer.nextSpan().name("foo"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { - this.traceAsyncListenableTaskExecutor - .execute(aRunnable(this.tracing, executed)); + this.traceAsyncListenableTaskExecutor.execute(aRunnable(this.tracing, executed)); } finally { span.finish(); @@ -111,8 +107,7 @@ public class TraceAsyncListenableTaskExecutorTest { Span span = this.tracer.nextSpan().name("foo"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { - this.traceAsyncListenableTaskExecutor - .execute(aRunnable(this.tracing, executed), 1L); + this.traceAsyncListenableTaskExecutor.execute(aRunnable(this.tracing, executed), 1L); } finally { span.finish(); @@ -129,8 +124,7 @@ public class TraceAsyncListenableTaskExecutorTest { Span spanFromListenable; try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { - spanFromListenable = this.traceAsyncListenableTaskExecutor - .submit(aCallable(this.tracing)).get(); + spanFromListenable = this.traceAsyncListenableTaskExecutor.submit(aCallable(this.tracing)).get(); } finally { span.finish(); @@ -145,8 +139,7 @@ public class TraceAsyncListenableTaskExecutorTest { Span span = this.tracer.nextSpan().name("foo"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { - this.traceAsyncListenableTaskExecutor - .submit(aRunnable(this.tracing, executed)).get(); + this.traceAsyncListenableTaskExecutor.submit(aRunnable(this.tracing, executed)).get(); } finally { span.finish(); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceCallableTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceCallableTests.java index 1f5d36da5..de50a2ac1 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceCallableTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceCallableTests.java @@ -44,8 +44,8 @@ public class TraceCallableTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .build(); Tracer tracer = this.tracing.tracer(); @@ -67,19 +67,16 @@ public class TraceCallableTests { } @Test - public void should_remove_span_from_thread_local_after_finishing_work() - throws Exception { + public void should_remove_span_from_thread_local_after_finishing_work() throws Exception { givenCallableGetsSubmitted(thatRetrievesTraceFromThreadLocal()); - Span secondSpan = whenNonTraceableCallableGetsSubmitted( - thatRetrievesTraceFromThreadLocal()); + Span secondSpan = whenNonTraceableCallableGetsSubmitted(thatRetrievesTraceFromThreadLocal()); then(secondSpan).isNull(); } @Test - public void should_remove_parent_span_from_thread_local_after_finishing_work() - throws Exception { + public void should_remove_parent_span_from_thread_local_after_finishing_work() throws Exception { Span parent = this.tracer.nextSpan().name("http:parent"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(parent)) { Span child = givenCallableGetsSubmitted(thatRetrievesTraceFromThreadLocal()); @@ -88,8 +85,7 @@ public class TraceCallableTests { } then(this.tracer.currentSpan()).isNull(); - Span secondSpan = whenNonTraceableCallableGetsSubmitted( - thatRetrievesTraceFromThreadLocal()); + Span secondSpan = whenNonTraceableCallableGetsSubmitted(thatRetrievesTraceFromThreadLocal()); then(secondSpan).isNull(); } @@ -103,8 +99,7 @@ public class TraceCallableTests { } @Test - public void should_take_name_of_span_from_to_string_if_span_name_annotation_is_missing() - throws Exception { + public void should_take_name_of_span_from_to_string_if_span_name_annotation_is_missing() throws Exception { whenCallableGetsSubmitted(thatRetrievesTraceFromThreadLocal()); then(this.spans).hasSize(1); @@ -132,15 +127,13 @@ public class TraceCallableTests { private Span whenCallableGetsSubmitted(Callable callable) throws InterruptedException, java.util.concurrent.ExecutionException { - return this.executor.submit( - new TraceCallable<>(this.tracing, new DefaultSpanNamer(), callable)) - .get(); + return this.executor.submit(new TraceCallable<>(this.tracing, new DefaultSpanNamer(), callable)).get(); } private Span whenATraceKeepingCallableGetsSubmitted() throws InterruptedException, java.util.concurrent.ExecutionException { - return this.executor.submit(new TraceCallable<>(this.tracing, - new DefaultSpanNamer(), new TraceKeepingCallable())).get(); + return this.executor + .submit(new TraceCallable<>(this.tracing, new DefaultSpanNamer(), new TraceKeepingCallable())).get(); } private Span whenNonTraceableCallableGetsSubmitted(Callable callable) diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceRunnableTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceRunnableTests.java index e90173901..d07d01085 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceRunnableTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceRunnableTests.java @@ -44,8 +44,8 @@ public class TraceRunnableTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .build(); Tracer tracer = this.tracing.tracer(); @@ -58,8 +58,7 @@ public class TraceRunnableTests { } @Test - public void should_remove_span_from_thread_local_after_finishing_work() - throws Exception { + public void should_remove_span_from_thread_local_after_finishing_work() throws Exception { // given TraceKeepingRunnable traceKeepingRunnable = runnableThatRetrievesTraceFromThreadLocal(); givenRunnableGetsSubmitted(traceKeepingRunnable); @@ -71,17 +70,15 @@ public class TraceRunnableTests { // then Span secondSpan = traceKeepingRunnable.span; - then(secondSpan.context().traceId()).as("second span id") - .isNotEqualTo(firstSpan.context().traceId()).as("first span id"); + then(secondSpan.context().traceId()).as("second span id").isNotEqualTo(firstSpan.context().traceId()) + .as("first span id"); // and - then(secondSpan.context().parentId()).as("saved span as remnant of first span") - .isNull(); + then(secondSpan.context().parentId()).as("saved span as remnant of first span").isNull(); } @Test - public void should_not_find_thread_local_in_non_traceable_callback() - throws Exception { + public void should_not_find_thread_local_in_non_traceable_callback() throws Exception { // given TraceKeepingRunnable traceKeepingRunnable = runnableThatRetrievesTraceFromThreadLocal(); givenRunnableGetsSubmitted(traceKeepingRunnable); @@ -107,8 +104,7 @@ public class TraceRunnableTests { } @Test - public void should_take_name_of_span_from_to_string_if_span_name_annotation_is_missing() - throws Exception { + public void should_take_name_of_span_from_to_string_if_span_name_annotation_is_missing() throws Exception { final AtomicReference span = new AtomicReference<>(); Runnable runnable = runnableWithCustomToString(span); @@ -127,13 +123,10 @@ public class TraceRunnableTests { } private void whenRunnableGetsSubmitted(Runnable runnable) throws Exception { - this.executor - .submit(new TraceRunnable(this.tracing, new DefaultSpanNamer(), runnable)) - .get(); + this.executor.submit(new TraceRunnable(this.tracing, new DefaultSpanNamer(), runnable)).get(); } - private void whenNonTraceableRunnableGetsSubmitted(Runnable runnable) - throws Exception { + private void whenNonTraceableRunnableGetsSubmitted(Runnable runnable) throws Exception { this.executor.submit(runnable).get(); } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceableExecutorServiceTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceableExecutorServiceTests.java index 37c4867ec..c3cfcb3d7 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceableExecutorServiceTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceableExecutorServiceTests.java @@ -68,8 +68,8 @@ public class TraceableExecutorServiceTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .build(); Tracer tracer = this.tracing.tracer(); @@ -77,8 +77,8 @@ public class TraceableExecutorServiceTests { @BeforeEach public void setup() { - this.traceManagerableExecutorService = new TraceableExecutorService( - beanFactory(true), this.executorService, "foo"); + this.traceManagerableExecutorService = new TraceableExecutorService(beanFactory(true), this.executorService, + "foo"); this.spans.clear(); this.spanVerifyingRunnable.clear(); } @@ -96,43 +96,35 @@ public class TraceableExecutorServiceTests { throws Exception { ScopedSpan span = this.tracer.startScopedSpan("http:PARENT"); try { - CompletableFuture.allOf(runnablesExecutedViaTraceManagerableExecutorService()) - .get(); + CompletableFuture.allOf(runnablesExecutedViaTraceManagerableExecutorService()).get(); } finally { span.finish(); } - then(this.spanVerifyingRunnable.traceIds.stream().distinct().collect(toList())) - .hasSize(1); - then(this.spanVerifyingRunnable.spanIds.stream().distinct().collect(toList())) - .hasSize(TOTAL_THREADS); + then(this.spanVerifyingRunnable.traceIds.stream().distinct().collect(toList())).hasSize(1); + then(this.spanVerifyingRunnable.spanIds.stream().distinct().collect(toList())).hasSize(TOTAL_THREADS); } @Test @SuppressWarnings("unchecked") - public void should_wrap_methods_in_trace_representation_only_for_non_tracing_callables() - throws Exception { + public void should_wrap_methods_in_trace_representation_only_for_non_tracing_callables() throws Exception { ExecutorService executorService = Mockito.mock(ExecutorService.class); - TraceableExecutorService traceExecutorService = new TraceableExecutorService( - beanFactory(true), executorService); + TraceableExecutorService traceExecutorService = new TraceableExecutorService(beanFactory(true), + executorService); traceExecutorService.invokeAll(callables()); - BDDMockito.then(executorService).should() - .invokeAll(BDDMockito.argThat(withSpanContinuingTraceCallablesOnly())); + BDDMockito.then(executorService).should().invokeAll(BDDMockito.argThat(withSpanContinuingTraceCallablesOnly())); traceExecutorService.invokeAll(callables(), 1L, TimeUnit.DAYS); - BDDMockito.then(executorService).should().invokeAll( - BDDMockito.argThat(withSpanContinuingTraceCallablesOnly()), + BDDMockito.then(executorService).should().invokeAll(BDDMockito.argThat(withSpanContinuingTraceCallablesOnly()), BDDMockito.eq(1L), BDDMockito.eq(TimeUnit.DAYS)); traceExecutorService.invokeAny(callables()); - BDDMockito.then(executorService).should() - .invokeAny(BDDMockito.argThat(withSpanContinuingTraceCallablesOnly())); + BDDMockito.then(executorService).should().invokeAny(BDDMockito.argThat(withSpanContinuingTraceCallablesOnly())); traceExecutorService.invokeAny(callables(), 1L, TimeUnit.DAYS); - BDDMockito.then(executorService).should().invokeAny( - BDDMockito.argThat(withSpanContinuingTraceCallablesOnly()), + BDDMockito.then(executorService).should().invokeAny(BDDMockito.argThat(withSpanContinuingTraceCallablesOnly()), BDDMockito.eq(1L), BDDMockito.eq(TimeUnit.DAYS)); } @@ -141,8 +133,8 @@ public class TraceableExecutorServiceTests { public void should_not_wrap_methods_in_trace_representation_only_for_non_tracing_callables_when_context_not_ready() throws Exception { ExecutorService executorService = Mockito.mock(ExecutorService.class); - TraceableExecutorService traceExecutorService = new TraceableExecutorService( - beanFactory(false), executorService); + TraceableExecutorService traceExecutorService = new TraceableExecutorService(beanFactory(false), + executorService); traceExecutorService.invokeAll(callables()); BDDMockito.then(executorService).should(BDDMockito.never()) @@ -150,8 +142,8 @@ public class TraceableExecutorServiceTests { traceExecutorService.invokeAll(callables(), 1L, TimeUnit.DAYS); BDDMockito.then(executorService).should(BDDMockito.never()).invokeAll( - BDDMockito.argThat(withSpanContinuingTraceCallablesOnly()), - BDDMockito.eq(1L), BDDMockito.eq(TimeUnit.DAYS)); + BDDMockito.argThat(withSpanContinuingTraceCallablesOnly()), BDDMockito.eq(1L), + BDDMockito.eq(TimeUnit.DAYS)); traceExecutorService.invokeAny(callables()); BDDMockito.then(executorService).should(BDDMockito.never()) @@ -159,16 +151,15 @@ public class TraceableExecutorServiceTests { traceExecutorService.invokeAny(callables(), 1L, TimeUnit.DAYS); BDDMockito.then(executorService).should(BDDMockito.never()).invokeAny( - BDDMockito.argThat(withSpanContinuingTraceCallablesOnly()), - BDDMockito.eq(1L), BDDMockito.eq(TimeUnit.DAYS)); + BDDMockito.argThat(withSpanContinuingTraceCallablesOnly()), BDDMockito.eq(1L), + BDDMockito.eq(TimeUnit.DAYS)); } private ArgumentMatcher>> withSpanContinuingTraceCallablesOnly() { return argument -> { try { BDDAssertions.then(argument).flatExtracting(Object::getClass) - .containsOnlyElementsOf( - Collections.singletonList(TraceCallable.class)); + .containsOnlyElementsOf(Collections.singletonList(TraceCallable.class)); } catch (AssertionError e) { return false; @@ -185,8 +176,7 @@ public class TraceableExecutorServiceTests { } @Test - public void should_propagate_trace_info_when_compleable_future_is_used() - throws Exception { + public void should_propagate_trace_info_when_compleable_future_is_used() throws Exception { ExecutorService executorService = this.executorService; BeanFactory beanFactory = beanFactory(true); // tag::completablefuture[] @@ -219,17 +209,14 @@ public class TraceableExecutorServiceTests { private CompletableFuture[] runnablesExecutedViaTraceManagerableExecutorService() { List> futures = new ArrayList<>(); for (int i = 0; i < TOTAL_THREADS; i++) { - futures.add(CompletableFuture.runAsync(this.spanVerifyingRunnable, - this.traceManagerableExecutorService)); + futures.add(CompletableFuture.runAsync(this.spanVerifyingRunnable, this.traceManagerableExecutorService)); } return futures.toArray(new CompletableFuture[futures.size()]); } BeanFactory beanFactory(boolean refreshed) { - BDDMockito.given(this.beanFactory.getBean(Tracing.class)) - .willReturn(this.tracing); - BDDMockito.given(this.beanFactory.getBean(SpanNamer.class)) - .willReturn(new DefaultSpanNamer()); + BDDMockito.given(this.beanFactory.getBean(Tracing.class)).willReturn(this.tracing); + BDDMockito.given(this.beanFactory.getBean(SpanNamer.class)).willReturn(new DefaultSpanNamer()); SleuthContextListenerAccessor.set(this.beanFactory, refreshed); return this.beanFactory; } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceableScheduledExecutorServiceTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceableScheduledExecutorServiceTest.java index 176b1bd01..966610f72 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceableScheduledExecutorServiceTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceableScheduledExecutorServiceTest.java @@ -50,8 +50,7 @@ public class TraceableScheduledExecutorServiceTest { StrictCurrentTraceContext currentTraceContext = StrictCurrentTraceContext.create(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).build(); @Mock(lenient = true) BeanFactory beanFactory; @@ -78,9 +77,8 @@ public class TraceableScheduledExecutorServiceTest { this.traceableScheduledExecutorService.schedule(aRunnable(), 1L, TimeUnit.DAYS); then(this.scheduledExecutorService).should().schedule( - BDDMockito.argThat( - matcher(Runnable.class, instanceOf(TraceRunnable.class))), - anyLong(), any(TimeUnit.class)); + BDDMockito.argThat(matcher(Runnable.class, instanceOf(TraceRunnable.class))), anyLong(), + any(TimeUnit.class)); } @Test @@ -88,81 +86,66 @@ public class TraceableScheduledExecutorServiceTest { this.traceableScheduledExecutorService.schedule(aCallable(), 1L, TimeUnit.DAYS); then(this.scheduledExecutorService).should().schedule( - BDDMockito.argThat( - matcher(Callable.class, instanceOf(TraceCallable.class))), - anyLong(), any(TimeUnit.class)); + BDDMockito.argThat(matcher(Callable.class, instanceOf(TraceCallable.class))), anyLong(), + any(TimeUnit.class)); } @Test public void should_schedule_at_fixed_rate_a_trace_runnable() throws Exception { - this.traceableScheduledExecutorService.scheduleAtFixedRate(aRunnable(), 1L, 1L, - TimeUnit.DAYS); + this.traceableScheduledExecutorService.scheduleAtFixedRate(aRunnable(), 1L, 1L, TimeUnit.DAYS); then(this.scheduledExecutorService).should().scheduleAtFixedRate( - BDDMockito.argThat( - matcher(Runnable.class, instanceOf(TraceRunnable.class))), - anyLong(), anyLong(), any(TimeUnit.class)); + BDDMockito.argThat(matcher(Runnable.class, instanceOf(TraceRunnable.class))), anyLong(), anyLong(), + any(TimeUnit.class)); } @Test public void should_schedule_with_fixed_delay_a_trace_runnable() throws Exception { - this.traceableScheduledExecutorService.scheduleWithFixedDelay(aRunnable(), 1L, 1L, - TimeUnit.DAYS); + this.traceableScheduledExecutorService.scheduleWithFixedDelay(aRunnable(), 1L, 1L, TimeUnit.DAYS); then(this.scheduledExecutorService).should().scheduleWithFixedDelay( - BDDMockito.argThat( - matcher(Runnable.class, instanceOf(TraceRunnable.class))), - anyLong(), anyLong(), any(TimeUnit.class)); + BDDMockito.argThat(matcher(Runnable.class, instanceOf(TraceRunnable.class))), anyLong(), anyLong(), + any(TimeUnit.class)); } @Test - public void should_not_schedule_a_trace_runnable_when_context_not_ready() - throws Exception { + public void should_not_schedule_a_trace_runnable_when_context_not_ready() throws Exception { SleuthContextListenerAccessor.set(this.beanFactory, false); this.traceableScheduledExecutorService.schedule(aRunnable(), 1L, TimeUnit.DAYS); then(this.scheduledExecutorService).should(never()).schedule( - BDDMockito.argThat( - matcher(Runnable.class, instanceOf(TraceRunnable.class))), - anyLong(), any(TimeUnit.class)); + BDDMockito.argThat(matcher(Runnable.class, instanceOf(TraceRunnable.class))), anyLong(), + any(TimeUnit.class)); } @Test - public void should_not_schedule_a_trace_callable_when_context_not_ready() - throws Exception { + public void should_not_schedule_a_trace_callable_when_context_not_ready() throws Exception { SleuthContextListenerAccessor.set(this.beanFactory, false); this.traceableScheduledExecutorService.schedule(aCallable(), 1L, TimeUnit.DAYS); then(this.scheduledExecutorService).should(never()).schedule( - BDDMockito.argThat( - matcher(Callable.class, instanceOf(TraceCallable.class))), - anyLong(), any(TimeUnit.class)); + BDDMockito.argThat(matcher(Callable.class, instanceOf(TraceCallable.class))), anyLong(), + any(TimeUnit.class)); } @Test - public void should_not_schedule_at_fixed_rate_a_trace_runnable_when_context_not_ready() - throws Exception { + public void should_not_schedule_at_fixed_rate_a_trace_runnable_when_context_not_ready() throws Exception { SleuthContextListenerAccessor.set(this.beanFactory, false); - this.traceableScheduledExecutorService.scheduleAtFixedRate(aRunnable(), 1L, 1L, - TimeUnit.DAYS); + this.traceableScheduledExecutorService.scheduleAtFixedRate(aRunnable(), 1L, 1L, TimeUnit.DAYS); then(this.scheduledExecutorService).should(never()).scheduleAtFixedRate( - BDDMockito.argThat( - matcher(Runnable.class, instanceOf(TraceRunnable.class))), - anyLong(), anyLong(), any(TimeUnit.class)); + BDDMockito.argThat(matcher(Runnable.class, instanceOf(TraceRunnable.class))), anyLong(), anyLong(), + any(TimeUnit.class)); } @Test - public void should_not_schedule_with_fixed_delay_a_trace_runnable_when_context_not_ready() - throws Exception { + public void should_not_schedule_with_fixed_delay_a_trace_runnable_when_context_not_ready() throws Exception { SleuthContextListenerAccessor.set(this.beanFactory, false); - this.traceableScheduledExecutorService.scheduleWithFixedDelay(aRunnable(), 1L, 1L, - TimeUnit.DAYS); + this.traceableScheduledExecutorService.scheduleWithFixedDelay(aRunnable(), 1L, 1L, TimeUnit.DAYS); then(this.scheduledExecutorService).should(never()).scheduleWithFixedDelay( - BDDMockito.argThat( - matcher(Runnable.class, instanceOf(TraceRunnable.class))), - anyLong(), anyLong(), any(TimeUnit.class)); + BDDMockito.argThat(matcher(Runnable.class, instanceOf(TraceRunnable.class))), anyLong(), anyLong(), + any(TimeUnit.class)); } Predicate instanceOf(Class clazz) { @@ -183,10 +166,8 @@ public class TraceableScheduledExecutorServiceTest { } BeanFactory beanFactory() { - BDDMockito.given(this.beanFactory.getBean(Tracing.class)) - .willReturn(this.tracing); - BDDMockito.given(this.beanFactory.getBean(SpanNamer.class)) - .willReturn(new DefaultSpanNamer()); + BDDMockito.given(this.beanFactory.getBean(Tracing.class)).willReturn(this.tracing); + BDDMockito.given(this.beanFactory.getBean(SpanNamer.class)).willReturn(new DefaultSpanNamer()); SleuthContextListenerAccessor.set(this.beanFactory, true); return this.beanFactory; } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/CircuitBreakerIntegrationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/CircuitBreakerIntegrationTests.java index b7cd2a409..cafb38c43 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/CircuitBreakerIntegrationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/CircuitBreakerIntegrationTests.java @@ -67,8 +67,7 @@ public class CircuitBreakerIntegrationTests { Span span = this.factory.create("name").run(tracer::currentSpan); then(span).isNotNull(); - then(scopedSpan.context().traceIdString()) - .isEqualTo(span.context().traceIdString()); + then(scopedSpan.context().traceIdString()).isEqualTo(span.context().traceIdString()); } finally { scopedSpan.finish(); @@ -94,12 +93,9 @@ public class CircuitBreakerIntegrationTests { })).isInstanceOf(IllegalStateException.class).hasMessageContaining("boom2"); then(this.spans).hasSize(2); - then(scopedSpan.context().traceIdString()) - .isEqualTo(first.get().context().traceIdString()); - then(scopedSpan.context().traceIdString()) - .isEqualTo(second.get().context().traceIdString()); - then(first.get().context().spanIdString()) - .isNotEqualTo(second.get().context().spanIdString()); + then(scopedSpan.context().traceIdString()).isEqualTo(first.get().context().traceIdString()); + then(scopedSpan.context().traceIdString()).isEqualTo(second.get().context().traceIdString()); + then(first.get().context().spanIdString()).isNotEqualTo(second.get().context().spanIdString()); MutableSpan reportedSpan = this.spans.get(0); then(reportedSpan.name()).contains("CircuitBreakerIntegrationTests"); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/CircuitBreakerTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/CircuitBreakerTests.java index 2cdc591db..56c39ad7a 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/CircuitBreakerTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/circuitbreaker/CircuitBreakerTests.java @@ -41,8 +41,8 @@ public class CircuitBreakerTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).sampler(Sampler.ALWAYS_SAMPLE).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .sampler(Sampler.ALWAYS_SAMPLE).build(); Tracer tracer = this.tracing.tracer(); @@ -69,8 +69,7 @@ public class CircuitBreakerTests { .run(new TraceSupplier<>(tracer, tracer::currentSpan)); then(span).isNotNull(); - then(scopedSpan.context().traceIdString()) - .isEqualTo(span.context().traceIdString()); + then(scopedSpan.context().traceIdString()).isEqualTo(span.context().traceIdString()); } finally { scopedSpan.finish(); @@ -87,23 +86,19 @@ public class CircuitBreakerTests { try { scopedSpan = tracer.startScopedSpan("start"); // when - BDDAssertions.thenThrownBy(() -> new Resilience4JCircuitBreakerFactory() - .create("name").run(new TraceSupplier<>(tracer, () -> { + BDDAssertions.thenThrownBy( + () -> new Resilience4JCircuitBreakerFactory().create("name").run(new TraceSupplier<>(tracer, () -> { first.set(tracer.currentSpan()); throw new IllegalStateException("boom"); }), new TraceFunction<>(tracer, throwable -> { second.set(tracer.currentSpan()); throw new IllegalStateException("boom2"); - }))).isInstanceOf(IllegalStateException.class) - .hasMessageContaining("boom2"); + }))).isInstanceOf(IllegalStateException.class).hasMessageContaining("boom2"); then(this.spans).hasSize(2); - then(scopedSpan.context().traceIdString()) - .isEqualTo(first.get().context().traceIdString()); - then(scopedSpan.context().traceIdString()) - .isEqualTo(second.get().context().traceIdString()); - then(first.get().context().spanIdString()) - .isNotEqualTo(second.get().context().spanIdString()); + then(scopedSpan.context().traceIdString()).isEqualTo(first.get().context().traceIdString()); + then(scopedSpan.context().traceIdString()).isEqualTo(second.get().context().traceIdString()); + then(first.get().context().spanIdString()).isNotEqualTo(second.get().context().spanIdString()); MutableSpan reportedSpan = this.spans.get(1); then(reportedSpan.name()).contains("CircuitBreakerTests"); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/KafkaFactoryBeanPostProcessorTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/KafkaFactoryBeanPostProcessorTests.java index 670ed02f0..43bed8da9 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/KafkaFactoryBeanPostProcessorTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/KafkaFactoryBeanPostProcessorTests.java @@ -83,8 +83,7 @@ class TestConsumerFactory implements ConsumerFactory { List postProcessors = new ArrayList<>(); @Override - public Consumer createConsumer(String groupId, String clientIdPrefix, - String clientIdSuffix) { + public Consumer createConsumer(String groupId, String clientIdPrefix, String clientIdSuffix) { return null; } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagationTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagationTest.java index 08cfc94a3..37345ed54 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagationTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagationTest.java @@ -26,8 +26,7 @@ import org.springframework.messaging.support.NativeMessageHeaderAccessor; import static org.assertj.core.api.Assertions.assertThat; -public class MessageHeaderPropagationTest - extends PropagationSetterTest { +public class MessageHeaderPropagationTest extends PropagationSetterTest { MessageHeaderAccessor carrier = new MessageHeaderAccessor(); @@ -49,8 +48,7 @@ public class MessageHeaderPropagationTest @Override protected Iterable read(MessageHeaderAccessor carrier, String key) { Object result = carrier.getHeader(key); - return result != null ? Collections.singleton(result.toString()) - : Collections.emptyList(); + return result != null ? Collections.singleton(result.toString()) : Collections.emptyList(); } @Test @@ -93,8 +91,7 @@ public class MessageHeaderPropagationTest MessageHeaderAccessor carrier = carrier(); carrier.setHeader(NativeMessageHeaderAccessor.NATIVE_HEADERS, "{spanTraceId=[123], spanId=[456], spanSampled=[0]}"); - MessageHeaderPropagation.removeAnyTraceHeaders(carrier, - Collections.singletonList("b3")); + MessageHeaderPropagation.removeAnyTraceHeaders(carrier, Collections.singletonList("b3")); } @Test diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagation_NativeTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagation_NativeTest.java index a24d22637..23145ffa5 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagation_NativeTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/MessageHeaderPropagation_NativeTest.java @@ -26,8 +26,7 @@ import org.springframework.messaging.support.NativeMessageHeaderAccessor; * * @author Marcin Grzejszczak */ -public class MessageHeaderPropagation_NativeTest - extends PropagationSetterTest { +public class MessageHeaderPropagation_NativeTest extends PropagationSetterTest { NativeMessageHeaderAccessor carrier = new NativeMessageHeaderAccessor() { }; diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfigurationIntegrationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfigurationIntegrationTests.java index 78d9365ee..be92a559b 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfigurationIntegrationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfigurationIntegrationTests.java @@ -46,36 +46,31 @@ import static org.mockito.Mockito.verify; class SleuthKafkaStreamsConfigurationIntegrationTests { private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() - .withConfiguration(AutoConfigurations.of(TraceAutoConfiguration.class, - SleuthKafkaStreamsConfiguration.class)) + .withConfiguration( + AutoConfigurations.of(TraceAutoConfiguration.class, SleuthKafkaStreamsConfiguration.class)) .withUserConfiguration(UserConfig.class); @Test void should_create_KafkaStreamsTracing() { - this.contextRunner.run( - context -> assertThat(context).hasSingleBean(KafkaStreamsTracing.class)); + this.contextRunner.run(context -> assertThat(context).hasSingleBean(KafkaStreamsTracing.class)); } @Test void should_not_create_KafkaStreamsTracing_when_KafkaStreams_not_present() { this.contextRunner.withClassLoader(new FilteredClassLoader(KafkaStreams.class)) - .run(context -> assertThat(context) - .doesNotHaveBean(KafkaStreamsTracing.class)); + .run(context -> assertThat(context).doesNotHaveBean(KafkaStreamsTracing.class)); } @Test void should_not_create_KafkaStreamsTracing_when_kafkastreams_disabled() { - this.contextRunner - .withPropertyValues("spring.sleuth.messaging.kafka.streams.enabled=false") - .run(context -> assertThat(context) - .doesNotHaveBean(KafkaStreamsTracing.class)); + this.contextRunner.withPropertyValues("spring.sleuth.messaging.kafka.streams.enabled=false") + .run(context -> assertThat(context).doesNotHaveBean(KafkaStreamsTracing.class)); } @Test void should_not_create_KafkaStreamsTracing_when_messaging_disabled() { this.contextRunner.withPropertyValues("spring.sleuth.messaging.enabled=false") - .run(context -> assertThat(context) - .doesNotHaveBean(KafkaStreamsTracing.class)); + .run(context -> assertThat(context).doesNotHaveBean(KafkaStreamsTracing.class)); } @Test @@ -93,8 +88,7 @@ class SleuthKafkaStreamsConfigurationIntegrationTests { @AfterEach void afterEach(CapturedOutput output) { - assertThat(output).doesNotContain( - "is not eligible for getting processed by all BeanPostProcessors"); + assertThat(output).doesNotContain("is not eligible for getting processed by all BeanPostProcessors"); } @Configuration diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfigurationIntegrationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfigurationIntegrationTests.java index ec6883893..d918f88a5 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfigurationIntegrationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfigurationIntegrationTests.java @@ -60,10 +60,8 @@ public class TraceMessagingAutoConfigurationIntegrationTests { // tag::custom_messaging_consumer_sampler[] @Bean(name = ConsumerSampler.NAME) SamplerFunction myMessagingSampler() { - return MessagingRuleSampler.newBuilder() - .putRule(channelNameEquals("alerts"), Sampler.NEVER_SAMPLE) - .putRule(Matchers.alwaysMatch(), RateLimitingSampler.create(100)) - .build(); + return MessagingRuleSampler.newBuilder().putRule(channelNameEquals("alerts"), Sampler.NEVER_SAMPLE) + .putRule(Matchers.alwaysMatch(), RateLimitingSampler.create(100)).build(); } // end::custom_messaging_consumer_sampler[] diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceSpringIntegrationAutoConfigurationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceSpringIntegrationAutoConfigurationTests.java index 84bca7c7c..80af66a89 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceSpringIntegrationAutoConfigurationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceSpringIntegrationAutoConfigurationTests.java @@ -32,34 +32,29 @@ class TraceSpringIntegrationAutoConfigurationTests { private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() .withConfiguration(AutoConfigurations.of(TraceAutoConfiguration.class, - TraceSpringMessagingAutoConfiguration.class, - TraceSpringIntegrationAutoConfiguration.class)); + TraceSpringMessagingAutoConfiguration.class, TraceSpringIntegrationAutoConfiguration.class)); @Test void should_not_create_tracing_channel_interceptor_when_function_on_the_classpath() { - this.contextRunner.run(context -> assertThat(context) - .doesNotHaveBean(TracingChannelInterceptor.class)); + this.contextRunner.run(context -> assertThat(context).doesNotHaveBean(TracingChannelInterceptor.class)); } @Test void should_create_tracing_channel_interceptor_when_function_not_on_the_classpath() { this.contextRunner.withClassLoader(new FilteredClassLoader(FunctionCatalog.class)) - .run(context -> assertThat(context) - .hasSingleBean(TracingChannelInterceptor.class)); + .run(context -> assertThat(context).hasSingleBean(TracingChannelInterceptor.class)); } @Test void should_create_tracing_channel_interceptor_when_function_on_the_classpath_but_enable_binding_is_set() { this.contextRunner.withUserConfiguration(WithEnabledBinding.class) - .run(context -> assertThat(context) - .hasSingleBean(TracingChannelInterceptor.class)); + .run(context -> assertThat(context).hasSingleBean(TracingChannelInterceptor.class)); } @Test void should_create_tracing_channel_interceptor_when_function_on_the_classpath_no_enable_binding_is_set_and_property_set() { this.contextRunner.withSystemProperties("spring.sleuth.integration.enabled=true") - .run(context -> assertThat(context) - .hasSingleBean(TracingChannelInterceptor.class)); + .run(context -> assertThat(context).hasSingleBean(TracingChannelInterceptor.class)); } @Configuration diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TracingChannelInterceptorTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TracingChannelInterceptorTest.java index c898b032b..db64342fa 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TracingChannelInterceptorTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TracingChannelInterceptorTest.java @@ -62,12 +62,10 @@ public class TracingChannelInterceptorTest { Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) // SINGLE_NO_PARENT more appropriate for messaging, but we check parent // hereTraceMessageHeaders - .propagationFactory( - B3Propagation.newFactoryBuilder().injectFormat(SINGLE).build()) + .propagationFactory(B3Propagation.newFactoryBuilder().injectFormat(SINGLE).build()) .addSpanHandler(this.spans).build(); - ChannelInterceptor interceptor = TracingChannelInterceptor.create(tracing, - new SleuthMessagingProperties()); + ChannelInterceptor interceptor = TracingChannelInterceptor.create(tracing, new SleuthMessagingProperties()); QueueChannel channel = new QueueChannel(); @@ -103,8 +101,7 @@ public class TracingChannelInterceptorTest { this.channel.send(MessageBuilder.withPayload("foo").build()); assertThat(this.channel.receive().getHeaders()).containsKey("b3"); - assertThat(this.spans).hasSize(1).extracting(MutableSpan::kind) - .containsExactly(Span.Kind.PRODUCER); + assertThat(this.spans).hasSize(1).extracting(MutableSpan::kind).containsExactly(Span.Kind.PRODUCER); } @Test @@ -115,8 +112,7 @@ public class TracingChannelInterceptorTest { assertThat(this.message).isNotNull(); assertThat(this.message.getHeaders()).containsKeys("b3", "nativeHeaders"); - assertThat(this.spans).extracting(MutableSpan::kind).contains(Span.Kind.CONSUMER, - Span.Kind.PRODUCER); + assertThat(this.spans).extracting(MutableSpan::kind).contains(Span.Kind.CONSUMER, Span.Kind.PRODUCER); } @Test @@ -125,8 +121,7 @@ public class TracingChannelInterceptorTest { this.channel.send(MessageBuilder.withPayload("foo").build()); - assertThat((Map) this.channel.receive().getHeaders().get(NATIVE_HEADERS)) - .containsOnlyKeys("b3"); + assertThat((Map) this.channel.receive().getHeaders().get(NATIVE_HEADERS)).containsOnlyKeys("b3"); } /** @@ -138,11 +133,11 @@ public class TracingChannelInterceptorTest { public void producerConsidersOldSpanIds() { this.channel.addInterceptor(producerSideOnly(this.interceptor)); - this.channel.send(MessageBuilder.withPayload("foo") - .setHeader("b3", "000000000000000a-000000000000000b-1").build()); + this.channel + .send(MessageBuilder.withPayload("foo").setHeader("b3", "000000000000000a-000000000000000b-1").build()); - TraceContext receiveContext = parseB3SingleFormat( - this.channel.receive().getHeaders().get("b3", String.class)).context(); + TraceContext receiveContext = parseB3SingleFormat(this.channel.receive().getHeaders().get("b3", String.class)) + .context(); assertThat(receiveContext.parentIdString()).isEqualTo("000000000000000b"); } @@ -153,15 +148,13 @@ public class TracingChannelInterceptorTest { NativeMessageHeaderAccessor accessor = new NativeMessageHeaderAccessor() { }; - accessor.setNativeHeader("b3", - "000000000000000a-000000000000000b-1-000000000000000a"); + accessor.setNativeHeader("b3", "000000000000000a-000000000000000b-1-000000000000000a"); - this.channel.send(MessageBuilder.withPayload("foo") - .copyHeaders(accessor.toMessageHeaders()).build()); + this.channel.send(MessageBuilder.withPayload("foo").copyHeaders(accessor.toMessageHeaders()).build()); TraceContext receiveContext = parseB3SingleFormat( - ((List) ((Map) this.channel.receive().getHeaders().get(NATIVE_HEADERS)) - .get("b3")).get(0).toString()).context(); + ((List) ((Map) this.channel.receive().getHeaders().get(NATIVE_HEADERS)).get("b3")).get(0).toString()) + .context(); assertThat(receiveContext.parentIdString()).isEqualTo("000000000000000b"); } @@ -175,10 +168,8 @@ public class TracingChannelInterceptorTest { this.channel.send(MessageBuilder.withPayload("foo").build()); - assertThat(this.channel.receive().getHeaders()).containsKeys("b3", - "nativeHeaders"); - assertThat(this.spans).hasSize(1).extracting(MutableSpan::kind) - .containsExactly(Span.Kind.CONSUMER); + assertThat(this.channel.receive().getHeaders()).containsKeys("b3", "nativeHeaders"); + assertThat(this.spans).hasSize(1).extracting(MutableSpan::kind).containsExactly(Span.Kind.CONSUMER); } @Test @@ -187,8 +178,7 @@ public class TracingChannelInterceptorTest { this.channel.send(MessageBuilder.withPayload("foo").build()); - assertThat((Map) this.channel.receive().getHeaders().get(NATIVE_HEADERS)) - .containsOnlyKeys("b3"); + assertThat((Map) this.channel.receive().getHeaders().get(NATIVE_HEADERS)).containsOnlyKeys("b3"); } @Test @@ -200,10 +190,8 @@ public class TracingChannelInterceptorTest { channel.send(MessageBuilder.withPayload("foo").build()); - assertThat(messages.get(0).getHeaders()).doesNotContainKeys("b3", - "nativeHeaders"); - assertThat(this.spans).extracting(MutableSpan::kind) - .containsExactly(Span.Kind.CONSUMER, null); + assertThat(messages.get(0).getHeaders()).doesNotContainKeys("b3", "nativeHeaders"); + assertThat(this.spans).extracting(MutableSpan::kind).containsExactly(Span.Kind.CONSUMER, null); } /** @@ -232,8 +220,7 @@ public class TracingChannelInterceptorTest { channel.send(MessageBuilder.withPayload("foo").build()); - assertThat((Map) messages.get(0).getHeaders().get(NATIVE_HEADERS)) - .doesNotContainKeys("b3"); + assertThat((Map) messages.get(0).getHeaders().get(NATIVE_HEADERS)).doesNotContainKeys("b3"); } @Test @@ -243,8 +230,8 @@ public class TracingChannelInterceptorTest { this.channel.send(MessageBuilder.withPayload("foo").build()); this.channel.receive(); - assertThat(this.spans).extracting(MutableSpan::kind) - .containsExactlyInAnyOrder(Span.Kind.CONSUMER, Span.Kind.PRODUCER); + assertThat(this.spans).extracting(MutableSpan::kind).containsExactlyInAnyOrder(Span.Kind.CONSUMER, + Span.Kind.PRODUCER); } @Test @@ -256,8 +243,8 @@ public class TracingChannelInterceptorTest { channel.send(MessageBuilder.withPayload("foo").build()); - assertThat(this.spans).extracting(MutableSpan::kind) - .containsExactly(Span.Kind.CONSUMER, null, Span.Kind.PRODUCER); + assertThat(this.spans).extracting(MutableSpan::kind).containsExactly(Span.Kind.CONSUMER, null, + Span.Kind.PRODUCER); } @Test @@ -269,10 +256,9 @@ public class TracingChannelInterceptorTest { errorChannelHeaders.put(MessageHeaders.REPLY_CHANNEL, errorsReplyChannel); errorChannelHeaders.put(MessageHeaders.ERROR_CHANNEL, errorsReplyChannel); this.channel.send(new ErrorMessage( - new MessagingException(MessageBuilder.withPayload("hi") - .setHeader("b3", "000000000000000a-000000000000000a") - .setReplyChannel(deadReplyChannel) - .setErrorChannel(deadReplyChannel).build()), + new MessagingException( + MessageBuilder.withPayload("hi").setHeader("b3", "000000000000000a-000000000000000a") + .setReplyChannel(deadReplyChannel).setErrorChannel(deadReplyChannel).build()), errorChannelHeaders)); this.message = this.channel.receive(); @@ -280,38 +266,30 @@ public class TracingChannelInterceptorTest { assertThat(this.message).isNotNull(); // Parse fails if trace or span ID are missing - TraceContext context = parseB3SingleFormat( - this.message.getHeaders().get("b3", String.class)).context(); + TraceContext context = parseB3SingleFormat(this.message.getHeaders().get("b3", String.class)).context(); assertThat(context.traceIdString()).isEqualTo("000000000000000a"); assertThat(context.spanIdString()).isNotEqualTo("000000000000000a"); assertThat(this.spans).hasSize(2); - assertThat(this.message.getHeaders().getReplyChannel()) - .isSameAs(errorsReplyChannel); - assertThat(this.message.getHeaders().getErrorChannel()) - .isSameAs(errorsReplyChannel); + assertThat(this.message.getHeaders().getReplyChannel()).isSameAs(errorsReplyChannel); + assertThat(this.message.getHeaders().getErrorChannel()).isSameAs(errorsReplyChannel); } @Test public void errorMessageOriginalMessageRetained() { this.channel.addInterceptor(this.interceptor); - Message originalMessage = MessageBuilder.withPayload("Hello") - .setHeader("header", "value").build(); - Message failedMessage = MessageBuilder.fromMessage(originalMessage) - .removeHeader("header").build(); - this.channel.send(new ErrorMessage(new MessagingException(failedMessage), - originalMessage.getHeaders(), originalMessage)); + Message originalMessage = MessageBuilder.withPayload("Hello").setHeader("header", "value").build(); + Message failedMessage = MessageBuilder.fromMessage(originalMessage).removeHeader("header").build(); + this.channel.send( + new ErrorMessage(new MessagingException(failedMessage), originalMessage.getHeaders(), originalMessage)); this.message = this.channel.receive(); assertThat(this.message).isNotNull(); - assertThat(this.message).isInstanceOfSatisfying(ErrorMessage.class, - errorMessage -> { - assertThat(errorMessage.getOriginalMessage()) - .isSameAs(originalMessage); - assertThat(errorMessage.getHeaders().get("header")) - .isEqualTo("value"); - }); + assertThat(this.message).isInstanceOfSatisfying(ErrorMessage.class, errorMessage -> { + assertThat(errorMessage.getOriginalMessage()).isSameAs(originalMessage); + assertThat(errorMessage.getHeaders().get("header")).isEqualTo("value"); + }); } @Test @@ -319,13 +297,11 @@ public class TracingChannelInterceptorTest { this.channel.addInterceptor(this.interceptor); Map errorChannelHeaders = new HashMap<>(); errorChannelHeaders.put("b3", "000000000000000a-000000000000000a"); - this.channel.send(new ErrorMessage(new MessagingException("exception"), - errorChannelHeaders)); + this.channel.send(new ErrorMessage(new MessagingException("exception"), errorChannelHeaders)); this.message = this.channel.receive(); - TraceContext receiveContext = parseB3SingleFormat( - this.message.getHeaders().get("b3", String.class)).context(); + TraceContext receiveContext = parseB3SingleFormat(this.message.getHeaders().get("b3", String.class)).context(); assertThat(receiveContext.traceIdString()).isEqualTo("000000000000000a"); assertThat(receiveContext.spanIdString()).isNotEqualTo("000000000000000a"); assertThat(this.spans).hasSize(2); @@ -342,8 +318,7 @@ public class TracingChannelInterceptorTest { headers.put(KafkaHeaders.MESSAGE_KEY, "hello"); channel.send(MessageBuilder.createMessage("foo", new MessageHeaders(headers))); - assertThat(this.spans).extracting(MutableSpan::remoteServiceName) - .contains("kafka"); + assertThat(this.spans).extracting(MutableSpan::remoteServiceName).contains("kafka"); } @Test @@ -357,8 +332,7 @@ public class TracingChannelInterceptorTest { headers.put(AmqpHeaders.RECEIVED_ROUTING_KEY, "hello"); channel.send(MessageBuilder.createMessage("foo", new MessageHeaders(headers))); - assertThat(this.spans).extracting(MutableSpan::remoteServiceName) - .contains("rabbitmq"); + assertThat(this.spans).extracting(MutableSpan::remoteServiceName).contains("rabbitmq"); } @Test @@ -371,8 +345,7 @@ public class TracingChannelInterceptorTest { Map headers = new HashMap<>(); channel.send(MessageBuilder.createMessage("foo", new MessageHeaders(headers))); - assertThat(this.spans).extracting(MutableSpan::remoteServiceName) - .containsOnly("broker", null); + assertThat(this.spans).extracting(MutableSpan::remoteServiceName).containsOnly("broker", null); } ChannelInterceptor producerSideOnly(ChannelInterceptor delegate) { @@ -383,8 +356,7 @@ public class TracingChannelInterceptorTest { } @Override - public void afterSendCompletion(Message message, MessageChannel channel, - boolean sent, Exception ex) { + public void afterSendCompletion(Message message, MessageChannel channel, boolean sent, Exception ex) { delegate.afterSendCompletion(message, channel, sent, ex); } }; @@ -398,29 +370,24 @@ public class TracingChannelInterceptorTest { } @Override - public void afterReceiveCompletion(Message message, MessageChannel channel, - Exception ex) { + public void afterReceiveCompletion(Message message, MessageChannel channel, Exception ex) { delegate.afterReceiveCompletion(message, channel, ex); } }; } ExecutorChannelInterceptor executorSideOnly(ChannelInterceptor delegate) { - class ExecutorSideOnly extends ChannelInterceptorAdapter - implements ExecutorChannelInterceptor { + class ExecutorSideOnly extends ChannelInterceptorAdapter implements ExecutorChannelInterceptor { @Override - public Message beforeHandle(Message message, MessageChannel channel, - MessageHandler handler) { - return ((ExecutorChannelInterceptor) delegate).beforeHandle(message, - channel, handler); + public Message beforeHandle(Message message, MessageChannel channel, MessageHandler handler) { + return ((ExecutorChannelInterceptor) delegate).beforeHandle(message, channel, handler); } @Override - public void afterMessageHandled(Message message, MessageChannel channel, - MessageHandler handler, Exception ex) { - ((ExecutorChannelInterceptor) delegate).afterMessageHandled(message, - channel, handler, ex); + public void afterMessageHandled(Message message, MessageChannel channel, MessageHandler handler, + Exception ex) { + ((ExecutorChannelInterceptor) delegate).afterMessageHandled(message, channel, handler, ex); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/mongodb/TraceMongoDbAutoConfigurationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/mongodb/TraceMongoDbAutoConfigurationTests.java index a812ebfd7..fa992af87 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/mongodb/TraceMongoDbAutoConfigurationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/mongodb/TraceMongoDbAutoConfigurationTests.java @@ -39,8 +39,7 @@ import static org.assertj.core.api.BDDAssertions.then; class TraceMongoDbAutoConfigurationTests { @Test - void should_record_a_span_when_working_with_mongodb_commands( - @Autowired TestSpanHandler handler) { + void should_record_a_span_when_working_with_mongodb_commands(@Autowired TestSpanHandler handler) { then(handler.spans()).isNotEmpty(); MutableSpan span = handler.get(0); then(span.traceId()).isNotEmpty(); @@ -58,8 +57,7 @@ class TraceMongoDbAutoConfigurationTests { } @Bean - TraceMongoClientSettingsBuilderCustomizer testMongoClientSettingsBuilderCustomizer( - Tracing tracing) { + TraceMongoClientSettingsBuilderCustomizer testMongoClientSettingsBuilderCustomizer(Tracing tracing) { return new TestMongoClientSettingsBuilderCustomizer(tracing); } @@ -67,8 +65,7 @@ class TraceMongoDbAutoConfigurationTests { } -class TestMongoClientSettingsBuilderCustomizer - extends TraceMongoClientSettingsBuilderCustomizer { +class TestMongoClientSettingsBuilderCustomizer extends TraceMongoClientSettingsBuilderCustomizer { TestMongoClientSettingsBuilderCustomizer(Tracing tracing) { super(tracing); @@ -77,12 +74,9 @@ class TestMongoClientSettingsBuilderCustomizer @Override public void customize(MongoClientSettings.Builder clientSettingsBuilder) { super.customize(clientSettingsBuilder); - CommandListener listener = clientSettingsBuilder.build().getCommandListeners() - .get(0); - listener.commandStarted(new CommandStartedEvent(0, null, "", "", - BDDMockito.mock(BsonDocument.class))); - listener.commandSucceeded(new CommandSucceededEvent(1, null, "", - BDDMockito.mock(BsonDocument.class), 100)); + CommandListener listener = clientSettingsBuilder.build().getCommandListeners().get(0); + listener.commandStarted(new CommandStartedEvent(0, null, "", "", BDDMockito.mock(BsonDocument.class))); + listener.commandSucceeded(new CommandSucceededEvent(1, null, "", BDDMockito.mock(BsonDocument.class), 100)); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/multiple/DemoApplication.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/multiple/DemoApplication.java index aed23e417..a0a72a7d0 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/multiple/DemoApplication.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/multiple/DemoApplication.java @@ -118,8 +118,7 @@ public class DemoApplication { } public List allSpans() { - return Arrays.asList(this.httpSpan, this.splitterSpan, this.aggregatorSpan, - this.serviceActivatorSpan); + return Arrays.asList(this.httpSpan, this.splitterSpan, this.aggregatorSpan, this.serviceActivatorSpan); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/multiple/MultipleHopsIntegrationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/multiple/MultipleHopsIntegrationTests.java index a50bdde40..da6a20aa7 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/multiple/MultipleHopsIntegrationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/multiple/MultipleHopsIntegrationTests.java @@ -56,12 +56,9 @@ import static org.assertj.core.api.BDDAssertions.then; import static org.awaitility.Awaitility.await; import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT; -@SpringBootTest(classes = MultipleHopsIntegrationTests.Config.class, - webEnvironment = RANDOM_PORT, - properties = { - "spring.sleuth.baggage.remote-fields=x-vcap-request-id,country-code", - "spring.sleuth.baggage.local-fields=bp", - "spring.sleuth.integration.enabled=true" }) +@SpringBootTest(classes = MultipleHopsIntegrationTests.Config.class, webEnvironment = RANDOM_PORT, + properties = { "spring.sleuth.baggage.remote-fields=x-vcap-request-id,country-code", + "spring.sleuth.baggage.local-fields=bp", "spring.sleuth.integration.enabled=true" }) public class MultipleHopsIntegrationTests { static final BaggageField REQUEST_ID = BaggageField.create("x-vcap-request-id"); @@ -90,21 +87,17 @@ public class MultipleHopsIntegrationTests { @Test public void should_prepare_spans_for_export() { - this.restTemplate.getForObject( - "http://localhost:" + this.config.port + "/greeting", String.class); + this.restTemplate.getForObject("http://localhost:" + this.config.port + "/greeting", String.class); await().atMost(5, SECONDS).untilAsserted(() -> { then(this.spans).hasSize(14); }); - then(this.spans).extracting(MutableSpan::name) - .containsAll(asList("GET /greeting", "send")); + then(this.spans).extracting(MutableSpan::name).containsAll(asList("GET /greeting", "send")); then(this.spans).extracting(MutableSpan::kind) // no server kind due to test constraints - .containsAll( - asList(Span.Kind.CONSUMER, Span.Kind.PRODUCER, Span.Kind.SERVER)); - then(this.spans.spans().stream().map(span -> span.tags().get("channel")) - .filter(Objects::nonNull).distinct().collect(toList())).hasSize(3) - .containsAll(asList("words", "counts", "greetings")); + .containsAll(asList(Span.Kind.CONSUMER, Span.Kind.PRODUCER, Span.Kind.SERVER)); + then(this.spans.spans().stream().map(span -> span.tags().get("channel")).filter(Objects::nonNull).distinct() + .collect(toList())).hasSize(3).containsAll(asList("words", "counts", "greetings")); } @Test @@ -122,8 +115,7 @@ public class MultipleHopsIntegrationTests { // set request ID in a header not with the api explicitly HttpHeaders headers = new HttpHeaders(); - headers.put(REQUEST_ID.name(), - Collections.singletonList("f4308d05-2228-4468-80f6-92a8377ba193")); + headers.put(REQUEST_ID.name(), Collections.singletonList("f4308d05-2228-4468-80f6-92a8377ba193")); RequestEntity requestEntity = new RequestEntity(headers, HttpMethod.GET, URI.create("http://localhost:" + this.config.port + "/greeting")); this.restTemplate.exchange(requestEntity, String.class); @@ -137,18 +129,15 @@ public class MultipleHopsIntegrationTests { }); List withBagTags = this.spans.spans().stream() - .filter(s -> s.tags().containsKey(BUSINESS_PROCESS.name())) - .collect(toList()); + .filter(s -> s.tags().containsKey(BUSINESS_PROCESS.name())).collect(toList()); // set with tag api then(withBagTags).as("only initialSpan was bag tagged").hasSize(1); - assertThat(withBagTags.get(0).tags()).containsEntry(BUSINESS_PROCESS.name(), - "ALM"); + assertThat(withBagTags.get(0).tags()).containsEntry(BUSINESS_PROCESS.name(), "ALM"); // set with baggage api then(this.application.allSpans()).as("All have request ID") - .allMatch(span -> "f4308d05-2228-4468-80f6-92a8377ba193" - .equals(REQUEST_ID.getValue(span.context()))); + .allMatch(span -> "f4308d05-2228-4468-80f6-92a8377ba193".equals(REQUEST_ID.getValue(span.context()))); // baz is not tagged in the initial span, only downstream! then(this.application.allSpans()).as("All downstream have country-code") @@ -158,8 +147,7 @@ public class MultipleHopsIntegrationTests { @Configuration @SpringBootApplication(exclude = JmxAutoConfiguration.class) - public static class Config - implements ApplicationListener { + public static class Config implements ApplicationListener { int port; diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/opentracing/OpenTracingTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/opentracing/OpenTracingTest.java index f1e4be26a..98b25a1d5 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/opentracing/OpenTracingTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/opentracing/OpenTracingTest.java @@ -55,8 +55,7 @@ import static org.springframework.boot.test.context.SpringBootTest.WebEnvironmen * * @author Marcin Grzejszczak */ -@SpringBootTest(webEnvironment = NONE, - properties = "spring.sleuth.baggage.remote-fields=country-code") +@SpringBootTest(webEnvironment = NONE, properties = "spring.sleuth.baggage.remote-fields=country-code") public class OpenTracingTest { @Autowired @@ -70,8 +69,8 @@ public class OpenTracingTest { @Test public void startWithOpenTracingAndFinishWithBrave() { - BraveSpan openTracingSpan = this.opentracing.buildSpan("encode") - .withTag("lc", "codec").withStartTimestamp(1L).start(); + BraveSpan openTracingSpan = this.opentracing.buildSpan("encode").withTag("lc", "codec").withStartTimestamp(1L) + .start(); Span braveSpan = openTracingSpan.unwrap(); @@ -83,14 +82,13 @@ public class OpenTracingTest { @Test public void extractTraceContext() { - Map map = singletonMap("b3", - "0000000000000001-0000000000000002-1"); + Map map = singletonMap("b3", "0000000000000001-0000000000000002-1"); - BraveSpanContext openTracingContext = this.opentracing - .extract(Format.Builtin.HTTP_HEADERS, new TextMapAdapter(map)); + BraveSpanContext openTracingContext = this.opentracing.extract(Format.Builtin.HTTP_HEADERS, + new TextMapAdapter(map)); - assertThat(openTracingContext.unwrap()).isEqualTo( - TraceContext.newBuilder().traceId(1L).spanId(2L).sampled(true).build()); + assertThat(openTracingContext.unwrap()) + .isEqualTo(TraceContext.newBuilder().traceId(1L).spanId(2L).sampled(true).build()); } @Test @@ -99,23 +97,21 @@ public class OpenTracingTest { map.put("b3", "0000000000000001-0000000000000002-1"); map.put("country-code", "FO"); - BraveSpanContext openTracingContext = this.opentracing - .extract(Format.Builtin.HTTP_HEADERS, new TextMapAdapter(map)); + BraveSpanContext openTracingContext = this.opentracing.extract(Format.Builtin.HTTP_HEADERS, + new TextMapAdapter(map)); - assertThat(openTracingContext.baggageItems()) - .containsExactly(entry("country-code", "FO")); + assertThat(openTracingContext.baggageItems()).containsExactly(entry("country-code", "FO")); } @Test public void extractTraceContextTextMap() { - Map map = singletonMap("b3", - "0000000000000001-0000000000000002-1"); + Map map = singletonMap("b3", "0000000000000001-0000000000000002-1"); - BraveSpanContext openTracingContext = this.opentracing - .extract(Format.Builtin.TEXT_MAP, new TextMapAdapter(map)); + BraveSpanContext openTracingContext = this.opentracing.extract(Format.Builtin.TEXT_MAP, + new TextMapAdapter(map)); - assertThat(openTracingContext.unwrap()).isEqualTo( - TraceContext.newBuilder().traceId(1L).spanId(2L).sampled(true).build()); + assertThat(openTracingContext.unwrap()) + .isEqualTo(TraceContext.newBuilder().traceId(1L).spanId(2L).sampled(true).build()); } @Test @@ -124,11 +120,11 @@ public class OpenTracingTest { map.put("B3", "0000000000000001-0000000000000002-1"); map.put("other", "1"); - BraveSpanContext openTracingContext = this.opentracing - .extract(Format.Builtin.HTTP_HEADERS, new TextMapAdapter(map)); + BraveSpanContext openTracingContext = this.opentracing.extract(Format.Builtin.HTTP_HEADERS, + new TextMapAdapter(map)); - assertThat(openTracingContext.unwrap()).isEqualTo( - TraceContext.newBuilder().traceId(1L).spanId(2L).sampled(true).build()); + assertThat(openTracingContext.unwrap()) + .isEqualTo(TraceContext.newBuilder().traceId(1L).spanId(2L).sampled(true).build()); } @Test @@ -160,13 +156,11 @@ public class OpenTracingTest { try (Scope scopeA = this.opentracing.scopeManager().activate(spanA)) { try (Scope scopeB = this.opentracing.scopeManager().activate(spanB)) { - assertThat( - this.opentracing.scopeManager().activeSpan().context().unwrap()) - .isEqualTo(spanB.context().unwrap()); + assertThat(this.opentracing.scopeManager().activeSpan().context().unwrap()) + .isEqualTo(spanB.context().unwrap()); } - assertThat(opentracing.scopeManager().activeSpan().context().unwrap()) - .isEqualTo(spanA.context().unwrap()); + assertThat(opentracing.scopeManager().activeSpan().context().unwrap()).isEqualTo(spanA.context().unwrap()); } } @@ -186,8 +180,7 @@ public class OpenTracingTest { Long idOfSpanA = spanA.context().spanId(); try (SpanInScope scopeA = this.brave.tracer().withSpanInScope(spanA)) { - Span spanB = this.brave.tracer().newChild(spanA.context()).name("spanB") - .start(); + Span spanB = this.brave.tracer().newChild(spanA.context()).name("spanB").start(); idOfSpanB = spanB.context().spanId(); parentIdOfSpanB = spanB.context().parentId(); try (SpanInScope scopeB = this.brave.tracer().withSpanInScope(spanB)) { @@ -199,8 +192,7 @@ public class OpenTracingTest { shouldBeIdOfSpanA = this.brave.currentTraceContext().get().spanId(); - Span spanC = this.brave.tracer().newChild(spanA.context()).name("spanC") - .start(); + Span spanC = this.brave.tracer().newChild(spanA.context()).name("spanC").start(); parentIdOfSpanC = spanC.context().parentId(); try (SpanInScope scopeC = this.brave.tracer().withSpanInScope(spanC)) { // nothing to do here @@ -213,16 +205,10 @@ public class OpenTracingTest { spanA.finish(); } - assertThat(shouldBeIdOfSpanA) - .as("SpanA should have been active again after closing B") - .isEqualTo(idOfSpanA); - assertThat(shouldBeIdOfSpanB) - .as("SpanB should have been active prior to its closure") - .isEqualTo(idOfSpanB); - assertThat(parentIdOfSpanB).as("SpanB's parent should be SpanA") - .isEqualTo(idOfSpanA); - assertThat(parentIdOfSpanC).as("SpanC's parent should be SpanA") - .isEqualTo(idOfSpanA); + assertThat(shouldBeIdOfSpanA).as("SpanA should have been active again after closing B").isEqualTo(idOfSpanA); + assertThat(shouldBeIdOfSpanB).as("SpanB should have been active prior to its closure").isEqualTo(idOfSpanB); + assertThat(parentIdOfSpanB).as("SpanB's parent should be SpanA").isEqualTo(idOfSpanA); + assertThat(parentIdOfSpanC).as("SpanC's parent should be SpanA").isEqualTo(idOfSpanA); } @Test @@ -231,8 +217,7 @@ public class OpenTracingTest { try (Scope scopeA = this.opentracing.activateSpan(spanA)) { BraveSpan spanB = this.opentracing.buildSpan("spanB").start(); // OpenTracing doesn't expose parent ID, so we will check trace ID instead - assertThat(spanB.context().toTraceId()) - .isEqualTo(spanA.context().toTraceId()); + assertThat(spanB.context().toTraceId()).isEqualTo(spanA.context().toTraceId()); } } @@ -240,8 +225,7 @@ public class OpenTracingTest { public void implicitParentFromSpanManager_start_ignoreActiveSpan() { BraveSpan spanA = this.opentracing.buildSpan("spanA").start(); try (Scope scopeA = this.opentracing.activateSpan(spanA)) { - BraveSpan spanB = this.opentracing.buildSpan("spanB").ignoreActiveSpan() - .start(); + BraveSpan spanB = this.opentracing.buildSpan("spanB").ignoreActiveSpan().start(); assertThat(spanB.unwrap().context().parentId()).isNull(); // new trace } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/quartz/TraceQuartzAutoConfigurationTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/quartz/TraceQuartzAutoConfigurationTest.java index 7a10cfe3c..815a8e23d 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/quartz/TraceQuartzAutoConfigurationTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/quartz/TraceQuartzAutoConfigurationTest.java @@ -38,9 +38,8 @@ import static org.mockito.Mockito.when; */ public class TraceQuartzAutoConfigurationTest { - private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() - .withConfiguration(AutoConfigurations.of(SchedulerConfig.class, - TracingConfig.class, TraceQuartzAutoConfiguration.class)); + private final ApplicationContextRunner contextRunner = new ApplicationContextRunner().withConfiguration( + AutoConfigurations.of(SchedulerConfig.class, TracingConfig.class, TraceQuartzAutoConfiguration.class)); @Test public void should_create_job_listener_bean_when_all_conditions_are_met() { diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/quartz/TracingJobListenerTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/quartz/TracingJobListenerTest.java index 8129ae5fc..3b8d9f06e 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/quartz/TracingJobListenerTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/quartz/TracingJobListenerTest.java @@ -74,11 +74,10 @@ public class TracingJobListenerTest { private CompletableFuture completableJob; - private StrictCurrentTraceContext currentTraceContext = StrictCurrentTraceContext - .create(); + private StrictCurrentTraceContext currentTraceContext = StrictCurrentTraceContext.create(); - private Tracing tracing = Tracing.newBuilder().addSpanHandler(spanHandler) - .currentTraceContext(currentTraceContext).build(); + private Tracing tracing = Tracing.newBuilder().addSpanHandler(spanHandler).currentTraceContext(currentTraceContext) + .build(); @BeforeEach public void setUp() throws Exception { @@ -86,17 +85,13 @@ public class TracingJobListenerTest { completableJob = new CompleteableTriggerListener(); scheduler = createScheduler(getClass().getSimpleName(), 1); - scheduler.addJob(newJob(ExceptionalJob.class).withIdentity(EXCEPTIONAL_JOB_KEY) - .storeDurably().build(), true); - scheduler.addJob(newJob(SuccessfulJob.class).withIdentity(SUCCESSFUL_JOB_KEY) - .storeDurably().build(), true); + scheduler.addJob(newJob(ExceptionalJob.class).withIdentity(EXCEPTIONAL_JOB_KEY).storeDurably().build(), true); + scheduler.addJob(newJob(SuccessfulJob.class).withIdentity(SUCCESSFUL_JOB_KEY).storeDurably().build(), true); scheduler.getListenerManager().addTriggerListener(listener); scheduler.getListenerManager().addJobListener(listener); - scheduler.getListenerManager() - .addTriggerListener((CompleteableTriggerListener) completableJob); - scheduler.getListenerManager() - .addJobListener((CompleteableTriggerListener) completableJob); + scheduler.getListenerManager().addTriggerListener((CompleteableTriggerListener) completableJob); + scheduler.getListenerManager().addJobListener((CompleteableTriggerListener) completableJob); scheduler.start(); } @@ -129,11 +124,9 @@ public class TracingJobListenerTest { } @Test - public void should_have_span_with_proper_name_and_tag_when_job_is_successful() - throws Exception { + public void should_have_span_with_proper_name_and_tag_when_job_is_successful() throws Exception { // given - Trigger trigger = newTrigger().withIdentity(TRIGGER_KEY) - .forJob(SUCCESSFUL_JOB_KEY).startNow().build(); + Trigger trigger = newTrigger().withIdentity(TRIGGER_KEY).forJob(SUCCESSFUL_JOB_KEY).startNow().build(); // when runJob(trigger); @@ -141,8 +134,7 @@ public class TracingJobListenerTest { // expect MutableSpan span = spanHandler.takeLocalSpan(); assertThat(span.name()).isEqualToIgnoringCase(SUCCESSFUL_JOB_KEY.toString()); - assertThat(span.tags().get(TRIGGER_TAG_KEY)) - .isEqualToIgnoringCase(TRIGGER_KEY.toString()); + assertThat(span.tags().get(TRIGGER_TAG_KEY)).isEqualToIgnoringCase(TRIGGER_KEY.toString()); } @Test @@ -171,8 +163,7 @@ public class TracingJobListenerTest { } @Test - public void should_not_complete_span_when_context_is_modified_to_remove_keys() - throws Exception { + public void should_not_complete_span_when_context_is_modified_to_remove_keys() throws Exception { // given scheduler.getListenerManager().addJobListener(new ContextModifyingJobListener()); Trigger trigger = newTrigger().forJob(EXCEPTIONAL_JOB_KEY).startNow().build(); @@ -184,13 +175,11 @@ public class TracingJobListenerTest { } @Test - public void should_have_parent_and_child_span_when_trigger_contains_span_info() - throws Exception { + public void should_have_parent_and_child_span_when_trigger_contains_span_info() throws Exception { // given JobDataMap data = new JobDataMap(); addSpanToJobData(data); - Trigger trigger = newTrigger().forJob(SUCCESSFUL_JOB_KEY).usingJobData(data) - .startNow().build(); + Trigger trigger = newTrigger().forJob(SUCCESSFUL_JOB_KEY).usingJobData(data).startNow().build(); // when runJob(trigger); @@ -208,8 +197,7 @@ public class TracingJobListenerTest { // given JobDataMap data = new JobDataMap(new HashMap()); addSpanToJobData(data); - Trigger trigger = newTrigger().forJob(SUCCESSFUL_JOB_KEY).usingJobData(data) - .startNow().build(); + Trigger trigger = newTrigger().forJob(SUCCESSFUL_JOB_KEY).usingJobData(data).startNow().build(); // when runJob(trigger); @@ -230,18 +218,15 @@ public class TracingJobListenerTest { Properties config = new Properties(); config.setProperty("org.quartz.scheduler.instanceName", name + "Scheduler"); config.setProperty("org.quartz.scheduler.instanceId", "AUTO"); - config.setProperty("org.quartz.threadPool.threadCount", - Integer.toString(threadPoolSize)); - config.setProperty("org.quartz.threadPool.class", - "org.quartz.simpl.SimpleThreadPool"); + config.setProperty("org.quartz.threadPool.threadCount", Integer.toString(threadPoolSize)); + config.setProperty("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool"); return new StdSchedulerFactory(config).getScheduler(); } void addSpanToJobData(JobDataMap data) { brave.Span span = tracing.tracer().nextSpan().start(); try (SpanInScope spanInScope = tracing.tracer().withSpanInScope(span)) { - tracing.propagation() - .injector((Setter) StringKeyDirtyFlagMap::put) + tracing.propagation().injector((Setter) StringKeyDirtyFlagMap::put) .inject(tracing.currentTraceContext().get(), data); } finally { @@ -249,8 +234,7 @@ public class TracingJobListenerTest { } } - public static class CompleteableTriggerListener extends CompletableFuture - implements TriggerListener, JobListener { + public static class CompleteableTriggerListener extends CompletableFuture implements TriggerListener, JobListener { @Override public String getName() { @@ -286,8 +270,7 @@ public class TracingJobListenerTest { } @Override - public void jobWasExecuted(JobExecutionContext context, - JobExecutionException jobException) { + public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) { } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfigurationAccessorConfiguration.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfigurationAccessorConfiguration.java index 5623beec9..eb34632c3 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfigurationAccessorConfiguration.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfigurationAccessorConfiguration.java @@ -35,8 +35,7 @@ public final class TraceReactorAutoConfigurationAccessorConfiguration { throw new IllegalStateException("Can't instantiate a utility class"); } - private static final Log log = LogFactory - .getLog(TraceReactorAutoConfigurationAccessorConfiguration.class); + private static final Log log = LogFactory.getLog(TraceReactorAutoConfigurationAccessorConfiguration.class); public static void close() { if (log.isTraceEnabled()) { diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationIntegrationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationIntegrationTests.java index 3da1f87b7..9dd9fba79 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationIntegrationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationIntegrationTests.java @@ -62,10 +62,8 @@ public class TraceRpcAutoConfigurationIntegrationTests { // tag::custom_rpc_server_sampler[] @Bean(name = RpcServerSampler.NAME) SamplerFunction myRpcSampler() { - Matcher userAuth = and(serviceEquals("users.UserService"), - methodEquals("GetUserToken")); - return RpcRuleSampler.newBuilder() - .putRule(serviceEquals("grpc.health.v1.Health"), Sampler.NEVER_SAMPLE) + Matcher userAuth = and(serviceEquals("users.UserService"), methodEquals("GetUserToken")); + return RpcRuleSampler.newBuilder().putRule(serviceEquals("grpc.health.v1.Health"), Sampler.NEVER_SAMPLE) .putRule(userAuth, RateLimitingSampler.create(100)).build(); } // end::custom_rpc_server_sampler[] diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationTests.java index fe35b0c89..3d07fe66d 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationTests.java @@ -35,8 +35,7 @@ public class TraceRpcAutoConfigurationTests { @Test public void defaultsToBraveRpcClientSampler() { contextRunner().run((context) -> { - SamplerFunction clientSampler = context.getBean(RpcTracing.class) - .clientSampler(); + SamplerFunction clientSampler = context.getBean(RpcTracing.class).clientSampler(); then(clientSampler).isSameAs(SamplerFunctions.deferDecision()); }); @@ -44,20 +43,17 @@ public class TraceRpcAutoConfigurationTests { @Test public void configuresUserProvidedRpcClientSampler() { - contextRunner().withUserConfiguration(RpcClientSamplerConfig.class) - .run((context) -> { - SamplerFunction clientSampler = context - .getBean(RpcTracing.class).clientSampler(); + contextRunner().withUserConfiguration(RpcClientSamplerConfig.class).run((context) -> { + SamplerFunction clientSampler = context.getBean(RpcTracing.class).clientSampler(); - then(clientSampler).isSameAs(RpcClientSamplerConfig.INSTANCE); - }); + then(clientSampler).isSameAs(RpcClientSamplerConfig.INSTANCE); + }); } @Test public void defaultsToBraveRpcServerSampler() { contextRunner().run((context) -> { - SamplerFunction serverSampler = context.getBean(RpcTracing.class) - .serverSampler(); + SamplerFunction serverSampler = context.getBean(RpcTracing.class).serverSampler(); then(serverSampler).isSameAs(SamplerFunctions.deferDecision()); }); @@ -65,19 +61,16 @@ public class TraceRpcAutoConfigurationTests { @Test public void configuresUserProvidedRpcServerSampler() { - contextRunner().withUserConfiguration(RpcServerSamplerConfig.class) - .run((context) -> { - SamplerFunction serverSampler = context - .getBean(RpcTracing.class).serverSampler(); + contextRunner().withUserConfiguration(RpcServerSamplerConfig.class).run((context) -> { + SamplerFunction serverSampler = context.getBean(RpcTracing.class).serverSampler(); - then(serverSampler).isSameAs(RpcServerSamplerConfig.INSTANCE); - }); + then(serverSampler).isSameAs(RpcServerSamplerConfig.INSTANCE); + }); } private ApplicationContextRunner contextRunner(String... propertyValues) { - return new ApplicationContextRunner().withPropertyValues(propertyValues) - .withConfiguration(AutoConfigurations.of(TraceAutoConfiguration.class, - TraceRpcAutoConfiguration.class)); + return new ApplicationContextRunner().withPropertyValues(propertyValues).withConfiguration( + AutoConfigurations.of(TraceAutoConfiguration.class, TraceRpcAutoConfiguration.class)); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAutoConfigurationTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAutoConfigurationTest.java index ff4335f65..580cf7e4a 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAutoConfigurationTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/scheduling/TraceSchedulingAutoConfigurationTest.java @@ -28,22 +28,18 @@ import static org.assertj.core.api.Assertions.assertThat; class TraceSchedulingAutoConfigurationTest { - private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() - .withConfiguration(AutoConfigurations.of(TraceAutoConfiguration.class, - TraceSchedulingAutoConfiguration.class)); + private final ApplicationContextRunner contextRunner = new ApplicationContextRunner().withConfiguration( + AutoConfigurations.of(TraceAutoConfiguration.class, TraceSchedulingAutoConfiguration.class)); @Test void shoud_create_TraceSchedulingAspect() { - this.contextRunner.run(context -> assertThat(context) - .hasSingleBean(TraceSchedulingAspect.class)); + this.contextRunner.run(context -> assertThat(context).hasSingleBean(TraceSchedulingAspect.class)); } @Test void shoud_not_create_TraceSchedulingAspect_without_aspectJ() { - this.contextRunner - .withClassLoader(new FilteredClassLoader(ProceedingJoinPoint.class)) - .run(context -> assertThat(context) - .doesNotHaveBean(TraceSchedulingAspect.class)); + this.contextRunner.withClassLoader(new FilteredClassLoader(ProceedingJoinPoint.class)) + .run(context -> assertThat(context).doesNotHaveBean(TraceSchedulingAspect.class)); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/CompositeHttpSamplerTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/CompositeHttpSamplerTests.java index 07629f76d..149f4712d 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/CompositeHttpSamplerTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/CompositeHttpSamplerTests.java @@ -38,14 +38,12 @@ public class CompositeHttpSamplerTests { @Test public void should_return_null_on_both_null() { - then(new CompositeHttpSampler(new NullSampler(), new NullSampler()) - .trySample(this.request)).isNull(); + then(new CompositeHttpSampler(new NullSampler(), new NullSampler()).trySample(this.request)).isNull(); } @ParameterizedTest @MethodSource("falseArgs") - void should_return_false_on_any_false(SamplerFunction left, - SamplerFunction right) { + void should_return_false_on_any_false(SamplerFunction left, SamplerFunction right) { then(new CompositeHttpSampler(left, right).trySample(this.request)).isFalse(); } @@ -57,8 +55,7 @@ public class CompositeHttpSamplerTests { @Test public void should_return_true_on_both_true() { - then(new CompositeHttpSampler(new TrueSampler(), new TrueSampler()) - .trySample(this.request)).isTrue(); + then(new CompositeHttpSampler(new TrueSampler(), new TrueSampler()).trySample(this.request)).isTrue(); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/IgnoreAutoConfiguredSkipPatternsIntegrationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/IgnoreAutoConfiguredSkipPatternsIntegrationTests.java index d8448b187..833d5b6f4 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/IgnoreAutoConfiguredSkipPatternsIntegrationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/IgnoreAutoConfiguredSkipPatternsIntegrationTests.java @@ -40,8 +40,7 @@ import static org.assertj.core.api.BDDAssertions.then; @SpringBootTest(classes = IgnoreAutoConfiguredSkipPatternsIntegrationTests.Config.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, - properties = { "management.endpoints.web.exposure.include:*", - "server.servlet.context-path:/context-path", + properties = { "management.endpoints.web.exposure.include:*", "server.servlet.context-path:/context-path", "spring.sleuth.web.ignoreAutoConfiguredSkipPatterns:true" }) public class IgnoreAutoConfiguredSkipPatternsIntegrationTests { @@ -62,8 +61,7 @@ public class IgnoreAutoConfiguredSkipPatternsIntegrationTests { @Test public void should_sample_actuator_endpoint_when_override_pattern_is_true() { - new RestTemplate().getForObject( - "http://localhost:" + this.port + "/context-path/actuator/health", + new RestTemplate().getForObject("http://localhost:" + this.port + "/context-path/actuator/health", String.class); then(this.tracer.currentSpan()).isNull(); @@ -72,9 +70,7 @@ public class IgnoreAutoConfiguredSkipPatternsIntegrationTests { @Test public void should_sample_non_actuator_endpoint_when_override_pattern_is_true() { - new RestTemplate().getForObject( - "http://localhost:" + this.port + "/context-path/something", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/context-path/something", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(1); @@ -82,9 +78,7 @@ public class IgnoreAutoConfiguredSkipPatternsIntegrationTests { @Test public void should_not_sample_default_skip_patterns_when_override_pattern_is_true() { - new RestTemplate().getForObject( - "http://localhost:" + this.port + "/context-path/index.html", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/context-path/index.html", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(0); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithContextPathWithBasePath.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithContextPathWithBasePath.java index ab2d8e6cd..c3a9aad9e 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithContextPathWithBasePath.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithContextPathWithBasePath.java @@ -38,11 +38,9 @@ import org.springframework.web.client.RestTemplate; import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest( - classes = SkipEndPointsIntegrationTestsWithContextPathWithBasePath.Config.class, +@SpringBootTest(classes = SkipEndPointsIntegrationTestsWithContextPathWithBasePath.Config.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, - properties = { "management.endpoints.web.exposure.include:*", - "server.servlet.context-path:/context-path" }) + properties = { "management.endpoints.web.exposure.include:*", "server.servlet.context-path:/context-path" }) public class SkipEndPointsIntegrationTestsWithContextPathWithBasePath { @Autowired @@ -62,8 +60,7 @@ public class SkipEndPointsIntegrationTestsWithContextPathWithBasePath { @Test public void should_not_sample_skipped_endpoint_with_context_path() { - new RestTemplate().getForObject( - "http://localhost:" + this.port + "/context-path/actuator/health", + new RestTemplate().getForObject("http://localhost:" + this.port + "/context-path/actuator/health", String.class); then(this.tracer.currentSpan()).isNull(); @@ -72,9 +69,7 @@ public class SkipEndPointsIntegrationTestsWithContextPathWithBasePath { @Test public void should_sample_non_actuator_endpoint_with_context_path() { - new RestTemplate().getForObject( - "http://localhost:" + this.port + "/context-path/something", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/context-path/something", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(1); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithContextPathWithoutBasePath.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithContextPathWithoutBasePath.java index 54fe84bb8..a155d2127 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithContextPathWithoutBasePath.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithContextPathWithoutBasePath.java @@ -38,11 +38,9 @@ import org.springframework.web.client.RestTemplate; import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest( - classes = SkipEndPointsIntegrationTestsWithContextPathWithoutBasePath.Config.class, +@SpringBootTest(classes = SkipEndPointsIntegrationTestsWithContextPathWithoutBasePath.Config.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, - properties = { "management.endpoints.web.exposure.include:*", - "server.servlet.context-path:/context-path", + properties = { "management.endpoints.web.exposure.include:*", "server.servlet.context-path:/context-path", "management.endpoints.web.base-path:/" }) public class SkipEndPointsIntegrationTestsWithContextPathWithoutBasePath { @@ -63,9 +61,7 @@ public class SkipEndPointsIntegrationTestsWithContextPathWithoutBasePath { @Test public void should_sample_non_actuator_endpoint_with_context_path() { - new RestTemplate().getForObject( - "http://localhost:" + this.port + "/context-path/something", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/context-path/something", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(1); @@ -73,9 +69,7 @@ public class SkipEndPointsIntegrationTestsWithContextPathWithoutBasePath { @Test public void should_sample_non_actuator_endpoint_with_context_path_and_health_in_path() { - new RestTemplate().getForObject( - "http://localhost:" + this.port + "/context-path/healthcare", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/context-path/healthcare", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(1); @@ -83,8 +77,7 @@ public class SkipEndPointsIntegrationTestsWithContextPathWithoutBasePath { @Test public void should_not_sample_actuator_endpoint_with_base_path_set_to_root() { - new RestTemplate().getForObject( - "http://localhost:" + this.port + "/context-path/health", String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/context-path/health", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(0); @@ -92,9 +85,7 @@ public class SkipEndPointsIntegrationTestsWithContextPathWithoutBasePath { @Test public void should_not_sample_actuator_endpoint_with_base_path_set_to_root_and_parameter() { - new RestTemplate().getForObject( - "http://localhost:" + this.port + "/context-path/metrics?xyz", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/context-path/metrics?xyz", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(0); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithoutContextPathWithBasePath.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithoutContextPathWithBasePath.java index af625c768..85977c14e 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithoutContextPathWithBasePath.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithoutContextPathWithBasePath.java @@ -38,8 +38,7 @@ import org.springframework.web.client.RestTemplate; import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest( - classes = SkipEndPointsIntegrationTestsWithoutContextPathWithBasePath.Config.class, +@SpringBootTest(classes = SkipEndPointsIntegrationTestsWithoutContextPathWithBasePath.Config.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, properties = { "management.endpoints.web.exposure.include:*" }) public class SkipEndPointsIntegrationTestsWithoutContextPathWithBasePath { @@ -61,8 +60,7 @@ public class SkipEndPointsIntegrationTestsWithoutContextPathWithBasePath { @Test public void should_sample_non_actuator_endpoint() { - new RestTemplate().getForObject("http://localhost:" + this.port + "/something", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/something", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(1); @@ -70,8 +68,7 @@ public class SkipEndPointsIntegrationTestsWithoutContextPathWithBasePath { @Test public void should_sample_non_actuator_endpoint_and_healthcare_in_path() { - new RestTemplate().getForObject("http://localhost:" + this.port + "/healthcare", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/healthcare", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(1); @@ -79,8 +76,7 @@ public class SkipEndPointsIntegrationTestsWithoutContextPathWithBasePath { @Test public void should_not_sample_actuator_endpoint() { - new RestTemplate().getForObject( - "http://localhost:" + this.port + "/actuator/health", String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/actuator/health", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(0); @@ -88,8 +84,7 @@ public class SkipEndPointsIntegrationTestsWithoutContextPathWithBasePath { @Test public void should_not_sample_actuator_endpoint_with_parameter() { - new RestTemplate().getForObject( - "http://localhost:" + this.port + "/actuator/metrics?xyz", String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/actuator/metrics?xyz", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(0); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithoutContextPathWithoutBasePath.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithoutContextPathWithoutBasePath.java index ef3fdb6e6..7c2c365e4 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithoutContextPathWithoutBasePath.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipEndPointsIntegrationTestsWithoutContextPathWithoutBasePath.java @@ -38,11 +38,9 @@ import org.springframework.web.client.RestTemplate; import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest( - classes = SkipEndPointsIntegrationTestsWithoutContextPathWithoutBasePath.Config.class, +@SpringBootTest(classes = SkipEndPointsIntegrationTestsWithoutContextPathWithoutBasePath.Config.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, - properties = { "management.endpoints.web.exposure.include:*", - "management.endpoints.web.base-path:/" }) + properties = { "management.endpoints.web.exposure.include:*", "management.endpoints.web.base-path:/" }) public class SkipEndPointsIntegrationTestsWithoutContextPathWithoutBasePath { @LocalServerPort @@ -62,8 +60,7 @@ public class SkipEndPointsIntegrationTestsWithoutContextPathWithoutBasePath { @Test public void should_sample_non_actuator_endpoint() { - new RestTemplate().getForObject("http://localhost:" + this.port + "/something", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/something", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(1); @@ -71,8 +68,7 @@ public class SkipEndPointsIntegrationTestsWithoutContextPathWithoutBasePath { @Test public void should_sample_non_actuator_endpoint_with_healthcare_in_path() { - new RestTemplate().getForObject("http://localhost:" + this.port + "/healthcare", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/healthcare", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(1); @@ -80,8 +76,7 @@ public class SkipEndPointsIntegrationTestsWithoutContextPathWithoutBasePath { @Test public void should_not_sample_actuator_endpoint() { - new RestTemplate().getForObject("http://localhost:" + this.port + "/health", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/health", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(0); @@ -89,8 +84,7 @@ public class SkipEndPointsIntegrationTestsWithoutContextPathWithoutBasePath { @Test public void should_not_sample_actuator_endpoint_with_parameter() { - new RestTemplate().getForObject("http://localhost:" + this.port + "/metrics?xyz", - String.class); + new RestTemplate().getForObject("http://localhost:" + this.port + "/metrics?xyz", String.class); then(this.tracer.currentSpan()).isNull(); then(this.spans).hasSize(0); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipPatternProviderConfigTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipPatternProviderConfigTest.java index 4b629770d..73d580bd9 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipPatternProviderConfigTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/SkipPatternProviderConfigTest.java @@ -55,36 +55,29 @@ import static org.assertj.core.api.BDDAssertions.then; */ public class SkipPatternProviderConfigTest { - private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner() - .withConfiguration(AutoConfigurations.of( - DispatcherServletAutoConfiguration.class, - InfoEndpointAutoConfiguration.class, - HealthEndpointAutoConfiguration.class, - EndpointAutoConfiguration.class, WebEndpointAutoConfiguration.class, - TraceAutoConfiguration.class, SkipPatternConfiguration.class)); + private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner().withConfiguration( + AutoConfigurations.of(DispatcherServletAutoConfiguration.class, InfoEndpointAutoConfiguration.class, + HealthEndpointAutoConfiguration.class, EndpointAutoConfiguration.class, + WebEndpointAutoConfiguration.class, TraceAutoConfiguration.class, SkipPatternConfiguration.class)); @Test public void should_return_null_when_cleared() throws Exception { contextRunner.withPropertyValues("spring.sleuth.web.skip-pattern") - .run(context -> then(context.getBean("sleuthSkipPatternProvider")) - .hasToString("null")); + .run(context -> then(context.getBean("sleuthSkipPatternProvider")).hasToString("null")); } @Test public void should_pick_skip_pattern_from_sleuth_properties() throws Exception { - contextRunner.withPropertyValues("spring.sleuth.web.skip-pattern=foo.*|bar.*") - .run(context -> { - final String pattern = extractPattern(context); - then(pattern).isEqualTo("foo.*|bar.*"); - }); + contextRunner.withPropertyValues("spring.sleuth.web.skip-pattern=foo.*|bar.*").run(context -> { + final String pattern = extractPattern(context); + then(pattern).isEqualTo("foo.*|bar.*"); + }); } @Test public void should_combine_skip_pattern_and_additional_pattern_when_all_are_not_empty() { - contextRunner - .withPropertyValues("spring.sleuth.web.skip-pattern=foo.*|bar.*", - "spring.sleuth.web.additional-skip-pattern=baz.*|faz.*") - .run(context -> { + contextRunner.withPropertyValues("spring.sleuth.web.skip-pattern=foo.*|bar.*", + "spring.sleuth.web.additional-skip-pattern=baz.*|faz.*").run(context -> { final String pattern = extractPattern(context); then(pattern).isEqualTo("foo.*|bar.*|baz.*|faz.*"); }); @@ -97,11 +90,9 @@ public class SkipPatternProviderConfigTest { } @Test - public void should_return_empty_when_management_context_has_no_context_path() - throws Exception { + public void should_return_empty_when_management_context_has_no_context_path() throws Exception { Optional pattern = new SkipPatternConfiguration.ManagementSkipPatternProviderConfig() - .skipPatternForManagementServerProperties(environment(), - new ManagementServerProperties()) + .skipPatternForManagementServerProperties(environment(), new ManagementServerProperties()) .skipPattern(); then(pattern).isEmpty(); @@ -111,10 +102,8 @@ public class SkipPatternProviderConfigTest { public void should_return_management_context_with_context_path() throws Exception { contextRunner .withConfiguration( - UserConfigurations.of(ManagementContextAutoConfiguration.class, - ServerPropertiesConfig.class)) - .withPropertyValues("management.server.servlet.context-path=foo") - .run(context -> { + UserConfigurations.of(ManagementContextAutoConfiguration.class, ServerPropertiesConfig.class)) + .withPropertyValues("management.server.servlet.context-path=foo").run(context -> { then(extractAllPatterns(context)).containsExactlyInAnyOrder( "/actuator(/|/(health|health/.*|info|info/.*))?", "foo.*", SleuthWebProperties.DEFAULT_SKIP_PATTERN); @@ -122,15 +111,11 @@ public class SkipPatternProviderConfigTest { } @Test - public void should_return_management_context_with_context_path_with_placeholders() - throws Exception { + public void should_return_management_context_with_context_path_with_placeholders() throws Exception { contextRunner .withConfiguration( - UserConfigurations.of(ManagementContextAutoConfiguration.class, - ServerPropertiesConfig.class)) - .withPropertyValues( - "management.server.servlet.context-path=${test:value}") - .run(context -> { + UserConfigurations.of(ManagementContextAutoConfiguration.class, ServerPropertiesConfig.class)) + .withPropertyValues("management.server.servlet.context-path=${test:value}").run(context -> { then(extractAllPatterns(context)).containsExactlyInAnyOrder( "/actuator(/|/(health|health/.*|info|info/.*))?", "value.*", SleuthWebProperties.DEFAULT_SKIP_PATTERN); @@ -140,9 +125,8 @@ public class SkipPatternProviderConfigTest { @Test public void should_return_empty_when_no_endpoints() { Optional pattern = new SkipPatternConfiguration.ActuatorSkipPatternProviderConfig() - .skipPatternForActuatorEndpointsSamePort(environment(), - new ServerProperties(), new WebEndpointProperties(), - Collections::emptyList) + .skipPatternForActuatorEndpointsSamePort(environment(), new ServerProperties(), + new WebEndpointProperties(), Collections::emptyList) .skipPattern(); then(pattern).isEmpty(); @@ -150,19 +134,15 @@ public class SkipPatternProviderConfigTest { @Test public void should_return_endpoints_without_context_path() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .run(context -> { - then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "/actuator(/|/(health|health/.*|info|info/.*))?", - SleuthWebProperties.DEFAULT_SKIP_PATTERN); - }); + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)).run(context -> { + then(extractAllPatterns(context)).containsExactlyInAnyOrder( + "/actuator(/|/(health|health/.*|info|info/.*))?", SleuthWebProperties.DEFAULT_SKIP_PATTERN); + }); } @Test public void should_return_endpoints_with_context_path() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) .withPropertyValues("server.servlet.context-path=foo").run(context -> { then(extractAllPatterns(context)).containsExactlyInAnyOrder( "foo/actuator(/|/(health|health/.*|info|info/.*))?", @@ -172,10 +152,8 @@ public class SkipPatternProviderConfigTest { @Test public void should_return_endpoints_with_context_path_with_placeholders() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .withPropertyValues("server.servlet.context-path=${test:foo}") - .run(context -> { + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + .withPropertyValues("server.servlet.context-path=${test:foo}").run(context -> { then(extractAllPatterns(context)).containsExactlyInAnyOrder( "foo/actuator(/|/(health|health/.*|info|info/.*))?", SleuthWebProperties.DEFAULT_SKIP_PATTERN); @@ -184,143 +162,111 @@ public class SkipPatternProviderConfigTest { @Test public void should_return_endpoints_without_context_path_and_base_path_set_to_root() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .withPropertyValues("management.endpoints.web.base-path=/") - .run(context -> { - then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "/(health|health/.*|info|info/.*)", + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + .withPropertyValues("management.endpoints.web.base-path=/").run(context -> { + then(extractAllPatterns(context)).containsExactlyInAnyOrder("/(health|health/.*|info|info/.*)", SleuthWebProperties.DEFAULT_SKIP_PATTERN); }); } @Test public void should_return_endpoints_without_context_path_and_base_path_set_to_root_with_placeholders() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .withPropertyValues("management.endpoints.web.base-path=${test:/}") - .run(context -> { - then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "/(health|health/.*|info|info/.*)", + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + .withPropertyValues("management.endpoints.web.base-path=${test:/}").run(context -> { + then(extractAllPatterns(context)).containsExactlyInAnyOrder("/(health|health/.*|info|info/.*)", SleuthWebProperties.DEFAULT_SKIP_PATTERN); }); } @Test public void should_return_endpoints_with_context_path_and_base_path_set_to_root() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .withPropertyValues("management.endpoints.web.base-path=/", - "server.servlet.context-path=foo") + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + .withPropertyValues("management.endpoints.web.base-path=/", "server.servlet.context-path=foo") .run(context -> { then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "foo(/|/(health|health/.*|info|info/.*))?", - SleuthWebProperties.DEFAULT_SKIP_PATTERN); + "foo(/|/(health|health/.*|info|info/.*))?", SleuthWebProperties.DEFAULT_SKIP_PATTERN); }); } @Test public void should_return_endpoints_with_context_path_and_base_path_set_to_root_with_placeholder() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .withPropertyValues("management.endpoints.web.base-path=${test:/}", - "server.servlet.context-path=foo") + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + .withPropertyValues("management.endpoints.web.base-path=${test:/}", "server.servlet.context-path=foo") .run(context -> { then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "foo(/|/(health|health/.*|info|info/.*))?", - SleuthWebProperties.DEFAULT_SKIP_PATTERN); + "foo(/|/(health|health/.*|info|info/.*))?", SleuthWebProperties.DEFAULT_SKIP_PATTERN); }); } @Test public void should_return_endpoints_with_context_path_and_base_path_set_to_root_different_port() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .withPropertyValues("management.endpoints.web.base-path=/", - "management.server.port=0", "server.servlet.context-path=foo") + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + .withPropertyValues("management.endpoints.web.base-path=/", "management.server.port=0", + "server.servlet.context-path=foo") .run(context -> { - then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "/(health|health/.*|info|info/.*)", + then(extractAllPatterns(context)).containsExactlyInAnyOrder("/(health|health/.*|info|info/.*)", SleuthWebProperties.DEFAULT_SKIP_PATTERN); }); } @Test public void should_return_endpoints_with_context_path_and_base_path_set_to_root_different_port_with_placeholder() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .withPropertyValues("management.endpoints.web.base-path=/", - "management.server.port=${some-port:0}", + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + .withPropertyValues("management.endpoints.web.base-path=/", "management.server.port=${some-port:0}", "server.servlet.context-path=${some-path:foo}") .run(context -> { - then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "/(health|health/.*|info|info/.*)", + then(extractAllPatterns(context)).containsExactlyInAnyOrder("/(health|health/.*|info|info/.*)", SleuthWebProperties.DEFAULT_SKIP_PATTERN); }); } @Test public void should_return_endpoints_with_actuator_context_path_only() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .withPropertyValues("management.endpoints.web.base-path=/mgt", - "server.servlet.context-path=foo") + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + .withPropertyValues("management.endpoints.web.base-path=/mgt", "server.servlet.context-path=foo") .run(context -> { then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "foo/mgt(/|/(health|health/.*|info|info/.*))?", - SleuthWebProperties.DEFAULT_SKIP_PATTERN); + "foo/mgt(/|/(health|health/.*|info|info/.*))?", SleuthWebProperties.DEFAULT_SKIP_PATTERN); }); } @Test public void should_return_endpoints_with_actuator_context_path_only_with_placeholder() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) .withPropertyValues("management.endpoints.web.base-path=/${test:mgt}", "server.servlet.context-path=${test2:foo}") .run(context -> { then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "foo/mgt(/|/(health|health/.*|info|info/.*))?", - SleuthWebProperties.DEFAULT_SKIP_PATTERN); + "foo/mgt(/|/(health|health/.*|info|info/.*))?", SleuthWebProperties.DEFAULT_SKIP_PATTERN); }); } @Test public void should_return_endpoints_with_actuator_default_context_path_different_port() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .withPropertyValues("management.server.port=0", - "server.servlet.context-path=foo") - .run(context -> { + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + .withPropertyValues("management.server.port=0", "server.servlet.context-path=foo").run(context -> { then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "/actuator(/|/(health|health/.*|info|info/.*))?", - SleuthWebProperties.DEFAULT_SKIP_PATTERN); + "/actuator(/|/(health|health/.*|info|info/.*))?", SleuthWebProperties.DEFAULT_SKIP_PATTERN); }); } @Test public void should_return_endpoints_with_actuator_context_path_only_different_port() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .withPropertyValues("management.endpoints.web.base-path=/mgt", - "management.server.port=0", "server.servlet.context-path=foo") + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + .withPropertyValues("management.endpoints.web.base-path=/mgt", "management.server.port=0", + "server.servlet.context-path=foo") .run(context -> { then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "/mgt(/|/(health|health/.*|info|info/.*))?", - SleuthWebProperties.DEFAULT_SKIP_PATTERN); + "/mgt(/|/(health|health/.*|info|info/.*))?", SleuthWebProperties.DEFAULT_SKIP_PATTERN); }); } @Test public void should_return_endpoints_with_context_path_different_port() { - contextRunner - .withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) - .withPropertyValues("management.server.port=0", - "server.servlet.context-path=foo") - .run(context -> { + contextRunner.withConfiguration(UserConfigurations.of(ServerPropertiesConfig.class)) + .withPropertyValues("management.server.port=0", "server.servlet.context-path=foo").run(context -> { then(extractAllPatterns(context)).containsExactlyInAnyOrder( - "/actuator(/|/(health|health/.*|info|info/.*))?", - SleuthWebProperties.DEFAULT_SKIP_PATTERN); + "/actuator(/|/(health|health/.*|info|info/.*))?", SleuthWebProperties.DEFAULT_SKIP_PATTERN); }); } @@ -346,8 +292,7 @@ public class SkipPatternProviderConfigTest { * Extracts the patterns from pattern provider */ private String extractPattern(ApplicationContext context) { - SkipPatternProvider skipPatternProvider = context - .getBean(SkipPatternProvider.class); + SkipPatternProvider skipPatternProvider = context.getBean(SkipPatternProvider.class); return skipPatternProvider.skipPattern().pattern(); } @@ -355,9 +300,8 @@ public class SkipPatternProviderConfigTest { * Extracts all single patterns */ private Collection extractAllPatterns(ApplicationContext context) { - return context.getBeansOfType(SingleSkipPattern.class).values().stream() - .map(SingleSkipPattern::skipPattern).filter(Optional::isPresent) - .map(Optional::get).map(Pattern::pattern).collect(Collectors.toList()); + return context.getBeansOfType(SingleSkipPattern.class).values().stream().map(SingleSkipPattern::skipPattern) + .filter(Optional::isPresent).map(Optional::get).map(Pattern::pattern).collect(Collectors.toList()); } @Configuration diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterTests.java index 10a8cc38b..0dd076fc2 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterTests.java @@ -56,17 +56,15 @@ public class TraceFilterTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder() - .currentTraceContext(ThreadLocalCurrentTraceContext.newBuilder() - .addScopeDecorator(StrictScopeDecorator.create()).build()) + Tracing tracing = Tracing.newBuilder().currentTraceContext( + ThreadLocalCurrentTraceContext.newBuilder().addScopeDecorator(StrictScopeDecorator.create()).build()) .addSpanHandler(this.spans).build(); Tracer tracer = this.tracing.tracer(); - HttpTracing httpTracing = HttpTracing.newBuilder(this.tracing) - .clientParser(new HttpClientParser()).serverParser(new HttpServerParser()) - .serverSampler(new SkipPatternHttpServerSampler(() -> Pattern.compile(""))) - .build(); + HttpTracing httpTracing = HttpTracing.newBuilder(this.tracing).clientParser(new HttpClientParser()) + .serverParser(new HttpServerParser()) + .serverSampler(new SkipPatternHttpServerSampler(() -> Pattern.compile(""))).build(); Filter filter = TracingFilter.create(this.httpTracing); @@ -85,8 +83,7 @@ public class TraceFilterTests { } public MockHttpServletRequestBuilder builder() { - return get("/?foo=bar").accept(MediaType.APPLICATION_JSON).header("User-Agent", - "MockMvc"); + return get("/?foo=bar").accept(MediaType.APPLICATION_JSON).header("User-Agent", "MockMvc"); } @AfterEach @@ -96,8 +93,7 @@ public class TraceFilterTests { @Test public void notTraced() throws Exception { - this.request = get("/favicon.ico").accept(MediaType.ALL) - .buildRequest(new MockServletContext()); + this.request = get("/favicon.ico").accept(MediaType.ALL).buildRequest(new MockServletContext()); neverSampleFilter().doFilter(this.request, this.response, this.filterChain); @@ -109,13 +105,10 @@ public class TraceFilterTests { Tracing tracing = Tracing.newBuilder() .currentTraceContext(ThreadLocalCurrentTraceContext.newBuilder() .addScopeDecorator(StrictScopeDecorator.create()).build()) - .addSpanHandler(this.spans).sampler(Sampler.NEVER_SAMPLE) - .supportsJoin(false).build(); - HttpTracing httpTracing = HttpTracing.newBuilder(tracing) - .clientParser(new HttpClientParser()).serverParser(new HttpServerParser()) - .serverSampler( - new SkipPatternHttpServerSampler(() -> Pattern.compile(""))) - .build(); + .addSpanHandler(this.spans).sampler(Sampler.NEVER_SAMPLE).supportsJoin(false).build(); + HttpTracing httpTracing = HttpTracing.newBuilder(tracing).clientParser(new HttpClientParser()) + .serverParser(new HttpServerParser()) + .serverSampler(new SkipPatternHttpServerSampler(() -> Pattern.compile(""))).build(); return TracingFilter.create(httpTracing); } @@ -124,15 +117,14 @@ public class TraceFilterTests { this.filter.doFilter(this.request, this.response, this.filterChain); then(this.spans).hasSize(1); - then(this.spans.get(0).tags()).containsEntry("http.path", "/") - .containsEntry("http.method", HttpMethod.GET.toString()); + then(this.spans.get(0).tags()).containsEntry("http.path", "/").containsEntry("http.method", + HttpMethod.GET.toString()); // we don't check for status_code anymore cause Brave doesn't support it oob // .containsEntry("http.status_code", "200") } @Test - public void shouldNotStoreHttpStatusCodeWhenResponseCodeHasNotYetBeenSet() - throws Exception { + public void shouldNotStoreHttpStatusCodeWhenResponseCodeHasNotYetBeenSet() throws Exception { this.response.setStatus(0); this.filter.doFilter(this.request, this.response, this.filterChain); @@ -143,8 +135,7 @@ public class TraceFilterTests { @Test public void startsNewTraceWithParentIdInHeaders() throws Exception { - this.request = builder() - .header("b3", "0000000000000002-0000000000000003-1-000000000000000a") + this.request = builder().header("b3", "0000000000000002-0000000000000003-1-000000000000000a") .buildRequest(new MockServletContext()); this.filter.doFilter(this.request, this.response, this.filterChain); @@ -152,8 +143,8 @@ public class TraceFilterTests { then(Tracing.current().tracer().currentSpan()).isNull(); then(this.spans).hasSize(1); then(this.spans.get(0).id()).isEqualTo("0000000000000003"); - then(this.spans.get(0).tags()).containsEntry("http.path", "/") - .containsEntry("http.method", HttpMethod.GET.toString()); + then(this.spans.get(0).tags()).containsEntry("http.path", "/").containsEntry("http.method", + HttpMethod.GET.toString()); } @Test @@ -192,8 +183,7 @@ public class TraceFilterTests { } @Test - public void doesntDetachASpanIfStatusCodeNotSuccessfulAndRequestWasProcessed() - throws Exception { + public void doesntDetachASpanIfStatusCodeNotSuccessfulAndRequestWasProcessed() throws Exception { Span span = this.tracer.nextSpan().name("http:foo"); this.response.setStatus(404); @@ -222,8 +212,7 @@ public class TraceFilterTests { this.request = builder().header("b3", "0000000000000014-000000000000000a") .buildRequest(new MockServletContext()); - TracingFilter.create(httpTracing).doFilter(this.request, this.response, - this.filterChain); + TracingFilter.create(httpTracing).doFilter(this.request, this.response, this.filterChain); then(Tracing.current().tracer().currentSpan()).isNull(); then(this.spans).hasSize(1); @@ -237,8 +226,7 @@ public class TraceFilterTests { this.filterChain = new MockFilterChain() { @Override - public void doFilter(javax.servlet.ServletRequest request, - javax.servlet.ServletResponse response) + public void doFilter(javax.servlet.ServletRequest request, javax.servlet.ServletResponse response) throws java.io.IOException, javax.servlet.ServletException { throw new RuntimeException("Planned"); } @@ -258,8 +246,7 @@ public class TraceFilterTests { @Test public void detachesSpanWhenResponseStatusIsNot2xx() throws Exception { - this.request = builder().header("b3", "14-a") - .buildRequest(new MockServletContext()); + this.request = builder().header("b3", "14-a").buildRequest(new MockServletContext()); this.response.setStatus(404); @@ -293,8 +280,7 @@ public class TraceFilterTests { @Test public void returns400IfSpanIsMalformedAndCreatesANewSpan() throws Exception { - this.request = builder().header("b3", "asd") - .buildRequest(new MockServletContext()); + this.request = builder().header("b3", "asd").buildRequest(new MockServletContext()); this.filter.doFilter(this.request, this.response, this.filterChain); @@ -305,8 +291,7 @@ public class TraceFilterTests { @Test public void returns200IfSpanParentIsMalformedAndCreatesANewSpan() throws Exception { - this.request = builder().header("b3", "asd") - .buildRequest(new MockServletContext()); + this.request = builder().header("b3", "asd").buildRequest(new MockServletContext()); this.filter.doFilter(this.request, this.response, this.filterChain); @@ -328,8 +313,7 @@ public class TraceFilterTests { @SuppressWarnings("Duplicates") @Test public void usesSamplingMechanismWhenIncomingTraceIsMalformed() throws Exception { - this.request = builder().header("b3", "asd") - .buildRequest(new MockServletContext()); + this.request = builder().header("b3", "asd").buildRequest(new MockServletContext()); neverSampleFilter().doFilter(this.request, this.response, this.filterChain); @@ -340,16 +324,15 @@ public class TraceFilterTests { // #668 @Test public void shouldSetTraceKeysForAnUntracedRequest() throws Exception { - this.request = builder().param("foo", "bar") - .buildRequest(new MockServletContext()); + this.request = builder().param("foo", "bar").buildRequest(new MockServletContext()); this.response.setStatus(295); this.filter.doFilter(this.request, this.response, this.filterChain); then(Tracing.current().tracer().currentSpan()).isNull(); then(this.spans).hasSize(1); - then(this.spans.get(0).tags()).containsEntry("http.path", "/") - .containsEntry("http.method", HttpMethod.GET.toString()); + then(this.spans.get(0).tags()).containsEntry("http.path", "/").containsEntry("http.method", + HttpMethod.GET.toString()); // we don't check for status_code anymore cause Brave doesn't support it oob // .containsEntry("http.status_code", "295") } @@ -367,8 +350,8 @@ public class TraceFilterTests { public void verifyParentSpanHttpTags() { then(this.spans).isNotEmpty(); - then(this.spans.get(0).tags()).containsEntry("http.path", "/") - .containsEntry("http.method", HttpMethod.GET.toString()); + then(this.spans.get(0).tags()).containsEntry("http.path", "/").containsEntry("http.method", + HttpMethod.GET.toString()); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceHttpAutoConfigurationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceHttpAutoConfigurationTests.java index def506747..359c57094 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceHttpAutoConfigurationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceHttpAutoConfigurationTests.java @@ -41,8 +41,7 @@ public class TraceHttpAutoConfigurationTests { @Test public void defaultsClientSamplerToDefer() { contextRunner().run((context) -> { - SamplerFunction clientSampler = context - .getBean(HttpTracing.class).clientRequestSampler(); + SamplerFunction clientSampler = context.getBean(HttpTracing.class).clientRequestSampler(); then(clientSampler).isSameAs(SamplerFunctions.deferDecision()); }); @@ -50,32 +49,26 @@ public class TraceHttpAutoConfigurationTests { @Test public void configuresClientSkipPattern() throws Exception { - contextRunner() - .withPropertyValues("spring.sleuth.web.client.skip-pattern=foo.*|bar.*") - .run((context) -> { - SamplerFunction clientSampler = context - .getBean(HttpTracing.class).clientRequestSampler(); + contextRunner().withPropertyValues("spring.sleuth.web.client.skip-pattern=foo.*|bar.*").run((context) -> { + SamplerFunction clientSampler = context.getBean(HttpTracing.class).clientRequestSampler(); - then(clientSampler).isInstanceOf(SkipPatternHttpClientSampler.class); - }); + then(clientSampler).isInstanceOf(SkipPatternHttpClientSampler.class); + }); } @Test public void configuresUserProvidedHttpClientSampler() { - contextRunner().withUserConfiguration(HttpClientSamplerConfig.class) - .run((context) -> { - SamplerFunction clientSampler = context - .getBean(HttpTracing.class).clientRequestSampler(); + contextRunner().withUserConfiguration(HttpClientSamplerConfig.class).run((context) -> { + SamplerFunction clientSampler = context.getBean(HttpTracing.class).clientRequestSampler(); - then(clientSampler).isSameAs(HttpClientSamplerConfig.INSTANCE); - }); + then(clientSampler).isSameAs(HttpClientSamplerConfig.INSTANCE); + }); } @Test public void defaultsServerSamplerToSkipPattern() { contextRunner().run((context) -> { - SamplerFunction serverSampler = context - .getBean(HttpTracing.class).serverRequestSampler(); + SamplerFunction serverSampler = context.getBean(HttpTracing.class).serverRequestSampler(); then(serverSampler).isInstanceOf(SkipPatternHttpServerSampler.class); }); @@ -83,13 +76,11 @@ public class TraceHttpAutoConfigurationTests { @Test public void defaultsServerSamplerToDeferWhenSkipPatternCleared() { - contextRunner().withPropertyValues("spring.sleuth.web.skip-pattern") - .run((context) -> { - SamplerFunction clientSampler = context - .getBean(HttpTracing.class).serverRequestSampler(); + contextRunner().withPropertyValues("spring.sleuth.web.skip-pattern").run((context) -> { + SamplerFunction clientSampler = context.getBean(HttpTracing.class).serverRequestSampler(); - then(clientSampler).isSameAs(SamplerFunctions.deferDecision()); - }); + then(clientSampler).isSameAs(SamplerFunctions.deferDecision()); + }); } @Test @@ -102,13 +93,11 @@ public class TraceHttpAutoConfigurationTests { SamplerFunction instance) { return (context) -> { - SamplerFunction serverSampler = context - .getBean(HttpTracing.class).serverRequestSampler(); + SamplerFunction serverSampler = context.getBean(HttpTracing.class).serverRequestSampler(); then(serverSampler).isInstanceOf(CompositeHttpSampler.class); - then(((CompositeHttpSampler) serverSampler).left) - .isInstanceOf(SkipPatternHttpServerSampler.class); + then(((CompositeHttpSampler) serverSampler).left).isInstanceOf(SkipPatternHttpServerSampler.class); then(((CompositeHttpSampler) serverSampler).right).isSameAs(instance); }; } @@ -116,10 +105,8 @@ public class TraceHttpAutoConfigurationTests { @Test public void defaultHttpClientParser() { contextRunner().run((context) -> { - HttpRequestParser clientRequestParser = context.getBean(HttpTracing.class) - .clientRequestParser(); - HttpResponseParser clientResponseParser = context.getBean(HttpTracing.class) - .clientResponseParser(); + HttpRequestParser clientRequestParser = context.getBean(HttpTracing.class).clientRequestParser(); + HttpResponseParser clientResponseParser = context.getBean(HttpTracing.class).clientResponseParser(); then(clientRequestParser).isInstanceOf(HttpRequestParser.Default.class); then(clientResponseParser).isInstanceOf(HttpResponseParser.Default.class); @@ -128,27 +115,20 @@ public class TraceHttpAutoConfigurationTests { @Test public void configuresUserProvidedHttpClientParser() { - contextRunner().withUserConfiguration(HttpClientParserConfig.class) - .run((context) -> { - HttpRequestParser clientRequestParser = context - .getBean(HttpTracing.class).clientRequestParser(); - HttpResponseParser clientResponseParser = context - .getBean(HttpTracing.class).clientResponseParser(); + contextRunner().withUserConfiguration(HttpClientParserConfig.class).run((context) -> { + HttpRequestParser clientRequestParser = context.getBean(HttpTracing.class).clientRequestParser(); + HttpResponseParser clientResponseParser = context.getBean(HttpTracing.class).clientResponseParser(); - then(clientRequestParser) - .isSameAs(HttpClientParserConfig.REQUEST_PARSER); - then(clientResponseParser) - .isSameAs(HttpClientParserConfig.RESPONSE_PARSER); - }); + then(clientRequestParser).isSameAs(HttpClientParserConfig.REQUEST_PARSER); + then(clientResponseParser).isSameAs(HttpClientParserConfig.RESPONSE_PARSER); + }); } @Test public void defaultHttpServerParser() { contextRunner().run((context) -> { - HttpRequestParser serverRequestParser = context.getBean(HttpTracing.class) - .serverRequestParser(); - HttpResponseParser serverResponseParser = context.getBean(HttpTracing.class) - .serverResponseParser(); + HttpRequestParser serverRequestParser = context.getBean(HttpTracing.class).serverRequestParser(); + HttpResponseParser serverResponseParser = context.getBean(HttpTracing.class).serverResponseParser(); then(serverRequestParser).isInstanceOf(HttpRequestParser.Default.class); then(serverResponseParser).isInstanceOf(HttpResponseParser.Default.class); @@ -157,18 +137,13 @@ public class TraceHttpAutoConfigurationTests { @Test public void configuresUserProvidedHttpServerParser() { - contextRunner().withUserConfiguration(HttpServerParserConfig.class) - .run((context) -> { - HttpRequestParser serverRequestParser = context - .getBean(HttpTracing.class).serverRequestParser(); - HttpResponseParser serverResponseParser = context - .getBean(HttpTracing.class).serverResponseParser(); + contextRunner().withUserConfiguration(HttpServerParserConfig.class).run((context) -> { + HttpRequestParser serverRequestParser = context.getBean(HttpTracing.class).serverRequestParser(); + HttpResponseParser serverResponseParser = context.getBean(HttpTracing.class).serverResponseParser(); - then(serverRequestParser) - .isSameAs(HttpServerParserConfig.REQUEST_PARSER); - then(serverResponseParser) - .isSameAs(HttpServerParserConfig.RESPONSE_PARSER); - }); + then(serverRequestParser).isSameAs(HttpServerParserConfig.REQUEST_PARSER); + then(serverResponseParser).isSameAs(HttpServerParserConfig.RESPONSE_PARSER); + }); } /** @@ -177,14 +152,10 @@ public class TraceHttpAutoConfigurationTests { @Test public void configuresUserProvidedHttpClientAndServerParser() { contextRunner().withUserConfiguration(HttpParserConfig.class).run((context) -> { - HttpRequestParser serverRequestParser = context.getBean(HttpTracing.class) - .serverRequestParser(); - HttpResponseParser serverResponseParser = context.getBean(HttpTracing.class) - .serverResponseParser(); - HttpRequestParser clientRequestParser = context.getBean(HttpTracing.class) - .clientRequestParser(); - HttpResponseParser clientResponseParser = context.getBean(HttpTracing.class) - .clientResponseParser(); + HttpRequestParser serverRequestParser = context.getBean(HttpTracing.class).serverRequestParser(); + HttpResponseParser serverResponseParser = context.getBean(HttpTracing.class).serverResponseParser(); + HttpRequestParser clientRequestParser = context.getBean(HttpTracing.class).clientRequestParser(); + HttpResponseParser clientResponseParser = context.getBean(HttpTracing.class).clientResponseParser(); then(clientRequestParser).isSameAs(HttpParserConfig.REQUEST_PARSER); then(clientResponseParser).isSameAs(HttpParserConfig.RESPONSE_PARSER); @@ -196,20 +167,17 @@ public class TraceHttpAutoConfigurationTests { @Test public void hasNoCycles() { contextRunner() - .withConfiguration(AutoConfigurations.of(SkipPatternConfiguration.class, - TraceHttpAutoConfiguration.class)) - .withInitializer(c -> ((GenericApplicationContext) c) - .setAllowCircularReferences(false)) + .withConfiguration( + AutoConfigurations.of(SkipPatternConfiguration.class, TraceHttpAutoConfiguration.class)) + .withInitializer(c -> ((GenericApplicationContext) c).setAllowCircularReferences(false)) .run((context) -> { BDDAssertions.then(context.isRunning()).isEqualTo(true); }); } private ApplicationContextRunner contextRunner(String... propertyValues) { - return new ApplicationContextRunner().withPropertyValues(propertyValues) - .withConfiguration(AutoConfigurations.of(TraceAutoConfiguration.class, - TraceHttpAutoConfiguration.class, - SkipPatternConfiguration.class)); + return new ApplicationContextRunner().withPropertyValues(propertyValues).withConfiguration(AutoConfigurations + .of(TraceAutoConfiguration.class, TraceHttpAutoConfiguration.class, SkipPatternConfiguration.class)); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceNoWebEnvironmentTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceNoWebEnvironmentTests.java index 80e02d1e9..9911374f7 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceNoWebEnvironmentTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceNoWebEnvironmentTests.java @@ -47,8 +47,7 @@ public class TraceNoWebEnvironmentTests { client.createSomeTestRequest(); } catch (Exception e) { - then(e.getCause().getClass()) - .isNotEqualTo(NoSuchBeanDefinitionException.class); + then(e.getCause().getClass()).isNotEqualTo(NoSuchBeanDefinitionException.class); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceRestTemplateInterceptorTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceRestTemplateInterceptorTests.java index eff1ef95e..2a8996f59 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceRestTemplateInterceptorTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceRestTemplateInterceptorTests.java @@ -58,18 +58,16 @@ public class TraceRestTemplateInterceptorTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .build(); Tracer tracer = this.tracing.tracer(); private TestController testController = new TestController(); - private MockMvc mockMvc = MockMvcBuilders.standaloneSetup(this.testController) - .build(); + private MockMvc mockMvc = MockMvcBuilders.standaloneSetup(this.testController).build(); - private RestTemplate template = new RestTemplate( - new MockMvcClientHttpRequestFactory(this.mockMvc)); + private RestTemplate template = new RestTemplate(new MockMvcClientHttpRequestFactory(this.mockMvc)); @BeforeEach public void setup() { @@ -77,8 +75,8 @@ public class TraceRestTemplateInterceptorTests { } private void setInterceptors(HttpTracing httpTracing) { - this.template.setInterceptors(Arrays.asList( - TracingClientHttpRequestInterceptor.create(httpTracing))); + this.template.setInterceptors( + Arrays.asList(TracingClientHttpRequestInterceptor.create(httpTracing))); } @AfterEach @@ -90,8 +88,7 @@ public class TraceRestTemplateInterceptorTests { @Test public void headersAddedWhenNoTracingWasPresent() { @SuppressWarnings("unchecked") - Map headers = this.template.getForEntity("/", Map.class) - .getBody(); + Map headers = this.template.getForEntity("/", Map.class).getBody(); // Default inject format for client spans is B3 multi then(headers.get("X-B3-TraceId")).isNotNull(); @@ -119,11 +116,10 @@ public class TraceRestTemplateInterceptorTests { // Issue #290 @Test public void requestHeadersAddedWhenTracing() { - setInterceptors(HttpTracing.newBuilder(this.tracing) - .clientRequestParser((request, context, span) -> { - HttpTags.URL.tag(request, context, span); - HttpRequestParser.DEFAULT.parse(request, context, span); - }).build()); + setInterceptors(HttpTracing.newBuilder(this.tracing).clientRequestParser((request, context, span) -> { + HttpTags.URL.tag(request, context, span); + HttpRequestParser.DEFAULT.parse(request, context, span); + }).build()); Span span = this.tracer.nextSpan().name("new trace"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { @@ -134,15 +130,15 @@ public class TraceRestTemplateInterceptorTests { } then(this.spans).isNotEmpty(); - then(this.spans.get(0).tags()).containsEntry("http.url", "/foo?a=b") - .containsEntry("http.path", "/foo").containsEntry("http.method", "GET"); + then(this.spans.get(0).tags()).containsEntry("http.url", "/foo?a=b").containsEntry("http.path", "/foo") + .containsEntry("http.method", "GET"); } @Test public void notSampledHeaderAddedWhenNotSampled() { this.tracing.close(); - this.tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).sampler(Sampler.NEVER_SAMPLE).build(); + this.tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .sampler(Sampler.NEVER_SAMPLE).build(); this.template.setInterceptors(Arrays.asList( TracingClientHttpRequestInterceptor.create(HttpTracing.create(tracing)))); @@ -180,8 +176,7 @@ public class TraceRestTemplateInterceptorTests { @Test public void createdSpanNameHasOnlyPrintableAsciiCharactersForNonEncodedURIWithNonAsciiChars() { - setInterceptors(HttpTracing.newBuilder(this.tracing) - .clientParser(new HttpClientParser()).build()); + setInterceptors(HttpTracing.newBuilder(this.tracing).clientParser(new HttpClientParser()).build()); Span span = this.tracer.nextSpan().name("new trace"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { @@ -220,8 +215,7 @@ public class TraceRestTemplateInterceptorTests { throw new RuntimeException("foo"); } - private void addHeaders(Map map, HttpHeaders headers, - String... names) { + private void addHeaders(Map map, HttpHeaders headers, String... names) { if (headers != null) { for (String name : names) { String value = headers.getFirst(name); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebClientDisabledTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebClientDisabledTests.java index 0286bbb74..9a4d09995 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebClientDisabledTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebClientDisabledTests.java @@ -25,8 +25,8 @@ import org.springframework.context.annotation.Configuration; /** * @author Marcin Grzejszczak */ -@SpringBootTest(classes = { TraceWebClientDisabledTests.Config.class }, properties = { - "spring.sleuth.web.enabled=true", "spring.sleuth.web.client.enabled=false" }) +@SpringBootTest(classes = { TraceWebClientDisabledTests.Config.class }, + properties = { "spring.sleuth.web.enabled=true", "spring.sleuth.web.client.enabled=false" }) public class TraceWebClientDisabledTests { @Test diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/GH846Tests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/GH846Tests.java index cb320bc42..aeba98dba 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/GH846Tests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/GH846Tests.java @@ -41,8 +41,7 @@ public class GH846Tests { public void doit() throws Exception { int count = this.myBean.listAndCount(); assertThat(this.myBean.getCountAtPostConstruct()) - .as("Change detected in RestTemplate interceptor *after* @PostConstruct") - .isEqualTo(count); + .as("Change detected in RestTemplate interceptor *after* @PostConstruct").isEqualTo(count); } @EnableAutoConfiguration @@ -77,8 +76,7 @@ public class GH846Tests { } public int listAndCount() { - for (ClientHttpRequestInterceptor interceptor : this.restTemplate - .getInterceptors()) { + for (ClientHttpRequestInterceptor interceptor : this.restTemplate.getInterceptors()) { System.out.println(interceptor); } return this.restTemplate.getInterceptors().size(); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/HttpClientBeanPostProcessorTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/HttpClientBeanPostProcessorTest.java index 944795599..80cff31a9 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/HttpClientBeanPostProcessorTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/HttpClientBeanPostProcessorTest.java @@ -45,8 +45,7 @@ public class HttpClientBeanPostProcessorTest { @Mock Bootstrap bootstrap; - TraceContext traceContext = TraceContext.newBuilder().traceId(1).spanId(2) - .sampled(true).build(); + TraceContext traceContext = TraceContext.newBuilder().traceId(1).spanId(2).sampled(true).build(); @BeforeEach public void setup() { @@ -63,10 +62,8 @@ public class HttpClientBeanPostProcessorTest { .handle(new BiConsumer>() { @Override public void accept(Connection t, SynchronousSink ctx) { - assertThat(ctx.currentContext().get(TraceContext.class)) - .isSameAs(traceContext); - assertThat(ctx.currentContext().get(PendingSpan.class)) - .isNotNull(); + assertThat(ctx.currentContext().get(TraceContext.class)).isSameAs(traceContext); + assertThat(ctx.currentContext().get(PendingSpan.class)).isNotNull(); } }); @@ -82,10 +79,8 @@ public class HttpClientBeanPostProcessorTest { .handle(new BiConsumer>() { @Override public void accept(Connection t, SynchronousSink ctx) { - assertThat(ctx.currentContext().getOrEmpty(TraceContext.class)) - .isEmpty(); - assertThat(ctx.currentContext().get(PendingSpan.class)) - .isNotNull(); + assertThat(ctx.currentContext().getOrEmpty(TraceContext.class)).isEmpty(); + assertThat(ctx.currentContext().get(PendingSpan.class)).isNotNull(); } }); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/MultipleAsyncRestTemplateTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/MultipleAsyncRestTemplateTests.java index a478f282b..d60ab0c56 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/MultipleAsyncRestTemplateTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/MultipleAsyncRestTemplateTests.java @@ -71,8 +71,7 @@ import static org.assertj.core.api.BDDAssertions.then; @DirtiesContext public class MultipleAsyncRestTemplateTests { - private static final Log log = LogFactory - .getLog(MultipleAsyncRestTemplateTests.class); + private static final Log log = LogFactory.getLog(MultipleAsyncRestTemplateTests.class); @Autowired @Qualifier("customAsyncRestTemplate") @@ -103,8 +102,7 @@ public class MultipleAsyncRestTemplateTests { public void should_pass_tracing_context_with_custom_async_client() throws Exception { Span span = this.tracer.nextSpan().name("foo"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { - String result = this.asyncRestTemplate - .getForEntity("http://localhost:" + this.port + "/foo", String.class) + String result = this.asyncRestTemplate.getForEntity("http://localhost:" + this.port + "/foo", String.class) .get().getBody(); then(span.context().traceIdString()).isEqualTo(result); } @@ -124,8 +122,7 @@ public class MultipleAsyncRestTemplateTests { } @Test - public void should_inject_traced_executor_that_passes_tracing_context() - throws Exception { + public void should_inject_traced_executor_that_passes_tracing_context() throws Exception { Span span = this.tracer.nextSpan().name("foo"); AtomicBoolean executed = new AtomicBoolean(false); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { @@ -135,8 +132,8 @@ public class MultipleAsyncRestTemplateTests { then(currentSpan).isNotNull(); long currentTraceId = currentSpan.context().traceId(); long initialTraceId = span.context().traceId(); - log.info("Hello from runnable before trace id check. Initial [" - + initialTraceId + "] current [" + currentTraceId + "]"); + log.info("Hello from runnable before trace id check. Initial [" + initialTraceId + "] current [" + + currentTraceId + "]"); then(currentTraceId).isEqualTo(initialTraceId); executed.set(true); log.info("Hello from runnable"); @@ -159,8 +156,7 @@ public class MultipleAsyncRestTemplateTests { @Bean(name = "customAsyncRestTemplate") public AsyncRestTemplate traceAsyncRestTemplate() { - return new AsyncRestTemplate(asyncClientFactory(), - clientHttpRequestFactory()); + return new AsyncRestTemplate(asyncClientFactory(), clientHttpRequestFactory()); } private ClientHttpRequestFactory clientHttpRequestFactory() { @@ -227,8 +223,7 @@ class CustomClientHttpRequestFactory implements ClientHttpRequestFactory { private final SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory(); @Override - public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) - throws IOException { + public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException { return this.factory.createRequest(uri, httpMethod); } @@ -243,8 +238,7 @@ class CustomAsyncClientHttpRequestFactory implements AsyncClientHttpRequestFacto } @Override - public AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod httpMethod) - throws IOException { + public AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod httpMethod) throws IOException { return this.factory.createAsyncRequest(uri, httpMethod); } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ReactorNettyHttpClientSpringBootTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ReactorNettyHttpClientSpringBootTests.java index 657732555..7d7f158fb 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ReactorNettyHttpClientSpringBootTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ReactorNettyHttpClientSpringBootTests.java @@ -72,8 +72,7 @@ public class ReactorNettyHttpClientSpringBootTests { @Autowired CurrentTraceContext currentTraceContext; - TraceContext context = TraceContext.newBuilder().traceId(1).spanId(1).sampled(true) - .build(); + TraceContext context = TraceContext.newBuilder().traceId(1).spanId(1).sampled(true).build(); @AfterEach public void tearDown() { @@ -84,11 +83,9 @@ public class ReactorNettyHttpClientSpringBootTests { @Test public void shouldRecordRemoteEndpoint() throws Exception { - disposableServer = HttpServer.create().port(0) - .handle((in, out) -> out.sendString(Flux.just("foo"))).bindNow(); + disposableServer = HttpServer.create().port(0).handle((in, out) -> out.sendString(Flux.just("foo"))).bindNow(); - HttpClientResponse response = httpClient.port(disposableServer.port()).get() - .uri("/").response().block(); + HttpClientResponse response = httpClient.port(disposableServer.port()).get().uri("/").response().block(); assertThat(response.status()).isEqualTo(HttpResponseStatus.OK); @@ -102,39 +99,34 @@ public class ReactorNettyHttpClientSpringBootTests { public void shouldUseInvocationContext() throws Exception { disposableServer = HttpServer.create().port(0) // this reads the trace context header, b3, returning it in the response - .handle((in, out) -> out - .sendString(Flux.just(in.requestHeaders().get("b3")))) - .bindNow(); + .handle((in, out) -> out.sendString(Flux.just(in.requestHeaders().get("b3")))).bindNow(); String b3SingleHeaderReadByServer; try (Scope ws = currentTraceContext.newScope(context)) { - b3SingleHeaderReadByServer = httpClient.port(disposableServer.port()).get() - .uri("/").responseContent().aggregate().asString().block(); + b3SingleHeaderReadByServer = httpClient.port(disposableServer.port()).get().uri("/").responseContent() + .aggregate().asString().block(); } MutableSpan clientSpan = spanHandler.takeRemoteSpan(CLIENT); - assertThat(b3SingleHeaderReadByServer).isEqualTo(context.traceIdString() + "-" - + clientSpan.id() + "-1-" + context.spanIdString()); + assertThat(b3SingleHeaderReadByServer) + .isEqualTo(context.traceIdString() + "-" + clientSpan.id() + "-1-" + context.spanIdString()); } @Test public void shouldSendTraceContextToServer_rootSpan() throws Exception { disposableServer = HttpServer.create().port(0) // this reads the trace context header, b3, returning it in the response - .handle((in, out) -> out - .sendString(Flux.just(in.requestHeaders().get("b3")))) - .bindNow(); + .handle((in, out) -> out.sendString(Flux.just(in.requestHeaders().get("b3")))).bindNow(); - Mono request = httpClient.port(disposableServer.port()).get().uri("/") - .responseContent().aggregate().asString(); + Mono request = httpClient.port(disposableServer.port()).get().uri("/").responseContent().aggregate() + .asString(); String b3SingleHeaderReadByServer = request.block(); MutableSpan clientSpan = spanHandler.takeRemoteSpan(CLIENT); - assertThat(b3SingleHeaderReadByServer) - .isEqualTo(clientSpan.traceId() + "-" + clientSpan.id() + "-1"); + assertThat(b3SingleHeaderReadByServer).isEqualTo(clientSpan.traceId() + "-" + clientSpan.id() + "-1"); } @Test @@ -143,11 +135,10 @@ public class ReactorNettyHttpClientSpringBootTests { throw new RuntimeException("test"); }).bindNow(); - Mono request = httpClient.port(disposableServer.port()).get().uri("/") - .responseContent().aggregate().asString(); + Mono request = httpClient.port(disposableServer.port()).get().uri("/").responseContent().aggregate() + .asString(); - assertThatThrownBy(request::block) - .hasCauseInstanceOf(PrematureCloseException.class); + assertThatThrownBy(request::block).hasCauseInstanceOf(PrematureCloseException.class); spanHandler.takeRemoteSpanWithError(CLIENT); } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRequestHttpHeadersFilterTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRequestHttpHeadersFilterTests.java index bb30f4b79..692b09683 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRequestHttpHeadersFilterTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRequestHttpHeadersFilterTests.java @@ -39,8 +39,8 @@ public class TraceRequestHttpHeadersFilterTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .build(); HttpTracing httpTracing = HttpTracing.newBuilder(this.tracing).build(); @@ -57,28 +57,20 @@ public class TraceRequestHttpHeadersFilterTests { httpHeaders.set("X-Hello", "World"); httpHeaders.set("X-B3-TraceId", "52f112af7472aff0"); httpHeaders.set("X-B3-SpanId", "53e6ab6fc5dfee58"); - MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar") - .headers(httpHeaders).build(); + MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar").headers(httpHeaders).build(); MockServerWebExchange exchange = MockServerWebExchange.builder(request).build(); - HttpHeaders filteredHeaders = filter.filter(requestHeaders(httpHeaders), - exchange); + HttpHeaders filteredHeaders = filter.filter(requestHeaders(httpHeaders), exchange); // we want to continue the trace - BDDAssertions.then(filteredHeaders.get("X-B3-TraceId")) - .isEqualTo(httpHeaders.get("X-B3-TraceId")); + BDDAssertions.then(filteredHeaders.get("X-B3-TraceId")).isEqualTo(httpHeaders.get("X-B3-TraceId")); // but we want to have a new span id - BDDAssertions.then(filteredHeaders.get("X-B3-SpanId")) - .isNotEqualTo(httpHeaders.get("X-B3-SpanId")); - BDDAssertions.then(filteredHeaders.get("X-Hello")) - .isEqualTo(Collections.singletonList("World")); + BDDAssertions.then(filteredHeaders.get("X-B3-SpanId")).isNotEqualTo(httpHeaders.get("X-B3-SpanId")); + BDDAssertions.then(filteredHeaders.get("X-Hello")).isEqualTo(Collections.singletonList("World")); BDDAssertions.then(filteredHeaders.get("X-Hello-Request")) .isEqualTo(Collections.singletonList("Request World")); BDDAssertions.then(filteredHeaders.get("X-Auth-User")).hasSize(1); - BDDAssertions - .then((Object) exchange - .getAttribute(TraceRequestHttpHeadersFilter.SPAN_ATTRIBUTE)) - .isNotNull(); + BDDAssertions.then((Object) exchange.getAttribute(TraceRequestHttpHeadersFilter.SPAN_ATTRIBUTE)).isNotNull(); } @Test @@ -87,12 +79,10 @@ public class TraceRequestHttpHeadersFilterTests { HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.set("X-Hello", "World"); httpHeaders.set("B3", "1111111111111111-1111111111111111"); - MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar") - .headers(httpHeaders).build(); + MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar").headers(httpHeaders).build(); MockServerWebExchange exchange = MockServerWebExchange.builder(request).build(); - HttpHeaders filteredHeaders = filter.filter(requestHeaders(httpHeaders), - exchange); + HttpHeaders filteredHeaders = filter.filter(requestHeaders(httpHeaders), exchange); // we want to continue the trace BDDAssertions.then(filteredHeaders.get("X-B3-TraceId")) @@ -102,15 +92,11 @@ public class TraceRequestHttpHeadersFilterTests { .isNotEqualTo(Collections.singletonList("1111111111111111")); // we don't want to propagate b3 BDDAssertions.then(filteredHeaders.get("B3")).isNullOrEmpty(); - BDDAssertions.then(filteredHeaders.get("X-Hello")) - .isEqualTo(Collections.singletonList("World")); + BDDAssertions.then(filteredHeaders.get("X-Hello")).isEqualTo(Collections.singletonList("World")); BDDAssertions.then(filteredHeaders.get("X-Hello-Request")) .isEqualTo(Collections.singletonList("Request World")); BDDAssertions.then(filteredHeaders.get("X-Auth-User")).hasSize(1); - BDDAssertions - .then((Object) exchange - .getAttribute(TraceRequestHttpHeadersFilter.SPAN_ATTRIBUTE)) - .isNotNull(); + BDDAssertions.then((Object) exchange.getAttribute(TraceRequestHttpHeadersFilter.SPAN_ATTRIBUTE)).isNotNull(); } @Test @@ -118,23 +104,17 @@ public class TraceRequestHttpHeadersFilterTests { HttpHeadersFilter filter = TraceRequestHttpHeadersFilter.create(this.httpTracing); HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.set("X-Hello", "World"); - MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar") - .headers(httpHeaders).build(); + MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar").headers(httpHeaders).build(); MockServerWebExchange exchange = MockServerWebExchange.builder(request).build(); - HttpHeaders filteredHeaders = filter.filter(requestHeaders(httpHeaders), - exchange); + HttpHeaders filteredHeaders = filter.filter(requestHeaders(httpHeaders), exchange); BDDAssertions.then(filteredHeaders.get("X-B3-TraceId")).isNotEmpty(); BDDAssertions.then(filteredHeaders.get("X-B3-SpanId")).isNotEmpty(); - BDDAssertions.then(filteredHeaders.get("X-Hello")) - .isEqualTo(Collections.singletonList("World")); + BDDAssertions.then(filteredHeaders.get("X-Hello")).isEqualTo(Collections.singletonList("World")); BDDAssertions.then(filteredHeaders.get("X-Hello-Request")) .isEqualTo(Collections.singletonList("Request World")); - BDDAssertions - .then((Object) exchange - .getAttribute(TraceRequestHttpHeadersFilter.SPAN_ATTRIBUTE)) - .isNotNull(); + BDDAssertions.then((Object) exchange.getAttribute(TraceRequestHttpHeadersFilter.SPAN_ATTRIBUTE)).isNotNull(); } // #1469 @@ -143,8 +123,7 @@ public class TraceRequestHttpHeadersFilterTests { HttpHeadersFilter filter = TraceRequestHttpHeadersFilter.create(this.httpTracing); HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.set("X-Hello", "World"); - MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar") - .headers(httpHeaders).build(); + MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar").headers(httpHeaders).build(); MockServerWebExchange exchange = MockServerWebExchange.builder(request).build(); HttpHeaders filteredHeaders = filter.filter(requestHeaders(), exchange); @@ -152,10 +131,7 @@ public class TraceRequestHttpHeadersFilterTests { BDDAssertions.then(filteredHeaders.get("X-B3-TraceId")).isNotEmpty(); BDDAssertions.then(filteredHeaders.get("X-B3-SpanId")).isNotEmpty(); BDDAssertions.then(filteredHeaders.get("X-Hello")).isNullOrEmpty(); - BDDAssertions - .then((Object) exchange - .getAttribute(TraceRequestHttpHeadersFilter.SPAN_ATTRIBUTE)) - .isNotNull(); + BDDAssertions.then((Object) exchange.getAttribute(TraceRequestHttpHeadersFilter.SPAN_ATTRIBUTE)).isNotNull(); } // #1352 @@ -165,22 +141,17 @@ public class TraceRequestHttpHeadersFilterTests { HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.add("X-Hello-Request", "Request World"); httpHeaders.addAll("X-Hello", Arrays.asList("World1", "World2")); - MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar") - .headers(httpHeaders).build(); + MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar").headers(httpHeaders).build(); MockServerWebExchange exchange = MockServerWebExchange.builder(request).build(); HttpHeaders filteredHeaders = filter.filter(httpHeaders, exchange); BDDAssertions.then(filteredHeaders.get("X-B3-TraceId")).isNotEmpty(); BDDAssertions.then(filteredHeaders.get("X-B3-SpanId")).isNotEmpty(); - BDDAssertions.then(filteredHeaders.get("X-Hello")) - .isEqualTo(Arrays.asList("World1", "World2")); + BDDAssertions.then(filteredHeaders.get("X-Hello")).isEqualTo(Arrays.asList("World1", "World2")); BDDAssertions.then(filteredHeaders.get("X-Hello-Request")) .isEqualTo(Collections.singletonList("Request World")); - BDDAssertions - .then((Object) exchange - .getAttribute(TraceRequestHttpHeadersFilter.SPAN_ATTRIBUTE)) - .isNotNull(); + BDDAssertions.then((Object) exchange.getAttribute(TraceRequestHttpHeadersFilter.SPAN_ATTRIBUTE)).isNotNull(); } private HttpHeaders requestHeaders() { diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceResponseHttpHeadersFilterTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceResponseHttpHeadersFilterTests.java index 9eaf6a263..bd7a97852 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceResponseHttpHeadersFilterTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceResponseHttpHeadersFilterTests.java @@ -35,8 +35,8 @@ public class TraceResponseHttpHeadersFilterTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .build(); HttpTracing httpTracing = HttpTracing.newBuilder(this.tracing).build(); @@ -48,12 +48,10 @@ public class TraceResponseHttpHeadersFilterTests { @Test public void should_not_report_span_when_no_span_was_present_in_attribute() { - HttpHeadersFilter filter = TraceResponseHttpHeadersFilter - .create(this.httpTracing); + HttpHeadersFilter filter = TraceResponseHttpHeadersFilter.create(this.httpTracing); HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.set("b3", "52f112af7472aff0-53e6ab6fc5dfee58"); - MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar") - .headers(httpHeaders).build(); + MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar").headers(httpHeaders).build(); MockServerWebExchange exchange = MockServerWebExchange.builder(request).build(); filter.filter(httpHeaders, exchange); @@ -63,15 +61,12 @@ public class TraceResponseHttpHeadersFilterTests { @Test public void should_report_span_when_span_was_present_in_attribute() { - HttpHeadersFilter filter = TraceResponseHttpHeadersFilter - .create(this.httpTracing); + HttpHeadersFilter filter = TraceResponseHttpHeadersFilter.create(this.httpTracing); HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.set("b3", "52f112af7472aff0-53e6ab6fc5dfee58"); - MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar") - .headers(httpHeaders).build(); + MockServerHttpRequest request = MockServerHttpRequest.post("foo/bar").headers(httpHeaders).build(); MockServerWebExchange exchange = MockServerWebExchange.builder(request).build(); - exchange.getAttributes().put(TraceResponseHttpHeadersFilter.SPAN_ATTRIBUTE, - this.tracing.tracer().nextSpan()); + exchange.getAttributes().put(TraceResponseHttpHeadersFilter.SPAN_ATTRIBUTE, this.tracing.tracer().nextSpan()); filter.filter(httpHeaders, exchange); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRestTemplateInterceptorIntegrationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRestTemplateInterceptorIntegrationTests.java index 649b0b695..018c658bb 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRestTemplateInterceptorIntegrationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceRestTemplateInterceptorIntegrationTests.java @@ -64,8 +64,8 @@ public class TraceRestTemplateInterceptorIntegrationTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .build(); Tracer tracer = this.tracing.tracer(); @@ -73,9 +73,8 @@ public class TraceRestTemplateInterceptorIntegrationTests { @BeforeEach public void setup() { - this.template.setInterceptors(Arrays - .asList(TracingClientHttpRequestInterceptor - .create(HttpTracing.create(this.tracing)))); + this.template.setInterceptors(Arrays.asList( + TracingClientHttpRequestInterceptor.create(HttpTracing.create(this.tracing)))); } @AfterEach @@ -87,14 +86,12 @@ public class TraceRestTemplateInterceptorIntegrationTests { // Issue #198 @Test public void spanRemovedFromThreadUponException() throws IOException { - this.mockWebServer.enqueue( - new MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AT_START)); + this.mockWebServer.enqueue(new MockResponse().setSocketPolicy(SocketPolicy.DISCONNECT_AT_START)); Span span = this.tracer.nextSpan().name("new trace"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { - this.template.getForEntity( - "http://localhost:" + this.mockWebServer.getPort() + "/exception", - Map.class).getBody(); + this.template.getForEntity("http://localhost:" + this.mockWebServer.getPort() + "/exception", Map.class) + .getBody(); fail("should throw an exception"); } catch (RuntimeException e) { diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientAutoConfigurationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientAutoConfigurationTests.java index dd4c168e5..be59a3afa 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientAutoConfigurationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientAutoConfigurationTests.java @@ -66,16 +66,14 @@ public class TraceWebClientAutoConfigurationTests { assertInterceptorsOrder(assertInterceptorsNotEmpty(this.builder.build())); } - private List assertInterceptorsNotEmpty( - RestTemplate restTemplate) { + private List assertInterceptorsNotEmpty(RestTemplate restTemplate) { then(restTemplate).isNotNull(); List interceptors = restTemplate.getInterceptors(); then(interceptors).isNotEmpty(); return interceptors; } - private void assertInterceptorsOrder( - List interceptors) { + private void assertInterceptorsOrder(List interceptors) { int traceInterceptorIndex = -1; int myInterceptorIndex = -1; int mySecondInterceptorIndex = -1; @@ -94,10 +92,9 @@ public class TraceWebClientAutoConfigurationTests { mySecondInterceptorIndex = i; } } - then(traceInterceptorIndex).isGreaterThanOrEqualTo(0) - .isLessThan(myInterceptorIndex).isLessThan(mySecondInterceptorIndex); - then(numberOfInstances.values()) - .as("Can't have duplicate entries for interceptors") + then(traceInterceptorIndex).isGreaterThanOrEqualTo(0).isLessThan(myInterceptorIndex) + .isLessThan(mySecondInterceptorIndex); + then(numberOfInstances.values()).as("Can't have duplicate entries for interceptors") .containsOnlyElementsOf(Collections.singletonList(1)); } @@ -118,8 +115,7 @@ public class TraceWebClientAutoConfigurationTests { // custom builder @Bean - RestTemplateBuilder myRestTemplateBuilder( - List customizers) { + RestTemplateBuilder myRestTemplateBuilder(List customizers) { return new RestTemplateBuilder().additionalCustomizers(customizers) .additionalInterceptors(new MyClientHttpRequestInterceptor()); } @@ -136,9 +132,8 @@ public class TraceWebClientAutoConfigurationTests { @Qualifier("secondRestTemplate") RestTemplate secondRestTemplate() { RestTemplate restTemplate = new RestTemplate(); - restTemplate - .setInterceptors(Arrays.asList(new MyClientHttpRequestInterceptor(), - new MySecondClientHttpRequestInterceptor())); + restTemplate.setInterceptors( + Arrays.asList(new MyClientHttpRequestInterceptor(), new MySecondClientHttpRequestInterceptor())); return restTemplate; } @@ -146,8 +141,7 @@ public class TraceWebClientAutoConfigurationTests { @Bean RestTemplateCustomizer myRestTemplateCustomizer() { return restTemplate -> { - restTemplate.getInterceptors().add(0, - new MySecondClientHttpRequestInterceptor()); + restTemplate.getInterceptors().add(0, new MySecondClientHttpRequestInterceptor()); }; } @@ -158,8 +152,8 @@ public class TraceWebClientAutoConfigurationTests { class MyClientHttpRequestInterceptor implements ClientHttpRequestInterceptor { @Override - public ClientHttpResponse intercept(HttpRequest request, byte[] body, - ClientHttpRequestExecution execution) throws IOException { + public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) + throws IOException { return execution.execute(request, body); } @@ -168,8 +162,8 @@ class MyClientHttpRequestInterceptor implements ClientHttpRequestInterceptor { class MySecondClientHttpRequestInterceptor implements ClientHttpRequestInterceptor { @Override - public ClientHttpResponse intercept(HttpRequest request, byte[] body, - ClientHttpRequestExecution execution) throws IOException { + public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) + throws IOException { return execution.execute(request, body); } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientBeanPostProcessorTest.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientBeanPostProcessorTest.java index 8c17e63d0..dd680f31e 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientBeanPostProcessorTest.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebClientBeanPostProcessorTest.java @@ -50,8 +50,7 @@ public class TraceWebClientBeanPostProcessorTest { @Test void should_add_filter_only_once_to_web_client() { - TraceWebClientBeanPostProcessor processor = new TraceWebClientBeanPostProcessor( - this.springContext); + TraceWebClientBeanPostProcessor processor = new TraceWebClientBeanPostProcessor(this.springContext); WebClient client = WebClient.create(); client = (WebClient) processor.postProcessAfterInitialization(client, "foo"); @@ -59,33 +58,28 @@ public class TraceWebClientBeanPostProcessorTest { client.mutate().filters(filters -> { BDDAssertions.then(filters).hasSize(1); - BDDAssertions.then(filters.get(0)) - .isInstanceOf(TraceExchangeFilterFunction.class); + BDDAssertions.then(filters.get(0)).isInstanceOf(TraceExchangeFilterFunction.class); }); } @Test void should_add_filter_only_once_to_web_client_via_builder() { - TraceWebClientBeanPostProcessor processor = new TraceWebClientBeanPostProcessor( - this.springContext); + TraceWebClientBeanPostProcessor processor = new TraceWebClientBeanPostProcessor(this.springContext); WebClient.Builder builder = WebClient.builder(); - builder = (WebClient.Builder) processor.postProcessAfterInitialization(builder, - "foo"); - builder = (WebClient.Builder) processor.postProcessAfterInitialization(builder, - "foo"); + builder = (WebClient.Builder) processor.postProcessAfterInitialization(builder, "foo"); + builder = (WebClient.Builder) processor.postProcessAfterInitialization(builder, "foo"); builder.build().mutate().filters(filters -> { BDDAssertions.then(filters).hasSize(1); - BDDAssertions.then(filters.get(0)) - .isInstanceOf(TraceExchangeFilterFunction.class); + BDDAssertions.then(filters.get(0)).isInstanceOf(TraceExchangeFilterFunction.class); }); } @Test void should_close_span_on_cancel() { - TraceWebClientSubscription traceSubscription = new TraceWebClientSubscription( - subscription, new AtomicReference<>(span)); + TraceWebClientSubscription traceSubscription = new TraceWebClientSubscription(subscription, + new AtomicReference<>(span)); traceSubscription.request(1); traceSubscription.cancel(); @@ -99,8 +93,8 @@ public class TraceWebClientBeanPostProcessorTest { @Test void should_not_crash_on_cancel_when_span_clear() { - TraceWebClientSubscription traceSubscription = new TraceWebClientSubscription( - subscription, new AtomicReference<>()); + TraceWebClientSubscription traceSubscription = new TraceWebClientSubscription(subscription, + new AtomicReference<>()); traceSubscription.request(1); traceSubscription.cancel(); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/discoveryexception/WebClientDiscoveryExceptionTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/discoveryexception/WebClientDiscoveryExceptionTests.java index 215089051..068b53065 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/discoveryexception/WebClientDiscoveryExceptionTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/discoveryexception/WebClientDiscoveryExceptionTests.java @@ -55,8 +55,7 @@ import org.springframework.web.client.RestTemplate; import static org.assertj.core.api.BDDAssertions.then; import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT; -@SpringBootTest(classes = { WebClientDiscoveryExceptionTests.TestConfiguration.class }, - webEnvironment = RANDOM_PORT) +@SpringBootTest(classes = { WebClientDiscoveryExceptionTests.TestConfiguration.class }, webEnvironment = RANDOM_PORT) @TestPropertySource(properties = { "spring.application.name=exceptionservice" }) @DirtiesContext public class WebClientDiscoveryExceptionTests { @@ -96,15 +95,14 @@ public class WebClientDiscoveryExceptionTests { // hystrix commands should finish at this point Thread.sleep(200); - then(this.spans.spans().stream().filter(span1 -> span1.kind() == Span.Kind.CLIENT) - .findFirst().get().error()).isNotNull(); + then(this.spans.spans().stream().filter(span1 -> span1.kind() == Span.Kind.CLIENT).findFirst().get().error()) + .isNotNull(); } @Test public void testFeignInterfaceWithException() throws Exception { shouldCloseSpanUponException( - (ResponseEntityProvider) (tests) -> tests.testFeignInterfaceWithException - .shouldFailToConnect()); + (ResponseEntityProvider) (tests) -> tests.testFeignInterfaceWithException.shouldFailToConnect()); } @Test diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/exception/WebClientExceptionTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/exception/WebClientExceptionTests.java index 267e26e1e..c009db210 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/exception/WebClientExceptionTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/exception/WebClientExceptionTests.java @@ -80,8 +80,7 @@ public class WebClientExceptionTests { // issue #198 @ParameterizedTest @MethodSource("parametersForShouldCloseSpanUponException") - public void shouldCloseSpanUponException(ResponseEntityProvider provider) - throws IOException { + public void shouldCloseSpanUponException(ResponseEntityProvider provider) throws IOException { Span span = this.tracer.tracer().nextSpan().name("new trace").start(); try (Tracer.SpanInScope ws = this.tracer.tracer().withSpanInScope(span)) { @@ -103,10 +102,9 @@ public class WebClientExceptionTests { static Stream parametersForShouldCloseSpanUponException() { return Stream.of( - (ResponseEntityProvider) (tests) -> tests.testFeignInterfaceWithException - .shouldFailToConnect(), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("https://exceptionservice/", Map.class)); + (ResponseEntityProvider) (tests) -> tests.testFeignInterfaceWithException.shouldFailToConnect(), + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("https://exceptionservice/", + Map.class)); } @FeignClient("exceptionservice") @@ -158,8 +156,7 @@ public class WebClientExceptionTests { @Bean public ServiceInstanceListSupplier serviceInstanceListSupplier(Environment env) { return ServiceInstanceListSupplier.fixed(env) - .instance("invalid.host.to.break.tests", 1234, "exceptionservice") - .build(); + .instance("invalid.host.to.break.tests", 1234, "exceptionservice").build(); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/FeignRetriesTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/FeignRetriesTests.java index d85124d8f..40e627ec7 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/FeignRetriesTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/FeignRetriesTests.java @@ -72,16 +72,15 @@ public class FeignRetriesTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .build(); HttpTracing httpTracing = HttpTracing.newBuilder(this.tracing).build(); @BeforeEach @AfterEach public void setup() { - BDDMockito.given(this.beanFactory.getBean(HttpTracing.class)) - .willReturn(this.httpTracing); + BDDMockito.given(this.beanFactory.getBean(HttpTracing.class)).willReturn(this.httpTracing); } @AfterEach @@ -97,8 +96,7 @@ public class FeignRetriesTests { }; String url = "http://localhost:" + this.server.getPort(); - TestInterface api = Feign.builder() - .client(new TracingFeignClient(this.httpTracing, client)) + TestInterface api = Feign.builder().client(new TracingFeignClient(this.httpTracing, client)) .target(TestInterface.class, url); try { @@ -121,19 +119,16 @@ public class FeignRetriesTests { } else { // with the second retry (first retry) we send back good result - return Response.builder().status(200).reason("OK") - .headers(new HashMap<>()).body("OK", Charset.defaultCharset()) - .request(Request.create(Request.HttpMethod.POST, "/foo", - new HashMap<>(), Request.Body.empty(), - new RequestTemplate())) + return Response.builder().status(200).reason("OK").headers(new HashMap<>()) + .body("OK", Charset.defaultCharset()).request(Request.create(Request.HttpMethod.POST, "/foo", + new HashMap<>(), Request.Body.empty(), new RequestTemplate())) .build(); } }; - TestInterface api = Feign.builder() - .client(new TracingFeignClient(this.httpTracing, (request, options) -> { - atomicInteger.incrementAndGet(); - return client.execute(request, options); - })).target(TestInterface.class, url); + TestInterface api = Feign.builder().client(new TracingFeignClient(this.httpTracing, (request, options) -> { + atomicInteger.incrementAndGet(); + return client.execute(request, options); + })).target(TestInterface.class, url); then(api.decodedPost()).isEqualTo("OK"); // request interception should take place only twice (1st request & 2nd retry) diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignAspectTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignAspectTests.java index f4406c0f2..4714b80ba 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignAspectTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TraceFeignAspectTests.java @@ -51,8 +51,7 @@ public class TraceFeignAspectTests { StrictCurrentTraceContext currentTraceContext = StrictCurrentTraceContext.create(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(currentTraceContext) - .build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(currentTraceContext).build(); HttpTracing httpTracing = HttpTracing.newBuilder(this.tracing).build(); @@ -84,10 +83,8 @@ public class TraceFeignAspectTests { } @Test - public void should_not_wrap_traced_feign_client_in_trace_representation() - throws Throwable { - given(this.pjp.getTarget()) - .willReturn(new TracingFeignClient(this.httpTracing, this.client)); + public void should_not_wrap_traced_feign_client_in_trace_representation() throws Throwable { + given(this.pjp.getTarget()).willReturn(new TracingFeignClient(this.httpTracing, this.client)); this.traceFeignAspect.feignClientWasCalled(this.pjp); diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignClientTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignClientTests.java index 355f1cd4b..989e55504 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignClientTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignClientTests.java @@ -51,8 +51,8 @@ public class TracingFeignClientTests { RequestTemplate requestTemplate = new RequestTemplate(); - Request request = Request.create(Request.HttpMethod.GET, "https://foo", - new HashMap<>(), null, null, requestTemplate); + Request request = Request.create(Request.HttpMethod.GET, "https://foo", new HashMap<>(), null, null, + requestTemplate); Request.Options options = new Request.Options(); @@ -60,8 +60,7 @@ public class TracingFeignClientTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(currentTraceContext) - .addSpanHandler(spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(currentTraceContext).addSpanHandler(spans).build(); Tracer tracer = this.tracing.tracer(); @@ -101,8 +100,7 @@ public class TracingFeignClientTests { public void should_log_error_when_exception_thrown() throws IOException { RuntimeException error = new RuntimeException("exception has occurred"); Span span = this.tracer.nextSpan().name("foo"); - BDDMockito.given(this.client.execute(BDDMockito.any(), BDDMockito.any())) - .willThrow(error); + BDDMockito.given(this.client.execute(BDDMockito.any(), BDDMockito.any())).willThrow(error); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span.start())) { this.traceFeignClient.execute(this.request, this.options); @@ -120,15 +118,13 @@ public class TracingFeignClientTests { @Test public void keep_requestTemplate() throws IOException { - BDDMockito.given(this.client.execute(BDDMockito.any(), BDDMockito.any())) - .willAnswer(new Answer() { - public Object answer(InvocationOnMock invocation) { - Object[] args = invocation.getArguments(); - Assert.assertEquals(((Request) args[0]).requestTemplate(), - requestTemplate); - return null; - } - }); + BDDMockito.given(this.client.execute(BDDMockito.any(), BDDMockito.any())).willAnswer(new Answer() { + public Object answer(InvocationOnMock invocation) { + Object[] args = invocation.getArguments(); + Assert.assertEquals(((Request) args[0]).requestTemplate(), requestTemplate); + return null; + } + }); this.traceFeignClient.execute(this.request, this.options); } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignObjectWrapperTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignObjectWrapperTests.java index 6cd136e3d..d10a0eed2 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignObjectWrapperTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/feign/TracingFeignObjectWrapperTests.java @@ -47,25 +47,21 @@ public class TracingFeignObjectWrapperTests { @Test public void should_wrap_a_client_into_lazy_trace_client() { - then(this.traceFeignObjectWrapper.wrap(mock(Client.class))) - .isExactlyInstanceOf(LazyTracingFeignClient.class); + then(this.traceFeignObjectWrapper.wrap(mock(Client.class))).isExactlyInstanceOf(LazyTracingFeignClient.class); } @Test public void should_not_wrap_a_bean_that_is_not_feign_related() { String notFeignRelatedObject = "object"; - then(this.traceFeignObjectWrapper.wrap(notFeignRelatedObject)) - .isSameAs(notFeignRelatedObject); + then(this.traceFeignObjectWrapper.wrap(notFeignRelatedObject)).isSameAs(notFeignRelatedObject); } // gh-1528 @Test public void should_wrap_feign_loadbalancer_client() { Client delegate = mock(Client.class); - BlockingLoadBalancerClient loadBalancerClient = mock( - BlockingLoadBalancerClient.class); - when(beanFactory.getBean(LoadBalancerClient.class)) - .thenReturn(loadBalancerClient); + BlockingLoadBalancerClient loadBalancerClient = mock(BlockingLoadBalancerClient.class); + when(beanFactory.getBean(LoadBalancerClient.class)).thenReturn(loadBalancerClient); Object wrapped = traceFeignObjectWrapper .wrap(new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient)); @@ -77,23 +73,19 @@ public class TracingFeignObjectWrapperTests { @Test public void should_wrap_subclass_of_feign_loadbalancer_client() { Client delegate = mock(Client.class); - BlockingLoadBalancerClient loadBalancerClient = mock( - BlockingLoadBalancerClient.class); - when(beanFactory.getBean(LoadBalancerClient.class)) - .thenReturn(loadBalancerClient); + BlockingLoadBalancerClient loadBalancerClient = mock(BlockingLoadBalancerClient.class); + when(beanFactory.getBean(LoadBalancerClient.class)).thenReturn(loadBalancerClient); - Object wrapped = traceFeignObjectWrapper.wrap( - new TestFeignBlockingLoadBalancerClient(delegate, loadBalancerClient)); + Object wrapped = traceFeignObjectWrapper + .wrap(new TestFeignBlockingLoadBalancerClient(delegate, loadBalancerClient)); assertThat(wrapped).isInstanceOf(TraceFeignBlockingLoadBalancerClient.class); } - static class TestFeignBlockingLoadBalancerClient - extends FeignBlockingLoadBalancerClient { + static class TestFeignBlockingLoadBalancerClient extends FeignBlockingLoadBalancerClient { - TestFeignBlockingLoadBalancerClient(Client delegate, - BlockingLoadBalancerClient loadBalancerClient) { + TestFeignBlockingLoadBalancerClient(Client delegate, BlockingLoadBalancerClient loadBalancerClient) { super(delegate, loadBalancerClient); } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/integration/WebClientTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/integration/WebClientTests.java index 5d8de3b49..bab90ab7c 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/integration/WebClientTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/integration/WebClientTests.java @@ -99,8 +99,8 @@ import static org.assertj.core.api.BDDAssertions.then; @SpringBootTest(classes = WebClientTests.TestConfiguration.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) -@TestPropertySource(properties = { "spring.application.name=fooservice", - "spring.sleuth.web.client.skip-pattern=/skip.*" }) +@TestPropertySource( + properties = { "spring.application.name=fooservice", "spring.sleuth.web.client.skip-pattern=/skip.*" }) @DirtiesContext public class WebClientTests { @@ -157,20 +157,17 @@ public class WebClientTests { @ParameterizedTest @MethodSource("parametersForShouldCreateANewSpanWithClientSideTagsWhenNoPreviousTracingWasPresent") @SuppressWarnings("unchecked") - public void shouldCreateANewSpanWithClientSideTagsWhenNoPreviousTracingWasPresent( - ResponseEntityProvider provider) { + public void shouldCreateANewSpanWithClientSideTagsWhenNoPreviousTracingWasPresent(ResponseEntityProvider provider) { ResponseEntity response = provider.get(this); Awaitility.await().atMost(2, TimeUnit.SECONDS).untilAsserted(() -> { then(getHeader(response, "b3")).isNull(); then(this.spans).isNotEmpty(); - Optional noTraceSpan = this.spans.spans().stream() - .filter(span -> "GET".equals(span.name()) && !span.tags().isEmpty() - && span.tags().containsKey("http.path")) + Optional noTraceSpan = this.spans.spans().stream().filter( + span -> "GET".equals(span.name()) && !span.tags().isEmpty() && span.tags().containsKey("http.path")) .findFirst(); then(noTraceSpan.isPresent()).isTrue(); - then(noTraceSpan.get().tags()).containsEntry("http.path", "/notrace") - .containsEntry("http.method", "GET"); + then(noTraceSpan.get().tags()).containsEntry("http.path", "/notrace").containsEntry("http.method", "GET"); // TODO: matches cause there is an issue with Feign not providing the full URL // at the interceptor level then(noTraceSpan.get().tags().get("http.path")).matches(".*/notrace"); @@ -179,7 +176,7 @@ public class WebClientTests { } static Stream parametersForShouldCreateANewSpanWithClientSideTagsWhenNoPreviousTracingWasPresent() { - return Stream.of( + return Stream.of((ResponseEntityProvider) (tests) -> tests.testFeignInterface.getNoTrace(), (ResponseEntityProvider) (tests) -> tests.testFeignInterface.getNoTrace(), (ResponseEntityProvider) (tests) -> tests.testFeignInterface.getNoTrace(), (ResponseEntityProvider) (tests) -> tests.testFeignInterface.getNoTrace(), @@ -187,32 +184,30 @@ public class WebClientTests { (ResponseEntityProvider) (tests) -> tests.testFeignInterface.getNoTrace(), (ResponseEntityProvider) (tests) -> tests.testFeignInterface.getNoTrace(), (ResponseEntityProvider) (tests) -> tests.testFeignInterface.getNoTrace(), - (ResponseEntityProvider) (tests) -> tests.testFeignInterface.getNoTrace(), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("http://fooservice/notrace", String.class), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("http://fooservice/notrace", String.class), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("http://fooservice/notrace", String.class), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("http://fooservice/notrace", String.class), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("http://fooservice/notrace", String.class), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("http://fooservice/notrace", String.class), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("http://fooservice/notrace", String.class), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("http://fooservice/notrace", String.class)); + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("http://fooservice/notrace", + String.class), + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("http://fooservice/notrace", + String.class), + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("http://fooservice/notrace", + String.class), + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("http://fooservice/notrace", + String.class), + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("http://fooservice/notrace", + String.class), + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("http://fooservice/notrace", + String.class), + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("http://fooservice/notrace", + String.class), + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("http://fooservice/notrace", + String.class)); } @ParameterizedTest @MethodSource("parametersForShouldPropagateNotSamplingHeader") @SuppressWarnings("unchecked") public void shouldPropagateNotSamplingHeader(ResponseEntityProvider provider) { - Span span = this.tracer - .nextSpan(TraceContextOrSamplingFlags.create(SamplingFlags.NOT_SAMPLED)) - .name("foo").start(); + Span span = this.tracer.nextSpan(TraceContextOrSamplingFlags.create(SamplingFlags.NOT_SAMPLED)).name("foo") + .start(); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { ResponseEntity> response = provider.get(this); @@ -228,17 +223,14 @@ public class WebClientTests { } static Stream parametersForShouldPropagateNotSamplingHeader() throws Exception { - return Stream.of( - (ResponseEntityProvider) (tests) -> tests.testFeignInterface.headers(), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("http://fooservice/", Map.class)); + return Stream.of((ResponseEntityProvider) (tests) -> tests.testFeignInterface.headers(), + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("http://fooservice/", Map.class)); } @ParameterizedTest @MethodSource("parametersForShouldAttachTraceIdWhenCallingAnotherService") @SuppressWarnings("unchecked") - public void shouldAttachTraceIdWhenCallingAnotherService( - ResponseEntityProvider provider) { + public void shouldAttachTraceIdWhenCallingAnotherService(ResponseEntityProvider provider) { Span span = this.tracer.nextSpan().name("foo").start(); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { @@ -258,35 +250,30 @@ public class WebClientTests { @Test @SuppressWarnings("unchecked") - public void shouldAttachTraceIdWhenCallingAnotherServiceForHttpClient() - throws Exception { + public void shouldAttachTraceIdWhenCallingAnotherServiceForHttpClient() throws Exception { Span span = this.tracer.nextSpan().name("foo").start(); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { - String response = this.httpClientBuilder.build().execute( - new HttpGet("http://localhost:" + this.port), + String response = this.httpClientBuilder.build().execute(new HttpGet("http://localhost:" + this.port), new BasicResponseHandler()); then(response).isNotEmpty(); } then(this.tracer.currentSpan()).isNull(); - then(this.spans).isNotEmpty().extracting("traceId", String.class) - .containsOnly(span.context().traceIdString()); + then(this.spans).isNotEmpty().extracting("traceId", String.class).containsOnly(span.context().traceIdString()); then(this.spans).extracting("kind.name").contains("CLIENT"); } @Test @SuppressWarnings("unchecked") - public void shouldAttachTraceIdWhenCallingAnotherServiceForAsyncHttpClient() - throws Exception { + public void shouldAttachTraceIdWhenCallingAnotherServiceForAsyncHttpClient() throws Exception { Span span = this.tracer.nextSpan().name("foo").start(); CloseableHttpAsyncClient client = this.httpAsyncClientBuilder.build(); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { client.start(); - Future future = client.execute( - new HttpGet("http://localhost:" + this.port), + Future future = client.execute(new HttpGet("http://localhost:" + this.port), new FutureCallback() { @Override public void completed(HttpResponse result) { @@ -310,8 +297,7 @@ public class WebClientTests { } then(this.tracer.currentSpan()).isNull(); - then(this.spans).isNotEmpty().extracting("traceId", String.class) - .containsOnly(span.context().traceIdString()); + then(this.spans).isNotEmpty().extracting("traceId", String.class).containsOnly(span.context().traceIdString()); then(this.spans).extracting("kind.name").contains("CLIENT"); } @@ -321,8 +307,8 @@ public class WebClientTests { Span span = this.tracer.nextSpan().name("foo").start(); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { - this.webClient.get().uri("http://localhost:" + this.port + "/traceid") - .retrieve().bodyToMono(String.class).block(); + this.webClient.get().uri("http://localhost:" + this.port + "/traceid").retrieve().bodyToMono(String.class) + .block(); } finally { span.finish(); @@ -337,8 +323,8 @@ public class WebClientTests { Span span = this.tracer.nextSpan().name("foo").start(); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { - this.webClient.get().uri("http://localhost:" + this.port + "/issue1462") - .retrieve().bodyToMono(String.class).block(); + this.webClient.get().uri("http://localhost:" + this.port + "/issue1462").retrieve().bodyToMono(String.class) + .block(); } catch (UnknownHttpStatusCodeException ex) { @@ -358,8 +344,7 @@ public class WebClientTests { @Test @Disabled("flakey") public void shouldNotTagOnCancel() { - this.webClient.get().uri("http://localhost:" + this.port + "/doNotSkip") - .retrieve().bodyToMono(String.class) + this.webClient.get().uri("http://localhost:" + this.port + "/doNotSkip").retrieve().bodyToMono(String.class) .subscribe(new BaseSubscriber() { @Override protected void hookOnSubscribe(Subscription subscription) { @@ -372,26 +357,23 @@ public class WebClientTests { @Test public void shouldRespectSkipPattern() { - this.webClient.get().uri("http://localhost:" + this.port + "/skip").retrieve() - .bodyToMono(String.class).block(); + this.webClient.get().uri("http://localhost:" + this.port + "/skip").retrieve().bodyToMono(String.class).block(); then(this.spans).isEmpty(); - this.webClient.get().uri("http://localhost:" + this.port + "/doNotSkip") - .retrieve().bodyToMono(String.class).block(); + this.webClient.get().uri("http://localhost:" + this.port + "/doNotSkip").retrieve().bodyToMono(String.class) + .block(); then(this.spans).isNotEmpty(); } static Stream parametersForShouldAttachTraceIdWhenCallingAnotherService() { - return Stream.of( - (ResponseEntityProvider) (tests) -> tests.testFeignInterface.headers(), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("http://fooservice/traceid", String.class)); + return Stream.of((ResponseEntityProvider) (tests) -> tests.testFeignInterface.headers(), + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("http://fooservice/traceid", + String.class)); } @ParameterizedTest @MethodSource("parametersForShouldAttachTraceIdWhenUsingFeignClientWithoutResponseBody") - public void shouldAttachTraceIdWhenUsingFeignClientWithoutResponseBody( - ResponseEntityProvider provider) { + public void shouldAttachTraceIdWhenUsingFeignClientWithoutResponseBody(ResponseEntityProvider provider) { Span span = this.tracer.nextSpan().name("foo").start(); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { @@ -406,11 +388,9 @@ public class WebClientTests { } static Stream parametersForShouldAttachTraceIdWhenUsingFeignClientWithoutResponseBody() { - return Stream.of( - (ResponseEntityProvider) (tests) -> tests.testFeignInterface - .noResponseBody(), - (ResponseEntityProvider) (tests) -> tests.template - .getForEntity("http://fooservice/noresponse", String.class)); + return Stream.of((ResponseEntityProvider) (tests) -> tests.testFeignInterface.noResponseBody(), + (ResponseEntityProvider) (tests) -> tests.template.getForEntity("http://fooservice/noresponse", + String.class)); } @Test @@ -424,16 +404,14 @@ public class WebClientTests { then(this.tracer.currentSpan()).isNull(); Optional storedSpan = this.spans.spans().stream() - .filter(span -> "404".equals(span.tags().get("http.status_code"))) - .findFirst(); + .filter(span -> "404".equals(span.tags().get("http.status_code"))).findFirst(); then(storedSpan.isPresent()).isTrue(); this.spans.spans().stream().forEach(span -> { int initialSize = span.annotations().size(); - int distinctSize = span.annotations().stream().map(Map.Entry::getValue) - .distinct().collect(Collectors.toList()).size(); + int distinctSize = span.annotations().stream().map(Map.Entry::getValue).distinct() + .collect(Collectors.toList()).size(); log.info("logs " + span.annotations()); - then(initialSize).as("there are no duplicate log entries") - .isEqualTo(distinctSize); + then(initialSize).as("there are no duplicate log entries").isEqualTo(distinctSize); }); then(this.spans).isNotEmpty().extracting("kind.name").contains("CLIENT"); @@ -454,8 +432,7 @@ public class WebClientTests { try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { RestTemplate template = this.restTemplateBuilder.build(); - template.getForObject("http://localhost:" + this.port + "/traceid", - String.class); + template.getForObject("http://localhost:" + this.port + "/traceid", String.class); } finally { span.finish(); @@ -475,8 +452,8 @@ public class WebClientTests { traceId.set(request.headers().getFirst("b3")); return exchange.exchange(request); - }).build().get().uri("http://localhost:" + this.port + "/traceid").retrieve() - .bodyToMono(String.class).block(); + }).build().get().uri("http://localhost:" + this.port + "/traceid").retrieve().bodyToMono(String.class) + .block(); } finally { span.finish(); @@ -517,18 +494,16 @@ public class WebClientTests { @Configuration @EnableAutoConfiguration( excludeName = "org.springframework.cloud.sleuth.instrument.web.TraceWebServletAutoConfiguration", - exclude = { GatewayClassPathWarningAutoConfiguration.class, - GatewayAutoConfiguration.class }) + exclude = { GatewayClassPathWarningAutoConfiguration.class, GatewayAutoConfiguration.class }) @EnableFeignClients - @LoadBalancerClient(value = "fooservice", - configuration = SimpleLoadBalancerClientConfiguration.class) + @LoadBalancerClient(value = "fooservice", configuration = SimpleLoadBalancerClientConfiguration.class) public static class TestConfiguration { @Bean BaggagePropagation.FactoryBuilder baggagePropagationFactoryBuilder() { // Use b3 single format as it is less verbose - return BaggagePropagation.newFactoryBuilder(B3Propagation.newFactoryBuilder() - .injectFormat(CLIENT, SINGLE_NO_PARENT).build()); + return BaggagePropagation.newFactoryBuilder( + B3Propagation.newFactoryBuilder().injectFormat(CLIENT, SINGLE_NO_PARENT).build()); } @Bean @@ -553,8 +528,7 @@ public class WebClientTests { } @Bean - TestErrorController testErrorController(ErrorAttributes errorAttributes, - Tracing tracer) { + TestErrorController testErrorController(ErrorAttributes errorAttributes, Tracing tracer) { return new TestErrorController(errorAttributes, tracer.tracer()); } @@ -628,16 +602,14 @@ public class WebClientTests { Span span; @RequestMapping(value = "/notrace", method = RequestMethod.GET) - public String notrace( - @RequestHeader(name = "b3", required = false) String b3Single) { + public String notrace(@RequestHeader(name = "b3", required = false) String b3Single) { then(b3Single).isNotNull(); return "OK"; } @RequestMapping(value = "/traceid", method = RequestMethod.GET) public String traceId(@RequestHeader("b3") String b3Single) { - TraceContextOrSamplingFlags traceContext = B3SingleFormat - .parseB3SingleFormat(b3Single); + TraceContextOrSamplingFlags traceContext = B3SingleFormat.parseB3SingleFormat(b3Single); then(traceContext.context()).isNotNull(); return b3Single; } @@ -653,8 +625,7 @@ public class WebClientTests { @RequestMapping("/noresponse") public void noResponse(@RequestHeader("b3") String b3Single) { - TraceContextOrSamplingFlags traceContext = B3SingleFormat - .parseB3SingleFormat(b3Single); + TraceContextOrSamplingFlags traceContext = B3SingleFormat.parseB3SingleFormat(b3Single); then(traceContext.context()).isNotNull(); } @@ -692,8 +663,7 @@ public class WebClientTests { @Bean public ServiceInstanceListSupplier serviceInstanceListSupplier(Environment env) { - return ServiceInstanceListSupplier.fixed(env) - .instance(this.port, "fooservice").build(); + return ServiceInstanceListSupplier.fixed(env).instance(this.port, "fooservice").build(); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/internal/LazyBeanTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/internal/LazyBeanTests.java index 64a83e446..9bc2a2581 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/internal/LazyBeanTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/internal/LazyBeanTests.java @@ -40,8 +40,7 @@ public class LazyBeanTests { context.register(BasicConfig.class); context.refresh(); - LazyBean provider = LazyBean.create(context, - CurrentTraceContext.class); + LazyBean provider = LazyBean.create(context, CurrentTraceContext.class); then(provider.get()).isNotNull(); } @@ -50,8 +49,7 @@ public class LazyBeanTests { public void should_return_null_when_no_basic_type() { context.refresh(); - LazyBean provider = LazyBean.create(context, - CurrentTraceContext.class); + LazyBean provider = LazyBean.create(context, CurrentTraceContext.class); then(provider.get()).isNull(); } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/internal/SpanNameUtilTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/internal/SpanNameUtilTests.java index e8b417488..31597f003 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/internal/SpanNameUtilTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/internal/SpanNameUtilTests.java @@ -29,8 +29,7 @@ public class SpanNameUtilTests { @Test public void should_convert_a_class_name_in_hyphen_based_notation() throws Exception { - BDDAssertions.then(SpanNameUtil.toLowerHyphen("MySuperClassName")) - .isEqualTo("my-super-class-name"); + BDDAssertions.then(SpanNameUtil.toLowerHyphen("MySuperClassName")).isEqualTo("my-super-class-name"); } @Test @@ -49,8 +48,7 @@ public class SpanNameUtilTests { for (int i = 0; i < 60; i++) { sb.append("a"); } - BDDAssertions.then(SpanNameUtil.shorten(sb.toString()).length()) - .isEqualTo(SpanNameUtil.MAX_NAME_LENGTH); + BDDAssertions.then(SpanNameUtil.shorten(sb.toString()).length()).isEqualTo(SpanNameUtil.MAX_NAME_LENGTH); } } diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/sampler/ProbabilityBasedSamplerTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/sampler/ProbabilityBasedSamplerTests.java index ef4345066..cdd032311 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/sampler/ProbabilityBasedSamplerTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/sampler/ProbabilityBasedSamplerTests.java @@ -38,20 +38,17 @@ public class ProbabilityBasedSamplerTests { this.samplerConfiguration.setProbability(1f); for (int i = 0; i < 10; i++) { - then(new ProbabilityBasedSampler(this.samplerConfiguration) - .isSampled(RANDOM.nextLong())).isTrue(); + then(new ProbabilityBasedSampler(this.samplerConfiguration).isSampled(RANDOM.nextLong())).isTrue(); } } @Test - public void should_reject_all_samples_when_config_has_0_probability() - throws Exception { + public void should_reject_all_samples_when_config_has_0_probability() throws Exception { this.samplerConfiguration.setProbability(0f); for (int i = 0; i < 10; i++) { - then(new ProbabilityBasedSampler(this.samplerConfiguration) - .isSampled(RANDOM.nextLong())).isFalse(); + then(new ProbabilityBasedSampler(this.samplerConfiguration).isSampled(RANDOM.nextLong())).isFalse(); } } @@ -67,8 +64,7 @@ public class ProbabilityBasedSamplerTests { } @Test - public void should_pass_given_percent_of_samples_with_fractional_element() - throws Exception { + public void should_pass_given_percent_of_samples_with_fractional_element() throws Exception { int numberOfIterations = 1000; float probability = 0.35f; this.samplerConfiguration.setProbability(probability); @@ -82,8 +78,8 @@ public class ProbabilityBasedSamplerTests { @Test public void should_fail_given_no_probability() { assertThatThrownBy(() -> new ProbabilityBasedSampler(this.samplerConfiguration)) - .isInstanceOf(IllegalArgumentException.class).hasMessage( - "probability property is required for ProbabilityBasedSampler"); + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("probability property is required for ProbabilityBasedSampler"); } private int countNumberOfSampledElements(int numberOfIterations) { diff --git a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/sampler/SamplerAutoConfigurationTests.java b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/sampler/SamplerAutoConfigurationTests.java index a8c86de0a..f1cbf6c6f 100644 --- a/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/sampler/SamplerAutoConfigurationTests.java +++ b/spring-cloud-sleuth-core/src/test/java/org/springframework/cloud/sleuth/sampler/SamplerAutoConfigurationTests.java @@ -60,36 +60,27 @@ public class SamplerAutoConfigurationTests { @Test void should_use_RateLimitedSampler_withTracingCustomizer() { - this.contextRunner.withUserConfiguration(WithTracingCustomizer.class) - .run((context -> { - final Sampler bean = context.getBean(Sampler.class); - BDDAssertions.then(bean).isInstanceOf(RateLimitingSampler.class); - })); + this.contextRunner.withUserConfiguration(WithTracingCustomizer.class).run((context -> { + final Sampler bean = context.getBean(Sampler.class); + BDDAssertions.then(bean).isInstanceOf(RateLimitingSampler.class); + })); } @Test void should_use_refresh_scope_sampler_when_no_property_passed_and_refresh_scope_present() { - this.contextRunner.withUserConfiguration(WithTracingCustomizer.class, - WithRefreshScope.class).run((context -> { - BDDAssertions.then(context.containsBean("defaultTraceSampler")) - .as("refresh scope bean should be set").isTrue(); - BDDAssertions - .then(context - .containsBean("defaultNonRefreshScopeTraceSampler")) - .as("non refresh scope bean should not be picked").isFalse(); - })); + this.contextRunner.withUserConfiguration(WithTracingCustomizer.class, WithRefreshScope.class).run((context -> { + BDDAssertions.then(context.containsBean("defaultTraceSampler")).as("refresh scope bean should be set") + .isTrue(); + BDDAssertions.then(context.containsBean("defaultNonRefreshScopeTraceSampler")) + .as("non refresh scope bean should not be picked").isFalse(); + })); } @Test void should_use_non_refresh_scope_sampler_when_property_passed_and_refresh_scope_present() { - this.contextRunner - .withUserConfiguration(WithTracingCustomizer.class, - WithRefreshScope.class) - .withPropertyValues("spring.sleuth.sampler.refresh.enabled=false") - .run((context -> { - BDDAssertions - .then(context - .containsBean("defaultNonRefreshScopeTraceSampler")) + this.contextRunner.withUserConfiguration(WithTracingCustomizer.class, WithRefreshScope.class) + .withPropertyValues("spring.sleuth.sampler.refresh.enabled=false").run((context -> { + BDDAssertions.then(context.containsBean("defaultNonRefreshScopeTraceSampler")) .as("non refresh scope bean should be picked").isTrue(); BDDAssertions.then(context.containsBean("defaultTraceSampler")) .as("refresh scope bean should not be set").isFalse(); diff --git a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-feign/src/test/java/sample/SampleFeignApplicationTests.java b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-feign/src/test/java/sample/SampleFeignApplicationTests.java index f0608eae3..12a162cb3 100644 --- a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-feign/src/test/java/sample/SampleFeignApplicationTests.java +++ b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-feign/src/test/java/sample/SampleFeignApplicationTests.java @@ -40,8 +40,7 @@ public class SampleFeignApplicationTests { // https://github.com/spring-cloud/spring-cloud-sleuth/issues/1396 @Test - public void should_not_pass_dash_as_default_service_name( - CapturedOutput outputCapture) { + public void should_not_pass_dash_as_default_service_name(CapturedOutput outputCapture) { log.info("HELLO"); BDDAssertions.then(outputCapture.toString()).doesNotContain("INFO [-,,,]"); diff --git a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/main/java/sample/SampleService.java b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/main/java/sample/SampleService.java index caa01ca56..0e30f4a9e 100644 --- a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/main/java/sample/SampleService.java +++ b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/main/java/sample/SampleService.java @@ -32,8 +32,7 @@ import org.springframework.web.client.RestTemplate; * */ @MessageEndpoint -public class SampleService - implements ApplicationListener { +public class SampleService implements ApplicationListener { private static final Log log = LogFactory.getLog(SampleService.class); @@ -45,8 +44,7 @@ public class SampleService @ServiceActivator(inputChannel = "messages") public void log(Message message) { log.info("Received: " + message); - this.restTemplate.getForObject("http://localhost:" + this.port + "/foo", - String.class); + this.restTemplate.getForObject("http://localhost:" + this.port + "/foo", String.class); } @Override diff --git a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/test/java/integration/IntegrationTestZipkinSpanHandler.java b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/test/java/integration/IntegrationTestZipkinSpanHandler.java index a0078a106..b5eb3cb35 100644 --- a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/test/java/integration/IntegrationTestZipkinSpanHandler.java +++ b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/test/java/integration/IntegrationTestZipkinSpanHandler.java @@ -32,8 +32,7 @@ import org.apache.commons.logging.Log; */ public class IntegrationTestZipkinSpanHandler extends SpanHandler { - private static final Log log = org.apache.commons.logging.LogFactory - .getLog(IntegrationTestZipkinSpanHandler.class); + private static final Log log = org.apache.commons.logging.LogFactory.getLog(IntegrationTestZipkinSpanHandler.class); public List spans = Collections.synchronizedList(new LinkedList<>()); diff --git a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/test/java/integration/MessagingApplicationTests.java b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/test/java/integration/MessagingApplicationTests.java index c2c6ee4b7..4fbdd11fc 100644 --- a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/test/java/integration/MessagingApplicationTests.java +++ b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-messaging/src/test/java/integration/MessagingApplicationTests.java @@ -42,9 +42,7 @@ import org.springframework.test.context.TestPropertySource; import static java.util.concurrent.TimeUnit.SECONDS; import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest( - classes = { IntegrationSpanCollectorConfig.class, - SampleMessagingApplication.class }, +@SpringBootTest(classes = { IntegrationSpanCollectorConfig.class, SampleMessagingApplication.class }, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT) @TestPropertySource(properties = { "sample.zipkin.enabled=true" }) @DirtiesContext @@ -66,12 +64,10 @@ public class MessagingApplicationTests extends AbstractIntegrationTest { public void should_have_passed_trace_id_when_message_is_about_to_be_sent() { long traceId = new Random().nextLong(); - await().atMost(15, SECONDS) - .untilAsserted(() -> httpMessageWithTraceIdInHeadersIsSuccessfullySent( - sampleAppUrl + "/", traceId).run()); + await().atMost(15, SECONDS).untilAsserted( + () -> httpMessageWithTraceIdInHeadersIsSuccessfullySent(sampleAppUrl + "/", traceId).run()); - await().atMost(15, SECONDS) - .untilAsserted(() -> thenAllSpansHaveTraceIdEqualTo(traceId)); + await().atMost(15, SECONDS).untilAsserted(() -> thenAllSpansHaveTraceIdEqualTo(traceId)); } @Test @@ -79,9 +75,8 @@ public class MessagingApplicationTests extends AbstractIntegrationTest { long traceId = new Random().nextLong(); long spanId = new Random().nextLong(); - await().atMost(15, SECONDS) - .untilAsserted(() -> httpMessageWithTraceIdInHeadersIsSuccessfullySent( - sampleAppUrl + "/", traceId, spanId).run()); + await().atMost(15, SECONDS).untilAsserted( + () -> httpMessageWithTraceIdInHeadersIsSuccessfullySent(sampleAppUrl + "/", traceId, spanId).run()); await().atMost(15, SECONDS).untilAsserted(() -> { thenAllSpansHaveTraceIdEqualTo(traceId); @@ -93,9 +88,8 @@ public class MessagingApplicationTests extends AbstractIntegrationTest { public void should_have_passed_trace_id_with_annotations_in_async_thread_when_message_is_about_to_be_sent() { long traceId = new Random().nextLong(); - await().atMost(15, SECONDS) - .untilAsserted(() -> httpMessageWithTraceIdInHeadersIsSuccessfullySent( - sampleAppUrl + "/xform", traceId).run()); + await().atMost(15, SECONDS).untilAsserted( + () -> httpMessageWithTraceIdInHeadersIsSuccessfullySent(sampleAppUrl + "/xform", traceId).run()); await().atMost(15, SECONDS).untilAsserted(() -> { thenAllSpansHaveTraceIdEqualTo(traceId); @@ -104,18 +98,17 @@ public class MessagingApplicationTests extends AbstractIntegrationTest { } private void thenThereIsAtLeastOneTagWithKey(String key) { - then(this.testSpanHandler.spans.stream().map(MutableSpan::tags) - .flatMap(m -> m.keySet().stream()).anyMatch(b -> b.equals(key))).isTrue(); + then(this.testSpanHandler.spans.stream().map(MutableSpan::tags).flatMap(m -> m.keySet().stream()) + .anyMatch(b -> b.equals(key))).isTrue(); } private void thenAllSpansHaveTraceIdEqualTo(long traceId) { String traceIdHex = Long.toHexString(traceId); - log.info("Stored spans: [\n" + this.testSpanHandler.spans.stream() - .map(MutableSpan::toString).collect(Collectors.joining("\n")) + "\n]"); - then(this.testSpanHandler.spans.stream() - .filter(span -> !span.traceId().equals(SpanUtil.idToHex(traceId))) - .collect(Collectors.toList())) - .describedAs("All spans have same trace id [" + traceIdHex + "]") + log.info("Stored spans: [\n" + + this.testSpanHandler.spans.stream().map(MutableSpan::toString).collect(Collectors.joining("\n")) + + "\n]"); + then(this.testSpanHandler.spans.stream().filter(span -> !span.traceId().equals(SpanUtil.idToHex(traceId))) + .collect(Collectors.toList())).describedAs("All spans have same trace id [" + traceIdHex + "]") .isEmpty(); } @@ -127,13 +120,11 @@ public class MessagingApplicationTests extends AbstractIntegrationTest { Optional lastHttpSpansParent = findLastHttpSpansParent(); // "http:/parent/" -> "message:messages" -> "http:/foo" (CS + CR) -> "http:/foo" // (SS) - thenAllSpansArePresent(firstHttpSpan, eventSpans, lastHttpSpansParent, - eventSentSpan, producerSpan); + thenAllSpansArePresent(firstHttpSpan, eventSpans, lastHttpSpansParent, eventSentSpan, producerSpan); then(this.testSpanHandler.spans).as("There were 6 spans").hasSize(6); log.info("Checking the parent child structure"); List> parentChild = this.testSpanHandler.spans.stream() - .filter(span -> span.parentId() != null) - .map(span -> this.testSpanHandler.spans.stream() + .filter(span -> span.parentId() != null).map(span -> this.testSpanHandler.spans.stream() .filter(span1 -> span1.id().equals(span.parentId())).findAny()) .collect(Collectors.toList()); log.info("List of parents and children " + parentChild); @@ -141,32 +132,27 @@ public class MessagingApplicationTests extends AbstractIntegrationTest { } private Optional findLastHttpSpansParent() { - return this.testSpanHandler.spans.stream() - .filter(span -> "GET /".equals(span.name()) && span.kind() != null) + return this.testSpanHandler.spans.stream().filter(span -> "GET /".equals(span.name()) && span.kind() != null) .findFirst(); } private Optional findSpanWithKind(Span.Kind kind) { - return this.testSpanHandler.spans.stream() - .filter(span -> kind.equals(span.kind())).findFirst(); + return this.testSpanHandler.spans.stream().filter(span -> kind.equals(span.kind())).findFirst(); } private List findAllEventRelatedSpans() { - return this.testSpanHandler.spans.stream() - .filter(span -> "send".equals(span.name()) && span.parentId() != null) + return this.testSpanHandler.spans.stream().filter(span -> "send".equals(span.name()) && span.parentId() != null) .collect(Collectors.toList()); } private Optional findFirstHttpRequestSpan() { return this.testSpanHandler.spans.stream() // home is the name of the method - .filter(span -> span.tags().values().stream().anyMatch("home"::equals)) - .findFirst(); + .filter(span -> span.tags().values().stream().anyMatch("home"::equals)).findFirst(); } - private void thenAllSpansArePresent(Optional firstHttpSpan, - List eventSpans, Optional lastHttpSpan, - Optional eventSentSpan, + private void thenAllSpansArePresent(Optional firstHttpSpan, List eventSpans, + Optional lastHttpSpan, Optional eventSentSpan, Optional eventReceivedSpan) { log.info("Found following spans"); log.info("First http span " + firstHttpSpan); @@ -174,8 +160,8 @@ public class MessagingApplicationTests extends AbstractIntegrationTest { log.info("Event sent span " + eventSentSpan); log.info("Event received span " + eventReceivedSpan); log.info("Last http span " + lastHttpSpan); - log.info("All found spans \n" + this.testSpanHandler.spans.stream() - .map(MutableSpan::toString).collect(Collectors.joining("\n"))); + log.info("All found spans \n" + + this.testSpanHandler.spans.stream().map(MutableSpan::toString).collect(Collectors.joining("\n"))); then(firstHttpSpan.isPresent()).isTrue(); then(eventSpans).isNotEmpty(); then(eventSentSpan.isPresent()).isTrue(); diff --git a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/AbstractIntegrationTest.java b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/AbstractIntegrationTest.java index 0c1facbe4..a249a0f1d 100644 --- a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/AbstractIntegrationTest.java +++ b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/AbstractIntegrationTest.java @@ -39,17 +39,14 @@ public abstract class AbstractIntegrationTest { protected final RestTemplate restTemplate = new AssertingRestTemplate(); public static ConditionFactory await() { - return Awaitility.await().pollInterval(POLL_INTERVAL, SECONDS).atMost(TIMEOUT, - SECONDS); + return Awaitility.await().pollInterval(POLL_INTERVAL, SECONDS).atMost(TIMEOUT, SECONDS); } - protected Runnable httpMessageWithTraceIdInHeadersIsSuccessfullySent(String endpoint, - long traceId) { + protected Runnable httpMessageWithTraceIdInHeadersIsSuccessfullySent(String endpoint, long traceId) { return new RequestSendingRunnable(this.restTemplate, endpoint, traceId, traceId); } - protected Runnable httpMessageWithTraceIdInHeadersIsSuccessfullySent(String endpoint, - long traceId, Long spanId) { + protected Runnable httpMessageWithTraceIdInHeadersIsSuccessfullySent(String endpoint, long traceId, Long spanId) { return new RequestSendingRunnable(this.restTemplate, endpoint, traceId, spanId); } diff --git a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/AssertingRestTemplate.java b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/AssertingRestTemplate.java index 792e83252..3523fb2e2 100644 --- a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/AssertingRestTemplate.java +++ b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/AssertingRestTemplate.java @@ -46,8 +46,8 @@ public class AssertingRestTemplate extends RestTemplate { @Override public void handleError(ClientHttpResponse response) throws IOException { if (hasError(response)) { - log.error("Response has status code [" + response.getStatusCode() - + "] and text [" + response.getStatusText() + "])"); + log.error("Response has status code [" + response.getStatusCode() + "] and text [" + + response.getStatusText() + "])"); } } }); @@ -60,8 +60,8 @@ public class AssertingRestTemplate extends RestTemplate { return super.doExecute(url, method, requestCallback, responseExtractor); } catch (Exception e) { - log.error("Exception occurred while sending the message to uri [" + url - + "]. Exception [" + e.getCause() + "]"); + log.error("Exception occurred while sending the message to uri [" + url + "]. Exception [" + e.getCause() + + "]"); throw new AssertionError(e); } } diff --git a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/RequestSendingRunnable.java b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/RequestSendingRunnable.java index 7aac73ded..27cbdef42 100644 --- a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/RequestSendingRunnable.java +++ b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/RequestSendingRunnable.java @@ -52,8 +52,7 @@ public class RequestSendingRunnable implements Runnable { private final long spanId; - public RequestSendingRunnable(RestTemplate restTemplate, String url, long traceId, - Long spanId) { + public RequestSendingRunnable(RestTemplate restTemplate, String url, long traceId, Long spanId) { this.restTemplate = restTemplate; this.url = url; this.traceId = traceId; @@ -62,11 +61,9 @@ public class RequestSendingRunnable implements Runnable { @Override public void run() { - log.info(String.format( - "Sending the request to url [%s] with trace id in headers [%d]", this.url, - this.traceId)); - ResponseEntity responseEntity = this.restTemplate - .exchange(requestWithTraceId(), String.class); + log.info( + String.format("Sending the request to url [%s] with trace id in headers [%d]", this.url, this.traceId)); + ResponseEntity responseEntity = this.restTemplate.exchange(requestWithTraceId(), String.class); then(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK); log.info(String.format("Received the following response [%s]", responseEntity)); } @@ -75,8 +72,7 @@ public class RequestSendingRunnable implements Runnable { HttpHeaders headers = new HttpHeaders(); headers.add("b3", idToHex(this.traceId) + "-" + idToHex(this.spanId)); URI uri = URI.create(this.url); - RequestEntity requestEntity = new RequestEntity<>(headers, HttpMethod.GET, - uri); + RequestEntity requestEntity = new RequestEntity<>(headers, HttpMethod.GET, uri); log.info("Request [" + requestEntity + "] is ready"); return requestEntity; } diff --git a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/SpanUtil.java b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/SpanUtil.java index 86208eb6d..a7aae9e70 100644 --- a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/SpanUtil.java +++ b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-test-core/src/main/java/tools/SpanUtil.java @@ -22,8 +22,7 @@ public final class SpanUtil { throw new IllegalStateException("Can't instantiate a utility class"); } - static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - 'a', 'b', 'c', 'd', 'e', 'f' }; + static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; // Represents given long id as 16-character lower-hex string public static String idToHex(long id) { diff --git a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-zipkin/src/main/java/sample/SampleController.java b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-zipkin/src/main/java/sample/SampleController.java index ccdfa4f84..08a29068f 100644 --- a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-zipkin/src/main/java/sample/SampleController.java +++ b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-zipkin/src/main/java/sample/SampleController.java @@ -35,8 +35,7 @@ import org.springframework.web.client.RestTemplate; * @author Spencer Gibb */ @RestController -public class SampleController - implements ApplicationListener { +public class SampleController implements ApplicationListener { private static final Log log = LogFactory.getLog(SampleController.class); @@ -57,8 +56,7 @@ public class SampleController public String hi() throws InterruptedException { Thread.sleep(this.random.nextInt(1000)); log.info("Home page"); - String s = this.restTemplate - .getForObject("http://localhost:" + this.port + "/hi2", String.class); + String s = this.restTemplate.getForObject("http://localhost:" + this.port + "/hi2", String.class); return "hi/" + s; } @@ -100,8 +98,7 @@ public class SampleController Thread.sleep(millis); this.tracer.currentSpan().tag("random-sleep-millis", String.valueOf(millis)); - String s = this.restTemplate - .getForObject("http://localhost:" + this.port + "/call", String.class); + String s = this.restTemplate.getForObject("http://localhost:" + this.port + "/call", String.class); span.finish(); return "traced/" + s; } @@ -112,8 +109,7 @@ public class SampleController log.info(String.format("Sleeping for [%d] millis", millis)); Thread.sleep(millis); this.tracer.currentSpan().tag("random-sleep-millis", String.valueOf(millis)); - String s = this.restTemplate - .getForObject("http://localhost:" + this.port + "/call", String.class); + String s = this.restTemplate.getForObject("http://localhost:" + this.port + "/call", String.class); return "start/" + s; } diff --git a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-zipkin/src/test/java/integration/ZipkinTests.java b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-zipkin/src/test/java/integration/ZipkinTests.java index c4f35bc3f..7154aeb2b 100644 --- a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-zipkin/src/test/java/integration/ZipkinTests.java +++ b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-zipkin/src/test/java/integration/ZipkinTests.java @@ -51,8 +51,7 @@ import org.springframework.test.context.TestPropertySource; import static java.util.concurrent.TimeUnit.SECONDS; import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest( - classes = { WaitUntilZipkinIsUpConfig.class, SampleZipkinApplication.class }, +@SpringBootTest(classes = { WaitUntilZipkinIsUpConfig.class, SampleZipkinApplication.class }, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT) @TestPropertySource(properties = { "sample.zipkin.enabled=true" }) public class ZipkinTests extends AbstractIntegrationTest { @@ -90,9 +89,8 @@ public class ZipkinTests extends AbstractIntegrationTest { long traceId = new Random().nextLong(); - await().atMost(10, SECONDS) - .untilAsserted(() -> httpMessageWithTraceIdInHeadersIsSuccessfullySent( - this.sampleAppUrl + "/hi2", traceId).run()); + await().atMost(10, SECONDS).untilAsserted( + () -> httpMessageWithTraceIdInHeadersIsSuccessfullySent(this.sampleAppUrl + "/hi2", traceId).run()); spansSentToZipkin(zipkin, traceId); } @@ -101,20 +99,15 @@ public class ZipkinTests extends AbstractIntegrationTest { return APP_NAME; } - void spansSentToZipkin(MockWebServer zipkin, long traceId) - throws InterruptedException { + void spansSentToZipkin(MockWebServer zipkin, long traceId) throws InterruptedException { RecordedRequest request = zipkin.takeRequest(); - List spans = SpanBytesDecoder.JSON_V2 - .decodeList(request.getBody().readByteArray()); + List spans = SpanBytesDecoder.JSON_V2.decodeList(request.getBody().readByteArray()); List traceIdsNotFoundInZipkin = traceIdsNotFoundInZipkin(spans, traceId); List serviceNamesNotFoundInZipkin = serviceNamesNotFoundInZipkin(spans); List tagsNotFoundInZipkin = hasRequiredTag(spans); - log.info(String.format("The following trace IDs were not found in Zipkin %s", - traceIdsNotFoundInZipkin)); - log.info(String.format("The following services were not found in Zipkin %s", - serviceNamesNotFoundInZipkin)); - log.info(String.format("The following tags were not found in Zipkin %s", - tagsNotFoundInZipkin)); + log.info(String.format("The following trace IDs were not found in Zipkin %s", traceIdsNotFoundInZipkin)); + log.info(String.format("The following services were not found in Zipkin %s", serviceNamesNotFoundInZipkin)); + log.info(String.format("The following tags were not found in Zipkin %s", tagsNotFoundInZipkin)); then(traceIdsNotFoundInZipkin).isEmpty(); then(serviceNamesNotFoundInZipkin).isEmpty(); then(tagsNotFoundInZipkin).isEmpty(); @@ -123,17 +116,15 @@ public class ZipkinTests extends AbstractIntegrationTest { List traceIdsNotFoundInZipkin(List spans, long traceId) { String traceIdString = SpanUtil.idToHex(traceId); - Optional traceIds = spans.stream().map(Span::traceId) - .filter(traceIdString::equals).findFirst(); - return traceIds.isPresent() ? Collections.emptyList() - : Collections.singletonList(traceIdString); + Optional traceIds = spans.stream().map(Span::traceId).filter(traceIdString::equals).findFirst(); + return traceIds.isPresent() ? Collections.emptyList() : Collections.singletonList(traceIdString); } List serviceNamesNotFoundInZipkin(List spans) { - List localServiceNames = spans.stream().map(Span::localServiceName) - .filter(Objects::nonNull).distinct().collect(Collectors.toList()); - List remoteServiceNames = spans.stream().map(Span::remoteServiceName) - .filter(Objects::nonNull).distinct().collect(Collectors.toList()); + List localServiceNames = spans.stream().map(Span::localServiceName).filter(Objects::nonNull).distinct() + .collect(Collectors.toList()); + List remoteServiceNames = spans.stream().map(Span::remoteServiceName).filter(Objects::nonNull) + .distinct().collect(Collectors.toList()); List names = new ArrayList<>(); names.addAll(localServiceNames); names.addAll(remoteServiceNames); @@ -142,11 +133,9 @@ public class ZipkinTests extends AbstractIntegrationTest { List hasRequiredTag(List spans) { String key = getRequiredTagKey(); - Optional keys = spans.stream() - .flatMap(span -> span.tags().keySet().stream()).filter(key::equals) + Optional keys = spans.stream().flatMap(span -> span.tags().keySet().stream()).filter(key::equals) .findFirst(); - return keys.isPresent() ? Collections.emptyList() - : Collections.singletonList(key); + return keys.isPresent() ? Collections.emptyList() : Collections.singletonList(key); } String getRequiredTagKey() { diff --git a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample/src/main/java/sample/SampleController.java b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample/src/main/java/sample/SampleController.java index 9e8cb1980..36fd17c67 100644 --- a/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample/src/main/java/sample/SampleController.java +++ b/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample/src/main/java/sample/SampleController.java @@ -35,8 +35,7 @@ import org.springframework.web.client.RestTemplate; * @author Spencer Gibb */ @RestController -public class SampleController - implements ApplicationListener { +public class SampleController implements ApplicationListener { private static final Log log = LogFactory.getLog(SampleController.class); @@ -58,8 +57,7 @@ public class SampleController log.info("hi!"); Thread.sleep(this.random.nextInt(1000)); - String s = this.restTemplate - .getForObject("http://localhost:" + this.port + "/hi2", String.class); + String s = this.restTemplate.getForObject("http://localhost:" + this.port + "/hi2", String.class); return "hi/" + s; } @@ -71,8 +69,7 @@ public class SampleController log.info("call"); int millis = SampleController.this.random.nextInt(1000); Thread.sleep(millis); - SampleController.this.tracer.currentSpan().tag("callable-sleep-millis", - String.valueOf(millis)); + SampleController.this.tracer.currentSpan().tag("callable-sleep-millis", String.valueOf(millis)); Span span = SampleController.this.tracer.currentSpan(); return "async hi: " + span; } @@ -104,8 +101,7 @@ public class SampleController Thread.sleep(millis); this.tracer.currentSpan().tag("random-sleep-millis", String.valueOf(millis)); - String s = this.restTemplate - .getForObject("http://localhost:" + this.port + "/call", String.class); + String s = this.restTemplate.getForObject("http://localhost:" + this.port + "/call", String.class); span.finish(); return "traced/" + s; } @@ -118,8 +114,7 @@ public class SampleController Thread.sleep(millis); this.tracer.currentSpan().tag("random-sleep-millis", String.valueOf(millis)); - String s = this.restTemplate - .getForObject("http://localhost:" + this.port + "/call", String.class); + String s = this.restTemplate.getForObject("http://localhost:" + this.port + "/call", String.class); return "start/" + s; } diff --git a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/DefaultEndpointLocator.java b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/DefaultEndpointLocator.java index 7e7f19d5c..61564ea78 100644 --- a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/DefaultEndpointLocator.java +++ b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/DefaultEndpointLocator.java @@ -41,8 +41,7 @@ import org.springframework.util.StringUtils; * * @author Dave Syer */ -class DefaultEndpointLocator implements EndpointLocator, - ApplicationListener { +class DefaultEndpointLocator implements EndpointLocator, ApplicationListener { private static final Log log = LogFactory.getLog(DefaultEndpointLocator.class); @@ -60,9 +59,8 @@ class DefaultEndpointLocator implements EndpointLocator, private InetAddress firstNonLoopbackAddress; - DefaultEndpointLocator(Registration registration, ServerProperties serverProperties, - Environment environment, ZipkinProperties zipkinProperties, - InetUtils inetUtils) { + DefaultEndpointLocator(Registration registration, ServerProperties serverProperties, Environment environment, + ZipkinProperties zipkinProperties, InetUtils inetUtils) { this.registration = registration; this.serverProperties = serverProperties; this.environment = environment; @@ -83,8 +81,7 @@ class DefaultEndpointLocator implements EndpointLocator, if (log.isDebugEnabled()) { log.debug("Span will contain serviceName [" + serviceName + "]"); } - Endpoint.Builder builder = Endpoint.newBuilder().serviceName(serviceName) - .port(getPort()); + Endpoint.Builder builder = Endpoint.newBuilder().serviceName(serviceName).port(getPort()); return addAddress(builder).build(); } @@ -129,8 +126,7 @@ class DefaultEndpointLocator implements EndpointLocator, return builder; } else if (this.environment.containsProperty(IP_ADDRESS_PROP_NAME) - && builder.parseIp(this.environment.getProperty(IP_ADDRESS_PROP_NAME, - String.class))) { + && builder.parseIp(this.environment.getProperty(IP_ADDRESS_PROP_NAME, String.class))) { return builder; } else { diff --git a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/DefaultZipkinRestTemplateCustomizer.java b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/DefaultZipkinRestTemplateCustomizer.java index 3ad42e90e..2339212d9 100644 --- a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/DefaultZipkinRestTemplateCustomizer.java +++ b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/DefaultZipkinRestTemplateCustomizer.java @@ -51,8 +51,8 @@ class DefaultZipkinRestTemplateCustomizer implements ZipkinRestTemplateCustomize private class GZipInterceptor implements ClientHttpRequestInterceptor { - public ClientHttpResponse intercept(HttpRequest request, byte[] body, - ClientHttpRequestExecution execution) throws IOException { + public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) + throws IOException { request.getHeaders().add("Content-Encoding", "gzip"); ByteArrayOutputStream gzipped = new ByteArrayOutputStream(); try (GZIPOutputStream compressor = new GZIPOutputStream(gzipped)) { diff --git a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/ZipkinAutoConfiguration.java b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/ZipkinAutoConfiguration.java index 736b8cd47..f5b93f6d5 100644 --- a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/ZipkinAutoConfiguration.java +++ b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/ZipkinAutoConfiguration.java @@ -78,11 +78,9 @@ import org.springframework.web.client.RestTemplate; */ @Configuration(proxyBeanMethods = false) @EnableConfigurationProperties(ZipkinProperties.class) -@ConditionalOnProperty(value = { "spring.sleuth.enabled", "spring.zipkin.enabled" }, - matchIfMissing = true) +@ConditionalOnProperty(value = { "spring.sleuth.enabled", "spring.zipkin.enabled" }, matchIfMissing = true) @AutoConfigureBefore(TraceAutoConfiguration.class) -@AutoConfigureAfter( - name = "org.springframework.cloud.autoconfigure.RefreshAutoConfiguration") +@AutoConfigureAfter(name = "org.springframework.cloud.autoconfigure.RefreshAutoConfiguration") @Import(ZipkinSenderConfigurationImportSelector.class) // public because the constant REPORTER_BEAN_NAME was documented public class ZipkinAutoConfiguration { @@ -119,28 +117,25 @@ public class ZipkinAutoConfiguration { @Bean(REPORTER_BEAN_NAME) @ConditionalOnMissingBean(name = REPORTER_BEAN_NAME) - public Reporter reporter(ReporterMetrics reporterMetrics, - ZipkinProperties zipkin, @Qualifier(SENDER_BEAN_NAME) Sender sender) { + public Reporter reporter(ReporterMetrics reporterMetrics, ZipkinProperties zipkin, + @Qualifier(SENDER_BEAN_NAME) Sender sender) { CheckResult checkResult = checkResult(sender, 1_000L); logCheckResult(sender, checkResult); // historical constraint. Note: AsyncReporter supports memory bounds - AsyncReporter asyncReporter = AsyncReporter.builder(sender) - .queuedMaxSpans(1000) - .messageTimeout(zipkin.getMessageTimeout(), TimeUnit.SECONDS) - .metrics(reporterMetrics).build(zipkin.getEncoder()); + AsyncReporter asyncReporter = AsyncReporter.builder(sender).queuedMaxSpans(1000) + .messageTimeout(zipkin.getMessageTimeout(), TimeUnit.SECONDS).metrics(reporterMetrics) + .build(zipkin.getEncoder()); return asyncReporter; } private void logCheckResult(Sender sender, CheckResult checkResult) { if (log.isDebugEnabled() && checkResult != null && checkResult.ok()) { - log.debug("Check result of the [" + sender.toString() + "] is [" + checkResult - + "]"); + log.debug("Check result of the [" + sender.toString() + "] is [" + checkResult + "]"); } else if (checkResult != null && !checkResult.ok()) { - log.warn("Check result of the [" + sender.toString() + "] contains an error [" - + checkResult + "]"); + log.warn("Check result of the [" + sender.toString() + "] contains an error [" + checkResult + "]"); } } @@ -165,8 +160,8 @@ public class ZipkinAutoConfiguration { return outcome[0]; } thread.interrupt(); - return CheckResult.failed(new TimeoutException( - thread.getName() + " timed out after " + deadlineMillis + "ms")); + return CheckResult + .failed(new TimeoutException(thread.getName() + " timed out after " + deadlineMillis + "ms")); } catch (InterruptedException e) { Thread.currentThread().interrupt(); @@ -176,8 +171,7 @@ public class ZipkinAutoConfiguration { /** Returns one handler for as many reporters as exist. */ @Bean - SpanHandler zipkinSpanHandler(@Nullable List> spanReporters, - @Nullable Tag errorTag) { + SpanHandler zipkinSpanHandler(@Nullable List> spanReporters, @Nullable Tag errorTag) { if (spanReporters == null) { return SpanHandler.NOOP; } @@ -202,8 +196,7 @@ public class ZipkinAutoConfiguration { @Bean TracingCustomizer reorderZipkinHandlersLast() { return builder -> { - List configuredSpanHandlers = new ArrayList<>( - builder.spanHandlers()); + List configuredSpanHandlers = new ArrayList<>(builder.spanHandlers()); configuredSpanHandlers.sort(SPAN_HANDLER_COMPARATOR); builder.clearSpanHandlers(); for (SpanHandler spanHandler : configuredSpanHandlers) { @@ -214,15 +207,14 @@ public class ZipkinAutoConfiguration { @Bean @ConditionalOnMissingBean - public ZipkinRestTemplateCustomizer zipkinRestTemplateCustomizer( - ZipkinProperties zipkinProperties) { + public ZipkinRestTemplateCustomizer zipkinRestTemplateCustomizer(ZipkinProperties zipkinProperties) { return new DefaultZipkinRestTemplateCustomizer(zipkinProperties); } @Configuration(proxyBeanMethods = false) @ConditionalOnMissingBean(EndpointLocator.class) - @ConditionalOnProperty(value = "spring.zipkin.locator.discovery.enabled", - havingValue = "false", matchIfMissing = true) + @ConditionalOnProperty(value = "spring.zipkin.locator.discovery.enabled", havingValue = "false", + matchIfMissing = true) protected static class DefaultEndpointLocatorConfiguration { @Autowired(required = false) @@ -239,8 +231,8 @@ public class ZipkinAutoConfiguration { @Bean public EndpointLocator zipkinEndpointLocator() { - return new DefaultEndpointLocator(null, this.serverProperties, - this.environment, this.zipkinProperties, this.inetUtils); + return new DefaultEndpointLocator(null, this.serverProperties, this.environment, this.zipkinProperties, + this.inetUtils); } } @@ -248,8 +240,7 @@ public class ZipkinAutoConfiguration { @Configuration(proxyBeanMethods = false) @ConditionalOnClass(Registration.class) @ConditionalOnMissingBean(EndpointLocator.class) - @ConditionalOnProperty(value = "spring.zipkin.locator.discovery.enabled", - havingValue = "true") + @ConditionalOnProperty(value = "spring.zipkin.locator.discovery.enabled", havingValue = "true") protected static class RegistrationEndpointLocatorConfiguration { @Autowired(required = false) @@ -269,8 +260,8 @@ public class ZipkinAutoConfiguration { @Bean public EndpointLocator zipkinEndpointLocator() { - return new DefaultEndpointLocator(this.registration, this.serverProperties, - this.environment, this.zipkinProperties, this.inetUtils); + return new DefaultEndpointLocator(this.registration, this.serverProperties, this.environment, + this.zipkinProperties, this.inetUtils); } } @@ -329,8 +320,7 @@ public class ZipkinAutoConfiguration { catch (RuntimeException ex) { // TODO: message lifted from ListReporter: this is probably too much // for warn level - log.warn("Exception occurred while trying to report the span " + span, - ex); + log.warn("Exception occurred while trying to report the span " + span, ex); } } } diff --git a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/LoadBalancerClientZipkinLoadBalancer.java b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/LoadBalancerClientZipkinLoadBalancer.java index 28b0e3f7d..c980eac30 100644 --- a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/LoadBalancerClientZipkinLoadBalancer.java +++ b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/LoadBalancerClientZipkinLoadBalancer.java @@ -29,8 +29,7 @@ class LoadBalancerClientZipkinLoadBalancer implements ZipkinLoadBalancer { private final ZipkinProperties zipkinProperties; - LoadBalancerClientZipkinLoadBalancer(LoadBalancerClient loadBalancerClient, - ZipkinProperties zipkinProperties) { + LoadBalancerClientZipkinLoadBalancer(LoadBalancerClient loadBalancerClient, ZipkinProperties zipkinProperties) { this.loadBalancerClient = loadBalancerClient; this.zipkinProperties = zipkinProperties; } diff --git a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/RestTemplateSender.java b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/RestTemplateSender.java index 5701e82c6..7dd590437 100644 --- a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/RestTemplateSender.java +++ b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/RestTemplateSender.java @@ -54,8 +54,7 @@ final class RestTemplateSender extends Sender { */ transient boolean closeCalled; - RestTemplateSender(RestTemplate restTemplate, String baseUrl, - BytesEncoder encoder) { + RestTemplateSender(RestTemplate restTemplate, String baseUrl, BytesEncoder encoder) { this.restTemplate = restTemplate; this.encoding = encoder.encoding(); if (encoder.equals(JSON_V2)) { @@ -71,8 +70,7 @@ final class RestTemplateSender extends Sender { this.url = baseUrl + (baseUrl.endsWith("/") ? "" : "/") + "api/v1/spans"; } else { - throw new UnsupportedOperationException( - "Unsupported encoding: " + this.encoding.name()); + throw new UnsupportedOperationException("Unsupported encoding: " + this.encoding.name()); } this.messageEncoder = BytesMessageEncoder.forEncoding(this.encoding); } @@ -124,8 +122,8 @@ final class RestTemplateSender extends Sender { void post(byte[] json) { HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.setContentType(this.mediaType); - RequestEntity requestEntity = new RequestEntity<>(json, httpHeaders, - HttpMethod.POST, URI.create(this.url)); + RequestEntity requestEntity = new RequestEntity<>(json, httpHeaders, HttpMethod.POST, + URI.create(this.url)); this.restTemplate.exchange(requestEntity, String.class); } diff --git a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinActiveMqSenderConfiguration.java b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinActiveMqSenderConfiguration.java index 6abd005fb..d4732bec3 100644 --- a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinActiveMqSenderConfiguration.java +++ b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinActiveMqSenderConfiguration.java @@ -52,8 +52,8 @@ class ZipkinActiveMqSenderConfiguration { @Bean(ZipkinAutoConfiguration.SENDER_BEAN_NAME) Sender activeMqSender(ActiveMQConnectionFactory factory) { - return ActiveMQSender.newBuilder().connectionFactory(factory) - .messageMaxBytes(this.messageMaxBytes).queue(this.queue).build(); + return ActiveMQSender.newBuilder().connectionFactory(factory).messageMaxBytes(this.messageMaxBytes) + .queue(this.queue).build(); } } diff --git a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinKafkaSenderConfiguration.java b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinKafkaSenderConfiguration.java index 0ad022b8f..39cc81445 100644 --- a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinKafkaSenderConfiguration.java +++ b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinKafkaSenderConfiguration.java @@ -69,8 +69,7 @@ class ZipkinKafkaSenderConfiguration { if (bootstrapServers instanceof List) { properties.put("bootstrap.servers", join((List) bootstrapServers)); } - return KafkaSender.newBuilder().topic(this.topic).overrides(properties) - .build(); + return KafkaSender.newBuilder().topic(this.topic).overrides(properties).build(); } } diff --git a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRabbitSenderConfiguration.java b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRabbitSenderConfiguration.java index b2457fa61..801680692 100644 --- a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRabbitSenderConfiguration.java +++ b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRabbitSenderConfiguration.java @@ -45,12 +45,9 @@ class ZipkinRabbitSenderConfiguration { private String addresses; @Bean(ZipkinAutoConfiguration.SENDER_BEAN_NAME) - Sender rabbitSender(CachingConnectionFactory connectionFactory, - RabbitProperties config) { - String addresses = StringUtils.hasText(this.addresses) ? this.addresses - : config.determineAddresses(); - return RabbitMQSender.newBuilder() - .connectionFactory(connectionFactory.getRabbitConnectionFactory()) + Sender rabbitSender(CachingConnectionFactory connectionFactory, RabbitProperties config) { + String addresses = StringUtils.hasText(this.addresses) ? this.addresses : config.determineAddresses(); + return RabbitMQSender.newBuilder().connectionFactory(connectionFactory.getRabbitConnectionFactory()) .queue(this.queue).addresses(addresses).build(); } diff --git a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRestTemplateSenderConfiguration.java b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRestTemplateSenderConfiguration.java index d65bd3137..f0eb92ead 100644 --- a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRestTemplateSenderConfiguration.java +++ b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRestTemplateSenderConfiguration.java @@ -52,8 +52,7 @@ import org.springframework.web.client.RestTemplate; @EnableConfigurationProperties(ZipkinSenderProperties.class) class ZipkinRestTemplateSenderConfiguration { - private static final Log log = LogFactory - .getLog(ZipkinRestTemplateSenderConfiguration.class); + private static final Log log = LogFactory.getLog(ZipkinRestTemplateSenderConfiguration.class); @Autowired ZipkinUrlExtractor extractor; @@ -63,8 +62,7 @@ class ZipkinRestTemplateSenderConfiguration { ZipkinRestTemplateCustomizer zipkinRestTemplateCustomizer) { RestTemplate restTemplate = new ZipkinRestTemplateWrapper(zipkin, this.extractor); restTemplate = zipkinRestTemplateCustomizer.customizeTemplate(restTemplate); - return new RestTemplateSender(restTemplate, zipkin.getBaseUrl(), - zipkin.getEncoder()); + return new RestTemplateSender(restTemplate, zipkin.getBaseUrl(), zipkin.getEncoder()); } @Bean @@ -145,8 +143,8 @@ class ZipkinRestTemplateSenderConfiguration { static class DiscoveryClientZipkinUrlExtractorConfiguration { @Configuration(proxyBeanMethods = false) - @ConditionalOnProperty(value = "spring.zipkin.discovery-client-enabled", - havingValue = "true", matchIfMissing = true) + @ConditionalOnProperty(value = "spring.zipkin.discovery-client-enabled", havingValue = "true", + matchIfMissing = true) static class ZipkinClientLoadBalancedConfiguration { @Autowired(required = false) @@ -154,17 +152,14 @@ class ZipkinRestTemplateSenderConfiguration { @Bean @ConditionalOnMissingBean - ZipkinLoadBalancer loadBalancerClientZipkinLoadBalancer( - ZipkinProperties zipkinProperties) { - return new LoadBalancerClientZipkinLoadBalancer(this.client, - zipkinProperties); + ZipkinLoadBalancer loadBalancerClientZipkinLoadBalancer(ZipkinProperties zipkinProperties) { + return new LoadBalancerClientZipkinLoadBalancer(this.client, zipkinProperties); } } @Configuration(proxyBeanMethods = false) - @ConditionalOnProperty(value = "spring.zipkin.discovery-client-enabled", - havingValue = "false") + @ConditionalOnProperty(value = "spring.zipkin.discovery-client-enabled", havingValue = "false") static class ZipkinClientNoOpConfiguration { @Bean @@ -205,8 +200,7 @@ class ZipkinRestTemplateWrapper extends RestTemplate { private final ZipkinUrlExtractor extractor; - ZipkinRestTemplateWrapper(ZipkinProperties zipkinProperties, - ZipkinUrlExtractor extractor) { + ZipkinRestTemplateWrapper(ZipkinProperties zipkinProperties, ZipkinUrlExtractor extractor) { this.zipkinProperties = zipkinProperties; this.extractor = extractor; setRequestFactory(clientHttpRequestFactory()); @@ -220,9 +214,8 @@ class ZipkinRestTemplateWrapper extends RestTemplate { } @Override - protected T doExecute(URI originalUrl, HttpMethod method, - RequestCallback requestCallback, ResponseExtractor responseExtractor) - throws RestClientException { + protected T doExecute(URI originalUrl, HttpMethod method, RequestCallback requestCallback, + ResponseExtractor responseExtractor) throws RestClientException { URI uri = this.extractor.zipkinUrl(this.zipkinProperties); URI newUri = resolvedZipkinUri(originalUrl, uri); return super.doExecute(newUri, method, requestCallback, responseExtractor); @@ -230,15 +223,14 @@ class ZipkinRestTemplateWrapper extends RestTemplate { private URI resolvedZipkinUri(URI originalUrl, URI resolvedZipkinUri) { try { - return new URI(resolvedZipkinUri.getScheme(), resolvedZipkinUri.getUserInfo(), - resolvedZipkinUri.getHost(), resolvedZipkinUri.getPort(), - originalUrl.getPath(), originalUrl.getQuery(), + return new URI(resolvedZipkinUri.getScheme(), resolvedZipkinUri.getUserInfo(), resolvedZipkinUri.getHost(), + resolvedZipkinUri.getPort(), originalUrl.getPath(), originalUrl.getQuery(), originalUrl.getFragment()); } catch (URISyntaxException e) { if (log.isDebugEnabled()) { - log.debug("Failed to create the new URI from original [" + originalUrl - + "] and new one [" + resolvedZipkinUri + "]"); + log.debug("Failed to create the new URI from original [" + originalUrl + "] and new one [" + + resolvedZipkinUri + "]"); } return originalUrl; } diff --git a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinSenderCondition.java b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinSenderCondition.java index 334d8e354..a62f713ff 100644 --- a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinSenderCondition.java +++ b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinSenderCondition.java @@ -31,16 +31,13 @@ import static org.springframework.cloud.sleuth.zipkin2.sender.ZipkinSenderConfig class ZipkinSenderCondition extends SpringBootCondition { @Override - public ConditionOutcome getMatchOutcome(ConditionContext context, - AnnotatedTypeMetadata md) { + public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata md) { String sourceClass = ""; if (md instanceof ClassMetadata) { sourceClass = ((ClassMetadata) md).getClassName(); } - ConditionMessage.Builder message = ConditionMessage.forCondition("ZipkinSender", - sourceClass); - String property = context.getEnvironment() - .getProperty("spring.zipkin.sender.type"); + ConditionMessage.Builder message = ConditionMessage.forCondition("ZipkinSender", sourceClass); + String property = context.getEnvironment().getProperty("spring.zipkin.sender.type"); if (StringUtils.isEmpty(property)) { return ConditionOutcome.match(message.because("automatic sender type")); } diff --git a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinSenderConfigurationImportSelector.java b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinSenderConfigurationImportSelector.java index 9996e32a2..4fb511395 100644 --- a/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinSenderConfigurationImportSelector.java +++ b/spring-cloud-sleuth-zipkin/src/main/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinSenderConfigurationImportSelector.java @@ -49,8 +49,7 @@ public class ZipkinSenderConfigurationImportSelector implements ImportSelector { return entry.getKey(); } } - throw new IllegalStateException( - "Unknown configuration class " + configurationClassName); + throw new IllegalStateException("Unknown configuration class " + configurationClassName); } @Override diff --git a/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/DefaultEndpointLocatorConfigurationTest.java b/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/DefaultEndpointLocatorConfigurationTest.java index 32ff08630..1b03e2860 100644 --- a/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/DefaultEndpointLocatorConfigurationTest.java +++ b/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/DefaultEndpointLocatorConfigurationTest.java @@ -49,68 +49,58 @@ public class DefaultEndpointLocatorConfigurationTest { @Test public void endpointLocatorShouldDefaultToServerPropertiesEndpointLocator() { - ConfigurableApplicationContext ctxt = new SpringApplication( - EmptyConfiguration.class).run("--spring.jmx.enabled=false"); - assertThat(ctxt.getBean(EndpointLocator.class)) - .isInstanceOf(DefaultEndpointLocator.class); + ConfigurableApplicationContext ctxt = new SpringApplication(EmptyConfiguration.class) + .run("--spring.jmx.enabled=false"); + assertThat(ctxt.getBean(EndpointLocator.class)).isInstanceOf(DefaultEndpointLocator.class); ctxt.close(); } @Test public void endpointLocatorShouldDefaultToServerPropertiesEndpointLocatorEvenWhenDiscoveryClientPresent() { - ConfigurableApplicationContext ctxt = new SpringApplication( - ConfigurationWithRegistration.class).run("--spring.jmx.enabled=false"); - assertThat(ctxt.getBean(EndpointLocator.class)) - .isInstanceOf(DefaultEndpointLocator.class); + ConfigurableApplicationContext ctxt = new SpringApplication(ConfigurationWithRegistration.class) + .run("--spring.jmx.enabled=false"); + assertThat(ctxt.getBean(EndpointLocator.class)).isInstanceOf(DefaultEndpointLocator.class); ctxt.close(); } @Test public void endpointLocatorShouldRespectExistingEndpointLocator() { - ConfigurableApplicationContext ctxt = new SpringApplication( - ConfigurationWithCustomLocator.class).run("--spring.jmx.enabled=false"); - assertThat(ctxt.getBean(EndpointLocator.class)) - .isSameAs(ConfigurationWithCustomLocator.locator); + ConfigurableApplicationContext ctxt = new SpringApplication(ConfigurationWithCustomLocator.class) + .run("--spring.jmx.enabled=false"); + assertThat(ctxt.getBean(EndpointLocator.class)).isSameAs(ConfigurationWithCustomLocator.locator); ctxt.close(); } @Test public void endpointLocatorShouldSetServiceNameToServiceId() { - ConfigurableApplicationContext ctxt = new SpringApplication( - ConfigurationWithRegistration.class).run("--spring.jmx.enabled=false", - "--spring.zipkin.locator.discovery.enabled=true"); - assertThat(ctxt.getBean(EndpointLocator.class).local().serviceName()) - .isEqualTo("from-registration"); + ConfigurableApplicationContext ctxt = new SpringApplication(ConfigurationWithRegistration.class) + .run("--spring.jmx.enabled=false", "--spring.zipkin.locator.discovery.enabled=true"); + assertThat(ctxt.getBean(EndpointLocator.class).local().serviceName()).isEqualTo("from-registration"); ctxt.close(); } @Test public void endpointLocatorShouldAcceptServiceNameOverride() { - ConfigurableApplicationContext ctxt = new SpringApplication( - ConfigurationWithRegistration.class).run("--spring.jmx.enabled=false", - "--spring.zipkin.locator.discovery.enabled=true", - "--spring.zipkin.service.name=foo"); - assertThat(ctxt.getBean(EndpointLocator.class).local().serviceName()) - .isEqualTo("foo"); + ConfigurableApplicationContext ctxt = new SpringApplication(ConfigurationWithRegistration.class).run( + "--spring.jmx.enabled=false", "--spring.zipkin.locator.discovery.enabled=true", + "--spring.zipkin.service.name=foo"); + assertThat(ctxt.getBean(EndpointLocator.class).local().serviceName()).isEqualTo("foo"); ctxt.close(); } @Test public void endpointLocatorShouldRespectExistingEndpointLocatorEvenWhenAskedToBeDiscovery() { - ConfigurableApplicationContext ctxt = new SpringApplication( - ConfigurationWithRegistration.class, ConfigurationWithCustomLocator.class) - .run("--spring.jmx.enabled=false", - "--spring.zipkin.locator.discovery.enabled=true"); - assertThat(ctxt.getBean(EndpointLocator.class)) - .isSameAs(ConfigurationWithCustomLocator.locator); + ConfigurableApplicationContext ctxt = new SpringApplication(ConfigurationWithRegistration.class, + ConfigurationWithCustomLocator.class).run("--spring.jmx.enabled=false", + "--spring.zipkin.locator.discovery.enabled=true"); + assertThat(ctxt.getBean(EndpointLocator.class)).isSameAs(ConfigurationWithCustomLocator.locator); ctxt.close(); } @Test public void portDefaultsTo8080() throws UnknownHostException { - DefaultEndpointLocator locator = new DefaultEndpointLocator(null, - new ServerProperties(), this.environment, new ZipkinProperties(), - localAddress(ADDRESS1234)); + DefaultEndpointLocator locator = new DefaultEndpointLocator(null, new ServerProperties(), this.environment, + new ZipkinProperties(), localAddress(ADDRESS1234)); assertThat(locator.local().port()).isEqualTo(8080); } @@ -120,17 +110,16 @@ public class DefaultEndpointLocatorConfigurationTest { ServerProperties properties = new ServerProperties(); properties.setPort(1234); - DefaultEndpointLocator locator = new DefaultEndpointLocator(null, properties, - this.environment, new ZipkinProperties(), localAddress(ADDRESS1234)); + DefaultEndpointLocator locator = new DefaultEndpointLocator(null, properties, this.environment, + new ZipkinProperties(), localAddress(ADDRESS1234)); assertThat(locator.local().port()).isEqualTo(1234); } @Test public void portDefaultsToLocalhost() throws UnknownHostException { - DefaultEndpointLocator locator = new DefaultEndpointLocator(null, - new ServerProperties(), this.environment, new ZipkinProperties(), - localAddress(ADDRESS1234)); + DefaultEndpointLocator locator = new DefaultEndpointLocator(null, new ServerProperties(), this.environment, + new ZipkinProperties(), localAddress(ADDRESS1234)); assertThat(locator.local().ipv4()).isEqualTo("1.2.3.4"); } @@ -140,9 +129,8 @@ public class DefaultEndpointLocatorConfigurationTest { ServerProperties properties = new ServerProperties(); properties.setAddress(InetAddress.getByAddress(ADDRESS1234)); - DefaultEndpointLocator locator = new DefaultEndpointLocator(null, properties, - this.environment, new ZipkinProperties(), - localAddress(new byte[] { 4, 4, 4, 4 })); + DefaultEndpointLocator locator = new DefaultEndpointLocator(null, properties, this.environment, + new ZipkinProperties(), localAddress(new byte[] { 4, 4, 4, 4 })); assertThat(locator.local().ipv4()).isEqualTo("1.2.3.4"); } @@ -153,8 +141,8 @@ public class DefaultEndpointLocatorConfigurationTest { ZipkinProperties zipkinProperties = new ZipkinProperties(); zipkinProperties.getService().setName("foo"); - DefaultEndpointLocator locator = new DefaultEndpointLocator(null, properties, - this.environment, zipkinProperties, localAddress(ADDRESS1234)); + DefaultEndpointLocator locator = new DefaultEndpointLocator(null, properties, this.environment, + zipkinProperties, localAddress(ADDRESS1234)); assertThat(locator.local().serviceName()).isEqualTo("foo"); } @@ -164,16 +152,15 @@ public class DefaultEndpointLocatorConfigurationTest { ServerProperties properties = new ServerProperties(); properties.setPort(-1); - DefaultEndpointLocator locator = new DefaultEndpointLocator(null, properties, - this.environment, new ZipkinProperties(), localAddress(ADDRESS1234)); + DefaultEndpointLocator locator = new DefaultEndpointLocator(null, properties, this.environment, + new ZipkinProperties(), localAddress(ADDRESS1234)); assertThat(locator.local().port()).isEqualTo(8080); } private InetUtils localAddress(byte[] address) throws UnknownHostException { InetUtils mocked = Mockito.spy(new InetUtils(new InetUtilsProperties())); - Mockito.when(mocked.findFirstNonLoopbackAddress()) - .thenReturn(InetAddress.getByAddress(address)); + Mockito.when(mocked.findFirstNonLoopbackAddress()).thenReturn(InetAddress.getByAddress(address)); return mocked; } diff --git a/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/ZipkinAutoConfigurationTests.java b/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/ZipkinAutoConfigurationTests.java index 8d6707c5e..ad3e2d0a6 100644 --- a/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/ZipkinAutoConfigurationTests.java +++ b/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/ZipkinAutoConfigurationTests.java @@ -123,13 +123,11 @@ public class ZipkinAutoConfigurationTests { @Test void should_apply_micrometer_reporter_metrics_when_meter_registry_bean_present() { - this.contextRunner.withUserConfiguration(WithMeterRegistry.class) - .run((context) -> { - ReporterMetrics bean = context.getBean(ReporterMetrics.class); + this.contextRunner.withUserConfiguration(WithMeterRegistry.class).run((context) -> { + ReporterMetrics bean = context.getBean(ReporterMetrics.class); - BDDAssertions.then(bean) - .isInstanceOf(MicrometerReporterMetrics.class); - }); + BDDAssertions.then(bean).isInstanceOf(MicrometerReporterMetrics.class); + }); } @Test @@ -143,30 +141,25 @@ public class ZipkinAutoConfigurationTests { @Test void should_apply_in_memory_metrics_when_meter_registry_class_missing() { - this.contextRunner.withClassLoader(new FilteredClassLoader(MeterRegistry.class)) - .run((context) -> { - ReporterMetrics bean = context.getBean(ReporterMetrics.class); + this.contextRunner.withClassLoader(new FilteredClassLoader(MeterRegistry.class)).run((context) -> { + ReporterMetrics bean = context.getBean(ReporterMetrics.class); - BDDAssertions.then(bean).isInstanceOf(InMemoryReporterMetrics.class); - }); + BDDAssertions.then(bean).isInstanceOf(InMemoryReporterMetrics.class); + }); } @Test void defaultsToV2Endpoint() throws Exception { this.context = new AnnotationConfigApplicationContext(); - environment().setProperty("spring.zipkin.base-url", - this.server.url("/").toString()); - this.context.register(ZipkinAutoConfiguration.class, - PropertyPlaceholderAutoConfiguration.class, TraceAutoConfiguration.class, - Config.class); + environment().setProperty("spring.zipkin.base-url", this.server.url("/").toString()); + this.context.register(ZipkinAutoConfiguration.class, PropertyPlaceholderAutoConfiguration.class, + TraceAutoConfiguration.class, Config.class); this.context.refresh(); - Span span = this.context.getBean(Tracing.class).tracer().nextSpan().name("foo") - .tag("foo", "bar").start(); + Span span = this.context.getBean(Tracing.class).tracer().nextSpan().name("foo").tag("foo", "bar").start(); span.finish(); - Awaitility.await().untilAsserted( - () -> then(this.server.getRequestCount()).isGreaterThan(1)); + Awaitility.await().untilAsserted(() -> then(this.server.getRequestCount()).isGreaterThan(1)); // first request is for health check this.server.takeRequest(); // second request is the span one @@ -183,20 +176,16 @@ public class ZipkinAutoConfigurationTests { @Test public void encoderDirectsEndpoint() throws Exception { this.context = new AnnotationConfigApplicationContext(); - environment().setProperty("spring.zipkin.base-url", - this.server.url("/").toString()); + environment().setProperty("spring.zipkin.base-url", this.server.url("/").toString()); environment().setProperty("spring.zipkin.encoder", "JSON_V1"); - this.context.register(ZipkinAutoConfiguration.class, - PropertyPlaceholderAutoConfiguration.class, TraceAutoConfiguration.class, - Config.class); + this.context.register(ZipkinAutoConfiguration.class, PropertyPlaceholderAutoConfiguration.class, + TraceAutoConfiguration.class, Config.class); this.context.refresh(); - Span span = this.context.getBean(Tracing.class).tracer().nextSpan().name("foo") - .tag("foo", "bar").start(); + Span span = this.context.getBean(Tracing.class).tracer().nextSpan().name("foo").tag("foo", "bar").start(); span.finish(); - Awaitility.await().untilAsserted( - () -> then(this.server.getRequestCount()).isGreaterThan(0)); + Awaitility.await().untilAsserted(() -> then(this.server.getRequestCount()).isGreaterThan(0)); // first request is for health check this.server.takeRequest(); // second request is the span one @@ -210,9 +199,8 @@ public class ZipkinAutoConfigurationTests { this.context = new AnnotationConfigApplicationContext(); environment().setProperty("spring.zipkin.rabbitmq.queue", "zipkin2"); environment().setProperty("spring.zipkin.sender.type", "rabbit"); - this.context.register(PropertyPlaceholderAutoConfiguration.class, - RabbitAutoConfiguration.class, ZipkinAutoConfiguration.class, - TraceAutoConfiguration.class); + this.context.register(PropertyPlaceholderAutoConfiguration.class, RabbitAutoConfiguration.class, + ZipkinAutoConfiguration.class, TraceAutoConfiguration.class); this.context.refresh(); then(this.context.getBean(Sender.class)).isInstanceOf(RabbitMQSender.class); @@ -225,9 +213,8 @@ public class ZipkinAutoConfigurationTests { this.context = new AnnotationConfigApplicationContext(); environment().setProperty("spring.zipkin.kafka.topic", "zipkin2"); environment().setProperty("spring.zipkin.sender.type", "kafka"); - this.context.register(PropertyPlaceholderAutoConfiguration.class, - KafkaAutoConfiguration.class, ZipkinAutoConfiguration.class, - TraceAutoConfiguration.class); + this.context.register(PropertyPlaceholderAutoConfiguration.class, KafkaAutoConfiguration.class, + ZipkinAutoConfiguration.class, TraceAutoConfiguration.class); this.context.refresh(); then(this.context.getBean(Sender.class)).isInstanceOf(KafkaSender.class); @@ -242,9 +229,8 @@ public class ZipkinAutoConfigurationTests { environment().setProperty("spring.zipkin.activemq.queue", "zipkin2"); environment().setProperty("spring.zipkin.activemq.message-max-bytes", "50"); environment().setProperty("spring.zipkin.sender.type", "activemq"); - this.context.register(PropertyPlaceholderAutoConfiguration.class, - ActiveMQAutoConfiguration.class, ZipkinAutoConfiguration.class, - TraceAutoConfiguration.class); + this.context.register(PropertyPlaceholderAutoConfiguration.class, ActiveMQAutoConfiguration.class, + ZipkinAutoConfiguration.class, TraceAutoConfiguration.class); this.context.refresh(); then(this.context.getBean(Sender.class)).isInstanceOf(ActiveMQSender.class); @@ -256,13 +242,11 @@ public class ZipkinAutoConfigurationTests { public void canOverrideBySender() throws Exception { this.context = new AnnotationConfigApplicationContext(); environment().setProperty("spring.zipkin.sender.type", "web"); - this.context.register(PropertyPlaceholderAutoConfiguration.class, - RabbitAutoConfiguration.class, KafkaAutoConfiguration.class, - ZipkinAutoConfiguration.class, TraceAutoConfiguration.class); + this.context.register(PropertyPlaceholderAutoConfiguration.class, RabbitAutoConfiguration.class, + KafkaAutoConfiguration.class, ZipkinAutoConfiguration.class, TraceAutoConfiguration.class); this.context.refresh(); - then(this.context.getBean(Sender.class).getClass().getName()) - .contains("RestTemplateSender"); + then(this.context.getBean(Sender.class).getClass().getName()).contains("RestTemplateSender"); this.context.close(); } @@ -271,13 +255,11 @@ public class ZipkinAutoConfigurationTests { public void canOverrideBySenderAndIsCaseInsensitive() throws Exception { this.context = new AnnotationConfigApplicationContext(); environment().setProperty("spring.zipkin.sender.type", "WEB"); - this.context.register(PropertyPlaceholderAutoConfiguration.class, - RabbitAutoConfiguration.class, KafkaAutoConfiguration.class, - ZipkinAutoConfiguration.class, TraceAutoConfiguration.class); + this.context.register(PropertyPlaceholderAutoConfiguration.class, RabbitAutoConfiguration.class, + KafkaAutoConfiguration.class, ZipkinAutoConfiguration.class, TraceAutoConfiguration.class); this.context.refresh(); - then(this.context.getBean(Sender.class).getClass().getName()) - .contains("RestTemplateSender"); + then(this.context.getBean(Sender.class).getClass().getName()).contains("RestTemplateSender"); this.context.close(); } @@ -286,9 +268,8 @@ public class ZipkinAutoConfigurationTests { public void rabbitWinsWhenKafkaPresent() throws Exception { this.context = new AnnotationConfigApplicationContext(); environment().setProperty("spring.zipkin.sender.type", "rabbit"); - this.context.register(PropertyPlaceholderAutoConfiguration.class, - RabbitAutoConfiguration.class, KafkaAutoConfiguration.class, - ZipkinAutoConfiguration.class, TraceAutoConfiguration.class); + this.context.register(PropertyPlaceholderAutoConfiguration.class, RabbitAutoConfiguration.class, + KafkaAutoConfiguration.class, ZipkinAutoConfiguration.class, TraceAutoConfiguration.class); this.context.refresh(); then(this.context.getBean(Sender.class)).isInstanceOf(RabbitMQSender.class); @@ -299,28 +280,24 @@ public class ZipkinAutoConfigurationTests { @Test public void supportsMultipleReporters() throws Exception { this.context = new AnnotationConfigApplicationContext(); - environment().setProperty("spring.zipkin.base-url", - this.server.url("/").toString()); - this.context.register(ZipkinAutoConfiguration.class, - PropertyPlaceholderAutoConfiguration.class, TraceAutoConfiguration.class, - Config.class, MultipleReportersConfig.class); + environment().setProperty("spring.zipkin.base-url", this.server.url("/").toString()); + this.context.register(ZipkinAutoConfiguration.class, PropertyPlaceholderAutoConfiguration.class, + TraceAutoConfiguration.class, Config.class, MultipleReportersConfig.class); this.context.refresh(); then(this.context.getBeansOfType(Sender.class)).hasSize(2); - then(this.context.getBeansOfType(Sender.class)) - .containsKeys(ZipkinAutoConfiguration.SENDER_BEAN_NAME, "otherSender"); + then(this.context.getBeansOfType(Sender.class)).containsKeys(ZipkinAutoConfiguration.SENDER_BEAN_NAME, + "otherSender"); then(this.context.getBeansOfType(Reporter.class)).hasSize(2); - then(this.context.getBeansOfType(Reporter.class)).containsKeys( - ZipkinAutoConfiguration.REPORTER_BEAN_NAME, "otherReporter"); + then(this.context.getBeansOfType(Reporter.class)).containsKeys(ZipkinAutoConfiguration.REPORTER_BEAN_NAME, + "otherReporter"); - Span span = this.context.getBean(Tracing.class).tracer().nextSpan().name("foo") - .tag("foo", "bar").start(); + Span span = this.context.getBean(Tracing.class).tracer().nextSpan().name("foo").tag("foo", "bar").start(); span.finish(); - Awaitility.await().untilAsserted( - () -> then(this.server.getRequestCount()).isGreaterThan(1)); + Awaitility.await().untilAsserted(() -> then(this.server.getRequestCount()).isGreaterThan(1)); // first request is for health check this.server.takeRequest(); // second request is the span one @@ -328,34 +305,28 @@ public class ZipkinAutoConfigurationTests { then(request.getPath()).isEqualTo("/api/v2/spans"); then(request.getBody().readUtf8()).contains("localEndpoint"); - MultipleReportersConfig.OtherSender sender = this.context - .getBean(MultipleReportersConfig.OtherSender.class); + MultipleReportersConfig.OtherSender sender = this.context.getBean(MultipleReportersConfig.OtherSender.class); Awaitility.await().untilAsserted(() -> then(sender.isSpanSent()).isTrue()); } @Test public void shouldOverrideDefaultBeans() { this.context = new AnnotationConfigApplicationContext(); - this.context.register(ZipkinAutoConfiguration.class, - PropertyPlaceholderAutoConfiguration.class, TraceAutoConfiguration.class, - Config.class, MyConfig.class); + this.context.register(ZipkinAutoConfiguration.class, PropertyPlaceholderAutoConfiguration.class, + TraceAutoConfiguration.class, Config.class, MyConfig.class); this.context.refresh(); then(this.context.getBeansOfType(Sender.class)).hasSize(1); - then(this.context.getBeansOfType(Sender.class)) - .containsKeys(ZipkinAutoConfiguration.SENDER_BEAN_NAME); + then(this.context.getBeansOfType(Sender.class)).containsKeys(ZipkinAutoConfiguration.SENDER_BEAN_NAME); then(this.context.getBeansOfType(Reporter.class)).hasSize(1); - then(this.context.getBeansOfType(Reporter.class)) - .containsKeys(ZipkinAutoConfiguration.REPORTER_BEAN_NAME); + then(this.context.getBeansOfType(Reporter.class)).containsKeys(ZipkinAutoConfiguration.REPORTER_BEAN_NAME); - Span span = this.context.getBean(Tracing.class).tracer().nextSpan().name("foo") - .tag("foo", "bar").start(); + Span span = this.context.getBean(Tracing.class).tracer().nextSpan().name("foo").tag("foo", "bar").start(); span.finish(); - Awaitility.await() - .untilAsserted(() -> then(this.server.getRequestCount()).isEqualTo(0)); + Awaitility.await().untilAsserted(() -> then(this.server.getRequestCount()).isEqualTo(0)); MyConfig.MySender sender = this.context.getBean(MyConfig.MySender.class); Awaitility.await().untilAsserted(() -> then(sender.isSpanSent()).isTrue()); @@ -375,8 +346,7 @@ public class ZipkinAutoConfigurationTests { RuntimeException exception = new RuntimeException("dead"); when(sender.check()).thenReturn(CheckResult.failed(exception)); - assertThat(ZipkinAutoConfiguration.checkResult(sender, 200).error()) - .isSameAs(exception); + assertThat(ZipkinAutoConfiguration.checkResult(sender, 200).error()).isSameAs(exception); } /** Bug in {@link Sender} as it shouldn't throw */ @@ -386,8 +356,7 @@ public class ZipkinAutoConfigurationTests { RuntimeException exception = new RuntimeException("dead"); when(sender.check()).thenThrow(exception); - assertThat(ZipkinAutoConfiguration.checkResult(sender, 200).error()) - .isSameAs(exception); + assertThat(ZipkinAutoConfiguration.checkResult(sender, 200).error()).isSameAs(exception); } @Test @@ -428,8 +397,7 @@ public class ZipkinAutoConfigurationTests { public String toString() { return "FakeSender{}"; } - }, 200).error()).isInstanceOf(TimeoutException.class) - .hasMessage("FakeSender{} check() timed out after 200ms"); + }, 200).error()).isInstanceOf(TimeoutException.class).hasMessage("FakeSender{} check() timed out after 200ms"); } @Configuration @@ -449,8 +417,7 @@ public class ZipkinAutoConfigurationTests { SpanHandler handlerOne() { return new SpanHandler() { @Override - public boolean end(TraceContext traceContext, MutableSpan span, - Cause cause) { + public boolean end(TraceContext traceContext, MutableSpan span, Cause cause) { span.name("foo"); return true; // keep this span } @@ -461,8 +428,7 @@ public class ZipkinAutoConfigurationTests { SpanHandler handlerTwo() { return new SpanHandler() { @Override - public boolean end(TraceContext traceContext, MutableSpan span, - Cause cause) { + public boolean end(TraceContext traceContext, MutableSpan span, Cause cause) { span.name(span.name() + " bar"); return true; // keep this span } diff --git a/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/ZipkinDiscoveryClientTests.java b/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/ZipkinDiscoveryClientTests.java index db7d65ef4..529d7e134 100644 --- a/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/ZipkinDiscoveryClientTests.java +++ b/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/ZipkinDiscoveryClientTests.java @@ -41,17 +41,17 @@ import org.springframework.context.annotation.Configuration; import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest(classes = ZipkinDiscoveryClientTests.Config.class, properties = { - "spring.zipkin.baseUrl=https://zipkin/", "spring.zipkin.sender.type=web" // override - // default - // priority - // which - // picks - // rabbit - // due - // to - // classpath -}) +@SpringBootTest(classes = ZipkinDiscoveryClientTests.Config.class, + properties = { "spring.zipkin.baseUrl=https://zipkin/", "spring.zipkin.sender.type=web" // override + // default + // priority + // which + // picks + // rabbit + // due + // to + // classpath + }) public class ZipkinDiscoveryClientTests { public static MockWebServer ZIPKIN_RULE = new MockWebServer(); @@ -75,8 +75,7 @@ public class ZipkinDiscoveryClientTests { span.finish(); - Awaitility.await().untilAsserted( - () -> then(ZIPKIN_RULE.getRequestCount()).isGreaterThan(0)); + Awaitility.await().untilAsserted(() -> then(ZIPKIN_RULE.getRequestCount()).isGreaterThan(0)); } @Configuration @@ -92,14 +91,13 @@ public class ZipkinDiscoveryClientTests { LoadBalancerClient loadBalancerClient() { return new LoadBalancerClient() { @Override - public T execute(String serviceId, LoadBalancerRequest request) - throws IOException { + public T execute(String serviceId, LoadBalancerRequest request) throws IOException { return null; } @Override - public T execute(String serviceId, ServiceInstance serviceInstance, - LoadBalancerRequest request) throws IOException { + public T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest request) + throws IOException { return null; } diff --git a/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/sender/RestTemplateSenderTest.java b/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/sender/RestTemplateSenderTest.java index ad16e3d12..7a218fc03 100644 --- a/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/sender/RestTemplateSenderTest.java +++ b/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/sender/RestTemplateSenderTest.java @@ -39,13 +39,11 @@ import static zipkin2.codec.SpanBytesEncoder.PROTO3; public class RestTemplateSenderTest { - static final Span SPAN = Span.newBuilder().traceId("7180c278b62e8f6a216a2aea45d08fc9") - .parentId("6b221d5bc9e6496c").id("5b4185666d50f68b").name("get /backend") - .kind(Span.Kind.SERVER).shared(true) - .localEndpoint(Endpoint.newBuilder().serviceName("backend") - .ip("192.168.99.101").port(9000).build()) - .timestamp(1472470996250000L).duration(100000L).putTag("http.method", "GET") - .putTag("http.path", "/backend").build(); + static final Span SPAN = Span.newBuilder().traceId("7180c278b62e8f6a216a2aea45d08fc9").parentId("6b221d5bc9e6496c") + .id("5b4185666d50f68b").name("get /backend").kind(Span.Kind.SERVER).shared(true) + .localEndpoint(Endpoint.newBuilder().serviceName("backend").ip("192.168.99.101").port(9000).build()) + .timestamp(1472470996250000L).duration(100000L).putTag("http.method", "GET").putTag("http.path", "/backend") + .build(); public MockWebServer server = new MockWebServer(); @@ -56,8 +54,7 @@ public class RestTemplateSenderTest { String endpoint = this.server.url("/api/v2/spans").toString(); - RestTemplateSender sender = new RestTemplateSender(new RestTemplate(), this.endpoint, - JSON_V2); + RestTemplateSender sender = new RestTemplateSender(new RestTemplate(), this.endpoint, JSON_V2); /** * Tests that json is not manipulated as a side-effect of using rest template. @@ -84,15 +81,13 @@ public class RestTemplateSenderTest { assertThat(request.getHeader("Content-Type")).isEqualTo("application/x-protobuf"); // proto3 encoding of ListOfSpan is simply a repeated span entry - assertThat(request.getBody().readByteArray()) - .containsExactly(SpanBytesEncoder.PROTO3.encode(SPAN)); + assertThat(request.getBody().readByteArray()).containsExactly(SpanBytesEncoder.PROTO3.encode(SPAN)); } Call send(Span... spans) { - SpanBytesEncoder bytesEncoder = this.sender.encoding() == Encoding.JSON - ? SpanBytesEncoder.JSON_V2 : SpanBytesEncoder.PROTO3; - return this.sender - .sendSpans(Stream.of(spans).map(bytesEncoder::encode).collect(toList())); + SpanBytesEncoder bytesEncoder = this.sender.encoding() == Encoding.JSON ? SpanBytesEncoder.JSON_V2 + : SpanBytesEncoder.PROTO3; + return this.sender.sendSpans(Stream.of(spans).map(bytesEncoder::encode).collect(toList())); } } diff --git a/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRestTemplateSenderConfigurationTest.java b/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRestTemplateSenderConfigurationTest.java index f071ee8f6..f3d75355a 100644 --- a/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRestTemplateSenderConfigurationTest.java +++ b/spring-cloud-sleuth-zipkin/src/test/java/org/springframework/cloud/sleuth/zipkin2/sender/ZipkinRestTemplateSenderConfigurationTest.java @@ -44,10 +44,8 @@ public class ZipkinRestTemplateSenderConfigurationTest { public void disableZipkinDiscoveryClient() { ConfigurableApplicationContext ctxt = new SpringApplication( ZipkinRestTemplateSenderConfigurationTest.MyDiscoveryClientZipkinUrlExtractorConfiguration.class, - ZipkinProperties.class) - .run("--spring.zipkin.discovery-client-enabled=false"); - assertThat(ctxt.getBean(ZipkinLoadBalancer.class)) - .isInstanceOf(NoOpZipkinLoadBalancer.class); + ZipkinProperties.class).run("--spring.zipkin.discovery-client-enabled=false"); + assertThat(ctxt.getBean(ZipkinLoadBalancer.class)).isInstanceOf(NoOpZipkinLoadBalancer.class); ctxt.close(); } @@ -55,10 +53,8 @@ public class ZipkinRestTemplateSenderConfigurationTest { public void enableZipkinDiscoveryClient() { ConfigurableApplicationContext ctxt = new SpringApplication( ZipkinRestTemplateSenderConfigurationTest.MyDiscoveryClientZipkinUrlExtractorConfiguration.class, - ZipkinProperties.class) - .run("--spring.zipkin.discovery-client-enabled=true"); - assertThat(ctxt.getBean(ZipkinLoadBalancer.class)) - .isInstanceOf(LoadBalancerClientZipkinLoadBalancer.class); + ZipkinProperties.class).run("--spring.zipkin.discovery-client-enabled=true"); + assertThat(ctxt.getBean(ZipkinLoadBalancer.class)).isInstanceOf(LoadBalancerClientZipkinLoadBalancer.class); ctxt.close(); } @@ -78,8 +74,7 @@ public class ZipkinRestTemplateSenderConfigurationTest { URI uri = extractor.zipkinUrl(zipkinProperties); - assertThat(uri.toString()) - .isEqualTo(URI.create(zipkinProperties.getBaseUrl()).toString()); + assertThat(uri.toString()).isEqualTo(URI.create(zipkinProperties.getBaseUrl()).toString()); assertThat(portCalculated).isFalse(); } @@ -92,8 +87,7 @@ public class ZipkinRestTemplateSenderConfigurationTest { URI uri = extractor.zipkinUrl(zipkinProperties); - assertThat(uri.toString()) - .isEqualTo(URI.create("https://example.com").toString()); + assertThat(uri.toString()).isEqualTo(URI.create("https://example.com").toString()); } @Test @@ -104,8 +98,7 @@ public class ZipkinRestTemplateSenderConfigurationTest { URI uri = extractor.zipkinUrl(zipkinProperties); - assertThat(uri.toString()) - .isEqualTo(URI.create(zipkinProperties.getBaseUrl()).toString()); + assertThat(uri.toString()).isEqualTo(URI.create(zipkinProperties.getBaseUrl()).toString()); } @Configuration @@ -113,8 +106,8 @@ public class ZipkinRestTemplateSenderConfigurationTest { static class MyDiscoveryClientZipkinUrlExtractorConfiguration { @Configuration - @ConditionalOnProperty(value = "spring.zipkin.discovery-client-enabled", - havingValue = "true", matchIfMissing = true) + @ConditionalOnProperty(value = "spring.zipkin.discovery-client-enabled", havingValue = "true", + matchIfMissing = true) static class ZipkinClientLoadBalancedConfiguration { @Autowired(required = false) @@ -122,17 +115,14 @@ public class ZipkinRestTemplateSenderConfigurationTest { @Bean @ConditionalOnMissingBean - ZipkinLoadBalancer loadBalancerClientZipkinLoadBalancer( - ZipkinProperties zipkinProperties) { - return new LoadBalancerClientZipkinLoadBalancer(this.client, - zipkinProperties); + ZipkinLoadBalancer loadBalancerClientZipkinLoadBalancer(ZipkinProperties zipkinProperties) { + return new LoadBalancerClientZipkinLoadBalancer(this.client, zipkinProperties); } } @Configuration - @ConditionalOnProperty(value = "spring.zipkin.discovery-client-enabled", - havingValue = "false") + @ConditionalOnProperty(value = "spring.zipkin.discovery-client-enabled", havingValue = "false") static class ZipkinClientNoOpConfiguration { @Bean diff --git a/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/DefaultTestAutoConfiguration.java b/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/DefaultTestAutoConfiguration.java index 02eaea5a1..243d8156a 100644 --- a/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/DefaultTestAutoConfiguration.java +++ b/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/DefaultTestAutoConfiguration.java @@ -28,8 +28,7 @@ import org.springframework.context.annotation.Configuration; @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) -@EnableAutoConfiguration( - exclude = { LoadBalancerAutoConfiguration.class, JmxAutoConfiguration.class }) +@EnableAutoConfiguration(exclude = { LoadBalancerAutoConfiguration.class, JmxAutoConfiguration.class }) @Configuration public @interface DefaultTestAutoConfiguration { diff --git a/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncIntegrationTests.java b/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncIntegrationTests.java index f6a2daa2f..c03f378c5 100644 --- a/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncIntegrationTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/TraceAsyncIntegrationTests.java @@ -45,8 +45,7 @@ public class TraceAsyncIntegrationTests { @ClassRule public static IntegrationTestSpanHandler spans = new IntegrationTestSpanHandler(); - TraceContext context = TraceContext.newBuilder().traceId(1).spanId(2).sampled(true) - .build(); + TraceContext context = TraceContext.newBuilder().traceId(1).spanId(2).sampled(true).build(); @Autowired AsyncLogic asyncLogic; @@ -62,8 +61,7 @@ public class TraceAsyncIntegrationTests { MutableSpan span = takeDesirableSpan(); assertThat(span.name()).isEqualTo("invoke-async"); assertThat(span.containsAnnotation("@Async")).isTrue(); - assertThat(span.tags()).containsEntry("class", "AsyncLogic") - .containsEntry("method", "invokeAsync"); + assertThat(span.tags()).containsEntry("class", "AsyncLogic").containsEntry("method", "invokeAsync"); // continues the trace assertThat(span.traceId()).isEqualTo(context.traceIdString()); @@ -78,8 +76,8 @@ public class TraceAsyncIntegrationTests { MutableSpan span = takeDesirableSpan(); assertThat(span.name()).isEqualTo("foo"); assertThat(span.containsAnnotation("@Async")).isTrue(); - assertThat(span.tags()).containsEntry("class", "AsyncLogic") - .containsEntry("method", "invokeAsync_customName"); + assertThat(span.tags()).containsEntry("class", "AsyncLogic").containsEntry("method", + "invokeAsync_customName"); // continues the trace assertThat(span.traceId()).isEqualTo(context.traceIdString()); diff --git a/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/issues/issue410/Issue410Tests.java b/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/issues/issue410/Issue410Tests.java index 3bcbfd297..784655cf5 100644 --- a/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/issues/issue410/Issue410Tests.java +++ b/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/issues/issue410/Issue410Tests.java @@ -57,8 +57,7 @@ import static org.assertj.core.api.BDDAssertions.then; /** * @author Marcin Grzejszczak */ -@SpringBootTest(classes = { AppConfig.class, Application.class }, - webEnvironment = WebEnvironment.RANDOM_PORT) +@SpringBootTest(classes = { AppConfig.class, Application.class }, webEnvironment = WebEnvironment.RANDOM_PORT) public class Issue410Tests { private static final Log log = LogFactory.getLog(Issue410Tests.class); @@ -86,14 +85,13 @@ public class Issue410Tests { Span span = this.tracer.nextSpan().name("foo"); log.info("Starting test"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { - String response = this.restTemplate.getForObject( - "http://localhost:" + port() + "/without_pool", String.class); + String response = this.restTemplate.getForObject("http://localhost:" + port() + "/without_pool", + String.class); then(response).isEqualTo(span.context().traceIdString()); Awaitility.await().untilAsserted(() -> { then(this.asyncTask.getSpan().get()).isNotNull(); - then(this.asyncTask.getSpan().get().context().traceId()) - .isEqualTo(span.context().traceId()); + then(this.asyncTask.getSpan().get().context().traceId()).isEqualTo(span.context().traceId()); }); } finally { @@ -108,14 +106,12 @@ public class Issue410Tests { Span span = this.tracer.nextSpan().name("foo"); log.info("Starting test"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { - String response = this.restTemplate.getForObject( - "http://localhost:" + port() + "/with_pool", String.class); + String response = this.restTemplate.getForObject("http://localhost:" + port() + "/with_pool", String.class); then(response).isEqualTo(span.context().traceIdString()); Awaitility.await().untilAsserted(() -> { then(this.asyncTask.getSpan().get()).isNotNull(); - then(this.asyncTask.getSpan().get().context().traceId()) - .isEqualTo(span.context().traceId()); + then(this.asyncTask.getSpan().get().context().traceId()).isEqualTo(span.context().traceId()); }); } finally { @@ -133,14 +129,13 @@ public class Issue410Tests { Span span = this.tracer.nextSpan().name("foo"); log.info("Starting test"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { - String response = this.restTemplate.getForObject( - "http://localhost:" + port() + "/completable", String.class); + String response = this.restTemplate.getForObject("http://localhost:" + port() + "/completable", + String.class); then(response).isEqualTo(span.context().traceIdString()); Awaitility.await().untilAsserted(() -> { then(this.asyncTask.getSpan().get()).isNotNull(); - then(this.asyncTask.getSpan().get().context().traceId()) - .isEqualTo(span.context().traceId()); + then(this.asyncTask.getSpan().get().context().traceId()).isEqualTo(span.context().traceId()); }); } finally { @@ -158,14 +153,13 @@ public class Issue410Tests { Span span = this.tracer.nextSpan().name("foo"); log.info("Starting test"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { - String response = this.restTemplate.getForObject( - "http://localhost:" + port() + "/taskScheduler", String.class); + String response = this.restTemplate.getForObject("http://localhost:" + port() + "/taskScheduler", + String.class); then(response).isEqualTo(span.context().traceIdString()); Awaitility.await().untilAsserted(() -> { then(this.asyncTask.getSpan().get()).isNotNull(); - then(this.asyncTask.getSpan().get().context().traceId()) - .isEqualTo(span.context().traceId()); + then(this.asyncTask.getSpan().get().context().traceId()).isEqualTo(span.context().traceId()); }); } finally { @@ -183,15 +177,13 @@ public class Issue410Tests { Span span = this.tracer.nextSpan().name("foo"); log.info("Starting test"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { - String response = this.restTemplate.getForObject( - "http://localhost:" + port() + "/threadPoolTaskScheduler_submit", - String.class); + String response = this.restTemplate + .getForObject("http://localhost:" + port() + "/threadPoolTaskScheduler_submit", String.class); then(response).isEqualTo(span.context().traceIdString()); Awaitility.await().untilAsserted(() -> { then(this.asyncTask.getSpan().get()).isNotNull(); - then(this.asyncTask.getSpan().get().context().traceId()) - .isEqualTo(span.context().traceId()); + then(this.asyncTask.getSpan().get().context().traceId()).isEqualTo(span.context().traceId()); }); } finally { @@ -206,15 +198,13 @@ public class Issue410Tests { Span span = this.tracer.nextSpan().name("foo"); log.info("Starting test"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { - String response = this.restTemplate.getForObject( - "http://localhost:" + port() + "/threadPoolTaskScheduler_schedule", - String.class); + String response = this.restTemplate + .getForObject("http://localhost:" + port() + "/threadPoolTaskScheduler_schedule", String.class); then(response).isEqualTo(span.context().traceIdString()); Awaitility.await().untilAsserted(() -> { then(this.asyncTask.getSpan().get()).isNotNull(); - then(this.asyncTask.getSpan().get().context().traceId()) - .isEqualTo(span.context().traceId()); + then(this.asyncTask.getSpan().get().context().traceId()).isEqualTo(span.context().traceId()); }); } finally { @@ -232,15 +222,13 @@ public class Issue410Tests { Span span = this.tracer.nextSpan().name("foo"); log.info("Starting test"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(span)) { - String response = this.restTemplate.getForObject( - "http://localhost:" + port() + "/scheduledThreadPoolExecutor", - String.class); + String response = this.restTemplate + .getForObject("http://localhost:" + port() + "/scheduledThreadPoolExecutor", String.class); then(response).isEqualTo(span.context().traceIdString()); Awaitility.await().untilAsserted(() -> { then(this.asyncTask.getSpan().get()).isNotNull(); - then(this.asyncTask.getSpan().get().context().traceId()) - .isEqualTo(span.context().traceId()); + then(this.asyncTask.getSpan().get().context().traceId()).isEqualTo(span.context().traceId()); }); } finally { @@ -345,17 +333,15 @@ class AsyncTask { AsyncTask.log.info("Second completable future"); return AsyncTask.this.tracer.currentSpan(); }, AsyncTask.this.executor); - CompletableFuture response = CompletableFuture.allOf(span1, span2) - .thenApply(ignoredVoid -> { - AsyncTask.log.info("Third completable future"); - Span joinedSpan1 = span1.join(); - Span joinedSpan2 = span2.join(); - then(joinedSpan2).isNotNull(); - then(joinedSpan1.context().traceId()) - .isEqualTo(joinedSpan2.context().traceId()); - AsyncTask.log.info("TraceIds are correct"); - return joinedSpan2; - }); + CompletableFuture response = CompletableFuture.allOf(span1, span2).thenApply(ignoredVoid -> { + AsyncTask.log.info("Third completable future"); + Span joinedSpan1 = span1.join(); + Span joinedSpan2 = span2.join(); + then(joinedSpan2).isNotNull(); + then(joinedSpan1.context().traceId()).isEqualTo(joinedSpan2.context().traceId()); + AsyncTask.log.info("TraceIds are correct"); + return joinedSpan2; + }); this.span.set(response.get()); return this.span.get(); } @@ -365,30 +351,25 @@ class AsyncTask { CompletableFuture span1 = CompletableFuture.supplyAsync(() -> { AsyncTask.log.info("First completable future"); return AsyncTask.this.tracer.currentSpan(); - }, new LazyTraceExecutor(AsyncTask.this.beanFactory, - AsyncTask.this.taskScheduler)); + }, new LazyTraceExecutor(AsyncTask.this.beanFactory, AsyncTask.this.taskScheduler)); CompletableFuture span2 = CompletableFuture.supplyAsync(() -> { AsyncTask.log.info("Second completable future"); return AsyncTask.this.tracer.currentSpan(); - }, new LazyTraceExecutor(AsyncTask.this.beanFactory, - AsyncTask.this.taskScheduler)); - CompletableFuture response = CompletableFuture.allOf(span1, span2) - .thenApply(ignoredVoid -> { - AsyncTask.log.info("Third completable future"); - Span joinedSpan1 = span1.join(); - Span joinedSpan2 = span2.join(); - then(joinedSpan2).isNotNull(); - then(joinedSpan1.context().traceId()) - .isEqualTo(joinedSpan2.context().traceId()); - AsyncTask.log.info("TraceIds are correct"); - return joinedSpan2; - }); + }, new LazyTraceExecutor(AsyncTask.this.beanFactory, AsyncTask.this.taskScheduler)); + CompletableFuture response = CompletableFuture.allOf(span1, span2).thenApply(ignoredVoid -> { + AsyncTask.log.info("Third completable future"); + Span joinedSpan1 = span1.join(); + Span joinedSpan2 = span2.join(); + then(joinedSpan2).isNotNull(); + then(joinedSpan1.context().traceId()).isEqualTo(joinedSpan2.context().traceId()); + AsyncTask.log.info("TraceIds are correct"); + return joinedSpan2; + }); this.span.set(response.get()); return this.span.get(); } - public Span scheduledThreadPoolExecutor() - throws ExecutionException, InterruptedException { + public Span scheduledThreadPoolExecutor() throws ExecutionException, InterruptedException { log.info("This task is running with ScheduledThreadPoolExecutor"); this.scheduledThreadPoolExecutor.submit(() -> { log.info("Hello from runnable"); @@ -397,8 +378,7 @@ class AsyncTask { return this.span.get(); } - public Span threadPoolTaskSchedulerSubmit() - throws ExecutionException, InterruptedException { + public Span threadPoolTaskSchedulerSubmit() throws ExecutionException, InterruptedException { log.info("This task is running with ThreadPoolTaskScheduler"); this.threadPoolTaskScheduler.submit(() -> { log.info("Hello from runnable"); @@ -407,8 +387,7 @@ class AsyncTask { return this.span.get(); } - public Span threadPoolTaskSchedulerSchedule() - throws ExecutionException, InterruptedException { + public Span threadPoolTaskSchedulerSchedule() throws ExecutionException, InterruptedException { log.info("This task is running with ThreadPoolTaskScheduler"); this.threadPoolTaskScheduler.schedule(() -> { log.info("Hello from runnable"); @@ -463,22 +442,19 @@ class Application { } @RequestMapping("/threadPoolTaskScheduler_submit") - public String threadPoolTaskSchedulerSubmit() - throws ExecutionException, InterruptedException { + public String threadPoolTaskSchedulerSubmit() throws ExecutionException, InterruptedException { log.info("Executing completable via ThreadPoolTaskScheduler"); return this.asyncTask.threadPoolTaskSchedulerSubmit().context().traceIdString(); } @RequestMapping("/threadPoolTaskScheduler_schedule") - public String threadPoolTaskSchedulerSchedule() - throws ExecutionException, InterruptedException { + public String threadPoolTaskSchedulerSchedule() throws ExecutionException, InterruptedException { log.info("Executing completable via ThreadPoolTaskScheduler"); return this.asyncTask.threadPoolTaskSchedulerSchedule().context().traceIdString(); } @RequestMapping("/scheduledThreadPoolExecutor") - public String scheduledThreadPoolExecutor() - throws ExecutionException, InterruptedException { + public String scheduledThreadPoolExecutor() throws ExecutionException, InterruptedException { log.info("Executing completable via ScheduledThreadPoolExecutor"); return this.asyncTask.scheduledThreadPoolExecutor().context().traceIdString(); } diff --git a/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/issues/issue546/Issue546Tests.java b/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/issues/issue546/Issue546Tests.java index c931be627..a1456a0ed 100644 --- a/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/issues/issue546/Issue546Tests.java +++ b/tests/spring-cloud-sleuth-instrumentation-async-tests/src/test/java/org/springframework/cloud/sleuth/instrument/async/issues/issue546/Issue546Tests.java @@ -49,9 +49,7 @@ public class Issue546Tests { @Test public void should_pass_tracing_info_when_using_callbacks() { - new RestTemplate().getForObject( - "http://localhost:" + port() + "/trace-async-rest-template", - String.class); + new RestTemplate().getForObject("http://localhost:" + port() + "/trace-async-rest-template", String.class); } private int port() { @@ -94,8 +92,7 @@ class Controller { } @RequestMapping("/trace-async-rest-template") - public void asyncTest(@RequestParam(required = false) boolean isSleep) - throws InterruptedException { + public void asyncTest(@RequestParam(required = false) boolean isSleep) throws InterruptedException { log.info("(/trace-async-rest-template) I got a request!"); final long traceId = this.tracer.tracer().currentSpan().context().traceId(); ListenableFuture> res = this.traceAsyncRestTemplate @@ -104,17 +101,13 @@ class Controller { Thread.sleep(1000); } res.addCallback(success -> { - then(Controller.this.tracer.tracer().currentSpan().context().traceId()) - .isEqualTo(traceId); + then(Controller.this.tracer.tracer().currentSpan().context().traceId()).isEqualTo(traceId); log.info("(/trace-async-rest-template) success"); - then(Controller.this.tracer.tracer().currentSpan().context().traceId()) - .isEqualTo(traceId); + then(Controller.this.tracer.tracer().currentSpan().context().traceId()).isEqualTo(traceId); }, failure -> { - then(Controller.this.tracer.tracer().currentSpan().context().traceId()) - .isEqualTo(traceId); + then(Controller.this.tracer.tracer().currentSpan().context().traceId()).isEqualTo(traceId); log.error("(/trace-async-rest-template) failure", failure); - then(Controller.this.tracer.tracer().currentSpan().context().traceId()) - .isEqualTo(traceId); + then(Controller.this.tracer.tracer().currentSpan().context().traceId()).isEqualTo(traceId); }); } diff --git a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue1125/ManuallyCreatedLoadBalancerFeignClientTests.java b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue1125/ManuallyCreatedLoadBalancerFeignClientTests.java index 05e579a90..36b259844 100644 --- a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue1125/ManuallyCreatedLoadBalancerFeignClientTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue1125/ManuallyCreatedLoadBalancerFeignClientTests.java @@ -49,8 +49,7 @@ import org.springframework.web.bind.annotation.RequestMethod; import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest(classes = Application.class, - webEnvironment = SpringBootTest.WebEnvironment.NONE) +@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest.WebEnvironment.NONE) @DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD) public class ManuallyCreatedLoadBalancerFeignClientTests { @@ -150,9 +149,9 @@ class MyDelegateClient implements Client { @Override public Response execute(Request request, Request.Options options) { this.wasCalled = true; - return Response.builder().body("foo", StandardCharsets.UTF_8) - .request(Request.create(Request.HttpMethod.POST, "/foo", new HashMap<>(), - Request.Body.empty(), new RequestTemplate())) + return Response + .builder().body("foo", StandardCharsets.UTF_8).request(Request.create(Request.HttpMethod.POST, "/foo", + new HashMap<>(), Request.Body.empty(), new RequestTemplate())) .headers(new HashMap<>()).status(200).build(); } diff --git a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue1125delegates/ManuallyCreatedDelegateLoadBalancerFeignClientTests.java b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue1125delegates/ManuallyCreatedDelegateLoadBalancerFeignClientTests.java index fd35cb64a..f2f7be677 100644 --- a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue1125delegates/ManuallyCreatedDelegateLoadBalancerFeignClientTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue1125delegates/ManuallyCreatedDelegateLoadBalancerFeignClientTests.java @@ -52,8 +52,7 @@ import org.springframework.web.bind.annotation.RequestMethod; import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest(classes = Application.class, - webEnvironment = SpringBootTest.WebEnvironment.NONE) +@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest.WebEnvironment.NONE) @DirtiesContext(classMode = ClassMode.AFTER_EACH_TEST_METHOD) public class ManuallyCreatedDelegateLoadBalancerFeignClientTests { @@ -114,11 +113,10 @@ class Application { } @Bean - public AnnotatedFeignClient annotatedFeignClient(Client client, Decoder decoder, - Encoder encoder, Contract contract) { - return Feign.builder().client(client).encoder(encoder).decoder(decoder) - .contract(contract).target(new HardCodedTarget<>( - AnnotatedFeignClient.class, "foo", "http://foo")); + public AnnotatedFeignClient annotatedFeignClient(Client client, Decoder decoder, Encoder encoder, + Contract contract) { + return Feign.builder().client(client).encoder(encoder).decoder(decoder).contract(contract) + .target(new HardCodedTarget<>(AnnotatedFeignClient.class, "foo", "http://foo")); } @Bean @@ -146,9 +144,9 @@ class MyDelegateClient implements Client { @Override public Response execute(Request request, Request.Options options) { this.wasCalled = true; - return Response.builder().body("foo", StandardCharsets.UTF_8) - .request(Request.create(Request.HttpMethod.POST, "/foo", new HashMap<>(), - Request.Body.empty(), new RequestTemplate())) + return Response + .builder().body("foo", StandardCharsets.UTF_8).request(Request.create(Request.HttpMethod.POST, "/foo", + new HashMap<>(), Request.Body.empty(), new RequestTemplate())) .headers(new HashMap<>()).status(200).build(); } diff --git a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue307/Issue307Tests.java b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue307/Issue307Tests.java index 37873c4b2..bbd270932 100644 --- a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue307/Issue307Tests.java +++ b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue307/Issue307Tests.java @@ -52,9 +52,8 @@ public class Issue307Tests { @Test public void should_start_context() { - try (ConfigurableApplicationContext applicationContext = SpringApplication.run( - SleuthSampleApplication.class, "--spring.jmx.enabled=false", - "--server.port=0")) { + try (ConfigurableApplicationContext applicationContext = SpringApplication.run(SleuthSampleApplication.class, + "--spring.jmx.enabled=false", "--server.port=0")) { // code } } @@ -67,8 +66,7 @@ public class Issue307Tests { @EnableFeignClients class SleuthSampleApplication { - private static final Logger LOG = LoggerFactory - .getLogger(SleuthSampleApplication.class.getName()); + private static final Logger LOG = LoggerFactory.getLogger(SleuthSampleApplication.class.getName()); @Autowired private RestTemplate restTemplate; diff --git a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue362/Issue362Tests.java b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue362/Issue362Tests.java index 33516003f..e6a3399f1 100644 --- a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue362/Issue362Tests.java +++ b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue362/Issue362Tests.java @@ -55,8 +55,7 @@ import org.springframework.web.client.RestTemplate; import static org.assertj.core.api.Assertions.fail; import static org.assertj.core.api.BDDAssertions.then; -@FeignClient(value = "myFeignClient", url = "http://localhost:9998", - configuration = CustomConfig.class) +@FeignClient(value = "myFeignClient", url = "http://localhost:9998", configuration = CustomConfig.class) interface MyFeignClient { @RequestMapping("/service/ok") @@ -71,8 +70,7 @@ interface MyFeignClient { * @author Marcin Grzejszczak */ -@SpringBootTest(classes = Application.class, - webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT) +@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT) @TestPropertySource(properties = { "server.port=9998" }) public class Issue362Tests { @@ -97,12 +95,10 @@ public class Issue362Tests { public void should_successfully_work_with_custom_error_decoder_when_sending_successful_request() { String securedURl = "http://localhost:9998/sleuth/test-ok"; - ResponseEntity response = this.template.getForEntity(securedURl, - String.class); + ResponseEntity response = this.template.getForEntity(securedURl, String.class); then(response.getBody()).isEqualTo("I'm OK"); - then(this.feignComponentAsserter.executedComponents).containsEntry(Client.class, - true); + then(this.feignComponentAsserter.executedComponents).containsEntry(Client.class, true); then(this.spans).hasSize(1); then(this.spans.get(0).tags()).containsEntry("http.path", "/service/ok"); } @@ -118,13 +114,12 @@ public class Issue362Tests { catch (Exception e) { } - then(this.feignComponentAsserter.executedComponents) - .containsEntry(ErrorDecoder.class, true) + then(this.feignComponentAsserter.executedComponents).containsEntry(ErrorDecoder.class, true) .containsEntry(Client.class, true); // retries then(this.spans).hasSize(5); - then(this.spans.spans().stream().map(span -> span.tags().get("http.status_code")) - .collect(Collectors.toList())).containsOnly("409"); + then(this.spans.spans().stream().map(span -> span.tags().get("http.status_code")).collect(Collectors.toList())) + .containsOnly("409"); } } @@ -205,8 +200,8 @@ class CustomConfig { public Exception decode(String methodKey, Response response) { this.feignComponentAsserter.executedComponents.put(ErrorDecoder.class, true); if (response.status() == 409) { - return new RetryableException(response.status(), "Article not Ready", - Request.HttpMethod.GET, new Date(), response.request()); + return new RetryableException(response.status(), "Article not Ready", Request.HttpMethod.GET, + new Date(), response.request()); } else { return super.decode(methodKey, response); @@ -225,8 +220,7 @@ class CustomConfig { } @Override - public Response execute(Request request, Request.Options options) - throws IOException { + public Response execute(Request request, Request.Options options) throws IOException { this.feignComponentAsserter.executedComponents.put(Client.class, true); return super.execute(request, options); } diff --git a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue393/Issue393Tests.java b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue393/Issue393Tests.java index 0fcb7028a..835f4ae75 100644 --- a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue393/Issue393Tests.java +++ b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue393/Issue393Tests.java @@ -56,10 +56,8 @@ interface MyNameRemote { * @author Marcin Grzejszczak */ -@SpringBootTest(classes = Application.class, - webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT) -@TestPropertySource( - properties = { "spring.application.name=demo-feign-uri", "server.port=9978" }) +@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT) +@TestPropertySource(properties = { "spring.application.name=demo-feign-uri", "server.port=9978" }) public class Issue393Tests { RestTemplate template = new RestTemplate(); @@ -84,8 +82,8 @@ public class Issue393Tests { then(response.getBody()).isEqualTo("mikesarver foo"); // retries then(this.spans).hasSize(2); - then(this.spans.spans().stream().map(span -> span.tags().get("http.path")) - .collect(Collectors.toList())).containsOnly("/name/mikesarver"); + then(this.spans.spans().stream().map(span -> span.tags().get("http.path")).collect(Collectors.toList())) + .containsOnly("/name/mikesarver"); } } diff --git a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue502/Issue502Tests.java b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue502/Issue502Tests.java index 4fcdd9db2..088899532 100644 --- a/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue502/Issue502Tests.java +++ b/tests/spring-cloud-sleuth-instrumentation-feign-tests/src/test/java/org/springframework/cloud/sleuth/instrument/feign/issues/issue502/Issue502Tests.java @@ -55,8 +55,7 @@ interface MyNameRemote { /** * @author Marcin Grzejszczak */ -@SpringBootTest(classes = Application.class, - webEnvironment = SpringBootTest.WebEnvironment.NONE) +@SpringBootTest(classes = Application.class, webEnvironment = SpringBootTest.WebEnvironment.NONE) public class Issue502Tests { @Autowired @@ -121,9 +120,9 @@ class MyClient implements Client { @Override public Response execute(Request request, Request.Options options) { this.wasCalled = true; - return Response.builder().body("foo", StandardCharsets.UTF_8) - .request(Request.create(Request.HttpMethod.POST, "/foo", new HashMap<>(), - Request.Body.empty(), new RequestTemplate())) + return Response + .builder().body("foo", StandardCharsets.UTF_8).request(Request.create(Request.HttpMethod.POST, "/foo", + new HashMap<>(), Request.Body.empty(), new RequestTemplate())) .headers(new HashMap<>()).status(200).build(); } diff --git a/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/GrpcTracingIntegrationTests.java b/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/GrpcTracingIntegrationTests.java index 618d469ea..c136c20f0 100644 --- a/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/GrpcTracingIntegrationTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/GrpcTracingIntegrationTests.java @@ -85,14 +85,12 @@ public class GrpcTracingIntegrationTests { @Test public void integrationTest() throws Exception { - ManagedChannel inProcessManagedChannel = this.clientManagedChannelBuilder - .inProcessChannelBuilder("testServer").directExecutor().build(); + ManagedChannel inProcessManagedChannel = this.clientManagedChannelBuilder.inProcessChannelBuilder("testServer") + .directExecutor().build(); - HelloServiceGrpcClient client = new HelloServiceGrpcClient( - inProcessManagedChannel); + HelloServiceGrpcClient client = new HelloServiceGrpcClient(inProcessManagedChannel); - assertThat(client.sayHello("Testy McTest Face")) - .isEqualTo("Hello Testy McTest Face"); + assertThat(client.sayHello("Testy McTest Face")).isEqualTo("Hello Testy McTest Face"); assertThat(this.spans).hasSize(2); assertThat(this.spans.get(0).kind()).isEqualTo(Kind.SERVER); assertThat(this.spans.get(1).kind()).isEqualTo(Kind.CLIENT); @@ -164,8 +162,7 @@ public class GrpcTracingIntegrationTests { private Logger logger = LoggerFactory.getLogger(HelloGrpcService.class); @Override - public void sayHello(HelloRequest request, - StreamObserver responseObserver) { + public void sayHello(HelloRequest request, StreamObserver responseObserver) { String message = "Hello " + request.getName(); this.logger.debug("In the grpc server stub."); HelloReply reply = HelloReply.newBuilder().setMessage(message).build(); @@ -191,11 +188,9 @@ public class GrpcTracingIntegrationTests { @Override public String sayHello(String name) throws Exception { - HelloServiceBlockingStub stub = HelloServiceGrpc - .newBlockingStub(this.managedChannel) - .withDeadlineAfter(3, TimeUnit.SECONDS); - HelloReply reply = stub - .sayHello(HelloRequest.newBuilder().setName(name).build()); + HelloServiceBlockingStub stub = HelloServiceGrpc.newBlockingStub(this.managedChannel).withDeadlineAfter(3, + TimeUnit.SECONDS); + HelloReply reply = stub.sayHello(HelloRequest.newBuilder().setName(name).build()); return reply.getMessage(); } diff --git a/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloReply.java b/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloReply.java index 670199fc3..da6b92467 100644 --- a/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloReply.java +++ b/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloReply.java @@ -70,8 +70,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp throw new java.lang.NullPointerException(); } int mutable_bitField0_ = 0; - com.google.protobuf.UnknownFieldSet.Builder unknownFields = com.google.protobuf.UnknownFieldSet - .newBuilder(); + com.google.protobuf.UnknownFieldSet.Builder unknownFields = com.google.protobuf.UnknownFieldSet.newBuilder(); try { boolean done = false; while (!done) { @@ -81,8 +80,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp done = true; break; default: - if (!parseUnknownFieldProto3(input, unknownFields, extensionRegistry, - tag)) { + if (!parseUnknownFieldProto3(input, unknownFields, extensionRegistry, tag)) { done = true; } break; @@ -97,8 +95,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp throw e.setUnfinishedMessage(this); } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(this); + throw new com.google.protobuf.InvalidProtocolBufferException(e).setUnfinishedMessage(this); } finally { this.unknownFields = unknownFields.build(); @@ -132,52 +129,40 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp return PARSER.parseFrom(data, extensionRegistry); } - public static HelloReply parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { + public static HelloReply parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static HelloReply parseFrom(byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) + public static HelloReply parseFrom(byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static HelloReply parseFrom(java.io.InputStream input) - throws java.io.IOException { + public static HelloReply parseFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input); } public static HelloReply parseFrom(java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input, - extensionRegistry); + com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input, extensionRegistry); } - public static HelloReply parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); + public static HelloReply parseDelimitedFrom(java.io.InputStream input) throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException(PARSER, input); } public static HelloReply parseDelimitedFrom(java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException(PARSER, input, extensionRegistry); } - public static HelloReply parseFrom(com.google.protobuf.CodedInputStream input) - throws java.io.IOException { + public static HelloReply parseFrom(com.google.protobuf.CodedInputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input); } public static HelloReply parseFrom(com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input, - extensionRegistry); + com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input, extensionRegistry); } public static Builder newBuilder() { @@ -204,8 +189,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp @Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { return HelloServiceOuterClass.internal_static_sample_grpc_HelloReply_fieldAccessorTable - .ensureFieldAccessorsInitialized(HelloReply.class, - HelloReply.Builder.class); + .ensureFieldAccessorsInitialized(HelloReply.class, HelloReply.Builder.class); } /** @@ -232,8 +216,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp public com.google.protobuf.ByteString getMessageBytes() { java.lang.Object ref = this.message_; if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = com.google.protobuf.ByteString - .copyFromUtf8((java.lang.String) ref); + com.google.protobuf.ByteString b = com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); this.message_ = b; return b; } @@ -257,8 +240,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp } @Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { + public void writeTo(com.google.protobuf.CodedOutputStream output) throws java.io.IOException { if (!getMessageBytes().isEmpty()) { com.google.protobuf.GeneratedMessageV3.writeString(output, 1, this.message_); } @@ -274,8 +256,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp size = 0; if (!getMessageBytes().isEmpty()) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, - this.message_); + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, this.message_); } size += this.unknownFields.getSerializedSize(); this.memoizedSize = size; @@ -323,8 +304,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp } @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + protected Builder newBuilderForType(com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { Builder builder = new Builder(parent); return builder; } @@ -346,8 +326,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp * * Protobuf type {@code HelloReply} */ - public static final class Builder - extends com.google.protobuf.GeneratedMessageV3.Builder implements + public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder implements // @@protoc_insertion_point(builder_implements:HelloReply) HelloReplyOrBuilder { @@ -370,8 +349,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp @Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { return HelloServiceOuterClass.internal_static_sample_grpc_HelloReply_fieldAccessorTable - .ensureFieldAccessorsInitialized(HelloReply.class, - HelloReply.Builder.class); + .ensureFieldAccessorsInitialized(HelloReply.class, HelloReply.Builder.class); } private void maybeForceBuilderInitialization() { @@ -420,8 +398,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp } @Override - public Builder setField(com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { + public Builder setField(com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) { return super.setField(field, value); } @@ -436,16 +413,13 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp } @Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, int index, + public Builder setRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field, int index, java.lang.Object value) { return super.setRepeatedField(field, index, value); } @Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { + public Builder addRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) { return super.addRepeatedField(field, value); } @@ -480,8 +454,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp @Override public Builder mergeFrom(com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { + com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { HelloReply parsedMessage = null; try { parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); @@ -535,8 +508,7 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp public com.google.protobuf.ByteString getMessageBytes() { java.lang.Object ref = this.message_; if (ref instanceof String) { - com.google.protobuf.ByteString b = com.google.protobuf.ByteString - .copyFromUtf8((java.lang.String) ref); + com.google.protobuf.ByteString b = com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); this.message_ = b; return b; } @@ -570,14 +542,12 @@ public final class HelloReply extends com.google.protobuf.GeneratedMessageV3 imp } @Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { + public final Builder setUnknownFields(final com.google.protobuf.UnknownFieldSet unknownFields) { return super.setUnknownFieldsProto3(unknownFields); } @Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { + public final Builder mergeUnknownFields(final com.google.protobuf.UnknownFieldSet unknownFields) { return super.mergeUnknownFields(unknownFields); } diff --git a/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloRequest.java b/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloRequest.java index a8aa7252d..18dad29f9 100644 --- a/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloRequest.java +++ b/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloRequest.java @@ -68,8 +68,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i throw new java.lang.NullPointerException(); } int mutable_bitField0_ = 0; - com.google.protobuf.UnknownFieldSet.Builder unknownFields = com.google.protobuf.UnknownFieldSet - .newBuilder(); + com.google.protobuf.UnknownFieldSet.Builder unknownFields = com.google.protobuf.UnknownFieldSet.newBuilder(); try { boolean done = false; while (!done) { @@ -79,8 +78,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i done = true; break; default: - if (!parseUnknownFieldProto3(input, unknownFields, extensionRegistry, - tag)) { + if (!parseUnknownFieldProto3(input, unknownFields, extensionRegistry, tag)) { done = true; } break; @@ -96,8 +94,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i throw e.setUnfinishedMessage(this); } catch (java.io.IOException e) { - throw new com.google.protobuf.InvalidProtocolBufferException(e) - .setUnfinishedMessage(this); + throw new com.google.protobuf.InvalidProtocolBufferException(e).setUnfinishedMessage(this); } finally { this.unknownFields = unknownFields.build(); @@ -131,52 +128,40 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i return PARSER.parseFrom(data, extensionRegistry); } - public static HelloRequest parseFrom(byte[] data) - throws com.google.protobuf.InvalidProtocolBufferException { + public static HelloRequest parseFrom(byte[] data) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data); } - public static HelloRequest parseFrom(byte[] data, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) + public static HelloRequest parseFrom(byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws com.google.protobuf.InvalidProtocolBufferException { return PARSER.parseFrom(data, extensionRegistry); } - public static HelloRequest parseFrom(java.io.InputStream input) - throws java.io.IOException { + public static HelloRequest parseFrom(java.io.InputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input); } public static HelloRequest parseFrom(java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input, - extensionRegistry); + com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input, extensionRegistry); } - public static HelloRequest parseDelimitedFrom(java.io.InputStream input) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input); + public static HelloRequest parseDelimitedFrom(java.io.InputStream input) throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException(PARSER, input); } public static HelloRequest parseDelimitedFrom(java.io.InputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3 - .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException(PARSER, input, extensionRegistry); } - public static HelloRequest parseFrom(com.google.protobuf.CodedInputStream input) - throws java.io.IOException { + public static HelloRequest parseFrom(com.google.protobuf.CodedInputStream input) throws java.io.IOException { return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input); } public static HelloRequest parseFrom(com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { - return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input, - extensionRegistry); + com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input, extensionRegistry); } public static Builder newBuilder() { @@ -203,8 +188,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i @Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { return HelloServiceOuterClass.internal_static_sample_grpc_HelloRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized(HelloRequest.class, - HelloRequest.Builder.class); + .ensureFieldAccessorsInitialized(HelloRequest.class, HelloRequest.Builder.class); } /** @@ -231,8 +215,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i public com.google.protobuf.ByteString getNameBytes() { java.lang.Object ref = this.name_; if (ref instanceof java.lang.String) { - com.google.protobuf.ByteString b = com.google.protobuf.ByteString - .copyFromUtf8((java.lang.String) ref); + com.google.protobuf.ByteString b = com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); this.name_ = b; return b; } @@ -256,8 +239,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i } @Override - public void writeTo(com.google.protobuf.CodedOutputStream output) - throws java.io.IOException { + public void writeTo(com.google.protobuf.CodedOutputStream output) throws java.io.IOException { if (!getNameBytes().isEmpty()) { com.google.protobuf.GeneratedMessageV3.writeString(output, 1, this.name_); } @@ -273,8 +255,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i size = 0; if (!getNameBytes().isEmpty()) { - size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, - this.name_); + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, this.name_); } size += this.unknownFields.getSerializedSize(); this.memoizedSize = size; @@ -322,8 +303,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i } @java.lang.Override - protected Builder newBuilderForType( - com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + protected Builder newBuilderForType(com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { Builder builder = new Builder(parent); return builder; } @@ -345,8 +325,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i * * Protobuf type {@code HelloRequest} */ - public static final class Builder - extends com.google.protobuf.GeneratedMessageV3.Builder implements + public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder implements // @@protoc_insertion_point(builder_implements:HelloRequest) HelloRequestOrBuilder { @@ -369,8 +348,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i @Override protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable() { return HelloServiceOuterClass.internal_static_sample_grpc_HelloRequest_fieldAccessorTable - .ensureFieldAccessorsInitialized(HelloRequest.class, - HelloRequest.Builder.class); + .ensureFieldAccessorsInitialized(HelloRequest.class, HelloRequest.Builder.class); } private void maybeForceBuilderInitialization() { @@ -419,8 +397,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i } @Override - public Builder setField(com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { + public Builder setField(com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) { return super.setField(field, value); } @@ -435,16 +412,13 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i } @Override - public Builder setRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, int index, + public Builder setRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field, int index, java.lang.Object value) { return super.setRepeatedField(field, index, value); } @Override - public Builder addRepeatedField( - com.google.protobuf.Descriptors.FieldDescriptor field, - java.lang.Object value) { + public Builder addRepeatedField(com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) { return super.addRepeatedField(field, value); } @@ -479,8 +453,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i @Override public Builder mergeFrom(com.google.protobuf.CodedInputStream input, - com.google.protobuf.ExtensionRegistryLite extensionRegistry) - throws java.io.IOException { + com.google.protobuf.ExtensionRegistryLite extensionRegistry) throws java.io.IOException { HelloRequest parsedMessage = null; try { parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); @@ -534,8 +507,7 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i public com.google.protobuf.ByteString getNameBytes() { java.lang.Object ref = this.name_; if (ref instanceof String) { - com.google.protobuf.ByteString b = com.google.protobuf.ByteString - .copyFromUtf8((java.lang.String) ref); + com.google.protobuf.ByteString b = com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); this.name_ = b; return b; } @@ -569,14 +541,12 @@ public final class HelloRequest extends com.google.protobuf.GeneratedMessageV3 i } @Override - public final Builder setUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { + public final Builder setUnknownFields(final com.google.protobuf.UnknownFieldSet unknownFields) { return super.setUnknownFieldsProto3(unknownFields); } @Override - public final Builder mergeUnknownFields( - final com.google.protobuf.UnknownFieldSet unknownFields) { + public final Builder mergeUnknownFields(final com.google.protobuf.UnknownFieldSet unknownFields) { return super.mergeUnknownFields(unknownFields); } diff --git a/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloServiceGrpc.java b/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloServiceGrpc.java index 72e8780d2..e2654a319 100644 --- a/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloServiceGrpc.java +++ b/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloServiceGrpc.java @@ -28,8 +28,7 @@ import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall; * The Hello service definition. * */ -@javax.annotation.Generated(value = "by gRPC proto compiler (version 1.15.1)", - comments = "Source: HelloService.proto") +@javax.annotation.Generated(value = "by gRPC proto compiler (version 1.15.1)", comments = "Source: HelloService.proto") public final class HelloServiceGrpc { public static final String SERVICE_NAME = "HelloService"; @@ -53,18 +52,14 @@ public final class HelloServiceGrpc { synchronized (HelloServiceGrpc.class) { if ((getSayHelloMethod = HelloServiceGrpc.getSayHelloMethod) == null) { HelloServiceGrpc.getSayHelloMethod = getSayHelloMethod = io.grpc.MethodDescriptor - .newBuilder() - .setType(io.grpc.MethodDescriptor.MethodType.UNARY) - .setFullMethodName( - generateFullMethodName("HelloService", "SayHello")) + .newBuilder().setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName("HelloService", "SayHello")) .setSampledToLocalTracing(true) - .setRequestMarshaller(io.grpc.protobuf.ProtoUtils - .marshaller(HelloRequest.getDefaultInstance())) - .setResponseMarshaller(io.grpc.protobuf.ProtoUtils - .marshaller(HelloReply.getDefaultInstance())) - .setSchemaDescriptor( - new HelloServiceMethodDescriptorSupplier("SayHello")) - .build(); + .setRequestMarshaller( + io.grpc.protobuf.ProtoUtils.marshaller(HelloRequest.getDefaultInstance())) + .setResponseMarshaller( + io.grpc.protobuf.ProtoUtils.marshaller(HelloReply.getDefaultInstance())) + .setSchemaDescriptor(new HelloServiceMethodDescriptorSupplier("SayHello")).build(); } } } @@ -99,8 +94,7 @@ public final class HelloServiceGrpc { synchronized (HelloServiceGrpc.class) { result = serviceDescriptor; if (result == null) { - serviceDescriptor = result = io.grpc.ServiceDescriptor - .newBuilder(SERVICE_NAME) + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) .setSchemaDescriptor(new HelloServiceFileDescriptorSupplier()) .addMethod(getSayHelloMethod()).build(); } @@ -121,8 +115,7 @@ public final class HelloServiceGrpc { * Sends a greeting * */ - public void sayHello(HelloRequest request, - io.grpc.stub.StreamObserver responseObserver) { + public void sayHello(HelloRequest request, io.grpc.stub.StreamObserver responseObserver) { asyncUnimplementedUnaryCall(getSayHelloMethod(), responseObserver); } @@ -130,8 +123,7 @@ public final class HelloServiceGrpc { public final io.grpc.ServerServiceDefinition bindService() { return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) .addMethod(getSayHelloMethod(), - asyncUnaryCall(new MethodHandlers( - this, METHODID_SAY_HELLO))) + asyncUnaryCall(new MethodHandlers(this, METHODID_SAY_HELLO))) .build(); } @@ -142,21 +134,18 @@ public final class HelloServiceGrpc { * The Hello service definition. * */ - public static final class HelloServiceStub - extends io.grpc.stub.AbstractStub { + public static final class HelloServiceStub extends io.grpc.stub.AbstractStub { private HelloServiceStub(io.grpc.Channel channel) { super(channel); } - private HelloServiceStub(io.grpc.Channel channel, - io.grpc.CallOptions callOptions) { + private HelloServiceStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { super(channel, callOptions); } @java.lang.Override - protected HelloServiceStub build(io.grpc.Channel channel, - io.grpc.CallOptions callOptions) { + protected HelloServiceStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { return new HelloServiceStub(channel, callOptions); } @@ -165,10 +154,8 @@ public final class HelloServiceGrpc { * Sends a greeting * */ - public void sayHello(HelloRequest request, - io.grpc.stub.StreamObserver responseObserver) { - asyncUnaryCall(getChannel().newCall(getSayHelloMethod(), getCallOptions()), - request, responseObserver); + public void sayHello(HelloRequest request, io.grpc.stub.StreamObserver responseObserver) { + asyncUnaryCall(getChannel().newCall(getSayHelloMethod(), getCallOptions()), request, responseObserver); } } @@ -178,21 +165,18 @@ public final class HelloServiceGrpc { * The Hello service definition. * */ - public static final class HelloServiceBlockingStub - extends io.grpc.stub.AbstractStub { + public static final class HelloServiceBlockingStub extends io.grpc.stub.AbstractStub { private HelloServiceBlockingStub(io.grpc.Channel channel) { super(channel); } - private HelloServiceBlockingStub(io.grpc.Channel channel, - io.grpc.CallOptions callOptions) { + private HelloServiceBlockingStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { super(channel, callOptions); } @java.lang.Override - protected HelloServiceBlockingStub build(io.grpc.Channel channel, - io.grpc.CallOptions callOptions) { + protected HelloServiceBlockingStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { return new HelloServiceBlockingStub(channel, callOptions); } @@ -202,8 +186,7 @@ public final class HelloServiceGrpc { * */ public HelloReply sayHello(HelloRequest request) { - return blockingUnaryCall(getChannel(), getSayHelloMethod(), getCallOptions(), - request); + return blockingUnaryCall(getChannel(), getSayHelloMethod(), getCallOptions(), request); } } @@ -213,21 +196,18 @@ public final class HelloServiceGrpc { * The Hello service definition. * */ - public static final class HelloServiceFutureStub - extends io.grpc.stub.AbstractStub { + public static final class HelloServiceFutureStub extends io.grpc.stub.AbstractStub { private HelloServiceFutureStub(io.grpc.Channel channel) { super(channel); } - private HelloServiceFutureStub(io.grpc.Channel channel, - io.grpc.CallOptions callOptions) { + private HelloServiceFutureStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { super(channel, callOptions); } @java.lang.Override - protected HelloServiceFutureStub build(io.grpc.Channel channel, - io.grpc.CallOptions callOptions) { + protected HelloServiceFutureStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { return new HelloServiceFutureStub(channel, callOptions); } @@ -236,16 +216,13 @@ public final class HelloServiceGrpc { * Sends a greeting * */ - public com.google.common.util.concurrent.ListenableFuture sayHello( - HelloRequest request) { - return futureUnaryCall( - getChannel().newCall(getSayHelloMethod(), getCallOptions()), request); + public com.google.common.util.concurrent.ListenableFuture sayHello(HelloRequest request) { + return futureUnaryCall(getChannel().newCall(getSayHelloMethod(), getCallOptions()), request); } } - private static final class MethodHandlers - implements io.grpc.stub.ServerCalls.UnaryMethod, + private static final class MethodHandlers implements io.grpc.stub.ServerCalls.UnaryMethod, io.grpc.stub.ServerCalls.ServerStreamingMethod, io.grpc.stub.ServerCalls.ClientStreamingMethod, io.grpc.stub.ServerCalls.BidiStreamingMethod { @@ -261,8 +238,7 @@ public final class HelloServiceGrpc { @java.lang.Override @java.lang.SuppressWarnings("unchecked") - public void invoke(Req request, - io.grpc.stub.StreamObserver responseObserver) { + public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) { switch (this.methodId) { case METHODID_SAY_HELLO: this.serviceImpl.sayHello((HelloRequest) request, @@ -275,8 +251,7 @@ public final class HelloServiceGrpc { @java.lang.Override @java.lang.SuppressWarnings("unchecked") - public io.grpc.stub.StreamObserver invoke( - io.grpc.stub.StreamObserver responseObserver) { + public io.grpc.stub.StreamObserver invoke(io.grpc.stub.StreamObserver responseObserver) { switch (this.methodId) { default: throw new AssertionError(); @@ -286,8 +261,7 @@ public final class HelloServiceGrpc { } private static abstract class HelloServiceBaseDescriptorSupplier - implements io.grpc.protobuf.ProtoFileDescriptorSupplier, - io.grpc.protobuf.ProtoServiceDescriptorSupplier { + implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier { HelloServiceBaseDescriptorSupplier() { } @@ -304,16 +278,14 @@ public final class HelloServiceGrpc { } - private static final class HelloServiceFileDescriptorSupplier - extends HelloServiceBaseDescriptorSupplier { + private static final class HelloServiceFileDescriptorSupplier extends HelloServiceBaseDescriptorSupplier { HelloServiceFileDescriptorSupplier() { } } - private static final class HelloServiceMethodDescriptorSupplier - extends HelloServiceBaseDescriptorSupplier + private static final class HelloServiceMethodDescriptorSupplier extends HelloServiceBaseDescriptorSupplier implements io.grpc.protobuf.ProtoMethodDescriptorSupplier { private final String methodName; diff --git a/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloServiceOuterClass.java b/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloServiceOuterClass.java index 79319fd03..a492ab4ca 100644 --- a/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloServiceOuterClass.java +++ b/tests/spring-cloud-sleuth-instrumentation-grpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/grpc/stubs/HelloServiceOuterClass.java @@ -26,12 +26,11 @@ public final class HelloServiceOuterClass { private static com.google.protobuf.Descriptors.FileDescriptor descriptor; static { - java.lang.String[] descriptorData = { - "\n\022HelloService.proto\022\013sample.grpc\"\034\n\014Hel" - + "loRequest\022\014\n\004name\030\001 \001(\t\"\035\n\nHelloReply\022\017\n" - + "\007message\030\001 \001(\t2P\n\014HelloService\022@\n\010SayHel" - + "lo\022\031.sample.grpc.HelloRequest\032\027.sample.g" - + "rpc.HelloReply\"\000B\002P\001b\006proto3" }; + java.lang.String[] descriptorData = { "\n\022HelloService.proto\022\013sample.grpc\"\034\n\014Hel" + + "loRequest\022\014\n\004name\030\001 \001(\t\"\035\n\nHelloReply\022\017\n" + + "\007message\030\001 \001(\t2P\n\014HelloService\022@\n\010SayHel" + + "lo\022\031.sample.grpc.HelloRequest\032\027.sample.g" + + "rpc.HelloReply\"\000B\002P\001b\006proto3" }; com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner = new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() { @Override public com.google.protobuf.ExtensionRegistry assignDescriptors( @@ -40,30 +39,23 @@ public final class HelloServiceOuterClass { return null; } }; - com.google.protobuf.Descriptors.FileDescriptor.internalBuildGeneratedFileFrom( - descriptorData, new com.google.protobuf.Descriptors.FileDescriptor[] {}, - assigner); - internal_static_sample_grpc_HelloRequest_descriptor = getDescriptor() - .getMessageTypes().get(0); + com.google.protobuf.Descriptors.FileDescriptor.internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] {}, assigner); + internal_static_sample_grpc_HelloRequest_descriptor = getDescriptor().getMessageTypes().get(0); internal_static_sample_grpc_HelloRequest_fieldAccessorTable = new com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_sample_grpc_HelloRequest_descriptor, - new java.lang.String[] { "Name", }); - internal_static_sample_grpc_HelloReply_descriptor = getDescriptor() - .getMessageTypes().get(1); + internal_static_sample_grpc_HelloRequest_descriptor, new java.lang.String[] { "Name", }); + internal_static_sample_grpc_HelloReply_descriptor = getDescriptor().getMessageTypes().get(1); internal_static_sample_grpc_HelloReply_fieldAccessorTable = new com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_sample_grpc_HelloReply_descriptor, - new java.lang.String[] { "Message", }); + internal_static_sample_grpc_HelloReply_descriptor, new java.lang.String[] { "Message", }); } private HelloServiceOuterClass() { } - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistryLite registry) { + public static void registerAllExtensions(com.google.protobuf.ExtensionRegistryLite registry) { } - public static void registerAllExtensions( - com.google.protobuf.ExtensionRegistry registry) { + public static void registerAllExtensions(com.google.protobuf.ExtensionRegistry registry) { registerAllExtensions((com.google.protobuf.ExtensionRegistryLite) registry); } diff --git a/tests/spring-cloud-sleuth-instrumentation-lettuce-tests/src/test/java/org/springframework/cloud/sleuth/instrument/redis/TraceRedisAutoConfigurationTests.java b/tests/spring-cloud-sleuth-instrumentation-lettuce-tests/src/test/java/org/springframework/cloud/sleuth/instrument/redis/TraceRedisAutoConfigurationTests.java index 391205d4c..167c21783 100644 --- a/tests/spring-cloud-sleuth-instrumentation-lettuce-tests/src/test/java/org/springframework/cloud/sleuth/instrument/redis/TraceRedisAutoConfigurationTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-lettuce-tests/src/test/java/org/springframework/cloud/sleuth/instrument/redis/TraceRedisAutoConfigurationTests.java @@ -70,16 +70,14 @@ public class TraceRedisAutoConfigurationTests { @Bean TestTraceLettuceClientResourcesBeanPostProcessor testTraceLettuceClientResourcesBeanPostProcessor( BeanFactory beanFactory, TraceRedisProperties traceRedisProperties) { - return new TestTraceLettuceClientResourcesBeanPostProcessor(beanFactory, - traceRedisProperties); + return new TestTraceLettuceClientResourcesBeanPostProcessor(beanFactory, traceRedisProperties); } } } -class TestTraceLettuceClientResourcesBeanPostProcessor - extends TraceLettuceClientResourcesBeanPostProcessor { +class TestTraceLettuceClientResourcesBeanPostProcessor extends TraceLettuceClientResourcesBeanPostProcessor { boolean tracingCalled = false; @@ -89,8 +87,7 @@ class TestTraceLettuceClientResourcesBeanPostProcessor } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { this.tracingCalled = true; return super.postProcessAfterInitialization(bean, beanName); } diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/ITTracingChannelInterceptorTests.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/ITTracingChannelInterceptorTests.java index f8b7b8f77..96caba1a9 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/ITTracingChannelInterceptorTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/ITTracingChannelInterceptorTests.java @@ -56,8 +56,7 @@ import static org.springframework.boot.test.context.SpringBootTest.WebEnvironmen * * @author Marcin Grzejszczak */ -@SpringBootTest(classes = ITTracingChannelInterceptorTests.App.class, - webEnvironment = WebEnvironment.NONE, +@SpringBootTest(classes = ITTracingChannelInterceptorTests.App.class, webEnvironment = WebEnvironment.NONE, properties = "spring.sleuth.integration.enabled=true") @DirtiesContext public class ITTracingChannelInterceptorTests implements MessageHandler { @@ -104,8 +103,7 @@ public class ITTracingChannelInterceptorTests implements MessageHandler { // formerly known as TraceChannelInterceptorTest.executableSpanCreation @Test public void propagatesNoopSpan() { - this.directChannel - .send(MessageBuilder.withPayload("hi").setHeader("b3", "0").build()); + this.directChannel.send(MessageBuilder.withPayload("hi").setHeader("b3", "0").build()); assertThat(this.message.getHeaders()).containsEntry("b3", "0"); @@ -114,27 +112,21 @@ public class ITTracingChannelInterceptorTests implements MessageHandler { @Test public void messageHeadersStillMutableForStomp() { - this.directChannel.send(MessageBuilder.withPayload("hi") - .setHeader("stompCommand", "DISCONNECT").build()); + this.directChannel.send(MessageBuilder.withPayload("hi").setHeader("stompCommand", "DISCONNECT").build()); - assertThat(MessageHeaderAccessor.getAccessor(this.message, - MessageHeaderAccessor.class)).isNotNull(); + assertThat(MessageHeaderAccessor.getAccessor(this.message, MessageHeaderAccessor.class)).isNotNull(); this.message = null; - this.directChannel.send(MessageBuilder.withPayload("hi") - .setHeader("simpMessageType", "sth").build()); + this.directChannel.send(MessageBuilder.withPayload("hi").setHeader("simpMessageType", "sth").build()); - assertThat(MessageHeaderAccessor.getAccessor(this.message, - MessageHeaderAccessor.class)).isNotNull(); + assertThat(MessageHeaderAccessor.getAccessor(this.message, MessageHeaderAccessor.class)).isNotNull(); } @Test public void messageHeadersImmutableForNonStomp() { - this.directChannel - .send(MessageBuilder.withPayload("hi").setHeader("foo", "bar").build()); + this.directChannel.send(MessageBuilder.withPayload("hi").setHeader("foo", "bar").build()); - assertThat(MessageHeaderAccessor.getAccessor(this.message, - MessageHeaderAccessor.class)).isNull(); + assertThat(MessageHeaderAccessor.getAccessor(this.message, MessageHeaderAccessor.class)).isNull(); } @Configuration @@ -155,8 +147,8 @@ public class ITTracingChannelInterceptorTests implements MessageHandler { @Bean Tracing tracing() { - return Tracing.newBuilder().currentTraceContext(currentTraceContext()) - .addSpanHandler(testSpanHandler()).build(); + return Tracing.newBuilder().currentTraceContext(currentTraceContext()).addSpanHandler(testSpanHandler()) + .build(); } @Bean diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/JmsTracingConfigurationTest.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/JmsTracingConfigurationTest.java index 46444309a..25aee6097 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/JmsTracingConfigurationTest.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/JmsTracingConfigurationTest.java @@ -56,9 +56,8 @@ import static org.assertj.core.api.Assertions.assertThat; */ public class JmsTracingConfigurationTest { - final ApplicationContextRunner contextRunner = new ApplicationContextRunner() - .withConfiguration(AutoConfigurations.of(JmsTestTracingConfiguration.class, - XAConfiguration.class, SimpleJmsListenerConfiguration.class)); + final ApplicationContextRunner contextRunner = new ApplicationContextRunner().withConfiguration(AutoConfigurations + .of(JmsTestTracingConfiguration.class, XAConfiguration.class, SimpleJmsListenerConfiguration.class)); static void checkConnection(AssertableApplicationContext ctx) throws JMSException { // Not using try-with-resources as that doesn't exist in JMS 1.1 @@ -88,11 +87,9 @@ public class JmsTracingConfigurationTest { } } - static void checkTopicConnection(AssertableApplicationContext ctx) - throws JMSException { + static void checkTopicConnection(AssertableApplicationContext ctx) throws JMSException { // Not using try-with-resources as that doesn't exist in JMS 1.1 - TopicConnection con = ctx.getBean(TopicConnectionFactory.class) - .createTopicConnection(); + TopicConnection con = ctx.getBean(TopicConnectionFactory.class).createTopicConnection(); try { con.setExceptionListener(exception -> { }); @@ -139,8 +136,7 @@ public class JmsTracingConfigurationTest { @EnableJms static class SimpleJmsListenerConfiguration implements JmsListenerConfigurer { - private static final Log log = LogFactory - .getLog(SimpleJmsListenerConfiguration.class); + private static final Log log = LogFactory.getLog(SimpleJmsListenerConfiguration.class); @Autowired CurrentTraceContext current; @@ -159,8 +155,7 @@ public class JmsTracingConfigurationTest { return message -> { log.info("Got message"); // Didn't restart the trace - assertThat(current.get()).isNotNull() - .extracting(TraceContext::parentIdAsLong).isNotEqualTo(0L); + assertThat(current.get()).isNotNull().extracting(TraceContext::parentIdAsLong).isNotEqualTo(0L); }; } diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfigurationTest.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfigurationTest.java index 256e1208c..c5fb5a299 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfigurationTest.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/SleuthKafkaStreamsConfigurationTest.java @@ -33,8 +33,7 @@ import static org.assertj.core.api.BDDAssertions.then; /** * @author Tim te Beek */ -@SpringBootTest(classes = SleuthKafkaStreamsConfigurationTest.Config.class, - webEnvironment = WebEnvironment.NONE) +@SpringBootTest(classes = SleuthKafkaStreamsConfigurationTest.Config.class, webEnvironment = WebEnvironment.NONE) public class SleuthKafkaStreamsConfigurationTest { @Autowired diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/StreamFunctionAdapterTests.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/StreamFunctionAdapterTests.java index 06ef84f32..f9fbb90c5 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/StreamFunctionAdapterTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/StreamFunctionAdapterTests.java @@ -38,8 +38,7 @@ import org.springframework.messaging.support.MessageBuilder; import static org.assertj.core.api.Assertions.assertThat; -@SpringBootTest(classes = StreamFunctionAdapterTests.Config.class, - webEnvironment = SpringBootTest.WebEnvironment.NONE) +@SpringBootTest(classes = StreamFunctionAdapterTests.Config.class, webEnvironment = SpringBootTest.WebEnvironment.NONE) public class StreamFunctionAdapterTests { @Autowired(required = false) @@ -56,8 +55,7 @@ public class StreamFunctionAdapterTests { @Test void should_instrument_a_simple_message_to_message_function() { - assertThat(tracingChannelInterceptor) - .as("Ensure that we're doing instrumentation via function wrapper") + assertThat(tracingChannelInterceptor).as("Ensure that we're doing instrumentation via function wrapper") .isNull(); this.inputDestination.send(MessageBuilder.withPayload("hello".getBytes()) @@ -69,8 +67,8 @@ public class StreamFunctionAdapterTests { String b3 = message.getHeaders().get("b3", String.class); assertThat(b3).startsWith("4883117762eb9420"); - assertThat(this.handler.spans()).hasSize(3).extracting("kind") - .containsOnly(Span.Kind.CONSUMER, null, Span.Kind.PRODUCER); + assertThat(this.handler.spans()).hasSize(3).extracting("kind").containsOnly(Span.Kind.CONSUMER, null, + Span.Kind.PRODUCER); } @Configuration @@ -99,8 +97,7 @@ class SimpleFunction implements Function, Message> { @Override public Message apply(Message input) { log.info("Hello from simple [{}]", input); - return MessageBuilder.createMessage(input.getPayload().toUpperCase(), - input.getHeaders()); + return MessageBuilder.createMessage(input.getPayload().toUpperCase(), input.getHeaders()); } } diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/StreamMessageOperatorsTests.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/StreamMessageOperatorsTests.java index 30024d2e2..ec4e13800 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/StreamMessageOperatorsTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/StreamMessageOperatorsTests.java @@ -43,8 +43,7 @@ import org.springframework.messaging.support.MessageBuilder; import static org.assertj.core.api.Assertions.assertThat; -@SpringBootTest(classes = StreamMessageOperatorsTests.Config.class, - webEnvironment = SpringBootTest.WebEnvironment.NONE) +@SpringBootTest(classes = StreamMessageOperatorsTests.Config.class, webEnvironment = SpringBootTest.WebEnvironment.NONE) public class StreamMessageOperatorsTests { @Autowired(required = false) @@ -61,8 +60,7 @@ public class StreamMessageOperatorsTests { @Test void should_instrument_a_simple_message_to_message_function() { - assertThat(tracingChannelInterceptor) - .as("Ensure that we're doing instrumentation via function wrapper") + assertThat(tracingChannelInterceptor).as("Ensure that we're doing instrumentation via function wrapper") .isNull(); this.inputDestination.send(MessageBuilder.withPayload("hello".getBytes()) @@ -74,8 +72,8 @@ public class StreamMessageOperatorsTests { String b3 = message.getHeaders().get("b3", String.class); assertThat(b3).startsWith("4883117762eb9420"); - assertThat(this.handler.spans()).hasSize(3).extracting("kind") - .containsOnly(Span.Kind.CONSUMER, null, Span.Kind.PRODUCER); + assertThat(this.handler.spans()).hasSize(3).extracting("kind").containsOnly(Span.Kind.CONSUMER, null, + Span.Kind.PRODUCER); } @Configuration @@ -97,11 +95,9 @@ public class StreamMessageOperatorsTests { } -class SimpleReactiveManualFunction - implements Function>, Flux>> { +class SimpleReactiveManualFunction implements Function>, Flux>> { - private static final Logger log = LoggerFactory - .getLogger(SimpleReactiveManualFunction.class); + private static final Logger log = LoggerFactory.getLogger(SimpleReactiveManualFunction.class); private final Tracing tracing; @@ -111,29 +107,19 @@ class SimpleReactiveManualFunction @Override public Flux> apply(Flux> input) { - return input.map( - message -> (MessagingSleuthOperators.asFunction(this.tracing, message)) - .andThen(msg -> MessagingSleuthOperators - .withSpanInScope(this.tracing, msg, stringMessage -> { - log.info("Hello from simple manual [{}]", - stringMessage.getPayload()); - return stringMessage; - })) - .andThen(msg -> MessagingSleuthOperators - .afterMessageHandled(this.tracing, msg, null)) - .andThen(msg -> { - MessagingSleuthOperators.withSpanInScope(this.tracing, msg, - stringMessage -> { - log.info("Here we may do some processing"); - }); - Map headers = new HashMap<>(msg.getHeaders()); - headers.put("destination", "specialDestination"); - return MessageBuilder.createMessage( - msg.getPayload().toUpperCase(), - new MessageHeaders(headers)); - }).andThen(msg -> MessagingSleuthOperators - .handleOutputMessage(this.tracing, msg)) - .apply(message)); + return input.map(message -> (MessagingSleuthOperators.asFunction(this.tracing, message)) + .andThen(msg -> MessagingSleuthOperators.withSpanInScope(this.tracing, msg, stringMessage -> { + log.info("Hello from simple manual [{}]", stringMessage.getPayload()); + return stringMessage; + })).andThen(msg -> MessagingSleuthOperators.afterMessageHandled(this.tracing, msg, null)) + .andThen(msg -> { + MessagingSleuthOperators.withSpanInScope(this.tracing, msg, stringMessage -> { + log.info("Here we may do some processing"); + }); + Map headers = new HashMap<>(msg.getHeaders()); + headers.put("destination", "specialDestination"); + return MessageBuilder.createMessage(msg.getPayload().toUpperCase(), new MessageHeaders(headers)); + }).andThen(msg -> MessagingSleuthOperators.handleOutputMessage(this.tracing, msg)).apply(message)); } } diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceContextPropagationChannelInterceptorTests.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceContextPropagationChannelInterceptorTests.java index dd1f26226..40a3e6802 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceContextPropagationChannelInterceptorTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceContextPropagationChannelInterceptorTests.java @@ -87,8 +87,7 @@ public class TraceContextPropagationChannelInterceptorTests { // Trace and Span IDs are implicitly checked TraceContext extracted = B3SingleFormat.parseB3SingleFormat(b3).context(); - assertThat(extracted.spanIdString()).as("spanId was equal to parent's id") - .isNotEqualTo(expectedSpanId); + assertThat(extracted.spanIdString()).as("spanId was equal to parent's id").isNotEqualTo(expectedSpanId); } @Configuration diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfiguration1664Tests.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfiguration1664Tests.java index d6b234734..ce8c95713 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfiguration1664Tests.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfiguration1664Tests.java @@ -89,8 +89,7 @@ class MySleuthKafka1664Aspect extends SleuthKafkaAspect { } @Override - public Object wrapListenerContainerCreation(ProceedingJoinPoint pjp) - throws Throwable { + public Object wrapListenerContainerCreation(ProceedingJoinPoint pjp) throws Throwable { this.adapterWrapped = true; return Mockito.mock(MessageListenerContainer.class); } diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfigurationTests.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfigurationTests.java index 7a6a30bab..e4acb4511 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfigurationTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceMessagingAutoConfigurationTests.java @@ -105,8 +105,8 @@ public class TraceMessagingAutoConfigurationTests { @Test public void defaultsToBraveProducerSampler() { contextRunner().run((context) -> { - SamplerFunction producerSampler = context - .getBean(MessagingTracing.class).producerSampler(); + SamplerFunction producerSampler = context.getBean(MessagingTracing.class) + .producerSampler(); then(producerSampler).isSameAs(SamplerFunctions.deferDecision()); }); @@ -114,20 +114,19 @@ public class TraceMessagingAutoConfigurationTests { @Test public void configuresUserProvidedProducerSampler() { - contextRunner().withUserConfiguration(ProducerSamplerConfig.class) - .run((context) -> { - SamplerFunction producerSampler = context - .getBean(MessagingTracing.class).producerSampler(); + contextRunner().withUserConfiguration(ProducerSamplerConfig.class).run((context) -> { + SamplerFunction producerSampler = context.getBean(MessagingTracing.class) + .producerSampler(); - then(producerSampler).isSameAs(ProducerSamplerConfig.INSTANCE); - }); + then(producerSampler).isSameAs(ProducerSamplerConfig.INSTANCE); + }); } @Test public void defaultsToBraveConsumerSampler() { contextRunner().run((context) -> { - SamplerFunction consumerSampler = context - .getBean(MessagingTracing.class).consumerSampler(); + SamplerFunction consumerSampler = context.getBean(MessagingTracing.class) + .consumerSampler(); then(consumerSampler).isSameAs(SamplerFunctions.deferDecision()); }); @@ -135,19 +134,17 @@ public class TraceMessagingAutoConfigurationTests { @Test public void configuresUserProvidedConsumerSampler() { - contextRunner().withUserConfiguration(ConsumerSamplerConfig.class) - .run((context) -> { - SamplerFunction consumerSampler = context - .getBean(MessagingTracing.class).consumerSampler(); + contextRunner().withUserConfiguration(ConsumerSamplerConfig.class).run((context) -> { + SamplerFunction consumerSampler = context.getBean(MessagingTracing.class) + .consumerSampler(); - then(consumerSampler).isSameAs(ConsumerSamplerConfig.INSTANCE); - }); + then(consumerSampler).isSameAs(ConsumerSamplerConfig.INSTANCE); + }); } private ApplicationContextRunner contextRunner(String... propertyValues) { - return new ApplicationContextRunner().withPropertyValues(propertyValues) - .withConfiguration(AutoConfigurations.of(TraceAutoConfiguration.class, - TraceMessagingAutoConfiguration.class)); + return new ApplicationContextRunner().withPropertyValues(propertyValues).withConfiguration( + AutoConfigurations.of(TraceAutoConfiguration.class, TraceMessagingAutoConfiguration.class)); } @Configuration @@ -165,8 +162,7 @@ public class TraceMessagingAutoConfigurationTests { } @Bean - SleuthRabbitBeanPostProcessor sleuthRabbitBeanPostProcessor( - BeanFactory beanFactory) { + SleuthRabbitBeanPostProcessor sleuthRabbitBeanPostProcessor(BeanFactory beanFactory) { return new TestSleuthRabbitBeanPostProcessor(beanFactory); } @@ -176,8 +172,7 @@ public class TraceMessagingAutoConfigurationTests { } @Bean - TestSleuthJmsBeanPostProcessor sleuthJmsBeanPostProcessor( - BeanFactory beanFactory) { + TestSleuthJmsBeanPostProcessor sleuthJmsBeanPostProcessor(BeanFactory beanFactory) { return new TestSleuthJmsBeanPostProcessor(beanFactory); } @@ -231,8 +226,7 @@ class MySleuthKafkaAspect extends SleuthKafkaAspect { } @Override - public Object wrapListenerContainerCreation(ProceedingJoinPoint pjp) - throws Throwable { + public Object wrapListenerContainerCreation(ProceedingJoinPoint pjp) throws Throwable { this.adapterWrapped = true; return Mockito.mock(MessageListenerContainer.class); } @@ -248,8 +242,7 @@ class TestSleuthJmsBeanPostProcessor extends TracingConnectionFactoryBeanPostPro } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) - throws BeansException { + public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { this.tracingCalled = true; return super.postProcessAfterInitialization(bean, beanName); } diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceStreamChannelInterceptorTests.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceStreamChannelInterceptorTests.java index 8a072eef4..23bc965b4 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceStreamChannelInterceptorTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceStreamChannelInterceptorTests.java @@ -45,8 +45,7 @@ import static org.assertj.core.api.Assertions.assertThat; * @author Spencer Gibb */ @SpringBootTest(classes = TraceStreamChannelInterceptorTests.App.class, - properties = { "spring.cloud.stream.source=testSupplier", - "spring.sleuth.integration.enabled=true" }) + properties = { "spring.cloud.stream.source=testSupplier", "spring.sleuth.integration.enabled=true" }) @DirtiesContext public class TraceStreamChannelInterceptorTests { @@ -90,8 +89,7 @@ public class TraceStreamChannelInterceptorTests { // Trace and Span IDs are implicitly checked TraceContext extracted = B3SingleFormat.parseB3SingleFormat(b3).context(); - assertThat(extracted.spanIdString()).as("spanId was equal to parent's id") - .isNotEqualTo(expectedSpanId); + assertThat(extracted.spanIdString()).as("spanId was equal to parent's id").isNotEqualTo(expectedSpanId); } @Configuration diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceWebSocketAutoConfigurationTests.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceWebSocketAutoConfigurationTests.java index b54858000..0e9cec9a7 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceWebSocketAutoConfigurationTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/TraceWebSocketAutoConfigurationTests.java @@ -43,15 +43,12 @@ public class TraceWebSocketAutoConfigurationTests { @Test public void should_register_interceptors_for_all_channels() { - then(this.delegatingWebSocketMessageBrokerConfiguration.clientInboundChannel() - .getInterceptors()) - .hasAtLeastOneElementOfType(TracingChannelInterceptor.class); - then(this.delegatingWebSocketMessageBrokerConfiguration.clientOutboundChannel() - .getInterceptors()) - .hasAtLeastOneElementOfType(TracingChannelInterceptor.class); - then(this.delegatingWebSocketMessageBrokerConfiguration.brokerChannel() - .getInterceptors()) - .hasAtLeastOneElementOfType(TracingChannelInterceptor.class); + then(this.delegatingWebSocketMessageBrokerConfiguration.clientInboundChannel().getInterceptors()) + .hasAtLeastOneElementOfType(TracingChannelInterceptor.class); + then(this.delegatingWebSocketMessageBrokerConfiguration.clientOutboundChannel().getInterceptors()) + .hasAtLeastOneElementOfType(TracingChannelInterceptor.class); + then(this.delegatingWebSocketMessageBrokerConfiguration.brokerChannel().getInterceptors()) + .hasAtLeastOneElementOfType(TracingChannelInterceptor.class); } @EnableAutoConfiguration diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/HelloSpringIntegration.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/HelloSpringIntegration.java index 243079ec6..d784c9ba6 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/HelloSpringIntegration.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/HelloSpringIntegration.java @@ -30,8 +30,7 @@ import org.springframework.integration.config.EnableIntegration; import org.springframework.scheduling.annotation.EnableAsync; import org.springframework.web.client.RestTemplate; -@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class, - HibernateJpaAutoConfiguration.class }) +@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class }) @ImportResource("classpath:beans/applicationContext.xml") @EnableIntegration @EnableAsync diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/HelloWorldRestController.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/HelloWorldRestController.java index f010e703a..d79a472be 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/HelloWorldRestController.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/HelloWorldRestController.java @@ -35,14 +35,12 @@ import org.springframework.web.bind.annotation.RestController; @RestController public class HelloWorldRestController { - private static final Logger LOG = LoggerFactory - .getLogger(HelloWorldRestController.class); + private static final Logger LOG = LoggerFactory.getLogger(HelloWorldRestController.class); @Autowired private ApplicationContext applicationContext; - @RequestMapping(path = "getHelloWorldMessage", method = RequestMethod.GET, - produces = MediaType.TEXT_PLAIN_VALUE) + @RequestMapping(path = "getHelloWorldMessage", method = RequestMethod.GET, produces = MediaType.TEXT_PLAIN_VALUE) public ResponseEntity getHelloWorld() throws Exception { LOG.info("Inside getHelloWorldMessage"); @@ -52,11 +50,9 @@ public class HelloWorldRestController { requestMessage[1] = "Hellow World Message 2"; requestMessage[2] = "Hellow World Message 3"; - PollableChannel outputChannel = (PollableChannel) this.applicationContext - .getBean("messagingOutputChannel"); + PollableChannel outputChannel = (PollableChannel) this.applicationContext.getBean("messagingOutputChannel"); - MessagingGateway messagingGateway = (MessagingGateway) this.applicationContext - .getBean("messagingGateway"); + MessagingGateway messagingGateway = (MessagingGateway) this.applicationContext.getBean("messagingGateway"); messagingGateway.processMessage(requestMessage); diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/Issue943Tests.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/Issue943Tests.java index e4a40f845..576a94c18 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/Issue943Tests.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/messaging/issues/issue_943/Issue943Tests.java @@ -38,24 +38,19 @@ public class Issue943Tests { @Test public void should_pass_tracing_context_via_spring_integration() { - try (ConfigurableApplicationContext applicationContext = SpringApplication.run( - HelloSpringIntegration.class, "--spring.jmx.enabled=false", - "--server.port=0", "--spring.sleuth.integration.enabled=true")) { + try (ConfigurableApplicationContext applicationContext = SpringApplication.run(HelloSpringIntegration.class, + "--spring.jmx.enabled=false", "--server.port=0", "--spring.sleuth.integration.enabled=true")) { // given Tracer tracer = applicationContext.getBean(Tracer.class); Span newSpan = tracer.nextSpan().name("foo").start(); String object; try (Tracer.SpanInScope ws = tracer.withSpanInScope(newSpan)) { - RestTemplate restTemplate = applicationContext - .getBean(RestTemplate.class); + RestTemplate restTemplate = applicationContext.getBean(RestTemplate.class); // when - object = restTemplate - .getForObject( - "http://localhost:" - + applicationContext.getEnvironment() - .getProperty("local.server.port") - + "/getHelloWorldMessage", - String.class); + object = restTemplate.getForObject( + "http://localhost:" + applicationContext.getEnvironment().getProperty("local.server.port") + + "/getHelloWorldMessage", + String.class); } // then @@ -63,15 +58,11 @@ public class Issue943Tests { then(object).contains("Hellow World Message 1 Persist into DB") .contains("Hellow World Message 2 Persist into DB") .contains("Hellow World Message 3 Persist into DB"); - then(spans.spans().stream().filter( - span -> span.traceId().equals(newSpan.context().traceIdString())) - .map(span -> span.tags().getOrDefault("channel", - span.tags().get("http.path"))) - .collect(Collectors.toList())) - .as("trace context was propagated successfully").isNotEmpty() - .contains("splitterOutChannel", "messagingChannel", - "messagingProcessedChannel", "messagingOutputChannel", - "/getHelloWorldMessage"); + then(spans.spans().stream().filter(span -> span.traceId().equals(newSpan.context().traceIdString())) + .map(span -> span.tags().getOrDefault("channel", span.tags().get("http.path"))) + .collect(Collectors.toList())).as("trace context was propagated successfully").isNotEmpty() + .contains("splitterOutChannel", "messagingChannel", "messagingProcessedChannel", + "messagingOutputChannel", "/getHelloWorldMessage"); } } diff --git a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/util/SpanUtil.java b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/util/SpanUtil.java index 0f7525648..463be41c8 100644 --- a/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/util/SpanUtil.java +++ b/tests/spring-cloud-sleuth-instrumentation-messaging-tests/src/test/java/org/springframework/cloud/sleuth/instrument/util/SpanUtil.java @@ -26,8 +26,7 @@ public final class SpanUtil { throw new IllegalStateException("Can't instantiate a utility class"); } - static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - 'a', 'b', 'c', 'd', 'e', 'f' }; + static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; // Represents given long id as 16-character lower-hex string public static String idToHex(long id) { diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/AbstractMvcIntegrationTest.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/AbstractMvcIntegrationTest.java index 9d456943c..28d9dd12f 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/AbstractMvcIntegrationTest.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/AbstractMvcIntegrationTest.java @@ -45,8 +45,7 @@ public abstract class AbstractMvcIntegrationTest { @BeforeEach public void setup() { - DefaultMockMvcBuilder mockMvcBuilder = MockMvcBuilders - .webAppContextSetup(this.webApplicationContext); + DefaultMockMvcBuilder mockMvcBuilder = MockMvcBuilders.webAppContextSetup(this.webApplicationContext); configureMockMvcBuilder(mockMvcBuilder); this.mockMvc = mockMvcBuilder.build(); } diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceAsyncIntegrationTests.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceAsyncIntegrationTests.java index a4530c0b0..95b165c26 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceAsyncIntegrationTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceAsyncIntegrationTests.java @@ -43,8 +43,7 @@ import org.springframework.scheduling.annotation.EnableAsync; import static java.util.concurrent.TimeUnit.SECONDS; import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest( - classes = { TraceAsyncIntegrationTests.TraceAsyncITestConfiguration.class }) +@SpringBootTest(classes = { TraceAsyncIntegrationTests.TraceAsyncITestConfiguration.class }) public class TraceAsyncIntegrationTests { @Autowired @@ -118,15 +117,14 @@ public class TraceAsyncIntegrationTests { private void thenTraceIdIsPassedFromTheCurrentThreadToTheAsyncOne(final Span span) { Awaitility.await().atMost(5, SECONDS).untilAsserted(() -> { - then(TraceAsyncIntegrationTests.this.classPerformingAsyncLogic.getSpan() - .context().traceId()).isEqualTo(span.context().traceId()); + then(TraceAsyncIntegrationTests.this.classPerformingAsyncLogic.getSpan().context().traceId()) + .isEqualTo(span.context().traceId()); then(this.spans).hasSize(2); // HTTP then(this.spans.get(0).name()).isEqualTo("http:existing"); // ASYNC - then(this.spans.get(1).tags()) - .containsEntry("class", "ClassPerformingAsyncLogic") - .containsEntry("method", "invokeAsynchronousLogic"); + then(this.spans.get(1).tags()).containsEntry("class", "ClassPerformingAsyncLogic").containsEntry("method", + "invokeAsynchronousLogic"); }); } @@ -135,23 +133,21 @@ public class TraceAsyncIntegrationTests { then(this.spans).hasSize(1); MutableSpan storedSpan = this.spans.get(0); then(storedSpan.name()).isEqualTo("invoke-asynchronous-logic"); - then(storedSpan.tags()).containsEntry("class", "ClassPerformingAsyncLogic") - .containsEntry("method", "invokeAsynchronousLogic"); + then(storedSpan.tags()).containsEntry("class", "ClassPerformingAsyncLogic").containsEntry("method", + "invokeAsynchronousLogic"); }); } - private void thenTraceIdIsPassedFromTheCurrentThreadToTheAsyncOneAndSpanHasCustomName( - final Span span) { + private void thenTraceIdIsPassedFromTheCurrentThreadToTheAsyncOneAndSpanHasCustomName(final Span span) { Awaitility.await().atMost(5, SECONDS).untilAsserted(() -> { - then(TraceAsyncIntegrationTests.this.classPerformingAsyncLogic.getSpan() - .context().traceId()).isEqualTo(span.context().traceId()); + then(TraceAsyncIntegrationTests.this.classPerformingAsyncLogic.getSpan().context().traceId()) + .isEqualTo(span.context().traceId()); then(this.spans).hasSize(2); // HTTP then(this.spans.get(0).name()).isEqualTo("http:existing"); // ASYNC - then(this.spans.get(1).tags()) - .containsEntry("class", "ClassPerformingAsyncLogic") - .containsEntry("method", "customNameInvokeAsynchronousLogic"); + then(this.spans.get(1).tags()).containsEntry("class", "ClassPerformingAsyncLogic").containsEntry("method", + "customNameInvokeAsynchronousLogic"); }); } @@ -160,8 +156,8 @@ public class TraceAsyncIntegrationTests { then(this.spans).hasSize(1); MutableSpan storedSpan = this.spans.get(0); then(storedSpan.name()).isEqualTo("foo"); - then(storedSpan.tags()).containsEntry("class", "ClassPerformingAsyncLogic") - .containsEntry("method", "customNameInvokeAsynchronousLogic"); + then(storedSpan.tags()).containsEntry("class", "ClassPerformingAsyncLogic").containsEntry("method", + "customNameInvokeAsynchronousLogic"); }); } diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceCustomFilterResponseInjectorTests.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceCustomFilterResponseInjectorTests.java index adc5e042f..334fcb650 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceCustomFilterResponseInjectorTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceCustomFilterResponseInjectorTests.java @@ -56,8 +56,7 @@ import static brave.propagation.B3SingleFormat.writeB3SingleFormat; import static org.assertj.core.api.BDDAssertions.then; import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.RANDOM_PORT; -@SpringBootTest(classes = TraceCustomFilterResponseInjectorTests.Config.class, - webEnvironment = RANDOM_PORT) +@SpringBootTest(classes = TraceCustomFilterResponseInjectorTests.Config.class, webEnvironment = RANDOM_PORT) @DirtiesContext public class TraceCustomFilterResponseInjectorTests { @@ -74,15 +73,12 @@ public class TraceCustomFilterResponseInjectorTests { @SuppressWarnings("unchecked") public void should_inject_trace_and_span_ids_in_response_headers() { RequestEntity requestEntity = RequestEntity - .get(URI.create("http://localhost:" + this.config.port + "/headers")) - .build(); + .get(URI.create("http://localhost:" + this.config.port + "/headers")).build(); @SuppressWarnings("rawtypes") - ResponseEntity responseEntity = this.restTemplate.exchange(requestEntity, - Map.class); + ResponseEntity responseEntity = this.restTemplate.exchange(requestEntity, Map.class); - then(responseEntity.getHeaders()).containsKey("b3") - .as("Trace headers must be present in response headers"); + then(responseEntity.getHeaders()).containsKey("b3").as("Trace headers must be present in response headers"); } @Configuration @@ -94,14 +90,13 @@ public class TraceCustomFilterResponseInjectorTests { @Bean BaggagePropagation.FactoryBuilder baggagePropagationFactoryBuilder() { // Use b3 single format as it is less verbose - return BaggagePropagation.newFactoryBuilder(B3Propagation.newFactoryBuilder() - .injectFormat(CLIENT, SINGLE_NO_PARENT).build()); + return BaggagePropagation.newFactoryBuilder( + B3Propagation.newFactoryBuilder().injectFormat(CLIENT, SINGLE_NO_PARENT).build()); } // tag::configuration[] @Bean - HttpResponseInjectingTraceFilter responseInjectingTraceFilter( - HttpTracing httpTracing) { + HttpResponseInjectingTraceFilter responseInjectingTraceFilter(HttpTracing httpTracing) { return new HttpResponseInjectingTraceFilter(httpTracing); } // end::configuration[] @@ -133,8 +128,8 @@ public class TraceCustomFilterResponseInjectorTests { } @Override - public void doFilter(ServletRequest request, ServletResponse servletResponse, - FilterChain filterChain) throws IOException, ServletException { + public void doFilter(ServletRequest request, ServletResponse servletResponse, FilterChain filterChain) + throws IOException, ServletException { HttpServletResponse response = (HttpServletResponse) servletResponse; Span currentSpan = this.httpTracing.tracing().tracer().currentSpan(); response.addHeader("b3", writeB3SingleFormat(currentSpan.context())); diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterIntegrationTests.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterIntegrationTests.java index 9600da01d..0b2e19982 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterIntegrationTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterIntegrationTests.java @@ -103,8 +103,7 @@ public class TraceFilterIntegrationTests extends AbstractMvcIntegrationTest { } @Test - public void should_ignore_sampling_the_span_if_uri_matches_management_properties_context_path() - throws Exception { + public void should_ignore_sampling_the_span_if_uri_matches_management_properties_context_path() throws Exception { MvcResult mvcResult = whenSentInfoWithTraceId(new Random().nextLong()); // https://github.com/spring-cloud/spring-cloud-sleuth/issues/327 @@ -142,23 +141,20 @@ public class TraceFilterIntegrationTests extends AbstractMvcIntegrationTest { Long expectedTraceId = new Random().nextLong(); MvcResult mvcResult = whenSentFutureWithTraceId(expectedTraceId); - this.mockMvc.perform(asyncDispatch(mvcResult)).andExpect(status().isOk()) - .andReturn(); + this.mockMvc.perform(asyncDispatch(mvcResult)).andExpect(status().isOk()).andReturn(); then(this.tracer.currentSpan()).isNull(); } @Test - public void should_add_a_custom_tag_to_the_span_created_in_controller() - throws Exception { + public void should_add_a_custom_tag_to_the_span_created_in_controller() throws Exception { Long expectedTraceId = new Random().nextLong(); MvcResult mvcResult = whenSentDeferredWithTraceId(expectedTraceId); - this.mockMvc.perform(asyncDispatch(mvcResult)).andExpect(status().isOk()) - .andReturn(); + this.mockMvc.perform(asyncDispatch(mvcResult)).andExpect(status().isOk()).andReturn(); - Optional taggedSpan = this.spans.spans().stream() - .filter(span -> span.tags().containsKey("tag")).findFirst(); + Optional taggedSpan = this.spans.spans().stream().filter(span -> span.tags().containsKey("tag")) + .findFirst(); then(taggedSpan.isPresent()).isTrue(); then(taggedSpan.get().tags()).containsEntry("tag", "value") .containsEntry("mvc.controller.method", "deferredMethod") @@ -167,8 +163,7 @@ public class TraceFilterIntegrationTests extends AbstractMvcIntegrationTest { } @Test - public void should_log_tracing_information_when_404_exception_was_thrown() - throws Exception { + public void should_log_tracing_information_when_404_exception_was_thrown() throws Exception { Long expectedTraceId = new Random().nextLong(); whenSentToNonExistentEndpointWithTraceId(expectedTraceId); @@ -176,14 +171,12 @@ public class TraceFilterIntegrationTests extends AbstractMvcIntegrationTest { // it's a span with the same ids then(this.spans).hasSize(1); MutableSpan serverSpan = this.spans.get(0); - then(serverSpan.tags()).containsEntry("custom", "tag") - .containsEntry("http.status_code", "404"); + then(serverSpan.tags()).containsEntry("custom", "tag").containsEntry("http.status_code", "404"); then(this.tracer.currentSpan()).isNull(); } @Test - public void should_log_tracing_information_when_500_exception_was_thrown() - throws Exception { + public void should_log_tracing_information_when_500_exception_was_thrown() throws Exception { Long expectedTraceId = new Random().nextLong(); try { @@ -197,32 +190,29 @@ public class TraceFilterIntegrationTests extends AbstractMvcIntegrationTest { // we need to dump the span cause it's not in TracingFilter since TF // has also error dispatch and the ErrorController would report the span then(this.spans).hasSize(1); - then(this.spans.get(0).error()).hasMessageContaining( - "Request processing failed; nested exception is java.lang.RuntimeException"); + then(this.spans.get(0).error()) + .hasMessageContaining("Request processing failed; nested exception is java.lang.RuntimeException"); } @Test - public void should_assume_that_a_request_without_span_and_with_trace_is_a_root_span() - throws Exception { + public void should_assume_that_a_request_without_span_and_with_trace_is_a_root_span() throws Exception { Long expectedTraceId = new Random().nextLong(); whenSentRequestWithTraceIdAndNoSpanId(expectedTraceId); whenSentRequestWithTraceIdAndNoSpanId(expectedTraceId); - then(this.spans.spans().stream().filter(span -> span.id().equals(span.traceId())) - .findAny().isPresent()).as("a root span exists").isTrue(); + then(this.spans.spans().stream().filter(span -> span.id().equals(span.traceId())).findAny().isPresent()) + .as("a root span exists").isTrue(); then(this.tracer.currentSpan()).isNull(); } @Test - public void should_return_custom_response_headers_when_custom_trace_filter_gets_registered() - throws Exception { + public void should_return_custom_response_headers_when_custom_trace_filter_gets_registered() throws Exception { Long expectedTraceId = new Random().nextLong(); MvcResult mvcResult = whenSentPingWithTraceId(expectedTraceId); - then(mvcResult.getResponse().getHeader("ZIPKIN-TRACE-ID")) - .isEqualTo(SpanUtil.idToHex(expectedTraceId)); + then(mvcResult.getResponse().getHeader("ZIPKIN-TRACE-ID")).isEqualTo(SpanUtil.idToHex(expectedTraceId)); then(this.spans).hasSize(1); then(this.spans.get(0).tags()).containsEntry("custom", "tag"); } @@ -233,9 +223,7 @@ public class TraceFilterIntegrationTests extends AbstractMvcIntegrationTest { } private MvcResult whenSentPingWithoutTracingData() throws Exception { - return this.mockMvc - .perform(MockMvcRequestBuilders.get("/ping").accept(MediaType.TEXT_PLAIN)) - .andReturn(); + return this.mockMvc.perform(MockMvcRequestBuilders.get("/ping").accept(MediaType.TEXT_PLAIN)).andReturn(); } private MvcResult whenSentPingWithTraceId(Long passedTraceId) throws Exception { @@ -254,16 +242,12 @@ public class TraceFilterIntegrationTests extends AbstractMvcIntegrationTest { return sendDeferredWithTraceId(passedTraceId); } - private MvcResult whenSentToNonExistentEndpointWithTraceId(Long passedTraceId) - throws Exception { - return sendRequestWithTraceId("/exception/nonExistent", passedTraceId, - HttpStatus.NOT_FOUND); + private MvcResult whenSentToNonExistentEndpointWithTraceId(Long passedTraceId) throws Exception { + return sendRequestWithTraceId("/exception/nonExistent", passedTraceId, HttpStatus.NOT_FOUND); } - private MvcResult whenSentToExceptionThrowingEndpoint(Long passedTraceId) - throws Exception { - return sendRequestWithTraceId("/throwsException", passedTraceId, - HttpStatus.INTERNAL_SERVER_ERROR); + private MvcResult whenSentToExceptionThrowingEndpoint(Long passedTraceId) throws Exception { + return sendRequestWithTraceId("/throwsException", passedTraceId, HttpStatus.INTERNAL_SERVER_ERROR); } private MvcResult sendPingWithTraceId(Long traceId) throws Exception { @@ -275,28 +259,19 @@ public class TraceFilterIntegrationTests extends AbstractMvcIntegrationTest { } private MvcResult sendRequestWithTraceId(String path, Long traceId) throws Exception { - return this.mockMvc - .perform(MockMvcRequestBuilders.get(path).accept(MediaType.TEXT_PLAIN) - .header("b3", - SpanUtil.idToHex(traceId) + "-" - + SpanUtil.idToHex(new Random().nextLong()))) - .andReturn(); + return this.mockMvc.perform(MockMvcRequestBuilders.get(path).accept(MediaType.TEXT_PLAIN).header("b3", + SpanUtil.idToHex(traceId) + "-" + SpanUtil.idToHex(new Random().nextLong()))).andReturn(); } - private MvcResult whenSentRequestWithTraceIdAndNoSpanId(Long traceId) - throws Exception { - return this.mockMvc.perform(MockMvcRequestBuilders.get("/ping") - .accept(MediaType.TEXT_PLAIN).header("b3", SpanUtil.idToHex(traceId))) - .andReturn(); + private MvcResult whenSentRequestWithTraceIdAndNoSpanId(Long traceId) throws Exception { + return this.mockMvc.perform(MockMvcRequestBuilders.get("/ping").accept(MediaType.TEXT_PLAIN).header("b3", + SpanUtil.idToHex(traceId))).andReturn(); } - private MvcResult sendRequestWithTraceId(String path, Long traceId, HttpStatus status) - throws Exception { + private MvcResult sendRequestWithTraceId(String path, Long traceId, HttpStatus status) throws Exception { return this.mockMvc - .perform(MockMvcRequestBuilders.get(path).accept(MediaType.TEXT_PLAIN) - .header("b3", - SpanUtil.idToHex(traceId) + "-" - + SpanUtil.idToHex(new Random().nextLong()))) + .perform(MockMvcRequestBuilders.get(path).accept(MediaType.TEXT_PLAIN).header("b3", + SpanUtil.idToHex(traceId) + "-" + SpanUtil.idToHex(new Random().nextLong()))) .andExpect(status().is(status.value())).andReturn(); } @@ -369,8 +344,7 @@ public class TraceFilterIntegrationTests extends AbstractMvcIntegrationTest { @Primary ManagementServerProperties managementServerProperties() { ManagementServerProperties managementServerProperties = new ManagementServerProperties(); - managementServerProperties.getServlet() - .setContextPath("/additionalContextPath"); + managementServerProperties.getServlet().setContextPath("/additionalContextPath"); return managementServerProperties; } @@ -392,16 +366,15 @@ class MyFilter extends GenericFilterBean { } @Override - public void doFilter(ServletRequest request, ServletResponse response, - FilterChain chain) throws IOException, ServletException { + public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) + throws IOException, ServletException { Span currentSpan = this.tracer.currentSpan(); if (currentSpan == null) { chain.doFilter(request, response); return; } // for readability we're returning trace id in a hex form - ((HttpServletResponse) response).addHeader("ZIPKIN-TRACE-ID", - currentSpan.context().traceIdString()); + ((HttpServletResponse) response).addHeader("ZIPKIN-TRACE-ID", currentSpan.context().traceIdString()); // we can also add some custom tags currentSpan.tag("custom", "tag"); chain.doFilter(request, response); diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterWebIntegrationMultipleFiltersTests.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterWebIntegrationMultipleFiltersTests.java index a7259ec81..dce8532d0 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterWebIntegrationMultipleFiltersTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterWebIntegrationMultipleFiltersTests.java @@ -170,8 +170,8 @@ public class TraceFilterWebIntegrationMultipleFiltersTests { } @Override - public void doFilter(ServletRequest request, ServletResponse response, - FilterChain chain) throws IOException, ServletException { + public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) + throws IOException, ServletException { Span currentSpan = this.tracer.tracer().currentSpan(); this.span.set(currentSpan); } diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterWebIntegrationTests.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterWebIntegrationTests.java index 85533acc2..7bf045a1f 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterWebIntegrationTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceFilterWebIntegrationTests.java @@ -76,8 +76,7 @@ public class TraceFilterWebIntegrationTests { @ClassRule public static IntegrationTestSpanHandler spanHandler = new IntegrationTestSpanHandler(); - private static final Logger log = LoggerFactory - .getLogger(TraceFilterWebIntegrationTests.class); + private static final Logger log = LoggerFactory.getLogger(TraceFilterWebIntegrationTests.class); @Autowired CurrentTraceContext currentTraceContext; @@ -91,8 +90,7 @@ public class TraceFilterWebIntegrationTests { @Test public void should_tag_url() { - new RestTemplate().getForObject("http://localhost:" + port() + "/good", - String.class); + new RestTemplate().getForObject("http://localhost:" + port() + "/good", String.class); then(this.currentTraceContext.get()).isNull(); then(spanHandler.takeRemoteSpan(Kind.SERVER).tags()).containsKey("http.url"); @@ -100,8 +98,7 @@ public class TraceFilterWebIntegrationTests { @Test public void should_tag_with_value_from_null_expression() { - new RestTemplate().getForObject("http://localhost:" + port() + "/null-parameter", - String.class); + new RestTemplate().getForObject("http://localhost:" + port() + "/null-parameter", String.class); then(this.currentTraceContext.get()).isNull(); then(spanHandler.takeRemoteSpan(Kind.SERVER).tags()).containsEntry("foo", "1001"); @@ -109,50 +106,42 @@ public class TraceFilterWebIntegrationTests { @Test public void should_tag_with_value_from_non_null_expression() { - new RestTemplate().getForObject( - "http://localhost:" + port() + "/null-parameter?bar=10", String.class); + new RestTemplate().getForObject("http://localhost:" + port() + "/null-parameter?bar=10", String.class); then(this.currentTraceContext.get()).isNull(); then(spanHandler.takeRemoteSpan(Kind.SERVER).tags()).containsEntry("foo", "11"); } @Test - public void exception_logging_span_handler_logs_synchronous_exceptions( - CapturedOutput capture) { + public void exception_logging_span_handler_logs_synchronous_exceptions(CapturedOutput capture) { try { - new RestTemplate().getForObject("http://localhost:" + port() + "/", - String.class); + new RestTemplate().getForObject("http://localhost:" + port() + "/", String.class); BDDAssertions.fail("should fail due to runtime exception"); } catch (Exception e) { } then(this.currentTraceContext.get()).isNull(); - MutableSpan fromFirstTraceFilterFlow = spanHandler.takeRemoteSpanWithErrorMessage( - Kind.SERVER, + MutableSpan fromFirstTraceFilterFlow = spanHandler.takeRemoteSpanWithErrorMessage(Kind.SERVER, "Request processing failed; nested exception is java.lang.RuntimeException: Throwing exception"); - then(fromFirstTraceFilterFlow.tags()).containsEntry("http.method", "GET") - .containsEntry("mvc.controller.class", "BasicErrorController"); + then(fromFirstTraceFilterFlow.tags()).containsEntry("http.method", "GET").containsEntry("mvc.controller.class", + "BasicErrorController"); // Trace IDs in logs: issue#714 String hex = fromFirstTraceFilterFlow.traceId(); thenLogsForExceptionLoggingFilterContainTracingInformation(capture, hex); } - private void thenLogsForExceptionLoggingFilterContainTracingInformation( - CapturedOutput capture, String hex) { + private void thenLogsForExceptionLoggingFilterContainTracingInformation(CapturedOutput capture, String hex) { String[] split = capture.toString().split("\n"); - List list = Arrays.stream(split) - .filter(s -> s.contains("Uncaught exception thrown")) - .filter(s -> s.contains(hex + "," + hex + "]")) - .collect(Collectors.toList()); + List list = Arrays.stream(split).filter(s -> s.contains("Uncaught exception thrown")) + .filter(s -> s.contains(hex + "," + hex + "]")).collect(Collectors.toList()); then(list).isNotEmpty(); } @Test public void should_create_spans_for_endpoint_returning_unsuccessful_result() { try { - new RestTemplate().getForObject( - "http://localhost:" + port() + "/test_bad_request", String.class); + new RestTemplate().getForObject("http://localhost:" + port() + "/test_bad_request", String.class); fail("should throw exception"); } catch (HttpClientErrorException e) { @@ -205,8 +194,7 @@ public class TraceFilterWebIntegrationTests { return new SpanHandler() { @Override public boolean end(TraceContext context, MutableSpan span, Cause cause) { - if (span.kind() != Kind.SERVER || span.error() == null - || !log.isErrorEnabled()) { + if (span.kind() != Kind.SERVER || span.error() == null || !log.isErrorEnabled()) { return true; // don't add overhead as we only log server errors } @@ -289,9 +277,8 @@ public class TraceFilterWebIntegrationTests { @RequestMapping("/null-parameter") @ContinueSpan - public String nullParameter( - @SpanTag(key = "foo", expression = "(#root?:1000)+1") @RequestParam( - value = "bar", required = false) Integer param) { + public String nullParameter(@SpanTag(key = "foo", expression = "(#root?:1000)+1") @RequestParam(value = "bar", + required = false) Integer param) { return "ok param=" + param; } @@ -300,8 +287,7 @@ public class TraceFilterWebIntegrationTests { @RestController public static class ExceptionThrowingController { - private static final Log log = LogFactory - .getLog(ExceptionThrowingController.class); + private static final Log log = LogFactory.getLog(ExceptionThrowingController.class); @RequestMapping("/") public void throwException() { diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebDisabledTests.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebDisabledTests.java index 3eea2d7b4..b7312daa7 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebDisabledTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebDisabledTests.java @@ -25,8 +25,7 @@ import org.springframework.context.annotation.Configuration; /** * @author Marcin Grzejszczak */ -@SpringBootTest(classes = { TraceWebDisabledTests.Config.class }, - properties = { "spring.sleuth.web.enabled=false" }) +@SpringBootTest(classes = { TraceWebDisabledTests.Config.class }, properties = { "spring.sleuth.web.enabled=false" }) public class TraceWebDisabledTests { @Test diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/RestTemplateTraceAspectIntegrationTests.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/RestTemplateTraceAspectIntegrationTests.java index 9c1f25e94..94680a846 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/RestTemplateTraceAspectIntegrationTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/RestTemplateTraceAspectIntegrationTests.java @@ -103,8 +103,7 @@ public class RestTemplateTraceAspectIntegrationTests { } @Test - public void should_set_span_data_on_headers_via_aspect_in_synchronous_call() - throws Exception { + public void should_set_span_data_on_headers_via_aspect_in_synchronous_call() throws Exception { whenARequestIsSentToASyncEndpoint(); thenTraceIdHasBeenSetOnARequestHeader(); @@ -112,8 +111,7 @@ public class RestTemplateTraceAspectIntegrationTests { } @Test - public void should_set_span_data_on_headers_when_sending_a_request_via_async_rest_template() - throws Exception { + public void should_set_span_data_on_headers_when_sending_a_request_via_async_rest_template() throws Exception { whenARequestIsSentToAnAsyncRestTemplateEndpoint(); thenTraceIdHasBeenSetOnARequestHeader(); @@ -121,8 +119,7 @@ public class RestTemplateTraceAspectIntegrationTests { } @Test - public void should_set_span_data_on_headers_via_aspect_in_asynchronous_callable() - throws Exception { + public void should_set_span_data_on_headers_via_aspect_in_asynchronous_callable() throws Exception { whenARequestIsSentToAnAsyncEndpoint("/callablePing"); thenTraceIdHasBeenSetOnARequestHeader(); @@ -130,8 +127,7 @@ public class RestTemplateTraceAspectIntegrationTests { } @Test - public void should_set_span_data_on_headers_via_aspect_in_asynchronous_web_async() - throws Exception { + public void should_set_span_data_on_headers_via_aspect_in_asynchronous_web_async() throws Exception { whenARequestIsSentToAnAsyncEndpoint("/webAsyncTaskPing"); thenTraceIdHasBeenSetOnARequestHeader(); @@ -140,8 +136,7 @@ public class RestTemplateTraceAspectIntegrationTests { // issue #1047 @Test - public void should_not_create_a_client_span_for_filtered_out_paths() - throws Exception { + public void should_not_create_a_client_span_for_filtered_out_paths() throws Exception { whenARequestIsSentToASyncEndpointThatShouldBeFilteredOut(); then(this.currentTraceContext.get()).isNull(); @@ -149,20 +144,15 @@ public class RestTemplateTraceAspectIntegrationTests { } private void whenARequestIsSentToAnAsyncRestTemplateEndpoint() throws Exception { - this.mockMvc.perform(MockMvcRequestBuilders.get("/asyncRestTemplate") - .accept(MediaType.TEXT_PLAIN)).andReturn(); + this.mockMvc.perform(MockMvcRequestBuilders.get("/asyncRestTemplate").accept(MediaType.TEXT_PLAIN)).andReturn(); } private void whenARequestIsSentToASyncEndpoint() throws Exception { - this.mockMvc.perform( - MockMvcRequestBuilders.get("/syncPing").accept(MediaType.TEXT_PLAIN)) - .andReturn(); + this.mockMvc.perform(MockMvcRequestBuilders.get("/syncPing").accept(MediaType.TEXT_PLAIN)).andReturn(); } - private void whenARequestIsSentToASyncEndpointThatShouldBeFilteredOut() - throws Exception { - this.mockMvc.perform(MockMvcRequestBuilders.get("/issue1047_start") - .accept(MediaType.TEXT_PLAIN)).andReturn(); + private void whenARequestIsSentToASyncEndpointThatShouldBeFilteredOut() throws Exception { + this.mockMvc.perform(MockMvcRequestBuilders.get("/issue1047_start").accept(MediaType.TEXT_PLAIN)).andReturn(); } private void thenTraceIdHasBeenSetOnARequestHeader() { @@ -172,17 +162,15 @@ public class RestTemplateTraceAspectIntegrationTests { // Brave was never designed to run tests of server and client in one test // that's why we have to pick only CLIENT side private void thenClientKindIsReported() { - assertThat(this.spans.spans().stream().map(MutableSpan::kind) - .collect(Collectors.toList())).contains(Span.Kind.CLIENT); + assertThat(this.spans.spans().stream().map(MutableSpan::kind).collect(Collectors.toList())) + .contains(Span.Kind.CLIENT); } private void whenARequestIsSentToAnAsyncEndpoint(String url) throws Exception { - MvcResult mvcResult = this.mockMvc - .perform(MockMvcRequestBuilders.get(url).accept(MediaType.TEXT_PLAIN)) + MvcResult mvcResult = this.mockMvc.perform(MockMvcRequestBuilders.get(url).accept(MediaType.TEXT_PLAIN)) .andExpect(request().asyncStarted()).andReturn(); mvcResult.getAsyncResult(SECONDS.toMillis(2)); - this.mockMvc.perform(asyncDispatch(mvcResult)).andDo(print()) - .andExpect(status().isOk()); + this.mockMvc.perform(asyncDispatch(mvcResult)).andDo(print()).andExpect(status().isOk()); } @EnableAutoConfiguration( @@ -205,8 +193,8 @@ public class RestTemplateTraceAspectIntegrationTests { @Bean public AsyncRestTemplate asyncRestTemplate(Tracing tracing) { AsyncRestTemplate asyncRestTemplate = new AsyncRestTemplate(); - asyncRestTemplate.setInterceptors(Collections.singletonList( - TracingAsyncClientHttpRequestInterceptor.create(tracing))); + asyncRestTemplate.setInterceptors( + Collections.singletonList(TracingAsyncClientHttpRequestInterceptor.create(tracing))); return asyncRestTemplate; } @@ -238,49 +226,39 @@ public class RestTemplateTraceAspectIntegrationTests { this.traceId = null; } - @RequestMapping(value = "/issue1047_end", method = RequestMethod.GET, - produces = MediaType.TEXT_PLAIN_VALUE) + @RequestMapping(value = "/issue1047_end", method = RequestMethod.GET, produces = MediaType.TEXT_PLAIN_VALUE) public String issue1047() { return "should_filter_out_this_endpoint"; } - @RequestMapping(value = "/issue1047_start", method = RequestMethod.GET, - produces = MediaType.TEXT_PLAIN_VALUE) + @RequestMapping(value = "/issue1047_start", method = RequestMethod.GET, produces = MediaType.TEXT_PLAIN_VALUE) public String issue1047Start() { return callAndReturnIssue1047(); } - @RequestMapping(value = "/", method = RequestMethod.GET, - produces = MediaType.TEXT_PLAIN_VALUE) - public String home( - @RequestHeader(value = "X-B3-SpanId", required = false) String traceId) { + @RequestMapping(value = "/", method = RequestMethod.GET, produces = MediaType.TEXT_PLAIN_VALUE) + public String home(@RequestHeader(value = "X-B3-SpanId", required = false) String traceId) { this.traceId = traceId == null ? "UNKNOWN" : traceId; return "trace=" + this.getTraceId(); } - @RequestMapping(value = "/customTag", method = RequestMethod.GET, - produces = MediaType.TEXT_PLAIN_VALUE) - public String customTag( - @RequestHeader(value = "X-B3-TraceId", required = false) String traceId) { + @RequestMapping(value = "/customTag", method = RequestMethod.GET, produces = MediaType.TEXT_PLAIN_VALUE) + public String customTag(@RequestHeader(value = "X-B3-TraceId", required = false) String traceId) { this.traceId = traceId == null ? "UNKNOWN" : traceId; return "trace=" + this.getTraceId(); } - @RequestMapping(value = "/asyncRestTemplate", method = RequestMethod.GET, - produces = MediaType.TEXT_PLAIN_VALUE) - public String asyncRestTemplate() - throws ExecutionException, InterruptedException { + @RequestMapping(value = "/asyncRestTemplate", method = RequestMethod.GET, produces = MediaType.TEXT_PLAIN_VALUE) + public String asyncRestTemplate() throws ExecutionException, InterruptedException { return callViaAsyncRestTemplateAndReturnOk(); } - @RequestMapping(value = "/syncPing", method = RequestMethod.GET, - produces = MediaType.TEXT_PLAIN_VALUE) + @RequestMapping(value = "/syncPing", method = RequestMethod.GET, produces = MediaType.TEXT_PLAIN_VALUE) public String syncPing() { return callAndReturnOk(); } - @RequestMapping(value = "/callablePing", method = RequestMethod.GET, - produces = MediaType.TEXT_PLAIN_VALUE) + @RequestMapping(value = "/callablePing", method = RequestMethod.GET, produces = MediaType.TEXT_PLAIN_VALUE) public Callable asyncPing() { return new Callable() { @Override @@ -290,8 +268,7 @@ public class RestTemplateTraceAspectIntegrationTests { }; } - @RequestMapping(value = "/webAsyncTaskPing", method = RequestMethod.GET, - produces = MediaType.TEXT_PLAIN_VALUE) + @RequestMapping(value = "/webAsyncTaskPing", method = RequestMethod.GET, produces = MediaType.TEXT_PLAIN_VALUE) public WebAsyncTask webAsyncTaskPing() { return new WebAsyncTask<>(new Callable() { @Override @@ -302,8 +279,7 @@ public class RestTemplateTraceAspectIntegrationTests { } private String callAndReturnIssue1047() { - this.restTemplate.getForObject( - "http://localhost:" + port() + "/issue1047_end", String.class); + this.restTemplate.getForObject("http://localhost:" + port() + "/issue1047_end", String.class); return "OK"; } @@ -312,10 +288,8 @@ public class RestTemplateTraceAspectIntegrationTests { return "OK"; } - private String callViaAsyncRestTemplateAndReturnOk() - throws ExecutionException, InterruptedException { - this.asyncRestTemplate - .getForEntity("http://localhost:" + port(), String.class).get(); + private String callViaAsyncRestTemplateAndReturnOk() throws ExecutionException, InterruptedException { + this.asyncRestTemplate.getForEntity("http://localhost:" + port(), String.class).get(); return "OK"; } diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebAsyncClientAutoConfigurationTests.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebAsyncClientAutoConfigurationTests.java index 243b80d28..5114cab20 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebAsyncClientAutoConfigurationTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TraceWebAsyncClientAutoConfigurationTests.java @@ -51,8 +51,7 @@ import static org.springframework.boot.test.context.SpringBootTest.WebEnvironmen * @author Marcin Grzejszczak */ -@SpringBootTest( - classes = { TraceWebAsyncClientAutoConfigurationTests.TestConfiguration.class }, +@SpringBootTest(classes = { TraceWebAsyncClientAutoConfigurationTests.TestConfiguration.class }, webEnvironment = RANDOM_PORT) public class TraceWebAsyncClientAutoConfigurationTests { @@ -74,12 +73,10 @@ public class TraceWebAsyncClientAutoConfigurationTests { } @Test - public void should_close_span_upon_success_callback() - throws ExecutionException, InterruptedException { + public void should_close_span_upon_success_callback() throws ExecutionException, InterruptedException { brave.Span initialSpan = this.tracer.tracer().nextSpan().name("foo"); - try (Tracer.SpanInScope ws = this.tracer.tracer() - .withSpanInScope(initialSpan.start())) { + try (Tracer.SpanInScope ws = this.tracer.tracer().withSpanInScope(initialSpan.start())) { ListenableFuture> future = this.asyncRestTemplate .getForEntity("http://localhost:" + port() + "/foo", String.class); String result = future.get().getBody(); @@ -91,11 +88,8 @@ public class TraceWebAsyncClientAutoConfigurationTests { } Awaitility.await().untilAsserted(() -> { - then(this.spans.spans().stream() - .filter(span -> Span.Kind.CLIENT == span.kind()).findFirst().get()) - .matches(span -> span.finishTimestamp() - - span.startTimestamp() >= TimeUnit.MILLISECONDS - .toMicros(100)); + then(this.spans.spans().stream().filter(span -> Span.Kind.CLIENT == span.kind()).findFirst().get()).matches( + span -> span.finishTimestamp() - span.startTimestamp() >= TimeUnit.MILLISECONDS.toMicros(100)); then(this.tracer.tracer().currentSpan()).isNull(); }); } @@ -104,8 +98,7 @@ public class TraceWebAsyncClientAutoConfigurationTests { public void should_close_span_upon_failure_callback() { ListenableFuture> future; try { - future = this.asyncRestTemplate.getForEntity( - "http://localhost:" + port() + "/blowsup", String.class); + future = this.asyncRestTemplate.getForEntity("http://localhost:" + port() + "/blowsup", String.class); future.get(); BDDAssertions.fail("should throw an exception from the controller"); } @@ -115,8 +108,8 @@ public class TraceWebAsyncClientAutoConfigurationTests { Awaitility.await().untilAsserted(() -> { MutableSpan reportedRpcSpan = new ArrayList<>(this.spans.spans()).stream() .filter(span -> Span.Kind.CLIENT == span.kind()).findFirst().get(); - then(reportedRpcSpan).matches(span -> span.finishTimestamp() - - span.startTimestamp() >= TimeUnit.MILLISECONDS.toMicros(100)); + then(reportedRpcSpan).matches( + span -> span.finishTimestamp() - span.startTimestamp() >= TimeUnit.MILLISECONDS.toMicros(100)); then(reportedRpcSpan.tags()).containsKey("error"); then(this.tracer.tracer().currentSpan()).isNull(); }); diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/exceptionresolver/Issue585Tests.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/exceptionresolver/Issue585Tests.java index 4363405ea..1386a6cd9 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/exceptionresolver/Issue585Tests.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/exceptionresolver/Issue585Tests.java @@ -49,8 +49,7 @@ import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExcep import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest(classes = TestConfig.class, - webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) +@SpringBootTest(classes = TestConfig.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) public class Issue585Tests { TestRestTemplate testRestTemplate = new TestRestTemplate(); @@ -66,14 +65,12 @@ public class Issue585Tests { @Test public void should_report_span_when_using_custom_exception_resolver() { - ResponseEntity entity = this.testRestTemplate.getForEntity( - "http://localhost:" + this.port + "/sleuthtest?greeting=foo", - String.class); + ResponseEntity entity = this.testRestTemplate + .getForEntity("http://localhost:" + this.port + "/sleuthtest?greeting=foo", String.class); then(this.currentTraceContext.get()).isNull(); then(entity.getStatusCode().value()).isEqualTo(500); - then(this.spans.get(0).tags()).containsEntry("custom", "tag") - .containsKeys("error"); + then(this.spans.get(0).tags()).containsEntry("custom", "tag").containsKeys("error"); } } @@ -113,18 +110,15 @@ class TestController { @ControllerAdvice class CustomExceptionHandler extends ResponseEntityExceptionHandler { - private final static Logger logger = LoggerFactory - .getLogger(CustomExceptionHandler.class); + private final static Logger logger = LoggerFactory.getLogger(CustomExceptionHandler.class); @Autowired private Tracing tracer; @ExceptionHandler(Exception.class) - protected ResponseEntity handleDefaultError(Exception ex, - HttpServletRequest request) { - ExceptionResponse exceptionResponse = new ExceptionResponse("ERR-01", - ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR, - request.getRequestURI(), Instant.now().toEpochMilli()); + protected ResponseEntity handleDefaultError(Exception ex, HttpServletRequest request) { + ExceptionResponse exceptionResponse = new ExceptionResponse("ERR-01", ex.getMessage(), + HttpStatus.INTERNAL_SERVER_ERROR, request.getRequestURI(), Instant.now().toEpochMilli()); reportErrorSpan(ex.getMessage()); return new ResponseEntity<>(exceptionResponse, HttpStatus.INTERNAL_SERVER_ERROR); } @@ -151,8 +145,7 @@ class ExceptionResponse { private Long epochTime; - ExceptionResponse(String errorCode, String errorMessage, HttpStatus httpStatus, - String path, Long epochTime) { + ExceptionResponse(String errorCode, String errorMessage, HttpStatus httpStatus, String path, Long epochTime) { this.errorCode = errorCode; this.errorMessage = errorMessage; this.httpStatus = httpStatus; diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/view/Issue469Tests.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/view/Issue469Tests.java index 173b164f8..30b4b6bcb 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/view/Issue469Tests.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/view/Issue469Tests.java @@ -27,10 +27,8 @@ import org.springframework.web.client.RestTemplate; import static org.assertj.core.api.BDDAssertions.then; -@SpringBootTest(classes = Issue469.class, - webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) -@TestPropertySource(properties = { "spring.mvc.view.prefix=/WEB-INF/jsp/", - "spring.mvc.view.suffix=.jsp" }) +@SpringBootTest(classes = Issue469.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) +@TestPropertySource(properties = { "spring.mvc.view.prefix=/WEB-INF/jsp/", "spring.mvc.view.suffix=.jsp" }) public class Issue469Tests { @Autowired @@ -44,8 +42,7 @@ public class Issue469Tests { @Test public void should_not_result_in_tracing_exceptions_when_using_view_controllers() { try { - this.restTemplate.getForObject("http://localhost:" + port() + "/welcome", - String.class); + this.restTemplate.getForObject("http://localhost:" + port() + "/welcome", String.class); } catch (Exception e) { // JSPs are not rendered diff --git a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/util/SpanUtil.java b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/util/SpanUtil.java index e4ae06344..cc5fa1e5f 100644 --- a/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/util/SpanUtil.java +++ b/tests/spring-cloud-sleuth-instrumentation-mvc-tests/src/test/java/org/springframework/cloud/sleuth/util/SpanUtil.java @@ -26,8 +26,7 @@ public final class SpanUtil { throw new IllegalStateException("Can't instantiate a utility class"); } - static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - 'a', 'b', 'c', 'd', 'e', 'f' }; + static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; // Represents given long id as 16-character lower-hex string public static String idToHex(long id) { diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/FlowsScopePassingSpanSubscriberTests.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/FlowsScopePassingSpanSubscriberTests.java index e80c2ad28..fd9f8f84f 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/FlowsScopePassingSpanSubscriberTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/FlowsScopePassingSpanSubscriberTests.java @@ -52,14 +52,12 @@ public class FlowsScopePassingSpanSubscriberTests { // iterator. That's not allowed, and will cause an exception // Fuseable$QueueSubscription.NOT_SUPPORTED_MESSAGE. // This ensures AssertJ uses normal toString. - StandardRepresentation.registerFormatterForType(ScopePassingSpanSubscriber.class, - Objects::toString); + StandardRepresentation.registerFormatterForType(ScopePassingSpanSubscriber.class, Objects::toString); } final CurrentTraceContext currentTraceContext = CurrentTraceContext.Default.create(); - TraceContext context = TraceContext.newBuilder().traceId(1).spanId(1).sampled(true) - .build(); + TraceContext context = TraceContext.newBuilder().traceId(1).spanId(1).sampled(true).build(); AnnotationConfigApplicationContext springContext = new AnnotationConfigApplicationContext(); @@ -133,21 +131,17 @@ public class FlowsScopePassingSpanSubscriberTests { transformer.apply(Mono.just(1)).subscribe(assertNoSpanSubscriber); - transformer.apply(Mono.error(new Exception()).hide()) - .subscribe(assertSpanSubscriber); + transformer.apply(Mono.error(new Exception()).hide()).subscribe(assertSpanSubscriber); - transformer.apply(Mono.error(new Exception())) - .subscribe(assertNoSpanSubscriber); + transformer.apply(Mono.error(new Exception())).subscribe(assertNoSpanSubscriber); - transformer.apply(Mono.empty().hide()) - .subscribe(assertSpanSubscriber); + transformer.apply(Mono.empty().hide()).subscribe(assertSpanSubscriber); transformer.apply(Mono.empty()).subscribe(assertNoSpanSubscriber); } - Awaitility.await() - .untilAsserted(() -> then(this.currentTraceContext.get()).isNull()); + Awaitility.await().untilAsserted(() -> then(this.currentTraceContext.get()).isNull()); } } diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/Issue866Configuration.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/Issue866Configuration.java index 4f77254ea..4ecbb4a93 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/Issue866Configuration.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/Issue866Configuration.java @@ -42,16 +42,13 @@ public class Issue866Configuration { @Bean HookRegisteringBeanDefinitionRegistryPostProcessor overridingProcessorForTests( ConfigurableApplicationContext context) { - log.info( - "Registering a HookRegisteringBeanDefinitionRegistryPostProcessor for context [" - + context + "]"); + log.info("Registering a HookRegisteringBeanDefinitionRegistryPostProcessor for context [" + context + "]"); TestHook hook = new TestHook(context); Issue866Configuration.hook = hook; return hook; } - public static class TestHook - extends HookRegisteringBeanDefinitionRegistryPostProcessor { + public static class TestHook extends HookRegisteringBeanDefinitionRegistryPostProcessor { public boolean executed = false; @@ -60,8 +57,7 @@ public class Issue866Configuration { } @Override - public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) - throws BeansException { + public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { super.postProcessBeanFactory(beanFactory); this.executed = true; } diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriberSpringBootTests.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriberSpringBootTests.java index 49386f6e7..311830181 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriberSpringBootTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriberSpringBootTests.java @@ -49,11 +49,9 @@ public class ScopePassingSpanSubscriberSpringBootTests { @Autowired CurrentTraceContext currentTraceContext; - TraceContext context = TraceContext.newBuilder().traceId(1).spanId(1).sampled(true) - .build(); + TraceContext context = TraceContext.newBuilder().traceId(1).spanId(1).sampled(true).build(); - TraceContext context2 = TraceContext.newBuilder().traceId(1).spanId(2).sampled(true) - .build(); + TraceContext context2 = TraceContext.newBuilder().traceId(1).spanId(2).sampled(true).build(); @Test public void should_pass_tracing_info_when_using_reactor() { @@ -77,12 +75,11 @@ public class ScopePassingSpanSubscriberSpringBootTests { final AtomicReference spanInOperation = new AtomicReference<>(); try (Scope ws = this.currentTraceContext.newScope(context)) { - Mono.just(1).flatMap(d -> Flux.just(d + 1).collectList().map(p -> p.get(0))) - .map(d -> d + 1).map((d) -> { - spanInOperation.set(this.currentTraceContext.get()); - return d + 1; - }).map(d -> d + 1).subscribe(d -> { - }); + Mono.just(1).flatMap(d -> Flux.just(d + 1).collectList().map(p -> p.get(0))).map(d -> d + 1).map((d) -> { + spanInOperation.set(this.currentTraceContext.get()); + return d + 1; + }).map(d -> d + 1).subscribe(d -> { + }); } then(this.currentTraceContext.get()).isNull(); @@ -94,24 +91,21 @@ public class ScopePassingSpanSubscriberSpringBootTests { final AtomicReference spanInOperation = new AtomicReference<>(); try (Scope ws = this.currentTraceContext.newScope(context)) { - Flux.just(1, 2, 3).publishOn(Schedulers.single()).log("reactor.1") - .map(d -> d + 1).map(d -> d + 1) - .publishOn(Schedulers.newSingle("secondThread")).log("reactor.2") - .map((d) -> { + Flux.just(1, 2, 3).publishOn(Schedulers.single()).log("reactor.1").map(d -> d + 1).map(d -> d + 1) + .publishOn(Schedulers.newSingle("secondThread")).log("reactor.2").map((d) -> { spanInOperation.set(this.currentTraceContext.get()); return d + 1; }).map(d -> d + 1).blockLast(); - Awaitility.await() - .untilAsserted(() -> then(spanInOperation.get()).isEqualTo(context)); + Awaitility.await().untilAsserted(() -> then(spanInOperation.get()).isEqualTo(context)); then(this.currentTraceContext.get()).isEqualTo(context); } then(this.currentTraceContext.get()).isNull(); try (Scope ws = this.currentTraceContext.newScope(context2)) { - Flux.just(1, 2, 3).publishOn(Schedulers.single()).log("reactor.") - .map(d -> d + 1).map(d -> d + 1).map((d) -> { + Flux.just(1, 2, 3).publishOn(Schedulers.single()).log("reactor.").map(d -> d + 1).map(d -> d + 1) + .map((d) -> { spanInOperation.set(this.currentTraceContext.get()); return d + 1; }).map(d -> d + 1).blockLast(); @@ -138,10 +132,9 @@ public class ScopePassingSpanSubscriberSpringBootTests { final AtomicReference spanInZipOperation = new AtomicReference<>(); try (Scope ws = this.currentTraceContext.newScope(context)) { - Mono.fromCallable(this.currentTraceContext::get).map(span -> span) - .doOnNext(spanInOperation::set) - .zipWith(Mono.fromCallable(this.currentTraceContext::get) - .map(span -> span).doOnNext(spanInZipOperation::set)) + Mono.fromCallable(this.currentTraceContext::get).map(span -> span).doOnNext(spanInOperation::set) + .zipWith(Mono.fromCallable(this.currentTraceContext::get).map(span -> span) + .doOnNext(spanInZipOperation::set)) .block(); } @@ -153,9 +146,7 @@ public class ScopePassingSpanSubscriberSpringBootTests { @Test public void should_work_for_mono_just_with_flat_map() { try (Scope ws = this.currentTraceContext.newScope(context)) { - Mono.just("value1") - .flatMap(request -> Mono.just("value2").then(Mono.just("foo"))) - .map(a -> "qwe").block(); + Mono.just("value1").flatMap(request -> Mono.just("value2").then(Mono.just("foo"))).map(a -> "qwe").block(); } } @@ -177,11 +168,8 @@ public class ScopePassingSpanSubscriberSpringBootTests { final AtomicReference spanInOperation = new AtomicReference<>(); try (Scope ws = this.currentTraceContext.newScope(context)) { - Flux.range(0, 5) - .flatMap(it -> Mono.delay(Duration.ofMillis(1)) - .map(context -> this.currentTraceContext.get()) - .doOnNext(spanInOperation::set)) - .blockFirst(); + Flux.range(0, 5).flatMap(it -> Mono.delay(Duration.ofMillis(1)) + .map(context -> this.currentTraceContext.get()).doOnNext(spanInOperation::set)).blockFirst(); } then(spanInOperation.get()).isEqualTo(context); diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriberTests.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriberTests.java index 22317dae0..c5d968251 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriberTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/ScopePassingSpanSubscriberTests.java @@ -55,17 +55,14 @@ public class ScopePassingSpanSubscriberTests { // iterator. That's not allowed, and will cause an exception // Fuseable$QueueSubscription.NOT_SUPPORTED_MESSAGE. // This ensures AssertJ uses normal toString. - StandardRepresentation.registerFormatterForType(ScopePassingSpanSubscriber.class, - Objects::toString); + StandardRepresentation.registerFormatterForType(ScopePassingSpanSubscriber.class, Objects::toString); } StrictCurrentTraceContext currentTraceContext = StrictCurrentTraceContext.create(); - TraceContext context = TraceContext.newBuilder().traceId(1).spanId(1).sampled(true) - .build(); + TraceContext context = TraceContext.newBuilder().traceId(1).spanId(1).sampled(true).build(); - TraceContext context2 = TraceContext.newBuilder().traceId(1).spanId(2).sampled(true) - .build(); + TraceContext context2 = TraceContext.newBuilder().traceId(1).spanId(2).sampled(true).build(); Subscriber assertNotScopePassingSpanSubscriber = new CoreSubscriber() { @Override @@ -132,8 +129,8 @@ public class ScopePassingSpanSubscriberTests { @Test public void should_propagate_current_context() { - ScopePassingSpanSubscriber subscriber = new ScopePassingSpanSubscriber<>(null, - Context.of("foo", "bar"), this.currentTraceContext, null); + ScopePassingSpanSubscriber subscriber = new ScopePassingSpanSubscriber<>(null, Context.of("foo", "bar"), + this.currentTraceContext, null); then((String) subscriber.currentContext().get("foo")).isEqualTo("bar"); } @@ -144,16 +141,16 @@ public class ScopePassingSpanSubscriberTests { @Test public void should_not_redundantly_copy_context() { Context initial = Context.of(TraceContext.class, context); - ScopePassingSpanSubscriber subscriber = new ScopePassingSpanSubscriber<>(null, - initial, this.currentTraceContext, context); + ScopePassingSpanSubscriber subscriber = new ScopePassingSpanSubscriber<>(null, initial, + this.currentTraceContext, context); then(initial).isSameAs(subscriber.currentContext()); } @Test public void should_set_empty_context_when_context_is_null() { - ScopePassingSpanSubscriber subscriber = new ScopePassingSpanSubscriber<>(null, - Context.empty(), this.currentTraceContext, null); + ScopePassingSpanSubscriber subscriber = new ScopePassingSpanSubscriber<>(null, Context.empty(), + this.currentTraceContext, null); then(subscriber.currentContext().isEmpty()).isTrue(); } @@ -161,9 +158,8 @@ public class ScopePassingSpanSubscriberTests { @Test public void should_put_current_span_to_context() { try (Scope ws = this.currentTraceContext.newScope(context2)) { - CoreSubscriber subscriber = new ScopePassingSpanSubscriber<>( - new BaseSubscriber() { - }, Context.empty(), currentTraceContext, context); + CoreSubscriber subscriber = new ScopePassingSpanSubscriber<>(new BaseSubscriber() { + }, Context.empty(), currentTraceContext, context); then(subscriber.currentContext().get(TraceContext.class)).isEqualTo(context); } @@ -179,14 +175,11 @@ public class ScopePassingSpanSubscriberTests { try (Scope ws = this.currentTraceContext.newScope(context)) { - transformer.apply(Mono.just(1)) - .subscribe(assertNotScopePassingSpanSubscriber); + transformer.apply(Mono.just(1)).subscribe(assertNotScopePassingSpanSubscriber); - transformer.apply(Mono.error(new Exception())) - .subscribe(assertNotScopePassingSpanSubscriber); + transformer.apply(Mono.error(new Exception())).subscribe(assertNotScopePassingSpanSubscriber); - transformer.apply(Mono.empty()) - .subscribe(assertNotScopePassingSpanSubscriber); + transformer.apply(Mono.empty()).subscribe(assertNotScopePassingSpanSubscriber); } } @@ -201,14 +194,11 @@ public class ScopePassingSpanSubscriberTests { try (Scope ws = this.currentTraceContext.newScope(context)) { - transformer.apply(Mono.just(1).hide()) - .subscribe(assertScopePassingSpanSubscriber); + transformer.apply(Mono.just(1).hide()).subscribe(assertScopePassingSpanSubscriber); - transformer.apply(Mono.error(new Exception()).hide()) - .subscribe(assertScopePassingSpanSubscriber); + transformer.apply(Mono.error(new Exception()).hide()).subscribe(assertScopePassingSpanSubscriber); - transformer.apply(Mono.empty().hide()) - .subscribe(assertScopePassingSpanSubscriber); + transformer.apply(Mono.empty().hide()).subscribe(assertScopePassingSpanSubscriber); } } diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfigurationAccessorConfiguration.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfigurationAccessorConfiguration.java index 5623beec9..eb34632c3 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfigurationAccessorConfiguration.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/TraceReactorAutoConfigurationAccessorConfiguration.java @@ -35,8 +35,7 @@ public final class TraceReactorAutoConfigurationAccessorConfiguration { throw new IllegalStateException("Can't instantiate a utility class"); } - private static final Log log = LogFactory - .getLog(TraceReactorAutoConfigurationAccessorConfiguration.class); + private static final Log log = LogFactory.getLog(TraceReactorAutoConfigurationAccessorConfiguration.class); public static void close() { if (log.isTraceEnabled()) { diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/FlatMapTests.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/FlatMapTests.java index 6bd84cb6a..7eb48f2da 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/FlatMapTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/FlatMapTests.java @@ -80,57 +80,48 @@ public class FlatMapTests { @Test public void should_work_with_flat_maps(CapturedOutput capture) { // given - ConfigurableApplicationContext context = new SpringApplicationBuilder( - FlatMapTests.TestConfiguration.class, Issue866Configuration.class) + ConfigurableApplicationContext context = new SpringApplicationBuilder(FlatMapTests.TestConfiguration.class, + Issue866Configuration.class) .web(WebApplicationType.REACTIVE) .properties("server.port=0", "spring.jmx.enabled=false", - "spring.application.name=TraceWebFluxTests", - "security.basic.enabled=false", + "spring.application.name=TraceWebFluxTests", "security.basic.enabled=false", "management.security.enabled=false") .run(); - assertReactorTracing(context, capture, - () -> context.getBean(TestConfiguration.class).spanInFoo); + assertReactorTracing(context, capture, () -> context.getBean(TestConfiguration.class).spanInFoo); } @Test - public void should_work_with_flat_maps_with_on_last_operator_instrumentation( - CapturedOutput capture) { + public void should_work_with_flat_maps_with_on_last_operator_instrumentation(CapturedOutput capture) { // given - ConfigurableApplicationContext context = new SpringApplicationBuilder( - FlatMapTests.TestConfiguration.class, Issue866Configuration.class) + ConfigurableApplicationContext context = new SpringApplicationBuilder(FlatMapTests.TestConfiguration.class, + Issue866Configuration.class) .web(WebApplicationType.REACTIVE) .properties("server.port=0", "spring.jmx.enabled=false", "spring.sleuth.reactor.decorate-on-each=false", - "spring.application.name=TraceWebFlux2Tests", - "security.basic.enabled=false", + "spring.application.name=TraceWebFlux2Tests", "security.basic.enabled=false", "management.security.enabled=false") .run(); - assertReactorTracing(context, capture, - () -> context.getBean(TestConfiguration.class).spanInFoo); + assertReactorTracing(context, capture, () -> context.getBean(TestConfiguration.class).spanInFoo); } @Test - public void should_work_with_flat_maps_with_on_manual_operator_instrumentation( - CapturedOutput capture) { + public void should_work_with_flat_maps_with_on_manual_operator_instrumentation(CapturedOutput capture) { // given ConfigurableApplicationContext context = new SpringApplicationBuilder( FlatMapTests.TestManualConfiguration.class, Issue866Configuration.class) .web(WebApplicationType.REACTIVE) .properties("server.port=0", "spring.jmx.enabled=false", "spring.sleuth.reactor.instrumentation-type=MANUAL", - "spring.application.name=TraceWebFlux3Tests", - "security.basic.enabled=false", + "spring.application.name=TraceWebFlux3Tests", "security.basic.enabled=false", "management.security.enabled=false") .run(); - assertReactorTracing(context, capture, - () -> context.getBean(TestManualConfiguration.class).spanInFoo); + assertReactorTracing(context, capture, () -> context.getBean(TestManualConfiguration.class).spanInFoo); } - private void assertReactorTracing(ConfigurableApplicationContext context, - CapturedOutput capture, SpanProvider spanProvider) { + private void assertReactorTracing(ConfigurableApplicationContext context, CapturedOutput capture, + SpanProvider spanProvider) { TestSpanHandler spans = context.getBean(TestSpanHandler.class); - int port = context.getBean(Environment.class).getProperty("local.server.port", - Integer.class); + int port = context.getBean(Environment.class).getProperty("local.server.port", Integer.class); RequestSender sender = context.getBean(RequestSender.class); FactoryUser factoryUser = context.getBean(FactoryUser.class); sender.port = port; @@ -152,29 +143,23 @@ public class FlatMapTests { LOGGER.info("Second trace start"); String secondTraceId = flatMapTraceId(spans, callFlatMap(port).block()); // then - then(firstTraceId).as("Id will not be reused between calls") - .isNotEqualTo(secondTraceId); + then(firstTraceId).as("Id will not be reused between calls").isNotEqualTo(secondTraceId); LOGGER.info("Id was not reused between calls"); thenSpanInFooHasSameTraceId(secondTraceId, spanProvider); LOGGER.info("Span in Foo has same trace id"); // and List requestUri = Arrays.stream(capture.toString().split("\n")) - .filter(s -> s.contains("Received a request to uri")) - .map(s -> s.split(",")[1]).collect(Collectors.toList()); - LOGGER.info( - "TracingFilter should not have any trace when receiving a request " - + requestUri); - then(requestUri).as( - "TracingFilter should not have any trace when receiving a request") - .containsOnly(""); + .filter(s -> s.contains("Received a request to uri")).map(s -> s.split(",")[1]) + .collect(Collectors.toList()); + LOGGER.info("TracingFilter should not have any trace when receiving a request " + requestUri); + then(requestUri).as("TracingFilter should not have any trace when receiving a request").containsOnly(""); // and #866 then(factoryUser.wasSchedulerWrapped).isTrue(); LOGGER.info("Factory was wrapped"); }); } - private void thenAllWebClientCallsHaveSameTraceId(String traceId, - RequestSender sender) { + private void thenAllWebClientCallsHaveSameTraceId(String traceId, RequestSender sender) { then(sender.span.context().traceIdString()).isEqualTo(traceId); } @@ -183,17 +168,15 @@ public class FlatMapTests { } private Mono callFlatMap(int port) { - return WebClient.create().get().uri("http://localhost:" + port + "/withFlatMap") - .exchange(); + return WebClient.create().get().uri("http://localhost:" + port + "/withFlatMap").exchange(); } private String flatMapTraceId(TestSpanHandler spans, ClientResponse response) { then(response.statusCode().value()).isEqualTo(200); then(spans).isNotEmpty(); LOGGER.info("Accumulated spans: " + spans); - List traceIdOfFlatMap = spans.spans().stream() - .filter(span -> span.tags().containsKey("http.path") - && span.tags().get("http.path").equals("/withFlatMap")) + List traceIdOfFlatMap = spans.spans().stream().filter( + span -> span.tags().containsKey("http.path") && span.tags().get("http.path").equals("/withFlatMap")) .map(MutableSpan::traceId).collect(Collectors.toList()); then(traceIdOfFlatMap).hasSize(1); return traceIdOfFlatMap.get(0); @@ -206,8 +189,7 @@ public class FlatMapTests { brave.Span spanInFoo; @Bean - RouterFunction handlers(Tracer tracer, - RequestSender requestSender) { + RouterFunction handlers(Tracer tracer, RequestSender requestSender) { return route(GET("/noFlatMap"), request -> { LOGGER.info("noFlatMap"); Flux one = requestSender.getAll().map(String::length); @@ -215,9 +197,8 @@ public class FlatMapTests { }).andRoute(GET("/withFlatMap"), request -> { LOGGER.info("withFlatMap"); Flux one = requestSender.getAll().map(String::length); - Flux response = one - .flatMap(size -> requestSender.getAll().doOnEach( - sig -> LOGGER.info(sig.getContext().toString()))) + Flux response = one.flatMap( + size -> requestSender.getAll().doOnEach(sig -> LOGGER.info(sig.getContext().toString()))) .map(string -> { LOGGER.info("WHATEVER YEAH"); return string.length(); @@ -265,24 +246,19 @@ public class FlatMapTests { brave.Span spanInFoo; @Bean - RouterFunction handlers(Tracing tracing, - ManualRequestSender requestSender) { + RouterFunction handlers(Tracing tracing, ManualRequestSender requestSender) { return route(GET("/noFlatMap"), request -> { ServerWebExchange exchange = request.exchange(); - WebFluxSleuthOperators.withSpanInScope(tracing, exchange, - () -> LOGGER.info("noFlatMap")); + WebFluxSleuthOperators.withSpanInScope(tracing, exchange, () -> LOGGER.info("noFlatMap")); Flux one = requestSender.getAll().map(String::length); return ServerResponse.ok().body(one, Integer.class); }).andRoute(GET("/withFlatMap"), request -> { ServerWebExchange exchange = request.exchange(); - WebFluxSleuthOperators.withSpanInScope(tracing, exchange, - () -> LOGGER.info("withFlatMap")); + WebFluxSleuthOperators.withSpanInScope(tracing, exchange, () -> LOGGER.info("withFlatMap")); Flux one = requestSender.getAll().map(String::length); Flux response = one - .flatMap(size -> requestSender.getAll() - .doOnEach(sig -> WebFluxSleuthOperators.withSpanInScope( - sig.getContext(), - () -> LOGGER.info(sig.getContext().toString())))) + .flatMap(size -> requestSender.getAll().doOnEach(sig -> WebFluxSleuthOperators + .withSpanInScope(sig.getContext(), () -> LOGGER.info(sig.getContext().toString())))) .map(string -> { WebFluxSleuthOperators.withSpanInScope(tracing, exchange, () -> LOGGER.info("WHATEVER YEAH")); diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/ManualRequestSender.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/ManualRequestSender.java index 9500eab7b..1144bbf7f 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/ManualRequestSender.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/ManualRequestSender.java @@ -29,8 +29,7 @@ import org.springframework.web.reactive.function.client.WebClient; class ManualRequestSender extends RequestSender { - private static final Logger LOGGER = LoggerFactory - .getLogger(ManualRequestSender.class); + private static final Logger LOGGER = LoggerFactory.getLogger(ManualRequestSender.class); ManualRequestSender(WebClient webClient, Tracer tracer) { super(webClient, tracer); @@ -38,25 +37,21 @@ class ManualRequestSender extends RequestSender { @Override public Mono get(Integer someParameterNotUsedNow) { - return Mono.just(this.webClient).doOnEach( - WebFluxSleuthOperators.withSpanInScope(SignalType.ON_NEXT, () -> { - this.span = this.tracer.currentSpan(); - LOGGER.info("getting for parameter {}", someParameterNotUsedNow); - })) - .flatMap(webClient -> Mono.subscriberContext() - .flatMap(ctx -> WebFluxSleuthOperators.withSpanInScope(ctx, - () -> webClient.method(HttpMethod.GET) - .uri("http://localhost:" + port + "/foo") - .retrieve().bodyToMono(String.class)))); + return Mono.just(this.webClient).doOnEach(WebFluxSleuthOperators.withSpanInScope(SignalType.ON_NEXT, () -> { + this.span = this.tracer.currentSpan(); + LOGGER.info("getting for parameter {}", someParameterNotUsedNow); + })).flatMap(webClient -> Mono.subscriberContext() + .flatMap(ctx -> WebFluxSleuthOperators.withSpanInScope(ctx, () -> webClient.method(HttpMethod.GET) + .uri("http://localhost:" + port + "/foo").retrieve().bodyToMono(String.class)))); } @Override public Flux getAll() { - return Flux.just("").flatMap(s -> Flux.deferWithContext(ctx -> Flux.just("") - .doOnNext(t -> WebFluxSleuthOperators.withSpanInScope(ctx, - () -> LOGGER.info("before merge"))) - .mergeWith(get(2)).mergeWith(get(3)).doOnNext(t -> WebFluxSleuthOperators - .withSpanInScope(ctx, () -> LOGGER.info("after merge"))))); + return Flux.just("") + .flatMap(s -> Flux.deferWithContext(ctx -> Flux.just("") + .doOnNext(t -> WebFluxSleuthOperators.withSpanInScope(ctx, () -> LOGGER.info("before merge"))) + .mergeWith(get(2)).mergeWith(get(3)) + .doOnNext(t -> WebFluxSleuthOperators.withSpanInScope(ctx, () -> LOGGER.info("after merge"))))); } } diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/RequestSender.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/RequestSender.java index 582299db0..aba073297 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/RequestSender.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/reactor/sample/RequestSender.java @@ -46,8 +46,7 @@ class RequestSender { public Mono get(Integer someParameterNotUsedNow) { LOGGER.info("getting for parameter {}", someParameterNotUsedNow); this.span = this.tracer.currentSpan(); - return this.webClient.method(HttpMethod.GET) - .uri("http://localhost:" + this.port + "/foo").retrieve() + return this.webClient.method(HttpMethod.GET).uri("http://localhost:" + this.port + "/foo").retrieve() .bodyToMono(String.class); } diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ITSpringConfiguredReactorClient.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ITSpringConfiguredReactorClient.java index d48b5b962..1be27c66e 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ITSpringConfiguredReactorClient.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ITSpringConfiguredReactorClient.java @@ -48,8 +48,7 @@ import static org.assertj.core.api.Assertions.assertThat; * present. */ // Function of spring context so that shutdown hooks happen! -abstract class ITSpringConfiguredReactorClient - extends ITHttpAsyncClient { +abstract class ITSpringConfiguredReactorClient extends ITHttpAsyncClient { @Before @After @@ -73,8 +72,7 @@ abstract class ITSpringConfiguredReactorClient AnnotationConfigApplicationContext result = new AnnotationConfigApplicationContext(); URI baseUrl = URI.create("http://127.0.0.1:" + server.getPort()); result.registerBean(HttpTracing.class, () -> httpTracing); - result.registerBean(CurrentTraceContext.class, - () -> httpTracing.tracing().currentTraceContext()); + result.registerBean(CurrentTraceContext.class, () -> httpTracing.tracing().currentTraceContext()); result.registerBean(HttpClient.class, () -> testHttpClient(baseUrl)); result.registerBean(URI.class, () -> baseUrl); result.register(componentClasses); @@ -84,10 +82,8 @@ abstract class ITSpringConfiguredReactorClient static HttpClient testHttpClient(URI baseUrl) { return HttpClient.create().baseUrl(baseUrl.toString()) - .tcpConfiguration(tcpClient -> tcpClient - .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 1000) - .doOnConnected(conn -> conn - .addHandler(new ReadTimeoutHandler(3, TimeUnit.SECONDS)))) + .tcpConfiguration(tcpClient -> tcpClient.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 1000) + .doOnConnected(conn -> conn.addHandler(new ReadTimeoutHandler(3, TimeUnit.SECONDS)))) .disableRetry(true).followRedirect(true); } @@ -97,14 +93,12 @@ abstract class ITSpringConfiguredReactorClient } @Override - final protected void get(AnnotationConfigApplicationContext context, - String pathIncludingQuery) { + final protected void get(AnnotationConfigApplicationContext context, String pathIncludingQuery) { getMono(context, pathIncludingQuery).block(); } @Override - final protected void post(AnnotationConfigApplicationContext context, - String pathIncludingQuery, String body) { + final protected void post(AnnotationConfigApplicationContext context, String pathIncludingQuery, String body) { postMono(context, pathIncludingQuery, body).block(); } @@ -115,12 +109,10 @@ abstract class ITSpringConfiguredReactorClient } /** Returns a {@link Mono} of the HTTP status code from the given "POST" request. */ - abstract Mono postMono(AnnotationConfigApplicationContext context, - String pathIncludingQuery, String body); + abstract Mono postMono(AnnotationConfigApplicationContext context, String pathIncludingQuery, String body); /** Returns a {@link Mono} of the HTTP status code. */ - abstract Mono getMono(AnnotationConfigApplicationContext context, - String pathIncludingQuery); + abstract Mono getMono(AnnotationConfigApplicationContext context, String pathIncludingQuery); /** * This assumes that implementations do not issue an HTTP request until diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ReactorNettyHttpClientBraveTests.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ReactorNettyHttpClientBraveTests.java index 154b2972c..c54445a93 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ReactorNettyHttpClientBraveTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/ReactorNettyHttpClientBraveTests.java @@ -72,18 +72,14 @@ public class ReactorNettyHttpClientBraveTests extends ITSpringConfiguredReactorC } @Override - Mono postMono(AnnotationConfigApplicationContext context, - String pathIncludingQuery, String body) { - return context.getBean(HttpClient.class).post() - .send(ByteBufFlux.fromString(Mono.just(body))).uri(pathIncludingQuery) - .response().map(r -> r.status().code()); + Mono postMono(AnnotationConfigApplicationContext context, String pathIncludingQuery, String body) { + return context.getBean(HttpClient.class).post().send(ByteBufFlux.fromString(Mono.just(body))) + .uri(pathIncludingQuery).response().map(r -> r.status().code()); } @Override - Mono getMono(AnnotationConfigApplicationContext context, - String pathIncludingQuery) { - return context.getBean(HttpClient.class).get().uri(pathIncludingQuery).response() - .map(r -> r.status().code()); + Mono getMono(AnnotationConfigApplicationContext context, String pathIncludingQuery) { + return context.getBean(HttpClient.class).get().uri(pathIncludingQuery).response().map(r -> r.status().code()); } } diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TestHttpCallbackSubscriber.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TestHttpCallbackSubscriber.java index d25d6d1f0..dc16677bd 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TestHttpCallbackSubscriber.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/TestHttpCallbackSubscriber.java @@ -90,8 +90,7 @@ final class TestHttpCallbackSubscriber implements CoreSubscriber { // Tests make a non-empty Mono subscription, which should not signal // onComplete() before onNext(). If we reach here, possibly instrumentation // is not signaling onNext() when it should. - callback.accept(null, - new AssertionError("onComplete() called before onNext!")); + callback.accept(null, new AssertionError("onComplete() called before onNext!")); } } diff --git a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/WebClientBraveTests.java b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/WebClientBraveTests.java index 145e3d1bc..67ead3e9c 100644 --- a/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/WebClientBraveTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-reactor-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/client/WebClientBraveTests.java @@ -48,25 +48,21 @@ public class WebClientBraveTests extends ITSpringConfiguredReactorClient { * {@link BeanPostProcessor}. */ public WebClientBraveTests() { - super(WebClientConfiguration.class, WebClientAutoConfiguration.class, - TraceWebClientBeanPostProcessor.class); + super(WebClientConfiguration.class, WebClientAutoConfiguration.class, TraceWebClientBeanPostProcessor.class); } @Override - Mono postMono(AnnotationConfigApplicationContext context, - String pathIncludingQuery, String body) { - return context.getBean(WebClient.Builder.class).build().post() - .uri(pathIncludingQuery).body(BodyInserters.fromValue(body)).exchange() + Mono postMono(AnnotationConfigApplicationContext context, String pathIncludingQuery, String body) { + return context.getBean(WebClient.Builder.class).build().post().uri(pathIncludingQuery) + .body(BodyInserters.fromValue(body)).exchange().map(ClientResponse::rawStatusCode); + } + + @Override + Mono getMono(AnnotationConfigApplicationContext context, String pathIncludingQuery) { + return context.getBean(WebClient.Builder.class).build().get().uri(pathIncludingQuery).exchange() .map(ClientResponse::rawStatusCode); } - @Override - Mono getMono(AnnotationConfigApplicationContext context, - String pathIncludingQuery) { - return context.getBean(WebClient.Builder.class).build().get() - .uri(pathIncludingQuery).exchange().map(ClientResponse::rawStatusCode); - } - @Test @Ignore("WebClient is blind to the implementation of redirects") @Override @@ -94,8 +90,7 @@ public class WebClientBraveTests extends ITSpringConfiguredReactorClient { */ @Bean @Order(0) - public WebClientCustomizer clientConnectorCustomizer(HttpClient httpClient, - URI baseUrl) { + public WebClientCustomizer clientConnectorCustomizer(HttpClient httpClient, URI baseUrl) { return (builder) -> builder.baseUrl(baseUrl.toString()) .clientConnector(new ReactorClientHttpConnector(httpClient)); } diff --git a/tests/spring-cloud-sleuth-instrumentation-rpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationIntegrationTests.java b/tests/spring-cloud-sleuth-instrumentation-rpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationIntegrationTests.java index 3da1f87b7..9dd9fba79 100644 --- a/tests/spring-cloud-sleuth-instrumentation-rpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationIntegrationTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-rpc-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rpc/TraceRpcAutoConfigurationIntegrationTests.java @@ -62,10 +62,8 @@ public class TraceRpcAutoConfigurationIntegrationTests { // tag::custom_rpc_server_sampler[] @Bean(name = RpcServerSampler.NAME) SamplerFunction myRpcSampler() { - Matcher userAuth = and(serviceEquals("users.UserService"), - methodEquals("GetUserToken")); - return RpcRuleSampler.newBuilder() - .putRule(serviceEquals("grpc.health.v1.Health"), Sampler.NEVER_SAMPLE) + Matcher userAuth = and(serviceEquals("users.UserService"), methodEquals("GetUserToken")); + return RpcRuleSampler.newBuilder().putRule(serviceEquals("grpc.health.v1.Health"), Sampler.NEVER_SAMPLE) .putRule(userAuth, RateLimitingSampler.create(100)).build(); } // end::custom_rpc_server_sampler[] diff --git a/tests/spring-cloud-sleuth-instrumentation-rxjava-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaSchedulersHookTests.java b/tests/spring-cloud-sleuth-instrumentation-rxjava-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaSchedulersHookTests.java index 226b8f582..d6278b2a2 100644 --- a/tests/spring-cloud-sleuth-instrumentation-rxjava-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaSchedulersHookTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-rxjava-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaSchedulersHookTests.java @@ -54,8 +54,8 @@ public class SleuthRxJavaSchedulersHookTests { TestSpanHandler spans = new TestSpanHandler(); - Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext) - .addSpanHandler(this.spans).build(); + Tracing tracing = Tracing.newBuilder().currentTraceContext(this.currentTraceContext).addSpanHandler(this.spans) + .build(); Tracer tracer = this.tracing.tracer(); @@ -76,13 +76,11 @@ public class SleuthRxJavaSchedulersHookTests { @Test public void should_not_override_existing_custom_hooks() { RxJavaPlugins.getInstance().registerErrorHandler(new MyRxJavaErrorHandler()); - RxJavaPlugins.getInstance() - .registerObservableExecutionHook(new MyRxJavaObservableExecutionHook()); + RxJavaPlugins.getInstance().registerObservableExecutionHook(new MyRxJavaObservableExecutionHook()); new SleuthRxJavaSchedulersHook(this.tracer, this.threadsToIgnore); - then(RxJavaPlugins.getInstance().getErrorHandler()) - .isExactlyInstanceOf(MyRxJavaErrorHandler.class); + then(RxJavaPlugins.getInstance().getErrorHandler()).isExactlyInstanceOf(MyRxJavaErrorHandler.class); then(RxJavaPlugins.getInstance().getObservableExecutionHook()) .isExactlyInstanceOf(MyRxJavaObservableExecutionHook.class); } @@ -90,8 +88,7 @@ public class SleuthRxJavaSchedulersHookTests { @Test public void should_wrap_delegates_action_in_wrapped_action_when_delegate_is_present_on_schedule() { RxJavaPlugins.getInstance().registerSchedulersHook(new MyRxJavaSchedulersHook()); - SleuthRxJavaSchedulersHook schedulersHook = new SleuthRxJavaSchedulersHook( - this.tracer, this.threadsToIgnore); + SleuthRxJavaSchedulersHook schedulersHook = new SleuthRxJavaSchedulersHook(this.tracer, this.threadsToIgnore); Action0 action = schedulersHook.onSchedule(() -> { caller = new StringBuilder("hello"); }); @@ -109,8 +106,8 @@ public class SleuthRxJavaSchedulersHookTests { throws ExecutionException, InterruptedException { String threadNameToIgnore = "^MyCustomThread.*$"; RxJavaPlugins.getInstance().registerSchedulersHook(new MyRxJavaSchedulersHook()); - SleuthRxJavaSchedulersHook schedulersHook = new SleuthRxJavaSchedulersHook( - this.tracer, Collections.singletonList(threadNameToIgnore)); + SleuthRxJavaSchedulersHook schedulersHook = new SleuthRxJavaSchedulersHook(this.tracer, + Collections.singletonList(threadNameToIgnore)); Future hello = executorService().submit((Callable) () -> { Action0 action = schedulersHook.onSchedule(() -> { caller = new StringBuilder("hello"); diff --git a/tests/spring-cloud-sleuth-instrumentation-rxjava-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaTests.java b/tests/spring-cloud-sleuth-instrumentation-rxjava-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaTests.java index a24efa0b8..e010f0b31 100644 --- a/tests/spring-cloud-sleuth-instrumentation-rxjava-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-rxjava-tests/src/test/java/org/springframework/cloud/sleuth/instrument/rxjava/SleuthRxJavaTests.java @@ -66,11 +66,8 @@ public class SleuthRxJavaTests { @Test public void should_create_new_span_when_rx_java_action_is_executed_and_there_was_no_span() { - Observable - .defer(() -> Observable.just( - (Action0) () -> this.caller = new StringBuffer("actual_action"))) - .subscribeOn(Schedulers.newThread()).toBlocking() - .subscribe(Action0::call); + Observable.defer(() -> Observable.just((Action0) () -> this.caller = new StringBuffer("actual_action"))) + .subscribeOn(Schedulers.newThread()).toBlocking().subscribe(Action0::call); then(this.caller.toString()).isEqualTo("actual_action"); then(this.tracer.currentSpan()).isNull(); @@ -84,10 +81,8 @@ public class SleuthRxJavaTests { Span spanInCurrentThread = this.tracer.nextSpan().name("current_span"); try (Tracer.SpanInScope ws = this.tracer.withSpanInScope(spanInCurrentThread)) { - Observable.defer(() -> Observable.just( - (Action0) () -> this.caller = new StringBuffer("actual_action"))) - .subscribeOn(Schedulers.newThread()).toBlocking() - .subscribe(Action0::call); + Observable.defer(() -> Observable.just((Action0) () -> this.caller = new StringBuffer("actual_action"))) + .subscribeOn(Schedulers.newThread()).toBlocking().subscribe(Action0::call); } finally { spanInCurrentThread.finish(); diff --git a/tests/spring-cloud-sleuth-instrumentation-scheduling-tests/src/test/java/org/springframework/cloud/sleuth/instrument/scheduling/TracingOnScheduledTests.java b/tests/spring-cloud-sleuth-instrumentation-scheduling-tests/src/test/java/org/springframework/cloud/sleuth/instrument/scheduling/TracingOnScheduledTests.java index 6eb792e5a..707175ffd 100644 --- a/tests/spring-cloud-sleuth-instrumentation-scheduling-tests/src/test/java/org/springframework/cloud/sleuth/instrument/scheduling/TracingOnScheduledTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-scheduling-tests/src/test/java/org/springframework/cloud/sleuth/instrument/scheduling/TracingOnScheduledTests.java @@ -93,8 +93,7 @@ public class TracingOnScheduledTests { } @Test - public void should_not_create_span_in_the_scheduled_class_that_matches_skip_pattern() - throws Exception { + public void should_not_create_span_in_the_scheduled_class_that_matches_skip_pattern() throws Exception { await().atMost(5, SECONDS).untilAsserted(() -> { then(this.beanWithScheduledMethodToBeIgnored.isExecuted()).isTrue(); then(this.beanWithScheduledMethodToBeIgnored.getSpan()).isNull(); @@ -105,12 +104,10 @@ public class TracingOnScheduledTests { Span storedSpan = TracingOnScheduledTests.this.beanWithScheduledMethod.getSpan(); then(storedSpan).isNotNull(); then(storedSpan.context().traceId()).isNotNull(); - MutableSpan foundSpan = spans.spans().stream() - .filter(span -> !span.tags().containsKey("error") - && span.tags().containsValue("TestBeanWithScheduledMethod")) + MutableSpan foundSpan = spans.spans().stream().filter( + span -> !span.tags().containsKey("error") && span.tags().containsValue("TestBeanWithScheduledMethod")) .findFirst().orElseThrow(() -> new AssertionError("Span is missing")); - then(foundSpan.tags()).contains( - new AbstractMap.SimpleEntry<>("class", "TestBeanWithScheduledMethod"), + then(foundSpan.tags()).contains(new AbstractMap.SimpleEntry<>("class", "TestBeanWithScheduledMethod"), new AbstractMap.SimpleEntry<>("method", "scheduledMethod")); then(foundSpan.finishTimestamp()).isGreaterThan(0L); } @@ -119,20 +116,17 @@ public class TracingOnScheduledTests { Span storedSpan = TracingOnScheduledTests.this.beanWithScheduledMethod.getSpan(); then(storedSpan).isNotNull(); then(storedSpan.context().traceId()).isNotNull(); - MutableSpan foundSpan = spans.spans().stream() - .filter(span -> span.tags().containsKey("error")).findFirst() + MutableSpan foundSpan = spans.spans().stream().filter(span -> span.tags().containsKey("error")).findFirst() .orElseThrow(() -> new AssertionError("Span is missing")); then(foundSpan.tags()).contains( - new AbstractMap.SimpleEntry<>("class", - "TestBeanWithScheduledMethodThatThrowsAnException"), + new AbstractMap.SimpleEntry<>("class", "TestBeanWithScheduledMethodThatThrowsAnException"), new AbstractMap.SimpleEntry<>("method", "scheduledMethod")); then(foundSpan.finishTimestamp()).isGreaterThan(0L); then(foundSpan.tags().get("error")).isNotEmpty(); } private void differentSpanHasBeenSetThan(final Span spanToCompare) { - then(TracingOnScheduledTests.this.beanWithScheduledMethod.getSpan()) - .isNotEqualTo(spanToCompare); + then(TracingOnScheduledTests.this.beanWithScheduledMethod.getSpan()).isNotEqualTo(spanToCompare); } } @@ -153,8 +147,7 @@ class ScheduledTestConfiguration { } @Bean - TestBeanWithScheduledMethodToBeIgnored testBeanWithScheduledMethodToBeIgnored( - Tracing tracing) { + TestBeanWithScheduledMethodToBeIgnored testBeanWithScheduledMethodToBeIgnored(Tracing tracing) { return new TestBeanWithScheduledMethodToBeIgnored(tracing); } diff --git a/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/GH1102Tests.java b/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/GH1102Tests.java index a01d8cc1d..c710a510e 100644 --- a/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/GH1102Tests.java +++ b/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/GH1102Tests.java @@ -60,8 +60,8 @@ public class GH1102Tests { public void should_store_retries_as_separate_spans() throws Exception { ScopedSpan foo = this.tracer.startScopedSpan("foo"); try { - this.webClient.get().uri("http://localhost:" + this.port + "/test").retrieve() - .bodyToMono(String.class).retry(1).block(); + this.webClient.get().uri("http://localhost:" + this.port + "/test").retrieve().bodyToMono(String.class) + .retry(1).block(); BDDAssertions.fail("should throw exception"); } catch (WebClientResponseException ex) { @@ -72,8 +72,7 @@ public class GH1102Tests { } // Default inject format for client spans is B3 multi - BDDAssertions.then(this.testRetry.getHttpHeaders().get("x-b3-traceid")) - .hasSize(1); + BDDAssertions.then(this.testRetry.getHttpHeaders().get("x-b3-traceid")).hasSize(1); } @EnableAutoConfiguration diff --git a/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebFluxTests.java b/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebFluxTests.java index 0ed1f125c..89f573aee 100644 --- a/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebFluxTests.java +++ b/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/instrument/web/TraceWebFluxTests.java @@ -54,18 +54,14 @@ public class TraceWebFluxTests { @Test public void should_instrument_web_filter() throws Exception { // setup - ConfigurableApplicationContext context = new SpringApplicationBuilder( - TraceWebFluxTests.Config.class) - .web(WebApplicationType.REACTIVE) - .properties("server.port=0", "spring.jmx.enabled=false", - "spring.sleuth.web.skipPattern=/skipped", - "spring.application.name=TraceWebFluxTests", - "security.basic.enabled=false", - "management.security.enabled=false") - .run(); + ConfigurableApplicationContext context = new SpringApplicationBuilder(TraceWebFluxTests.Config.class) + .web(WebApplicationType.REACTIVE) + .properties("server.port=0", "spring.jmx.enabled=false", "spring.sleuth.web.skipPattern=/skipped", + "spring.application.name=TraceWebFluxTests", "security.basic.enabled=false", + "management.security.enabled=false") + .run(); TestSpanHandler spans = context.getBean(TestSpanHandler.class); - int port = context.getBean(Environment.class).getProperty("local.server.port", - Integer.class); + int port = context.getBean(Environment.class).getProperty("local.server.port", Integer.class); Controller2 controller2 = context.getBean(Controller2.class); clean(spans, controller2); @@ -106,10 +102,8 @@ public class TraceWebFluxTests { controller2.span = null; } - private void thenSpanWasReportedWithTags(TestSpanHandler spans, - ClientResponse response) { - Awaitility.await() - .untilAsserted(() -> then(response.statusCode().value()).isEqualTo(200)); + private void thenSpanWasReportedWithTags(TestSpanHandler spans, ClientResponse response) { + Awaitility.await().untilAsserted(() -> then(response.statusCode().value()).isEqualTo(200)); then(spans).hasSize(1); then(spans.get(0).name()).isEqualTo("GET /api/c2/{id}"); then(spans.get(0).tags()).containsEntry("mvc.controller.method", "successful") @@ -117,26 +111,21 @@ public class TraceWebFluxTests { then(spans.get(0).remoteIp()).isEqualTo("127.0.0.1"); } - private void thenSpanWasReportedWithRemoteIpTags(TestSpanHandler spans, - ClientResponse response) { - Awaitility.await() - .untilAsserted(() -> then(response.statusCode().value()).isEqualTo(200)); + private void thenSpanWasReportedWithRemoteIpTags(TestSpanHandler spans, ClientResponse response) { + Awaitility.await().untilAsserted(() -> then(response.statusCode().value()).isEqualTo(200)); then(spans).hasSize(1); then(spans.get(0).remoteIp()).isEqualTo("203.0.113.195"); } - private void thenFunctionalSpanWasReportedWithTags(TestSpanHandler spans, - ClientResponse response) { - Awaitility.await() - .untilAsserted(() -> then(response.statusCode().value()).isEqualTo(200)); + private void thenFunctionalSpanWasReportedWithTags(TestSpanHandler spans, ClientResponse response) { + Awaitility.await().untilAsserted(() -> then(response.statusCode().value()).isEqualTo(200)); then(spans).hasSize(1); then(spans.get(0).name()).isEqualTo("GET /api/fn/{id}"); then(spans.get(0).tags()).hasEntrySatisfying("mvc.controller.class", value -> then(value).startsWith("TraceWebFluxTests$Config$$Lambda$")); } - private void thenNoSpanWasReported(TestSpanHandler spans, ClientResponse response, - Controller2 controller2) { + private void thenNoSpanWasReported(TestSpanHandler spans, ClientResponse response, Controller2 controller2) { Awaitility.await().untilAsserted(() -> { then(response.statusCode().value()).isEqualTo(200); then(spans).isEmpty(); @@ -146,30 +135,25 @@ public class TraceWebFluxTests { } private ClientResponse whenRequestIsSent(int port, String path) { - Mono exchange = WebClient.create().get() - .uri("http://localhost:" + port + path).exchange(); + Mono exchange = WebClient.create().get().uri("http://localhost:" + port + path).exchange(); return exchange.block(); } private ClientResponse whenRequestWithXForwardedForIsSent(int port, String path) { - Mono exchange = WebClient.create().get() - .uri("http://localhost:" + port + path) - .header("X-Forwarded-For", "203.0.113.195, 70.41.3.18, 150.172.238.178") - .exchange(); + Mono exchange = WebClient.create().get().uri("http://localhost:" + port + path) + .header("X-Forwarded-For", "203.0.113.195, 70.41.3.18, 150.172.238.178").exchange(); return exchange.block(); } private ClientResponse whenRequestIsSentToSkippedPattern(int port) { - Mono exchange = WebClient.create().get() - .uri("http://localhost:" + port + "/skipped").exchange(); + Mono exchange = WebClient.create().get().uri("http://localhost:" + port + "/skipped") + .exchange(); return exchange.block(); } private ClientResponse whenNonSampledRequestIsSent(int port) { - Mono exchange = WebClient.create().get() - .uri("http://localhost:" + port + "/api/c2/10") - .header("b3", EXPECTED_TRACE_ID + "-" + EXPECTED_TRACE_ID + "-0") - .exchange(); + Mono exchange = WebClient.create().get().uri("http://localhost:" + port + "/api/c2/10") + .header("b3", EXPECTED_TRACE_ID + "-" + EXPECTED_TRACE_ID + "-0").exchange(); return exchange.block(); } @@ -201,10 +185,8 @@ public class TraceWebFluxTests { @Bean RouterFunction route() { - return RouterFunctions.route() - .GET("/api/fn/{id}", serverRequest -> ServerResponse.ok() - .bodyValue(serverRequest.pathVariable("id"))) - .build(); + return RouterFunctions.route().GET("/api/fn/{id}", + serverRequest -> ServerResponse.ok().bodyValue(serverRequest.pathVariable("id"))).build(); } } diff --git a/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/util/SpanUtil.java b/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/util/SpanUtil.java index e4ae06344..cc5fa1e5f 100644 --- a/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/util/SpanUtil.java +++ b/tests/spring-cloud-sleuth-instrumentation-webflux-tests/src/test/java/org/springframework/cloud/sleuth/util/SpanUtil.java @@ -26,8 +26,7 @@ public final class SpanUtil { throw new IllegalStateException("Can't instantiate a utility class"); } - static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - 'a', 'b', 'c', 'd', 'e', 'f' }; + static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; // Represents given long id as 16-character lower-hex string public static String idToHex(long id) {