Java Code Examples for io.opencensus.common.Scope#close()

@Override
public void filter(
    ContainerRequestContext requestContext, ContainerResponseContext responseContext)
    throws IOException {
  HttpRequestContext context = (HttpRequestContext) requestContext.getProperty(CONTEXT_PROPERTY);
  if (context == null) {
    // JAX-RS response filters are always invoked - we only want to record something if
    // request came through this filter
    return;
  }
  Scope scope = (Scope) requestContext.getProperty(SPAN_PROPERTY);
  if (scope != null) {
    scope.close();
  }
  if (responseContext.getLength() > 0) {
    handler.handleMessageSent(context, responseContext.getLength());
  }
  ExtendedContainerRequest extendedRequest = new ExtendedContainerRequest(requestContext, info);
  handler.handleEnd(context, extendedRequest, responseContext, null);
}
 

/**
 * Reads the metrics from the {@link MetricProducerManager} and exports them to the {@code
 * metricExporter}.
 *
 * @param metricExporter the exporter called to export the metrics read.
 * @since 0.19
 */
public void readAndExport(MetricExporter metricExporter) {
  Span span =
      tracer
          .spanBuilder(spanName)
          .setRecordEvents(true)
          .setSampler(probabilitySampler)
          .startSpan();
  Scope scope = tracer.withSpan(span);
  try {
    ArrayList<Metric> metricsList = new ArrayList<>();
    for (MetricProducer metricProducer : metricProducerManager.getAllMetricProducer()) {
      metricsList.addAll(metricProducer.getMetrics());
    }
    metricExporter.export(metricsList);
  } catch (Throwable e) {
    logger.log(Level.WARNING, "Exception thrown by the metrics exporter.", e);
    span.setStatus(
        Status.UNKNOWN.withDescription("Exception when export metrics: " + exceptionMessage(e)));
  } finally {
    scope.close();
    span.end();
  }
}
 

@Override
public void export(Collection<SpanData> spanDataList) {
  // Start a new span with explicit 1/10000 sampling probability to avoid the case when user
  // sets the default sampler to always sample and we get the gRPC span of the stackdriver
  // export call always sampled and go to an infinite loop.
  io.opencensus.trace.Span span =
      tracer
          .spanBuilder(EXPORT_STACKDRIVER_TRACES)
          .setSampler(probabilitySampler)
          .setRecordEvents(true)
          .startSpan();
  Scope scope = tracer.withSpan(span);
  try {
    List<Span> spans = new ArrayList<>(spanDataList.size());
    for (SpanData spanData : spanDataList) {
      spans.add(generateSpan(spanData, RESOURCE_LABELS, fixedAttributes));
    }
    // Sync call because it is already called for a batch of data, and on a separate thread.
    // TODO(bdrutu): Consider to make this async in the future.
    traceServiceClient.batchWriteSpans(projectName, spans);
  } finally {
    scope.close();
    span.end(END_SPAN_OPTIONS);
  }
}
 

static Object proceed(
    ProceedingJoinPoint call, Tracer tracer, String spanName, String... annotations)
    throws Throwable {
  Scope scope = tracer.spanBuilder(spanName).startScopedSpan();
  try {
    for (String annotation : annotations) {
      tracer.getCurrentSpan().addAnnotation(annotation);
    }

    return call.proceed();

  } catch (Throwable t) {
    Map<String, AttributeValue> attributes = new HashMap<String, AttributeValue>();
    String message = t.getMessage();
    attributes.put(
        "message", AttributeValue.stringAttributeValue(message == null ? "null" : message));
    attributes.put("type", AttributeValue.stringAttributeValue(t.getClass().toString()));

    Span span = tracer.getCurrentSpan();
    span.addAnnotation("error", attributes);
    span.setStatus(Status.UNKNOWN);
    throw t;
  } finally {
    scope.close();
  }
}
 

/**
 * It intercepts http requests and starts a span.
 *
 * @since 0.23.0
 */
public ListenableFuture<ClientHttpResponse> intercept(
    HttpRequest request,
    byte[] body,
    org.springframework.http.client.AsyncClientHttpRequestExecution execution)
    throws IOException {
  HttpRequestContext context = handler.handleStart(tracer.getCurrentSpan(), request, request);

  Scope ws = tracer.withSpan(handler.getSpanFromContext(context));
  try {
    ListenableFuture<ClientHttpResponse> result = execution.executeAsync(request, body);
    result.addCallback(
        new TracingAsyncClientHttpRequestInterceptor.TraceListenableFutureCallback(
            context, handler));
    return result;
  } catch (IOException e) {
    handler.handleEnd(context, null, null, e);
    throw e;
  } finally {
    if (ws != null) {
      ws.close();
    }
  }
}
 

