@Override public void handleDelivery( String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) { metrics.incrementMessages(); this.collector.acceptSpans(body, NOOP); } }
public void acceptSpans( byte[] serializedSpans, BytesDecoder<Span> decoder, Callback<Void> callback) { metrics.incrementBytes(serializedSpans.length); List<Span> spans; try { spans = decodeList(decoder, serializedSpans); } catch (RuntimeException e) { callback.onError(errorReading(e)); return; } accept(spans, callback); }
public Collector build() { return new Collector(this); } }
public void acceptSpans(byte[] serialized, Callback<Void> callback) { BytesDecoder<Span> decoder; try { decoder = SpanBytesDecoderDetector.decoderForListMessage(serialized); } catch (RuntimeException e) { metrics.incrementBytes(serialized.length); callback.onError(errorReading(e)); return; } acceptSpans(serialized, decoder, callback); }
public void accept(List<Span> spans, Callback<Void> callback) { if (spans.isEmpty()) { callback.onSuccess(null); return; } metrics.incrementSpans(spans.size()); List<Span> sampled = sample(spans); if (sampled.isEmpty()) { callback.onSuccess(null); return; } try { record(sampled, acceptSpansCallback(sampled)); callback.onSuccess(null); } catch (RuntimeException e) { callback.onError(errorStoringSpans(sampled, e)); return; } }
try { Span span = SpanBytesDecoder.THRIFT.decodeOne(bytes); collector.accept(Collections.singletonList(span), NOOP); } catch (RuntimeException e) { metrics.incrementMessagesDropped(); collector.acceptSpans(bytes, NOOP);
@Override public void onEvents(PartitionContext context, Iterable<EventData> messages) throws ExecutionException, InterruptedException { // don't issue a write until we checkpoint or exit this callback List<Span> buffer = new ArrayList<>(); for (EventData data : messages) { byte[] bytes = data.getBytes(); BytesDecoder<Span> decoder = decoderForListMessage(bytes); List<Span> nextSpans = decoder.decodeList(bytes); buffer.addAll(nextSpans); if (maybeCheckpoint(context, data, nextSpans.size())) { collector.accept(buffer, NOOP); buffer.clear(); } } if (!buffer.isEmpty()) { collector.accept(buffer, NOOP); } }
ZipkinDispatcher(StorageComponent storage, CollectorMetrics metrics, MockWebServer server) { this.consumer = Collector.newBuilder(getClass()).storage(storage).metrics(metrics).build(); this.metrics = metrics; this.server = server; }
@Override public void run() { ConsumerIterator<byte[], byte[]> messages = stream.iterator(); while (messages.hasNext()) { byte[] bytes = messages.next().message(); metrics.incrementMessages(); if (bytes.length < 2) { // need two bytes to check if protobuf metrics.incrementMessagesDropped(); continue; } // If we received legacy single-span encoding, decode it into a singleton list if (!protobuf3(bytes) && bytes[0] <= 16 && bytes[0] != 12 /* thrift, but not a list */) { try { metrics.incrementBytes(bytes.length); Span span = SpanBytesDecoder.THRIFT.decodeOne(bytes); collector.accept(Collections.singletonList(span), NOOP); } catch (RuntimeException e) { metrics.incrementMessagesDropped(); } } else { collector.acceptSpans(bytes, NOOP); } } }
collector.accept( spans, new Callback<Void>() {
@Autowired ZipkinHttpCollector( StorageComponent storage, CollectorSampler sampler, CollectorMetrics metrics) { this.metrics = metrics.forTransport("http"); this.collector = Collector.newBuilder(getClass()) .storage(storage) .sampler(sampler) .metrics(this.metrics) .build(); this.JSON_V2 = new HttpCollector(SpanBytesDecoder.JSON_V2); this.PROTO3 = new HttpCollector(SpanBytesDecoder.PROTO3); this.JSON_V1 = new HttpCollector(SpanBytesDecoder.JSON_V1); this.THRIFT = new HttpCollector(SpanBytesDecoder.THRIFT); this.errorCallback = new Receiver.ErrorCallback() { @Override public void error(HttpServerExchange exchange, IOException e) { ZipkinHttpCollector.this.metrics.incrementMessagesDropped(); ZipkinHttpCollector.error(exchange, e); } }; }
@Override public void processRecords(ProcessRecordsInput processRecordsInput) { for (Record record : processRecordsInput.getRecords()) { collector.acceptSpans(record.getData().array(), NOOP); } }
@Override public void handle(HttpServerExchange exchange, byte[] body) { String encoding = exchange.getRequestHeaders().getFirst(CONTENT_ENCODING); if (encoding != null && encoding.contains("gzip")) { try { body = gunzip(body); } catch (IOException e) { metrics.incrementMessagesDropped(); exchange .setStatusCode(400) .getResponseSender() .send("Cannot gunzip spans: " + e.getMessage() + "\n"); return; } } collector.acceptSpans( body, decoder, new Callback<Void>() { @Override public void onSuccess(Void value) { exchange.setStatusCode(202).getResponseSender().close(); } @Override public void onError(Throwable t) { error(exchange, t); } }); } }
consumer.acceptSpans( body, decoder,