@Override
public Span start() {
  final io.opencensus.trace.SpanBuilder sb;

  if (ignoreActiveSpan) {

    if (parentSpan != null) {
      sb = tracer.spanBuilderWithExplicitParent(opName, parentSpan);
    } else if (parentContext != null) {
      sb = tracer.spanBuilderWithRemoteParent(opName, parentContext);
    } else {
      sb = tracer.spanBuilderWithRemoteParent(opName, INVALID);
    }

  } else {
    sb = tracer.spanBuilder(opName);
  }
  // We only use the always on sampler for our spans.
  // We could set it globally, but some other libraries (gRPC)
  // create spans through the opencensus tracing global and we don't want them always sampled.
  sb.setSampler(Samplers.alwaysSample());

  final io.opencensus.trace.Span span = sb.startSpan();
  span.putAttributes(attributes);
  return new OpenCensusSpanAdapter(span);
}
 

/**
 * Main method.
 *
 * @param args the main arguments.
 */
public static void main(String[] args) {

  // WARNING: Be careful before you set sampler value to always sample, especially in
  // production environment. Trace data is often very large in size and is expensive to
  // collect. This is why rather than collecting traces for every request(i.e. alwaysSample),
  // downsampling is prefered.
  //
  // By default, OpenCensus provides a probabilistic sampler that will trace once in every
  // 10,000 requests, that's why if default probabilistic sampler is used
  // you might not see trace data printed or exported and this is expected behavior.

  TraceConfig traceConfig = Tracing.getTraceConfig();
  traceConfig.updateActiveTraceParams(
      traceConfig.getActiveTraceParams().toBuilder().setSampler(Samplers.alwaysSample()).build());

  LoggingTraceExporter.register();
  doWork();

  // Wait for a duration longer than reporting duration (5s) to ensure spans are exported.
  // Spans are exported every 5 seconds
  sleep(5100);
}
 

/**
 * Main method.
 *
 * @param args the main arguments.
 */
public static void main(String[] args) {

  // WARNING: Be careful before you set sampler value to always sample, especially in
  // production environment. Trace data is often very large in size and is expensive to
  // collect. This is why rather than collecting traces for every request(i.e. alwaysSample),
  // downsampling is prefered.
  //
  // By default, OpenCensus provides a probabilistic sampler that will trace once in every
  // 10,000 requests, that's why if default probabilistic sampler is used
  // you might not see trace data printed or exported and this is expected behavior.

  TraceConfig traceConfig = Tracing.getTraceConfig();
  traceConfig.updateActiveTraceParams(
      traceConfig.getActiveTraceParams().toBuilder().setSampler(Samplers.alwaysSample()).build());

  LoggingTraceExporter.register();
  try (Scope ss = tracer.spanBuilderWithExplicitParent("MyRootSpan", null).startScopedSpan()) {
    doWork();
  }

  // Wait for a duration longer than reporting duration (5s) to ensure spans are exported.
  // Spans are exported every 5 seconds
  sleep(5100);
}
 

/** Say hello to server. */
public void greet(String name) {
  logger.info("Will try to greet " + name + " ...");
  HelloRequest request = HelloRequest.newBuilder().setName(name).build();
  HelloReply response;

  SpanBuilder spanBuilder =
      tracer.spanBuilder("client").setRecordEvents(true).setSampler(Samplers.alwaysSample());
  try (Scope scope = spanBuilder.startScopedSpan()) {
    tracer.getCurrentSpan().addAnnotation("Saying Hello to Server.");
    response = blockingStub.sayHello(request);
    tracer.getCurrentSpan().addAnnotation("Received response from Server.");
  } catch (StatusRuntimeException e) {
    tracer
        .getCurrentSpan()
        .setStatus(
            CanonicalCode.valueOf(e.getStatus().getCode().name())
                .toStatus()
                .withDescription(e.getMessage()));
    logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
    return;
  }
  logger.info("Greeting: " + response.getMessage());
}
 

