com.google.devtools.cloudtrace.v2.BatchWriteSpansRequest Java Examples

@Test
public void sendSpans() {
  onClientCall(
      observer -> {
        observer.onNext(Empty.getDefaultInstance());
        observer.onCompleted();
      });

  reporter.report(TestObjects.CLIENT_SPAN);
  reporter.flush();

  ArgumentCaptor<BatchWriteSpansRequest> requestCaptor =
      ArgumentCaptor.forClass(BatchWriteSpansRequest.class);

  verify(traceService).batchWriteSpans(requestCaptor.capture(), any());

  BatchWriteSpansRequest request = requestCaptor.getValue();
  assertThat(request.getName()).isEqualTo("projects/" + projectId);

  assertThat(request.getSpansList()).containsExactlyElementsOf(
      SpanTranslator.translate(projectId, asList(TestObjects.CLIENT_SPAN)));
}
 

@Test(expected = IllegalStateException.class)
public void execute_timeout() throws Throwable {
  long overriddenTimeout = 50;
  call = new BatchWriteSpansCall(server.getChannel(), BatchWriteSpansRequest.newBuilder().build(), overriddenTimeout);
  onClientCall(
          observer ->
                  Executors.newSingleThreadExecutor().submit(() ->
                  {
                    try {
                      Thread.sleep(overriddenTimeout + 10);
                    } catch (InterruptedException e) {}
                    observer.onCompleted();
                  }));

  call.execute();
}
 

void verifyRequestSent(List<Span> spans) throws IOException {
  onClientCall(
      observer -> {
        observer.onNext(Empty.getDefaultInstance());
        observer.onCompleted();
      });

  List<byte[]> encodedSpans =
      spans.stream().map(StackdriverEncoder.V2::encode).collect(Collectors.toList());

  sender.sendSpans(encodedSpans).execute();

  BatchWriteSpansRequest request = takeRequest();

  List<com.google.devtools.cloudtrace.v2.Span> translated =
      SpanTranslator.translate(projectId, spans);

  // sanity check the data
  assertThat(request.getSpansList()).containsExactlyElementsOf(translated);

  // verify our estimate is correct
  int actualSize = request.getSerializedSize();
  assertThat(sender.messageSizeInBytes(encodedSpans)).isEqualTo(actualSize);
}
 

@Test
public void accept() throws Exception {
  onClientCall(
      observer -> {
        observer.onNext(Empty.getDefaultInstance());
        observer.onCompleted();
      });

  spanConsumer.accept(asList(TestObjects.CLIENT_SPAN)).execute();

  ArgumentCaptor<BatchWriteSpansRequest> requestCaptor =
      ArgumentCaptor.forClass(BatchWriteSpansRequest.class);

  verify(traceService).batchWriteSpans(requestCaptor.capture(), any());

  BatchWriteSpansRequest request = requestCaptor.getValue();
  assertThat(request.getName()).isEqualTo("projects/" + projectId);
  assertThat(request.getSpansList())
      .isEqualTo(SpanTranslator.translate(projectId, asList(TestObjects.CLIENT_SPAN)));
}
 

StackdriverSender(Builder builder) {
  channel = builder.channel;
  callOptions = builder.callOptions;
  projectName = ByteString.copyFromUtf8("projects/" + builder.projectId);
  serverResponseTimeoutMs = builder.serverResponseTimeoutMs;
  traceIdPrefix = projectName.concat(ByteString.copyFromUtf8("/traces/"));
  shutdownChannelOnClose = builder.shutdownChannelOnClose;
  projectNameFieldSize = CodedOutputStream.computeBytesSize(1, projectName);

  // The size of the contents of the Span.name field, used to preallocate the correct sized
  // buffer when computing Span.name.
  spanNameSize = traceIdPrefix.size() + 32 + SPAN_ID_PREFIX.size() + 16;

  spanNameFieldSize = CodedOutputStream.computeTagSize(1)
      + CodedOutputStream.computeUInt32SizeNoTag(spanNameSize) + spanNameSize;

  BatchWriteSpansRequest healthcheckRequest = BatchWriteSpansRequest.newBuilder()
      .setNameBytes(projectName)
      .addSpans(Span.newBuilder().build())
      .build();
  healthcheckCall = new BatchWriteSpansCall(healthcheckRequest);
}
 

@Override
public Call<Void> sendSpans(List<byte[]> traceIdPrefixedSpans) {
  if (closeCalled) throw new IllegalStateException("closed");
  int length = traceIdPrefixedSpans.size();
  if (length == 0) return Call.create(null);

  BatchWriteSpansRequest.Builder request = BatchWriteSpansRequest.newBuilder()
      .setNameBytes(projectName);
  for (byte[] traceIdPrefixedSpan : traceIdPrefixedSpans) {
    request.addSpans(parseTraceIdPrefixedSpan(traceIdPrefixedSpan, spanNameSize, traceIdPrefix));
  }

  return new BatchWriteSpansCall(request.build()).map(EmptyToVoid.INSTANCE);
}
 

