brave.http.HttpRequest Java Examples

@Test public void customSampler() throws IOException {
  String path = "/foo";

  SamplerFunction<HttpRequest> sampler = HttpRuleSampler.newBuilder()
    .putRule(pathStartsWith(path), Sampler.NEVER_SAMPLE)
    .build();

  httpTracing = httpTracing.toBuilder().serverSampler(sampler).build();
  init();

  Request request = new Request.Builder().url(url(path)).build();
  try (Response response = client.newCall(request).execute()) {
    assertThat(response.isSuccessful()).isTrue();
  }

  // @After will check that nothing is reported
}
 

@Test public void customSampler() throws IOException {
  String path = "/foo";

  closeClient(client);

  SamplerFunction<HttpRequest> sampler = HttpRuleSampler.newBuilder()
    .putRule(pathStartsWith(path), Sampler.NEVER_SAMPLE)
    .build();

  httpTracing = httpTracing.toBuilder().clientSampler(sampler).build();
  client = newClient(server.getPort());

  server.enqueue(new MockResponse());
  get(client, path);

  assertThat(extract(takeRequest()).sampled()).isFalse();
}
 

private SamplerFunction<HttpRequest> combineUserProvidedSamplerWithSkipPatternSampler(
		@Nullable SamplerFunction<HttpRequest> serverSampler,
		@Nullable SkipPatternProvider provider) {
	SamplerFunction<HttpRequest> skipPatternSampler = provider != null
			? new SkipPatternHttpServerSampler(provider) : null;
	if (serverSampler == null && skipPatternSampler == null) {
		return SamplerFunctions.deferDecision();
	}
	else if (serverSampler == null) {
		return skipPatternSampler;
	}
	else if (skipPatternSampler == null) {
		return serverSampler;
	}
	return new CompositeHttpSampler(skipPatternSampler, serverSampler);
}
 

@Override
public Boolean trySample(HttpRequest request) {
	// If either decision is false, return false
	Boolean leftDecision = this.left.trySample(request);
	if (Boolean.FALSE.equals(leftDecision)) {
		return false;
	}
	Boolean rightDecision = this.right.trySample(request);
	if (Boolean.FALSE.equals(rightDecision)) {
		return false;
	}
	// If either decision is null, return the other
	if (leftDecision == null) {
		return rightDecision;
	}
	if (rightDecision == null) {
		return leftDecision;
	}
	// Neither are null and at least one is true
	return rightDecision;
}
 

private ContextConsumer<AssertableApplicationContext> thenCompositeHttpServerSamplerOf(
		SamplerFunction<HttpRequest> instance) {
	return (context) -> {

		SamplerFunction<HttpRequest> serverSampler = context
				.getBean(HttpTracing.class).serverRequestSampler();

		then(serverSampler).isInstanceOf(CompositeHttpSampler.class);

		then(((CompositeHttpSampler) serverSampler).left)
				.isInstanceOf(SkipPatternHttpServerSampler.class);
		then(((CompositeHttpSampler) serverSampler).right).isSameAs(instance);
	};
}
 

@Bean
@ConditionalOnMissingBean(name = HttpClientSampler.NAME)
SamplerFunction<HttpRequest> sleuthHttpClientSampler(
		SleuthWebProperties sleuthWebProperties) {
	String skipPattern = sleuthWebProperties.getClient().getSkipPattern();
	if (skipPattern == null) {
		return SamplerFunctions.deferDecision();
	}

	return new SkipPatternHttpClientSampler(Pattern.compile(skipPattern));
}
 

@Bean(name = HttpServerSampler.NAME)
SamplerFunction<HttpRequest> myHttpSampler(SkipPatternProvider provider) {
	Pattern pattern = provider.skipPattern();
	return request -> {
		String url = request.path();
		boolean shouldSkip = pattern.matcher(url).matches();
		if (shouldSkip) {
			return false;
		}
		return null;
	};
}
 

@Override
public final Boolean trySample(HttpRequest request) {
	String url = request.path();
	boolean shouldSkip = pattern().matcher(url).matches();
	if (shouldSkip) {
		return false;
	}
	return null;
}
 

@Test
public void defaultsClientSamplerToDefer() {
	contextRunner().run((context) -> {
		SamplerFunction<HttpRequest> clientSampler = context
				.getBean(HttpTracing.class).clientRequestSampler();

		then(clientSampler).isSameAs(SamplerFunctions.deferDecision());
	});
}
 

@Test
public void configuresClientSkipPattern() throws Exception {
	contextRunner()
			.withPropertyValues("spring.sleuth.web.client.skip-pattern=foo.*|bar.*")
			.run((context) -> {
				SamplerFunction<HttpRequest> clientSampler = context
						.getBean(HttpTracing.class).clientRequestSampler();

				then(clientSampler).isInstanceOf(SkipPatternHttpClientSampler.class);
			});
}
 

@Test
public void configuresUserProvidedHttpClientSampler() {
	contextRunner().withUserConfiguration(HttpClientSamplerConfig.class)
			.run((context) -> {
				SamplerFunction<HttpRequest> clientSampler = context
						.getBean(HttpTracing.class).clientRequestSampler();

				then(clientSampler).isSameAs(HttpClientSamplerConfig.INSTANCE);
			});
}
 