@Test
public void updateTraceParams_All() {
  TraceParams traceParams =
      TraceParams.DEFAULT
          .toBuilder()
          .setSampler(Samplers.alwaysSample())
          .setMaxNumberOfAttributes(8)
          .setMaxNumberOfAnnotations(9)
          .setMaxNumberOfMessageEvents(10)
          .setMaxNumberOfLinks(11)
          .build();
  assertThat(traceParams.getSampler()).isEqualTo(Samplers.alwaysSample());
  assertThat(traceParams.getMaxNumberOfAttributes()).isEqualTo(8);
  assertThat(traceParams.getMaxNumberOfAnnotations()).isEqualTo(9);
  // test maxNumberOfNetworkEvent can be set via maxNumberOfMessageEvent
  assertThat(traceParams.getMaxNumberOfNetworkEvents()).isEqualTo(10);
  assertThat(traceParams.getMaxNumberOfMessageEvents()).isEqualTo(10);
  assertThat(traceParams.getMaxNumberOfLinks()).isEqualTo(11);
}
 

@Test
public void startSpan_CreatesTheCorrectSpanImplInstance() {
  assertThat(
          SpanBuilderImpl.createWithParent(SPAN_NAME, null, spanBuilderOptions)
              .setSampler(Samplers.alwaysSample())
              .startSpan())
      .isInstanceOf(RecordEventsSpanImpl.class);
  assertThat(
          SpanBuilderImpl.createWithParent(SPAN_NAME, null, spanBuilderOptions)
              .setRecordEvents(true)
              .setSampler(Samplers.neverSample())
              .startSpan())
      .isInstanceOf(RecordEventsSpanImpl.class);
  assertThat(
          SpanBuilderImpl.createWithParent(SPAN_NAME, null, spanBuilderOptions)
              .setSampler(Samplers.neverSample())
              .startSpan())
      .isInstanceOf(NoRecordEventsSpanImpl.class);
}
 

@Test
public void startSpanIncreaseNumberOfChildren() {
  RecordEventsSpanImpl parent =
      (RecordEventsSpanImpl)
          SpanBuilderImpl.createWithParent(SPAN_NAME, null, spanBuilderOptions)
              .setSampler(Samplers.alwaysSample())
              .startSpan();
  assertThat(parent.getContext().getTraceOptions().isSampled()).isTrue();
  assertThat(parent.toSpanData().getChildSpanCount()).isEqualTo(0);
  RecordEventsSpanImpl span =
      (RecordEventsSpanImpl)
          SpanBuilderImpl.createWithParent(SPAN_NAME, parent, spanBuilderOptions)
              .setSampler(Samplers.alwaysSample())
              .startSpan();
  assertThat(span.getContext().getTraceOptions().isSampled()).isTrue();
  assertThat(span.toSpanData().getChildSpanCount()).isEqualTo(0);
  assertThat(parent.toSpanData().getChildSpanCount()).isEqualTo(1);
  span =
      (RecordEventsSpanImpl)
          SpanBuilderImpl.createWithParent(SPAN_NAME, parent, spanBuilderOptions)
              .setSampler(Samplers.alwaysSample())
              .startSpan();
  assertThat(span.getContext().getTraceOptions().isSampled()).isTrue();
  assertThat(span.toSpanData().getChildSpanCount()).isEqualTo(0);
  assertThat(parent.toSpanData().getChildSpanCount()).isEqualTo(2);
}
 

@Test
public void startRemoteChildSpan_WithSpecifiedSampler() {
  Span rootSpan =
      SpanBuilderImpl.createWithParent(SPAN_NAME, null, spanBuilderOptions)
          .setSampler(Samplers.alwaysSample())
          .startSpan();
  assertThat(rootSpan.getContext().isValid()).isTrue();
  assertThat(rootSpan.getContext().getTraceOptions().isSampled()).isTrue();
  // Apply given sampler before default sampler for spans with remote parent.
  Span childSpan =
      SpanBuilderImpl.createWithRemoteParent(SPAN_NAME, rootSpan.getContext(), spanBuilderOptions)
          .setSampler(Samplers.neverSample())
          .startSpan();
  assertThat(childSpan.getContext().isValid()).isTrue();
  assertThat(childSpan.getContext().getTraceId()).isEqualTo(rootSpan.getContext().getTraceId());
  assertThat(childSpan.getContext().getTraceOptions().isSampled()).isFalse();
}
 

