Zipkin library

include/envoy/runtime/runtime.h

@@ -27,6 +27,8 @@ class RandomGenerator {
   virtual std::string uuid() PURE;
 };
 
+typedef std::unique_ptr<RandomGenerator> RandomGeneratorPtr;
+
 /**
  * A snapshot of runtime data.
  */

source/common/common/hex.cc

@@ -1,5 +1,6 @@
 #include "common/common/hex.h"
 
+#include <array>
 #include <cstdint>
 #include <string>
 #include <vector>
@@ -43,3 +44,19 @@ std::vector<uint8_t> Hex::decode(const std::string& hex_string) {
 
   return segment;
 }
+
+std::string Hex::uint64ToHex(uint64_t value) {
+  std::array<uint8_t, 8> data;
+
+  // This is explicitly done for performance reasons
+  data[7] = (value & 0x00000000000000FF);
+  data[6] = (value & 0x000000000000FF00) >> 8;
+  data[5] = (value & 0x0000000000FF0000) >> 16;
+  data[4] = (value & 0x00000000FF000000) >> 24;
+  data[3] = (value & 0x000000FF00000000) >> 32;
+  data[2] = (value & 0x0000FF0000000000) >> 40;
+  data[1] = (value & 0x00FF000000000000) >> 48;
+  data[0] = (value & 0xFF00000000000000) >> 56;
+
+  return encode(&data[0], data.size());
+}

source/common/common/hex.h

@@ -32,4 +32,10 @@ class Hex final {
    * @return binary data
    */
   static std::vector<uint8_t> decode(const std::string& input);
+
+  /**
+   * Converts the given 64-bit integer into a hexadecimal string.
+   * @param value The integer to be converted.
+   */
+  static std::string uint64ToHex(uint64_t value);
 };

source/common/tracing/zipkin/BUILD

@@ -0,0 +1,36 @@
+licenses(["notice"])  # Apache 2
+
+package(default_visibility = ["//visibility:public"])
+
+load("//bazel:envoy_build_system.bzl", "envoy_cc_library")
+
+envoy_cc_library(
+    name = "zipkin_lib",
+    srcs = [
+        "span_buffer.cc",
+        "span_context.cc",
+        "tracer.cc",
+        "util.cc",
+        "zipkin_core_types.cc",
+    ],
+    hdrs = [
+        "span_buffer.h",
+        "span_context.h",
+        "tracer.h",
+        "tracer_interface.h",
+        "util.h",
+        "zipkin_core_constants.h",
+        "zipkin_core_types.h",
+        "zipkin_json_field_names.h",
+    ],
+    external_deps = ["rapidjson"],
+    deps = [
+        "//include/envoy/common:optional",
+        "//include/envoy/common:time_interface",
+        "//include/envoy/runtime:runtime_interface",
+        "//source/common/common:hex_lib",
+        "//source/common/common:singleton",
+        "//source/common/common:utility_lib",
+        "//source/common/network:address_lib",
+    ],
+)

source/common/tracing/zipkin/span_buffer.cc

@@ -0,0 +1,30 @@
+#include "common/tracing/zipkin/span_buffer.h"
+
+namespace Zipkin {
+
+bool SpanBuffer::addSpan(SpanPtr&& span) {
+  if (span_buffer_.size() == span_buffer_.capacity()) {
+    // Buffer full
+    return false;
+  }
+  span_buffer_.push_back(std::move(span));
+
+  return true;
+}
+
+std::string SpanBuffer::toStringifiedJsonArray() {
+  std::string stringified_json_array = "[";
+
+  if (pendingSpans()) {
+    stringified_json_array += span_buffer_[0]->toJson();
+    const uint64_t size = span_buffer_.size();
+    for (uint64_t i = 1; i < size; i++) {
+      stringified_json_array += ",";
+      stringified_json_array += span_buffer_[i]->toJson();
+    }
+  }
+  stringified_json_array += "]";
+
+  return stringified_json_array;
+}
+} // Zipkin

