示例#1
0
 /**
  * Sets the current Trace/Span state. Using this method indicates we are part of an existing
  * trace/span.
  *
  * @param traceId Trace id.
  * @param spanId Span id.
  * @param parentSpanId Parent span id. Can be <code>null</code>.
  * @param name Name should not be empty or <code>null</code>.
  * @see ServerTracer#setStateNoTracing()
  * @see ServerTracer#setStateUnknown(String)
  */
 public void setStateCurrentTrace(
     long traceId, long spanId, @Nullable Long parentSpanId, @Nullable String name) {
   checkNotBlank(name, "Null or blank span name");
   spanAndEndpoint()
       .state()
       .setCurrentServerSpan(ServerSpan.create(traceId, spanId, parentSpanId, name));
 }
  @Test
  public void testSetServerSendInCaseOfThreadDuration() throws UnsupportedEncodingException {
    when(mockServerSpan.getSpan()).thenReturn(mockSpan);
    when(mockServerSpanState.getCurrentServerSpan()).thenReturn(mockServerSpan);
    when(mockServerSpanState.getServerSpanThreadDuration()).thenReturn(DURATION_MS);
    when(mockServerSpanState.getServerEndPoint()).thenReturn(mockEndPoint);
    serverTracer.setServerSend();
    verify(mockServerSpanState, times(3)).getCurrentServerSpan();
    verify(mockServerSpanState, times(2)).getServerEndPoint();

    final Annotation expectedServerSendAnnotation = new Annotation();
    expectedServerSendAnnotation.setHost(mockEndPoint);
    expectedServerSendAnnotation.setValue(zipkinCoreConstants.SERVER_SEND);
    expectedServerSendAnnotation.setTimestamp(CURRENT_TIME_MICROSECONDS);

    final BinaryAnnotation expectedThreadDurationAnnotation = new BinaryAnnotation();
    expectedThreadDurationAnnotation.setAnnotation_type(AnnotationType.STRING);
    expectedThreadDurationAnnotation.setHost(mockEndPoint);
    expectedThreadDurationAnnotation.setKey(BraveAnnotations.THREAD_DURATION);
    final ByteBuffer bb = ByteBuffer.wrap(String.valueOf(DURATION_MS).getBytes("UTF-8"));
    expectedThreadDurationAnnotation.setValue(bb);

    verify(mockSpan).addToAnnotations(expectedServerSendAnnotation);
    verify(mockSpan).addToBinary_annotations(expectedThreadDurationAnnotation);

    verify(mockServerSpanState).getServerSpanThreadDuration();
    verify(mockSpanCollector).collect(mockSpan);
    verify(mockServerSpanState).setCurrentServerSpan(null);
    verifyNoMoreInteractions(mockServerSpanState, mockSpanCollector, mockSpan);
  }
 @Test
 public void testGetAndSetCurrentServerSpan() {
   assertEquals(ServerSpan.create(null), serverAndClientSpanState.getCurrentServerSpan());
   serverAndClientSpanState.setCurrentServerSpan(mockServerSpan);
   assertSame(mockServerSpan, serverAndClientSpanState.getCurrentServerSpan());
   assertNull("Should not have been modified.", serverAndClientSpanState.getCurrentClientSpan());
 }
 @Test
 public void testSubmitAnnotationWithStartEndDateNoServerSpan() {
   when(mockServerSpanState.getCurrentServerSpan()).thenReturn(mockServerSpan);
   when(mockServerSpan.getSpan()).thenReturn(null);
   serverTracer.submitAnnotation(ANNOTATION_NAME, START_DATE, END_DATE);
   verify(mockServerSpanState).getCurrentServerSpan();
   verifyNoMoreInteractions(mockServerSpanState, mockSpanCollector, mockAnnotationSubmitter);
 }
  @Test
  public void testSetServerSendShouldNoServerSpan() {

    when(mockServerSpanState.getCurrentServerSpan()).thenReturn(mockServerSpan);
    when(mockServerSpan.getSpan()).thenReturn(null);
    serverTracer.setServerSend();
    verify(mockServerSpanState).getCurrentServerSpan();
    verifyNoMoreInteractions(mockServerSpanState, mockSpanCollector, mockSpan);
  }
  @Test
  public void testSetServerReceivedNoServerSpan() {

    when(mockServerSpanState.getCurrentServerSpan()).thenReturn(mockServerSpan);
    when(mockServerSpan.getSpan()).thenReturn(null);
    serverTracer.setServerReceived();
    verify(mockServerSpanState).getCurrentServerSpan();
    verifyNoMoreInteractions(mockServerSpanState, mockSpanCollector, mockAnnotationSubmitter);
  }
  @Test
  public void testSubmitBinaryAnnotationInt() {
    when(mockServerSpan.getSpan()).thenReturn(mockSpan);
    when(mockServerSpanState.getCurrentServerSpan()).thenReturn(mockServerSpan);
    when(mockServerSpanState.getEndPoint()).thenReturn(mockEndPoint);
    serverTracer.submitBinaryAnnotation(KEY, INT_VALUE);
    verify(mockServerSpanState).getCurrentServerSpan();
    verify(mockServerSpanState).getEndPoint();

    verify(mockAnnotationSubmitter).submitBinaryAnnotation(mockSpan, mockEndPoint, KEY, INT_VALUE);
    verifyNoMoreInteractions(mockServerSpanState, mockSpanCollector, mockAnnotationSubmitter);
  }
  @Test
  public void testSubmitAnnotationString() {
    when(mockServerSpan.getSpan()).thenReturn(mockSpan);
    when(mockServerSpanState.getCurrentServerSpan()).thenReturn(mockServerSpan);
    when(mockServerSpanState.getEndPoint()).thenReturn(mockEndPoint);
    serverTracer.submitAnnotation(ANNOTATION_NAME);
    verify(mockServerSpanState).getCurrentServerSpan();
    verify(mockServerSpanState).getEndPoint();

    verify(mockAnnotationSubmitter).submitAnnotation(mockSpan, mockEndPoint, ANNOTATION_NAME);
    verifyNoMoreInteractions(mockServerSpanState, mockSpanCollector, mockAnnotationSubmitter);
  }