@Test
public void startRemoteChildSpan_WithoutSpecifiedSampler() {
  Span rootSpan =
      SpanBuilderImpl.createWithParent(SPAN_NAME, null, spanBuilderOptions)
          .setSampler(Samplers.neverSample())
          .startSpan();
  assertThat(rootSpan.getContext().isValid()).isTrue();
  assertThat(rootSpan.getContext().getTraceOptions().isSampled()).isFalse();
  // Apply default sampler (always true in the tests) for spans with remote parent.
  Span childSpan =
      SpanBuilderImpl.createWithRemoteParent(SPAN_NAME, rootSpan.getContext(), spanBuilderOptions)
          .startSpan();
  assertThat(childSpan.getContext().isValid()).isTrue();
  assertThat(childSpan.getContext().getTraceId()).isEqualTo(rootSpan.getContext().getTraceId());
  assertThat(childSpan.getContext().getTraceOptions().isSampled()).isTrue();
}
 

@Test
public void startChildSpan_WithSpecifiedSampler() {
  Span rootSpan =
      SpanBuilderImpl.createWithParent(SPAN_NAME, null, spanBuilderOptions)
          .setSampler(Samplers.alwaysSample())
          .startSpan();
  assertThat(rootSpan.getContext().isValid()).isTrue();
  assertThat(rootSpan.getContext().getTraceOptions().isSampled()).isTrue();
  // Apply the given sampler for child spans.
  Span childSpan =
      SpanBuilderImpl.createWithParent(SPAN_NAME, rootSpan, spanBuilderOptions)
          .setSampler(Samplers.neverSample())
          .startSpan();
  assertThat(childSpan.getContext().isValid()).isTrue();
  assertThat(childSpan.getContext().getTraceId()).isEqualTo(rootSpan.getContext().getTraceId());
  assertThat(childSpan.getContext().getTraceOptions().isSampled()).isFalse();
}
 

@Test
public void startChildSpan_SampledLinkedParent() {
  Span rootSpanUnsampled =
      SpanBuilderImpl.createWithParent(SPAN_NAME, null, spanBuilderOptions)
          .setSampler(Samplers.neverSample())
          .startSpan();
  assertThat(rootSpanUnsampled.getContext().getTraceOptions().isSampled()).isFalse();
  Span rootSpanSampled =
      SpanBuilderImpl.createWithParent(SPAN_NAME, null, spanBuilderOptions)
          .setSampler(Samplers.alwaysSample())
          .startSpan();
  assertThat(rootSpanSampled.getContext().getTraceOptions().isSampled()).isTrue();
  // Sampled because the linked parent is sampled.
  Span childSpan =
      SpanBuilderImpl.createWithParent(SPAN_NAME, rootSpanUnsampled, spanBuilderOptions)
          .setParentLinks(Collections.singletonList(rootSpanSampled))
          .startSpan();
  assertThat(childSpan.getContext().isValid()).isTrue();
  assertThat(childSpan.getContext().getTraceId())
      .isEqualTo(rootSpanUnsampled.getContext().getTraceId());
  assertThat(childSpan.getContext().getTraceOptions().isSampled()).isTrue();
}
 

@Test
public void updateTraceParams() {
  TraceParams traceParams =
      TraceParams.DEFAULT
          .toBuilder()
          .setSampler(Samplers.alwaysSample())
          .setMaxNumberOfAttributes(8)
          .setMaxNumberOfAnnotations(9)
          .setMaxNumberOfNetworkEvents(10)
          .setMaxNumberOfLinks(11)
          .build();
  traceConfig.updateActiveTraceParams(traceParams);
  assertThat(traceConfig.getActiveTraceParams()).isEqualTo(traceParams);
  traceConfig.updateActiveTraceParams(TraceParams.DEFAULT);
  assertThat(traceConfig.getActiveTraceParams()).isEqualTo(TraceParams.DEFAULT);
}
 

@Before
@Override
public void setup() {
  super.setup();
  handler = new TestHandler();

  SpanExporter exporter = Tracing.getExportComponent().getSpanExporter();
  exporter.registerHandler("testing", handler);

  TraceParams params =
      Tracing.getTraceConfig()
          .getActiveTraceParams()
          .toBuilder()
          .setSampler(Samplers.alwaysSample())
          .build();
  Tracing.getTraceConfig().updateActiveTraceParams(params);
}
 