@Test
public void defaultsServerSamplerToSkipPattern() {
	contextRunner().run((context) -> {
		SamplerFunction<HttpRequest> serverSampler = context
				.getBean(HttpTracing.class).serverRequestSampler();

		then(serverSampler).isInstanceOf(SkipPatternHttpServerSampler.class);
	});
}
 

@Test
public void defaultsServerSamplerToDeferWhenSkipPatternCleared() {
	contextRunner().withPropertyValues("spring.sleuth.web.skip-pattern")
			.run((context) -> {
				SamplerFunction<HttpRequest> clientSampler = context
						.getBean(HttpTracing.class).serverRequestSampler();

				then(clientSampler).isSameAs(SamplerFunctions.deferDecision());
			});
}
 

@Bean(name = HttpClientSampler.NAME)
@HttpClientSampler
public SamplerFunction<HttpRequest> clientHttpSampler() {
	return arg -> true;
}
 

@Override
public Boolean trySample(HttpRequest arg) {
	return null;
}
 

@Bean(name = HttpClientSampler.NAME)
@HttpClientSampler
public SamplerFunction<HttpRequest> clientHttpSampler() {
	return arg -> true;
}
 

public void setServerSampler(SamplerFunction<HttpRequest> serverSampler) {
  this.serverSampler = serverSampler;
}
 

@Bean(name = HttpClientSampler.NAME)
@HttpClientSampler
public SamplerFunction<HttpRequest> clientHttpSampler() {
	return arg -> true;
}
 

public void setClientSampler(SamplerFunction<HttpRequest> clientSampler) {
  this.clientSampler = clientSampler;
}
 

@JsonIgnore
public SamplerFunction<HttpRequest> getClientSampler() {
  return clientSampler;
}
 

@Override
public Boolean trySample(HttpRequest arg) {
	return false;
}
 

@Override
public Boolean trySample(HttpRequest arg) {
	return true;
}
 

@ParameterizedTest
@MethodSource("falseArgs")
void should_return_false_on_any_false(SamplerFunction<HttpRequest> left,
		SamplerFunction<HttpRequest> right) {
	then(new CompositeHttpSampler(left, right).trySample(this.request)).isFalse();
}
 

@Bean(HttpServerSampler.NAME)
SamplerFunction<HttpRequest> sleuthHttpServerSampler() {
	return INSTANCE;
}
 

@Bean(HttpClientSampler.NAME)
SamplerFunction<HttpRequest> sleuthHttpClientSampler() {
	return INSTANCE;
}
 

CompositeHttpSampler(SamplerFunction<HttpRequest> left,
		SamplerFunction<HttpRequest> right) {
	this.left = left;
	this.right = right;
}
 

@Bean
@ConditionalOnMissingBean
// NOTE: stable bean name as might be used outside sleuth
HttpTracing httpTracing(Tracing tracing, @Nullable SkipPatternProvider provider,
		@Nullable @HttpClientRequestParser HttpRequestParser httpClientRequestParser,
		@Nullable @HttpClientResponseParser HttpResponseParser httpClientResponseParser,
		@Nullable brave.http.HttpClientParser clientParser,
		@Nullable @HttpServerRequestParser HttpRequestParser httpServerRequestParser,
		@Nullable @HttpServerResponseParser HttpResponseParser httpServerResponseParser,
		@Nullable brave.http.HttpServerParser serverParser,
		@HttpClientSampler SamplerFunction<HttpRequest> httpClientSampler,
		@Nullable @HttpServerSampler SamplerFunction<HttpRequest> httpServerSampler,
		@Nullable List<HttpTracingCustomizer> httpTracingCustomizers) {
	SamplerFunction<HttpRequest> combinedSampler = combineUserProvidedSamplerWithSkipPatternSampler(
			httpServerSampler, provider);
	HttpTracing.Builder builder = HttpTracing.newBuilder(tracing)
			.clientSampler(httpClientSampler).serverSampler(combinedSampler);

	if (httpClientRequestParser != null || httpClientResponseParser != null) {
		if (httpClientRequestParser != null) {
			builder.clientRequestParser(httpClientRequestParser);
		}
		if (httpClientResponseParser != null) {
			builder.clientResponseParser(httpClientResponseParser);
		}
	}
	else if (clientParser != null) { // consider deprecated last
		builder.clientParser(clientParser);
	}

	if (httpServerRequestParser != null || httpServerResponseParser != null) {
		if (httpServerRequestParser != null) {
			builder.serverRequestParser(httpServerRequestParser);
		}
		if (httpServerResponseParser != null) {
			builder.serverResponseParser(httpServerResponseParser);
		}
	}
	else if (serverParser != null) { // consider deprecated last
		builder.serverParser(serverParser);
	}

	if (httpTracingCustomizers != null) {
		for (HttpTracingCustomizer customizer : httpTracingCustomizers) {
			customizer.customize(builder);
		}
	}
	return builder.build();
}
 

@JsonIgnore
public void setServerSampler(SamplerFunction<HttpRequest> sampler) {
  this.serverSampler = sampler;
}
 

@JsonIgnore
public SamplerFunction<HttpRequest> getServerSampler() {
  return serverSampler;
}
 

@JsonIgnore
public void setClientSampler(SamplerFunction<HttpRequest> sampler) {
  this.clientSampler = sampler;
}