source/common/tracing/zipkin/span_buffer.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "common/tracing/zipkin/zipkin_core_types.h"
+
+namespace Zipkin {
+
+/**
+ * This class implements a simple buffer to store Zipkin tracing spans
+ * prior to flushing them.
+ */
+class SpanBuffer {
+public:
+  /**
+   * Constructor that creates an empty buffer. Space needs to be allocated by invoking
+   * the method allocateBuffer(size).
+   */
+  SpanBuffer() {}
+
+  /**
+   * Constructor that initializes a buffer with the given size.
+   *
+   * @param size The desired buffer size.
+   */
+  SpanBuffer(uint64_t size) { allocateBuffer(size); }
+
+  /**
+   * Allocates space for an empty buffer or resizes a previously-allocated one.
+   *
+   * @param size The desired buffer size.
+   */
+  void allocateBuffer(uint64_t size) { span_buffer_.reserve(size); }
+
+  /**
+   * Adds the given Zipkin span to the buffer.
+   *
+   * @param span The span to be added to the buffer.
+   *
+   * @return true if the span was successfully added, or false if the buffer was full.
+   */
+  bool addSpan(SpanPtr&& span);
+
+  /**
+   * Empties the buffer. This method is supposed to be called when all buffered spans
+   * have been sent to to the Zipkin service.
+   */
+  void clear() { span_buffer_.clear(); }
+
+  /**
+   * @return the number of spans currently buffered.
+   */
+  uint64_t pendingSpans() { return span_buffer_.size(); }
+
+  /**
+   * @return the contents of the buffer as a stringified array of JSONs, where
+   * each JSON in the array corresponds to one Zipkin span.
+   */
+  std::string toStringifiedJsonArray();
+
+private:
+  // We use a pre-allocated vector to improve performance
+  std::vector<SpanPtr> span_buffer_;
+};
+} // Zipkin

source/common/tracing/zipkin/span_context.cc