/**
 * Converts {@link TraceParams} to {@link TraceConfig}.
 *
 * @param traceParams the {@code TraceParams}.
 * @return {@code TraceConfig}.
 */
static TraceConfig toTraceConfigProto(TraceParams traceParams) {
  TraceConfig.Builder traceConfigProtoBuilder = TraceConfig.newBuilder();
  Sampler librarySampler = traceParams.getSampler();

  if (Samplers.alwaysSample().equals(librarySampler)) {
    traceConfigProtoBuilder.setConstantSampler(
        ConstantSampler.newBuilder().setDecision(ConstantDecision.ALWAYS_ON).build());
  } else if (Samplers.neverSample().equals(librarySampler)) {
    traceConfigProtoBuilder.setConstantSampler(
        ConstantSampler.newBuilder().setDecision(ConstantDecision.ALWAYS_OFF).build());
  } else {
    // TODO: consider exposing the sampling probability of ProbabilitySampler.
    double samplingProbability = parseSamplingProbability(librarySampler);
    traceConfigProtoBuilder.setProbabilitySampler(
        ProbabilitySampler.newBuilder().setSamplingProbability(samplingProbability).build());
  } // TODO: add support for RateLimitingSampler.

  return traceConfigProtoBuilder.build();
}
 

/**
 * Converts {@link TraceConfig} to {@link TraceParams}.
 *
 * @param traceConfigProto {@code TraceConfig}.
 * @param currentTraceParams current {@code TraceParams}.
 * @return updated {@code TraceParams}.
 * @since 0.17
 */
static TraceParams fromTraceConfigProto(
    TraceConfig traceConfigProto, TraceParams currentTraceParams) {
  TraceParams.Builder builder = currentTraceParams.toBuilder();
  if (traceConfigProto.hasConstantSampler()) {
    ConstantSampler constantSampler = traceConfigProto.getConstantSampler();
    ConstantDecision decision = constantSampler.getDecision();
    if (ConstantDecision.ALWAYS_ON.equals(decision)) {
      builder.setSampler(Samplers.alwaysSample());
    } else if (ConstantDecision.ALWAYS_OFF.equals(decision)) {
      builder.setSampler(Samplers.neverSample());
    } // else if (ConstantDecision.ALWAYS_PARENT.equals(decision)) {
    // For ALWAYS_PARENT, don't need to update configs since in Java by default parent sampling
    // decision always takes precedence.
    // }
  } else if (traceConfigProto.hasProbabilitySampler()) {
    builder.setSampler(
        Samplers.probabilitySampler(
            traceConfigProto.getProbabilitySampler().getSamplingProbability()));
  } // TODO: add support for RateLimitingSampler.
  return builder.build();
}
 

@Test
public void applyUpdatedConfig() {
  TraceConfig configProto =
      TraceConfig.newBuilder()
          .setProbabilitySampler(
              ProbabilitySampler.newBuilder().setSamplingProbability(0.01).build())
          .build();
  UpdatedLibraryConfig updatedLibraryConfig =
      UpdatedLibraryConfig.newBuilder().setConfig(configProto).build();
  TraceParams traceParams =
      TraceProtoUtils.getUpdatedTraceParams(updatedLibraryConfig, mockTraceConfig);
  TraceParams expectedParams =
      DEFAULT_PARAMS.toBuilder().setSampler(Samplers.probabilitySampler(0.01)).build();
  Mockito.verify(mockTraceConfig, Mockito.times(1)).getActiveTraceParams();
  assertThat(traceParams).isEqualTo(expectedParams);
}
 

/** Main method. This comment makes the linter happy. */
public static void main(String[] args) throws Exception {
  LOG.info("MetaStore server");
  printVersion();

  ArgumentParser parser = ArgumentParsers.newFor("metastore").build();
  parser.addArgument("-c", "--config").required(false);

  Namespace res = parser.parseArgs(args);
  String configPath = res.getString("config");
  if (configPath == null) {
    LOG.info("No configuration file set via argument, setting from environment.");
    configPath = System.getenv("METASTORE_CONFIG_PATH");
    LOG.info("Taking configuration file: " + configPath);
  } else {
    LOG.info("Taking configuration file: " + configPath);
  }

  // 2. Configure 100% sample rate, otherwise, few traces will be sampled.
  TraceConfig traceConfig = Tracing.getTraceConfig();
  TraceParams activeTraceParams = traceConfig.getActiveTraceParams();
  traceConfig.updateActiveTraceParams(
      activeTraceParams.toBuilder().setSampler(Samplers.alwaysSample()).build());

  String port = System.getenv("PORT");
  if (port == null) {
    port = "8980";
  }
  MetaStoreServer server = new MetaStoreServer(configPath, Integer.valueOf(port));
  server.start();
  server.blockUntilShutdown();
}
 