示例#9
0
 /**
  * Sets the current Trace/Span state. Using this method indicates that we got no information about
  * being part of an existing trace or about the fact that we should not trace the current request.
  * In this case the ServerTracer will decide what to do.
  *
  * @param spanName The name of our current request/span.
  */
 public void setStateUnknown(String spanName) {
   checkNotBlank(spanName, "Null or blank span name");
   for (TraceFilter traceFilter : traceFilters()) {
     if (traceFilter.trace(spanName) == false) {
       spanAndEndpoint().state().setCurrentServerSpan(ServerSpan.NOT_SAMPLED);
       return;
     }
   }
   long newSpanId = randomGenerator().nextLong();
   spanAndEndpoint()
       .state()
       .setCurrentServerSpan(ServerSpan.create(newSpanId, newSpanId, null, spanName));
 }
示例#10
0
  @Test
  public void testSetServerReceived() {
    when(mockServerSpan.getSpan()).thenReturn(mockSpan);
    when(mockServerSpanState.getCurrentServerSpan()).thenReturn(mockServerSpan);
    when(mockServerSpanState.getEndPoint()).thenReturn(mockEndPoint);
    serverTracer.setServerReceived();
    verify(mockServerSpanState).getCurrentServerSpan();
    verify(mockServerSpanState).getEndPoint();

    verify(mockAnnotationSubmitter)
        .submitAnnotation(mockSpan, mockEndPoint, zipkinCoreConstants.SERVER_RECV);

    verifyNoMoreInteractions(mockServerSpanState, mockSpanCollector, mockAnnotationSubmitter);
  }
  @Test
  public void testSetServerReceived() {
    when(mockServerSpan.getSpan()).thenReturn(mockSpan);
    when(mockServerSpanState.getCurrentServerSpan()).thenReturn(mockServerSpan);
    when(mockServerSpanState.getServerEndPoint()).thenReturn(mockEndPoint);
    serverTracer.setServerReceived();

    final Annotation expectedAnnotation = new Annotation();
    expectedAnnotation.setHost(mockEndPoint);
    expectedAnnotation.setValue(zipkinCoreConstants.SERVER_RECV);
    expectedAnnotation.setTimestamp(CURRENT_TIME_MICROSECONDS);

    verify(mockServerSpanState).getCurrentServerSpan();
    verify(mockServerSpanState).getServerEndPoint();
    verify(mockSpan).addToAnnotations(expectedAnnotation);

    verifyNoMoreInteractions(mockServerSpanState, mockSpan, mockSpanCollector);
  }
示例#12
0
  @Test
  public void testSetServerSendInCaseOfThreadDuration() {
    when(mockServerSpan.getSpan()).thenReturn(mockSpan);
    when(mockServerSpanState.getCurrentServerSpan()).thenReturn(mockServerSpan);
    when(mockServerSpanState.getServerSpanThreadDuration()).thenReturn(DURATION_MS);
    when(mockServerSpanState.getEndPoint()).thenReturn(mockEndPoint);
    serverTracer.setServerSend();
    verify(mockServerSpanState).getCurrentServerSpan();
    verify(mockServerSpanState, times(2)).getEndPoint();

    verify(mockAnnotationSubmitter)
        .submitAnnotation(mockSpan, mockEndPoint, zipkinCoreConstants.SERVER_SEND);
    verify(mockAnnotationSubmitter)
        .submitBinaryAnnotation(
            mockSpan, mockEndPoint, BraveAnnotations.THREAD_DURATION, String.valueOf(DURATION_MS));
    verify(mockServerSpanState).getServerSpanThreadDuration();
    verify(mockSpanCollector).collect(mockSpan);
    verify(mockServerSpanState).setCurrentServerSpan(null);
    verifyNoMoreInteractions(mockServerSpanState, mockSpanCollector, mockAnnotationSubmitter);
  }