@Test
public void testWithTagMapUsingWrap() {
  Runnable runnable;
  Scope scopedTags = CurrentTagMapUtils.withTagMap(tagContext);
  try {
    assertThat(CurrentTagMapUtils.getCurrentTagMap()).isSameInstanceAs(tagContext);
    runnable =
        Context.current()
            .wrap(
                new Runnable() {
                  @Override
                  public void run() {
                    assertThat(CurrentTagMapUtils.getCurrentTagMap())
                        .isSameInstanceAs(tagContext);
                  }
                });
  } finally {
    scopedTags.close();
  }
  assertThat(tagContextToList(CurrentTagMapUtils.getCurrentTagMap())).isEmpty();
  // When we run the runnable we will have the TagContext in the current Context.
  runnable.run();
}
 

@Test
public void addToCurrentTagsWithBuilder() {
  TagContext scopedTags = tagger.emptyBuilder().put(KEY_1, VALUE_1).build();
  Scope scope1 = tagger.withTagContext(scopedTags);
  try {
    Scope scope2 = tagger.currentBuilder().put(KEY_2, VALUE_2).buildScoped();
    try {
      assertThat(tagContextToList(tagger.getCurrentTagContext()))
          .containsExactly(Tag.create(KEY_1, VALUE_1), Tag.create(KEY_2, VALUE_2));
    } finally {
      scope2.close();
    }
    assertThat(tagger.getCurrentTagContext()).isSameInstanceAs(scopedTags);
  } finally {
    scope1.close();
  }
}
 

@Test
public void withTagContext() {
  assertThat(tagContextToList(tagger.getCurrentTagContext())).isEmpty();
  TagContext scopedTags = tagger.emptyBuilder().put(KEY_1, VALUE_1).build();
  Scope scope = tagger.withTagContext(scopedTags);
  try {
    assertThat(tagger.getCurrentTagContext()).isSameInstanceAs(scopedTags);
  } finally {
    scope.close();
  }
  assertThat(tagContextToList(tagger.getCurrentTagContext())).isEmpty();
}
 

@Test
public void rawContextDataWithTracingData() {
  OpenCensusTraceContextDataInjector plugin = new OpenCensusTraceContextDataInjector();
  SpanContext spanContext =
      SpanContext.create(
          TraceId.fromLowerBase16("e17944156660f55b8cae5ce3f45d4a40"),
          SpanId.fromLowerBase16("fc3d2ba0d283b66a"),
          TraceOptions.builder().setIsSampled(true).build(),
          EMPTY_TRACESTATE);
  Scope scope = tracer.withSpan(new TestSpan(spanContext));
  try {
    String key = "myTestKey";
    ThreadContext.put(key, "myTestValue");
    try {
      assertThat(plugin.rawContextData().toMap())
          .containsExactly(
              "myTestKey",
              "myTestValue",
              "traceId",
              "e17944156660f55b8cae5ce3f45d4a40",
              "spanId",
              "fc3d2ba0d283b66a",
              "traceSampled",
              "true");
    } finally {
      ThreadContext.remove(key);
    }
  } finally {
    scope.close();
  }
}
 

@Test
public void handleStartShouldCreateChildSpanInCurrentContext() {
  Scope scope = tracer.withSpan(parentSpan);
  try {
    HttpRequestContext context = handler.handleStart(null, carrier, request);
    verify(tracer).spanBuilderWithExplicitParent(any(String.class), same(parentSpan));
    assertThat(context.span).isEqualTo(childSpan);
  } finally {
    scope.close();
  }
}
 

private static void logWithSpan(
    SpanContext spanContext, Function<Logger, Void> loggingFunction, Logger logger) {
  Scope scope = tracer.withSpan(new TestSpan(spanContext));
  try {
    loggingFunction.apply(logger);
  } finally {
    scope.close();
  }
}
 