@@ -0,0 +1,152 @@
+#include "common/tracing/zipkin/span_context.h"
+
+#include "common/common/utility.h"
+#include "common/tracing/zipkin/zipkin_core_constants.h"
+
+namespace Zipkin {
+
+namespace {
+// The functions below are needed due to the "C++ static initialization order fiasco."
+
+/**
+ * @return String that separates the span-context fields in its string-serialized form.
+ */
+static const std::string& fieldSeparator() {
+  static const std::string* field_separator = new std::string(";");
+
+  return *field_separator;
+}
+
+/**
+ * @return String value corresponding to an empty span context.
+ */
+static const std::string& unitializedSpanContext() {
+  static const std::string* unitialized_span_context =
+      new std::string("0000000000000000" + fieldSeparator() + "0000000000000000" +
+                      fieldSeparator() + "0000000000000000");
+
+  return *unitialized_span_context;
+}
+
+/**
+ * @return String with regular expression to match a 16-digit hexadecimal number.
+ */
+static const std::string& hexDigitGroupRegexStr() {
+  static const std::string* hex_digit_group_regex_str = new std::string("([0-9,a-z]{16})");
+
+  return *hex_digit_group_regex_str;
+}
+
+/**
+ * @return a string with a regular expression to match a valid string-serialized span context.
+ *
+ * Note that a function is needed because we cannot concatenate static strings from
+ * different compilation units at initialization time (the initialization order is not
+ * guaranteed). In this case, the compilation units are ZipkinCoreConstants and SpanContext.
+ */
+static const std::string& spanContextRegexStr() {
+  // ^([0-9,a-z]{16});([0-9,a-z]{16});([0-9,a-z]{16})((;(cs|sr|cr|ss))*)$
+  static const std::string* span_context_regex_str = new std::string(
+      "^" + hexDigitGroupRegexStr() + fieldSeparator() + hexDigitGroupRegexStr() +
+      fieldSeparator() + hexDigitGroupRegexStr() + "((" + fieldSeparator() + "(" +
+      ZipkinCoreConstants::get().CLIENT_SEND + "|" + ZipkinCoreConstants::get().SERVER_RECV + "|" +
+      ZipkinCoreConstants::get().CLIENT_RECV + "|" + ZipkinCoreConstants::get().SERVER_SEND +
+      "))*)$");
+
+  return *span_context_regex_str;
+}
+
+/**
+ * @return a regex to match a valid string-serialization of a span context.
+ *
+ * Note that a function is needed because the string used to build the regex
+ * cannot be initialized statically.
+ */
+static const std::regex& spanContextRegex() {
+  static const std::regex* span_context_regex = new std::regex(spanContextRegexStr());
+
+  return *span_context_regex;
+}
+} // namespace
+
+SpanContext::SpanContext(const Span& span) {
+  trace_id_ = span.traceId();
+  id_ = span.id();
+  parent_id_ = span.isSetParentId() ? span.parentId() : 0;
+
+  for (const Annotation& annotation : span.annotations()) {
+    if (annotation.value() == ZipkinCoreConstants::get().CLIENT_RECV) {
+      annotation_values_.cr_ = true;
+    } else if (annotation.value() == ZipkinCoreConstants::get().CLIENT_SEND) {
+      annotation_values_.cs_ = true;
+    } else if (annotation.value() == ZipkinCoreConstants::get().SERVER_RECV) {
+      annotation_values_.sr_ = true;
+    } else if (annotation.value() == ZipkinCoreConstants::get().SERVER_SEND) {
+      annotation_values_.ss_ = true;
+    }
+  }
+
+  is_initialized_ = true;
+}
+
+const std::string SpanContext::serializeToString() {
+  if (!is_initialized_) {
+    return unitializedSpanContext();
+  }
+
+  std::string result;
+  result = traceIdAsHexString() + fieldSeparator() + idAsHexString() + fieldSeparator() +
+           parentIdAsHexString();
+
+  if (annotation_values_.cr_) {
+    result += fieldSeparator() + ZipkinCoreConstants::get().CLIENT_RECV;
+  }
+  if (annotation_values_.cs_) {
+    result += fieldSeparator() + ZipkinCoreConstants::get().CLIENT_SEND;
+  }
+  if (annotation_values_.sr_) {
+    result += fieldSeparator() + ZipkinCoreConstants::get().SERVER_RECV;
+  }
+  if (annotation_values_.ss_) {
+    result += fieldSeparator() + ZipkinCoreConstants::get().SERVER_SEND;
+  }
+
+  return result;
+}
+
+void SpanContext::populateFromString(const std::string& span_context_str) {
+  std::smatch match;
+
+  trace_id_ = parent_id_ = id_ = 0;
+  annotation_values_.cs_ = annotation_values_.cr_ = annotation_values_.ss_ =
+      annotation_values_.sr_ = false;
+
+  if (std::regex_search(span_context_str, match, spanContextRegex())) {
+    // This is a valid string encoding of the context
+    trace_id_ = std::stoull(match.str(1), nullptr, 16);
+    id_ = std::stoull(match.str(2), nullptr, 16);
+    parent_id_ = std::stoull(match.str(3), nullptr, 16);
+
+    std::string matched_annotations = match.str(4);
+    if (matched_annotations.size() > 0) {
+      std::vector<std::string> annotation_value_strings =
+          StringUtil::split(matched_annotations, fieldSeparator());
+      for (const std::string& annotation_value : annotation_value_strings) {
+        if (annotation_value == ZipkinCoreConstants::get().CLIENT_RECV) {
+          annotation_values_.cr_ = true;
+        } else if (annotation_value == ZipkinCoreConstants::get().CLIENT_SEND) {
+          annotation_values_.cs_ = true;
+        } else if (annotation_value == ZipkinCoreConstants::get().SERVER_RECV) {
+          annotation_values_.sr_ = true;
+        } else if (annotation_value == ZipkinCoreConstants::get().SERVER_SEND) {
+          annotation_values_.ss_ = true;
+        }
+      }
+    }
+
+    is_initialized_ = true;
+  } else {
+    is_initialized_ = false;
+  }
+}
+} // Zipkin