void verifyPatchRequestSent() {
  ArgumentCaptor<BatchWriteSpansRequest> requestCaptor =
          ArgumentCaptor.forClass(BatchWriteSpansRequest.class);

  verify(traceService).batchWriteSpans(requestCaptor.capture(), any());

  BatchWriteSpansRequest request = requestCaptor.getValue();
  assertThat(request).isEqualTo(BatchWriteSpansRequest.getDefaultInstance());
}
 

BatchWriteSpansRequest takeRequest() {
  ArgumentCaptor<BatchWriteSpansRequest> requestCaptor =
      ArgumentCaptor.forClass(BatchWriteSpansRequest.class);

  verify(traceService).batchWriteSpans(requestCaptor.capture(), any());

  return requestCaptor.getValue();
}
 

@Override
public void flush() {
  List<Span> spans = new ArrayList<>(queue.size());
  queue.drain(spans::add);
  if (spans.isEmpty()) {
    return;
  }

  List<com.google.devtools.cloudtrace.v2.Span> translated =
      SpanTranslator.translate(projectId, spans);

  BatchWriteSpansRequest request =
      BatchWriteSpansRequest.newBuilder()
          .setName("projects/" + projectId)
          .addAllSpans(translated)
          .build();

  Futures.addCallback(
      traceServiceClient.get().batchWriteSpans(request),
      new FutureCallback<Empty>() {
        @Override
        public void onFailure(Throwable t) {
          logger.warn("Error reporting traces.", t);
        }

        @Override
        public void onSuccess(Empty result) {
          logger.trace("Successfully reported traces.");
        }
      },
      MoreExecutors.directExecutor());
}
 

StackdriverStorage(Builder builder, UnaryGrpcClient grpcClient) {
  this.grpcClient = grpcClient;
  projectId = builder.projectId;
  BatchWriteSpansRequest healthcheckRequest = BatchWriteSpansRequest.newBuilder()
      .setName("projects/" + builder.projectId)
      .build();
  healthcheckCall = new BatchWriteSpansCall(grpcClient, healthcheckRequest);
}
 

@Override
public Call<Void> accept(List<Span> spans) {
  if (spans.isEmpty()) return Call.create(null);
  List<com.google.devtools.cloudtrace.v2.Span> stackdriverSpans =
      SpanTranslator.translate(projectId, spans);
  BatchWriteSpansRequest request =
      BatchWriteSpansRequest.newBuilder()
          .setName(projectName)
          .addAllSpans(stackdriverSpans)
          .build();
  return new BatchWriteSpansCall(grpcClient, request);
}
 

@Override
public void batchWriteSpans(BatchWriteSpansRequest request,
    StreamObserver<Empty> responseObserver) {
  final List<Span> spansList = request.getSpansList();
  for (Span span : spansList) {
    spanIds.add(span.getSpanId());
    spanCountdown.countDown();
  }
  responseObserver.onNext(Empty.getDefaultInstance());
  responseObserver.onCompleted();
}
 

@Test
public void mockGrpcServerServesOverSSL() { // sanity checks the mock server
  TraceServiceGrpc.TraceServiceBlockingStub sslTraceService =
      Clients.builder("gproto+https://" + mockServer.grpcURI() + "/")
          .factory(ClientFactory.builder()
              .tlsCustomizer(tls -> tls.trustManager(InsecureTrustManagerFactory.INSTANCE))
              .build())
          .build(TraceServiceGrpc.TraceServiceBlockingStub.class);

  sslTraceService.batchWriteSpans(BatchWriteSpansRequest.getDefaultInstance());
}
 

@Override
public void batchWriteSpans(BatchWriteSpansRequest request,
		StreamObserver<Empty> responseObserver) {
	request.getSpansList().forEach((span) -> this.traces.put(span.getSpanId(), span));
	responseObserver.onNext(Empty.getDefaultInstance());
	responseObserver.onCompleted();
}
 

BatchWriteSpansCall(BatchWriteSpansRequest request) {
  super(channel, TraceServiceGrpc.getBatchWriteSpansMethod(), callOptions, request, serverResponseTimeoutMs);
}
 

BatchWriteSpansCall(UnaryGrpcClient grpcClient, BatchWriteSpansRequest request) {
  this.grpcClient = grpcClient;
  this.request = request;
}
 

BatchWriteSpansCall(Channel channel, BatchWriteSpansRequest request, long serverResponseTimeout) {
  super(channel, TraceServiceGrpc.getBatchWriteSpansMethod(), DEFAULT, request, serverResponseTimeout);
  this.channel = channel;
}
 

@Before
public void setUp() {
  server.getServiceRegistry().addService(traceService);
  call = new BatchWriteSpansCall(server.getChannel(), BatchWriteSpansRequest.newBuilder().build(), DEFAULT_SERVER_TIMEOUT_MS);
}