Java Code Examples for brave.propagation.Propagation#Factory

TestServer(Propagation.Factory propagationFactory, ApplicationConfig application) {
  extractor = propagationFactory.get().extractor(Map::get);
  linkLocalIp = Platform.get().linkLocalIp();
  if (linkLocalIp != null) {
    // avoid dubbo's logic which might pick docker ip
    System.setProperty(CommonConstants.DUBBO_IP_TO_BIND, linkLocalIp);
    System.setProperty(Constants.DUBBO_IP_TO_REGISTRY, linkLocalIp);
  }
  service = new ServiceConfig<>();
  service.setApplication(application);
  service.setRegistry(new RegistryConfig(RegistryConfig.NO_AVAILABLE));
  service.setProtocol(new ProtocolConfig("dubbo", PickUnusedPort.get()));
  service.setInterface(GreeterService.class);
  service.setRef((method, parameterTypes, args) -> {
    requestQueue.add(extractor.extract(RpcContext.getContext().getAttachments()));
    return args[0];
  });
}
 

TestServer(Propagation.Factory propagationFactory) {
  extractor = propagationFactory.get().extractor(Map::get);
  linkLocalIp = Platform.get().linkLocalIp();
  if (linkLocalIp != null) {
    // avoid dubbo's logic which might pick docker ip
    System.setProperty(Constants.DUBBO_IP_TO_BIND, linkLocalIp);
    System.setProperty(Constants.DUBBO_IP_TO_REGISTRY, linkLocalIp);
  }
  service = new ServiceConfig<>();
  service.setApplication(new ApplicationConfig("bean-provider"));
  service.setRegistry(new RegistryConfig(RegistryConfig.NO_AVAILABLE));
  service.setProtocol(new ProtocolConfig("dubbo", PickUnusedPort.get()));
  service.setInterface(GreeterService.class);
  service.setRef((method, parameterTypes, args) -> {
    requestQueue.add(extractor.extract(RpcContext.getContext().getAttachments()));
    return args[0];
  });
}
 

Tracer(
  Clock clock,
  Propagation.Factory propagationFactory,
  SpanHandler spanHandler,
  PendingSpans pendingSpans,
  Sampler sampler,
  CurrentTraceContext currentTraceContext,
  boolean traceId128Bit,
  boolean supportsJoin,
  boolean alwaysSampleLocal,
  AtomicBoolean noop
) {
  this.clock = clock;
  this.propagationFactory = propagationFactory;
  this.spanHandler = spanHandler;
  this.pendingSpans = pendingSpans;
  this.sampler = sampler;
  this.currentTraceContext = currentTraceContext;
  this.traceId128Bit = traceId128Bit;
  this.supportsJoin = supportsJoin;
  this.alwaysSampleLocal = alwaysSampleLocal;
  this.noop = noop;
}
 

@Bean
@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<SpanHandler> spanHandlers,
		@Nullable List<TracingCustomizer> tracingCustomizers) {
	Tracing.Builder builder = Tracing.newBuilder().sampler(sampler)
			.localServiceName(StringUtils.isEmpty(serviceName) ? DEFAULT_SERVICE_NAME
					: serviceName)
			.propagationFactory(factory).currentTraceContext(currentTraceContext)
			.traceId128Bit(sleuthProperties.isTraceId128())
			.supportsJoin(sleuthProperties.isSupportsJoin());
	if (spanHandlers != null) {
		for (SpanHandler spanHandlerFactory : spanHandlers) {
			builder.addSpanHandler(spanHandlerFactory);
		}
	}
	if (tracingCustomizers != null) {
		for (TracingCustomizer customizer : tracingCustomizers) {
			customizer.customize(builder);
		}
	}

	return builder.build();
}
 

@Override public Propagation.Factory getObject() {
  BaggagePropagation.FactoryBuilder builder =
    BaggagePropagation.newFactoryBuilder(propagationFactory);
  if (configs != null) {
    builder.clear();
    for (BaggagePropagationConfig config : configs) {
      builder.add(config);
    }
  }
  if (customizers != null) {
    for (BaggagePropagationCustomizer customizer : customizers) customizer.customize(builder);
  }
  return builder.build();
}
 