@Test
public void setCurrentTagsWithBuilder() {
  assertThat(tagContextToList(tagger.getCurrentTagContext())).isEmpty();
  Scope scope = tagger.emptyBuilder().put(KEY_1, VALUE_1).buildScoped();
  try {
    assertThat(tagContextToList(tagger.getCurrentTagContext()))
        .containsExactly(Tag.create(KEY_1, VALUE_1));
  } finally {
    scope.close();
  }
  assertThat(tagContextToList(tagger.getCurrentTagContext())).isEmpty();
}
 

@Test
public void createBuilderFromCurrentTags() {
  TagContext scopedTags = tagger.emptyBuilder().put(KEY_1, VALUE_1).build();
  Scope scope = tagger.withTagContext(scopedTags);
  try {
    TagContext newTags = tagger.currentBuilder().put(KEY_2, VALUE_2).build();
    assertThat(tagContextToList(newTags))
        .containsExactly(Tag.create(KEY_1, VALUE_1), Tag.create(KEY_2, VALUE_2));
    assertThat(tagger.getCurrentTagContext()).isSameInstanceAs(scopedTags);
  } finally {
    scope.close();
  }
}
 

@Test
public void withSpan_CloseDetaches() {
  assertThat(CurrentSpanUtils.getCurrentSpan()).isEqualTo(BlankSpan.INSTANCE);
  Scope ws = CurrentSpanUtils.withSpan(span, false);
  try {
    assertThat(CurrentSpanUtils.getCurrentSpan()).isSameInstanceAs(span);
  } finally {
    ws.close();
  }
  assertThat(CurrentSpanUtils.getCurrentSpan()).isEqualTo(BlankSpan.INSTANCE);
  verifyZeroInteractions(span);
}
 

private TagContext getResultOfWithTagContext(TagContext tagsToSet) {
  Scope scope = tagger.withTagContext(tagsToSet);
  try {
    return ContextUtils.getValue(Context.current());
  } finally {
    scope.close();
  }
}
 

@Test
public void testWithTagMap() {
  assertThat(tagContextToList(CurrentTagMapUtils.getCurrentTagMap())).isEmpty();
  Scope scopedTags = CurrentTagMapUtils.withTagMap(tagContext);
  try {
    assertThat(CurrentTagMapUtils.getCurrentTagMap()).isSameInstanceAs(tagContext);
  } finally {
    scopedTags.close();
  }
  assertThat(tagContextToList(CurrentTagMapUtils.getCurrentTagMap())).isEmpty();
}
 

private static LogEntry getEnhancedLogEntry(LoggingEnhancer loggingEnhancer, Span span) {
  Scope scope = tracer.withSpan(span);
  try {
    LogEntry.Builder builder = LogEntry.newBuilder(null);
    loggingEnhancer.enhanceLogEntry(builder);
    return builder.build();
  } finally {
    scope.close();
  }
}
 

@Test
public void startSpanWithInvalidParentFromContext() {
  Scope ws = tracer.withSpan(BlankSpan.INSTANCE);
  try {
    assertThat(tracer.getCurrentSpan()).isSameInstanceAs(BlankSpan.INSTANCE);
    when(tracer.spanBuilderWithExplicitParent(same(SPAN_NAME), same(BlankSpan.INSTANCE)))
        .thenReturn(spanBuilder);
    assertThat(tracer.spanBuilder(SPAN_NAME)).isSameInstanceAs(spanBuilder);
  } finally {
    ws.close();
  }
}
 

@Test
public void startSpanWithParentFromContext() {
  Scope ws = tracer.withSpan(span);
  try {
    assertThat(tracer.getCurrentSpan()).isSameInstanceAs(span);
    when(tracer.spanBuilderWithExplicitParent(same(SPAN_NAME), same(span)))
        .thenReturn(spanBuilder);
    assertThat(tracer.spanBuilder(SPAN_NAME)).isSameInstanceAs(spanBuilder);
  } finally {
    ws.close();
  }
}
 

@Test
public void withSpan_CloseDetachesAndEndsSpan() {
  assertThat(CurrentSpanUtils.getCurrentSpan()).isEqualTo(BlankSpan.INSTANCE);
  Scope ss = CurrentSpanUtils.withSpan(span, true);
  try {
    assertThat(CurrentSpanUtils.getCurrentSpan()).isSameInstanceAs(span);
  } finally {
    ss.close();
  }
  assertThat(CurrentSpanUtils.getCurrentSpan()).isEqualTo(BlankSpan.INSTANCE);
  verify(span).end(same(EndSpanOptions.DEFAULT));
}