private void cleanupPods() {
  try {
    try (Scope ignored = tracer.spanBuilder("Styx.KubernetesDockerRunner.cleanupPods")
        .setRecordEvents(true)
        .setSampler(Samplers.alwaysSample())
        .startScopedSpan()) {
      tryCleanupPods();
    }
  } catch (Throwable t) {
    LOG.warn("Error while cleaning pods", t);
  }
}
 

void tick() {
  try (Scope ignored = tracer.spanBuilder("Styx.TriggerManager.tick")
      .setRecordEvents(true)
      .setSampler(Samplers.alwaysSample())
      .startScopedSpan()) {
    tick0();
  }
}
 

void tick() {
  try (Scope ignored = tracer.spanBuilder("Styx.BackfillTriggerManager.tick")
      .setRecordEvents(true)
      .setSampler(Samplers.alwaysSample())
      .startScopedSpan()) {
    tick0();
  }
}
 

void tick() {
  try (Scope ignored = tracer.spanBuilder("Styx.Cleaner.tick")
      .setRecordEvents(true)
      .setSampler(Samplers.alwaysSample())
      .startScopedSpan()) {
    tick0();
  }
}
 

void tick() {
  try (Scope ignored = tracer.spanBuilder("Styx.Scheduler.tick")
      .setRecordEvents(true)
      .setSampler(Samplers.alwaysSample())
      .startScopedSpan()) {
    tick0();
  }
}
 

private static void initTracingAndLoggingExporter() {
  TraceConfig traceConfig = Tracing.getTraceConfig();
  traceConfig.updateActiveTraceParams(
      traceConfig.getActiveTraceParams().toBuilder().setSampler(Samplers.alwaysSample()).build());

  LoggingTraceExporter.register();
}
 

/** Main launcher for the QuickStart example. */
public static void main(String[] args) throws InterruptedException {
  TagContextBuilder tagContextBuilder =
      tagger.currentBuilder().put(FRONTEND_KEY, TagValue.create("mobile-ios9.3.5"));
  SpanBuilder spanBuilder =
      tracer
          .spanBuilder("my.org/ProcessVideo")
          .setRecordEvents(true)
          .setSampler(Samplers.alwaysSample());
  viewManager.registerView(VIDEO_SIZE_VIEW);
  LoggingTraceExporter.register();

  // Process video.
  // Record the processed video size.
  try (Scope scopedTags = tagContextBuilder.buildScoped();
      Scope scopedSpan = spanBuilder.startScopedSpan()) {
    tracer.getCurrentSpan().addAnnotation("Start processing video.");
    // Sleep for [0,10] milliseconds to fake work.
    Thread.sleep(new Random().nextInt(10) + 1);
    statsRecorder.newMeasureMap().put(VIDEO_SIZE, 25 * MiB).record();
    tracer.getCurrentSpan().addAnnotation("Finished processing video.");
  } catch (Exception e) {
    tracer.getCurrentSpan().addAnnotation("Exception thrown when processing video.");
    tracer.getCurrentSpan().setStatus(Status.UNKNOWN);
    logger.severe(e.getMessage());
  }

  logger.info("Wait longer than the reporting duration...");
  // Wait for a duration longer than reporting duration (5s) to ensure spans are exported.
  // TODO(songya): remove the gap once we add a shutdown hook for exporting unflushed spans.
  Thread.sleep(5100);
  ViewData viewData = viewManager.getView(VIDEO_SIZE_VIEW_NAME);
  logger.info(
      String.format("Recorded stats for %s:\n %s", VIDEO_SIZE_VIEW_NAME.asString(), viewData));
}
 