/** Less overhead and distraction for the edge case of correlation-only. */
@Test public void extract_baggage_onlyOneExtraWhenNothingRemote() {
  Propagation.Factory factory = newFactoryBuilder(B3Propagation.FACTORY)
      .add(SingleBaggageField.local(vcapRequestId))
      .add(SingleBaggageField.local(amznTraceId)).build();
  extractor = factory.get().extractor(Map::get);

  TraceContextOrSamplingFlags extracted = extractor.extract(request);
  assertThat(extracted.extra())
      .hasSize(1)
      .noneMatch(Extra.class::isInstance);
}
 

@Test public void allKeyNames_baggagePropagation_noRemote() {
  Propagation.Factory factory = BaggagePropagation.newFactoryBuilder(B3SinglePropagation.FACTORY)
      .add(SingleBaggageField.local(BaggageField.create("redacted"))) // local shouldn't return
      .add(SingleBaggageField.local(BaggageField.create("user-id")))
      .add(SingleBaggageField.local(BaggageField.create("session-id"))).build();

  assertThat(BaggagePropagation.allKeyNames(factory.get()))
      .containsExactly("b3");
}
 

/**
 * @param delegate some configuration of {@link B3Propagation#newFactoryBuilder()}
 * @param customTraceIdName something not "b3"
 */
public static Propagation.Factory create(Propagation.Factory delegate, String customTraceIdName) {
  if (delegate == null) throw new NullPointerException("delegate == null");
  if (customTraceIdName == null) throw new NullPointerException("customTraceIdName == null");
  if (!delegate.create(KeyFactory.STRING).keys().contains("b3")) {
    throw new IllegalArgumentException("delegate must implement B3 propagation");
  }
  return new CustomTraceIdPropagation(delegate, customTraceIdName);
}
 

CustomTraceIdPropagation(Propagation.Factory factory, String customTraceIdName) {
  this.factory = factory;
  this.delegate = factory.get();
  this.customTraceIdName = customTraceIdName;
  //this.b3Key = keyFactory.create("b3", "X-B3-TraceId");
  List<String> allKeys = new ArrayList<>(delegate.keys());
  allKeys.add(customTraceIdName);
  this.allKeys = Collections.unmodifiableList(allKeys);
}
 

@Override public Propagation.Factory getObject() {
  logger.warn("The factory '" + getClass().getName() + "' will be removed in a future release.\n"
      + "Use '" + BaggagePropagationFactoryBean.class.getName() + "' instead");
  ExtraFieldPropagation.FactoryBuilder builder =
      ExtraFieldPropagation.newFactoryBuilder(propagationFactory);
  if (fields != null) {
    for (String field : fields) builder.addField(field);
  }
  if (customizers != null) {
    for (ExtraFieldCustomizer customizer : customizers) customizer.customize(builder);
  }
  return builder.build();
}
 

Factory(Propagation.Factory primary) {
  this.primary = primary;
}
 

@Bean
Propagation.Factory propagationFactory() {
	return B3SinglePropagation.FACTORY;
}
 

@Override public Class<? extends Propagation.Factory> getObjectType() {
  return Propagation.Factory.class;
}
 

/** Configures propagation for {@link #USER_NAME}, using the remote header "user_name" */
@Bean Propagation.Factory propagationFactory() {
  return BaggagePropagation.newFactoryBuilder(B3Propagation.FACTORY)
      .add(SingleBaggageField.newBuilder(USER_NAME).addKeyName("user_name").build())
      .build();
}
 

public void setPropagationFactory(Propagation.Factory propagationFactory) {
  this.propagationFactory = propagationFactory;
}
 

/**
 * The {@link StackdriverTracePropagation#FACTORY} as a bean.
 * @return The bean.
 */
@Singleton
@Requires(beans = StackdriverSender.class)
protected Propagation.Factory stackdriverPropagation() {
    return StackdriverTracePropagation.FACTORY;
}
 

/**
 * @param primary typically constructed by {@link B3Propagation#newFactoryBuilder()}
 */
public static Propagation.Factory newFactory(Propagation.Factory primary) {
  if (primary == null) throw new NullPointerException("primary == null");
  return new Factory(primary);
}
 

/** @deprecated Since 5.12 use {@link #propagation()} as non-string keys are unsupported. */
@Deprecated public abstract Propagation.Factory propagationFactory();
 

@Override public Propagation.Factory propagationFactory() {
  return propagationFactory;
}
 

public void setPropagationFactory(Propagation.Factory propagationFactory) {
  this.propagationFactory = propagationFactory;
}