brave.propagation.Propagation.Setter Java Examples

@Test public void setterAdapter() {
  Map<String, Integer> map = new LinkedHashMap<>();
  map.put("1", 1);
  map.put("2", 2);

  Setter<Map<Integer, String>, String> wrappedSetter = new SetterAdapter<>(setter, map);

  Map<Integer, String> request = new LinkedHashMap<>();

  wrappedSetter.put(request, "1", "one");
  wrappedSetter.put(request, "2", "two");
  wrappedSetter.put(request, "3", "three");

  assertThat(request)
      .hasSize(2)
      .containsEntry(1, "one")
      .containsEntry(2, "two");
}
 

/**
 * Creates a potentially composite injector if the input is an instance of {@link RemoteSetter}.
 * Otherwise, a deferred injector is return that examples the request parameter to decide if it is
 * remote or not.
 */
public <R> TraceContext.Injector<R> newInjector(Setter<R, String> setter) {
  if (setter == null) throw new NullPointerException("setter == null");
  if (setter instanceof RemoteSetter) {
    RemoteSetter<?> remoteSetter = (RemoteSetter<?>) setter;
    switch (remoteSetter.spanKind()) {
      case CLIENT:
        return new RemoteInjector<>(setter, clientInjectorFunction);
      case PRODUCER:
        return new RemoteInjector<>(setter, producerInjectorFunction);
      case CONSUMER:
        return new RemoteInjector<>(setter, consumerInjectorFunction);
      default: // SERVER is nonsense as it cannot be injected
    }
  }
  return new DeferredInjector<>(setter, this);
}
 

void addSpanToJobData(JobDataMap data) {
	brave.Span span = tracing.tracer().nextSpan().start();
	try (SpanInScope spanInScope = tracing.tracer().withSpanInScope(span)) {
		tracing.propagation()
				.injector((Setter<JobDataMap, String>) StringKeyDirtyFlagMap::put)
				.inject(tracing.currentTraceContext().get(), data);
	}
	finally {
		span.finish();
	}
}
 

private <C> Setter<C, String> inject(final Map<String, List<String>> requestHeaders) {
    return (carrier, key, value) -> {
        if (!requestHeaders.containsKey(key)) {
            requestHeaders.put(key, Collections.singletonList(value));
        }
    };
}
 

static InjectorFunction newInjectorFunction(String keyName, AtomicInteger callCount) {
  return new InjectorFunction() {
    @Override public List<String> keyNames() {
      return Arrays.asList(keyName);
    }

    @Override public <R> void inject(Setter<R, String> setter, TraceContext context, R request) {
      callCount.incrementAndGet();
    }
  };
}
 

@Override protected Setter<HttpClientRequest, String> setter() {
  return SETTER;
}
 

private Setter<Invocation, String> injector() {
  return (invocation, key, value) -> invocation.getContext().put(key, value);
}
 

@Override protected Setter<RpcClientRequest, String> setter() {
  return SETTER;
}
 

@Test public void setter_equalsHashCodeString() {
  assertDelegates(
      () -> mock(Setter.class),
      g -> new SetterAdapter<>(g, Collections.emptyMap())
  );
}
 

@Override public <R> void inject(Setter<R, String> setter, TraceContext context, R request) {
  for (InjectorFunction injectorFunction : injectorFunctions) {
    injectorFunction.inject(setter, context, request);
  }
}
 

RemoteInjector(Setter<R, String> setter, InjectorFunction injectorFunction) {
  this.injectorFunction = injectorFunction;
  this.setter = setter;
}
 

DeferredInjector(Setter<R, String> setter, InjectorFactory injectorFactory) {
  this.setter = setter;
  this.injectorFactory = injectorFactory;
}
 

/** Like {@see TraceContext.Injector#inject} except the {@code setter} is explicit. */
<R> void inject(Setter<R, String> setter, TraceContext context, R request);
 

@Override public <R> void inject(Setter<R, String> setter, TraceContext context, R request) {
}
 

@Override protected Setter<URLConnection, String> setter() {
  return URLConnection::setRequestProperty;
}
 

@Override protected Setter<TextMap, String> setter() {
  return TextMap::put;
}
 

AWSInjector(AWSPropagation propagation, Setter<R, String> setter) {
  this.propagation = propagation;
  this.setter = setter;
}