private static void initTracing() {
  TraceConfig traceConfig = Tracing.getTraceConfig();
  Logger.getRootLogger().setLevel(Level.INFO);
  traceConfig.updateActiveTraceParams(
      traceConfig.getActiveTraceParams().toBuilder().setSampler(Samplers.alwaysSample()).build());

  LoggingTraceExporter.register();
  // Register Jaeger Tracing. Refer to https://www.jaegertracing.io/docs/1.8/getting-started/ to
  // run Jaeger
  JaegerTraceExporter.createAndRegister("http://localhost:14268/api/traces", "helloworldclient");
}
 

private static void initTracing() {
  TraceConfig traceConfig = Tracing.getTraceConfig();

  // default sampler is set to Samplers.alwaysSample() for demonstration. In production
  // or in high QPS environment please use default sampler.
  traceConfig.updateActiveTraceParams(
      traceConfig.getActiveTraceParams().toBuilder().setSampler(Samplers.alwaysSample()).build());

  // Register LoggingTraceExporter to see traces in logs.
  LoggingTraceExporter.register();

  // Register Jaeger Tracing. Refer to https://www.jaegertracing.io/docs/1.8/getting-started/ to
  // run Jaeger
  JaegerTraceExporter.createAndRegister("http://localhost:14268/api/traces", "helloworldserver");
}
 

/**
 * Main method.
 *
 * @param args the main arguments.
 */
public static void main(String[] args) {

  // WARNING: Be careful before you set sampler value to always sample, especially in
  // production environment. Trace data is often very large in size and is expensive to
  // collect. This is why rather than collecting traces for every request(i.e. alwaysSample),
  // downsampling is prefered.
  //
  // By default, OpenCensus provides a probabilistic sampler that will trace once in every
  // 10,000 requests, that's why if default probabilistic sampler is used
  // you might not see trace data printed or exported and this is expected behavior.

  TraceConfig traceConfig = Tracing.getTraceConfig();
  traceConfig.updateActiveTraceParams(
      traceConfig.getActiveTraceParams().toBuilder().setSampler(Samplers.alwaysSample()).build());

  LoggingTraceExporter.register();
  Span span = tracer.spanBuilderWithExplicitParent("MyRootSpan", null).startSpan();
  try (Scope ws = tracer.withSpan(span)) {
    doWork();
  }
  span.end();

  // Wait for a duration longer than reporting duration (5s) to ensure spans are exported.
  // Spans are exported every 5 seconds
  sleep(5100);
}
 

private static void performWork(Span parent) {
  SpanBuilder spanBuilder =
      tracer
          .spanBuilderWithExplicitParent("internal_work", parent)
          .setRecordEvents(true)
          .setSampler(Samplers.alwaysSample());
  try (Scope scope = spanBuilder.startScopedSpan()) {
    Span span = tracer.getCurrentSpan();
    span.putAttribute("my_attribute", AttributeValue.stringAttributeValue("blue"));
    span.addAnnotation("Performing work.");
    sleepFor(20); // Working hard here.
    span.addAnnotation("Done work.");
  }
}
 

@Test
public void defaultTraceParams() {
  assertThat(TraceParams.DEFAULT.getSampler()).isEqualTo(Samplers.probabilitySampler(1e-4));
  assertThat(TraceParams.DEFAULT.getMaxNumberOfAttributes()).isEqualTo(32);
  assertThat(TraceParams.DEFAULT.getMaxNumberOfAnnotations()).isEqualTo(32);
  assertThat(TraceParams.DEFAULT.getMaxNumberOfNetworkEvents()).isEqualTo(128);
  assertThat(TraceParams.DEFAULT.getMaxNumberOfMessageEvents()).isEqualTo(128);
  assertThat(TraceParams.DEFAULT.getMaxNumberOfLinks()).isEqualTo(32);
}
 

@Test
public void updateActiveTraceParams_NoOpImplementation() {
  TraceParams traceParams =
      TraceParams.DEFAULT
          .toBuilder()
          .setSampler(Samplers.alwaysSample())
          .setMaxNumberOfAttributes(8)
          .setMaxNumberOfAnnotations(9)
          .setMaxNumberOfNetworkEvents(10)
          .setMaxNumberOfMessageEvents(10)
          .setMaxNumberOfLinks(11)
          .build();
  traceConfig.updateActiveTraceParams(traceParams);
  assertThat(traceConfig.getActiveTraceParams()).isEqualTo(TraceParams.DEFAULT);
}