Zipkin exporter

CMakeLists.txt

@@ -53,6 +53,7 @@ if(WITH_STL)
 endif()
 
 option(WITH_OTLP "Whether to include the OpenTelemetry Protocol in the SDK" OFF)
+option(WITH_ZIPKIN "Whether to include the Zipkin exporter in the SDK" OFF)
 
 option(WITH_PROMETHEUS "Whether to include the Prometheus Client in the SDK"
        OFF)
@@ -162,6 +163,7 @@ include_directories(sdk/include)
 include_directories(sdk)
 add_subdirectory(sdk)
 include_directories(.)
+include_directories(ext/include)
 add_subdirectory(exporters)
 if(WITH_EXAMPLES)
   add_subdirectory(examples)

exporters/CMakeLists.txt

@@ -9,6 +9,10 @@ if(WITH_PROMETHEUS)
   add_subdirectory(prometheus)
 endif()
 
+if(WITH_ZIPKIN)
+  add_subdirectory(zipkin)
+endif()
+
 if(WITH_ELASTICSEARCH)
   add_subdirectory(elasticsearch)
 endif()

exporters/zipkin/CMakeLists.txt

@@ -0,0 +1,31 @@
+# Copyright 2020, OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+include_directories(include)
+find_package(CURL REQUIRED)
+if(CURL_FOUND)
+  add_compile_definitions(WITH_CURL)
+endif()
+add_library(zipkin_trace_exporter src/zipkin_exporter.cc src/recordable.cc)
+if(BUILD_TESTING)
+  add_executable(zipkin_recordable_test test/zipkin_recordable_test.cc)
+
+  target_link_libraries(zipkin_recordable_test ${GTEST_BOTH_LIBRARIES}
+                        ${CMAKE_THREAD_LIBS_INIT} zipkin_trace_exporter)
+
+  gtest_add_tests(
+    TARGET zipkin_recordable_test
+    TEST_PREFIX exporter.
+    TEST_LIST zipkin_recordable_test)
+endif() # BUILD_TESTING

exporters/zipkin/include/opentelemetry/exporters/zipkin/recordable.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "nlohmann/json.hpp"
+#include "opentelemetry/sdk/trace/recordable.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace zipkin
+{
+using ZipkinSpan = nlohmann::json;
+
+enum class TransportFormat
+{
+  JSON,
+  PROTOBUF
+};
+
+class Recordable final : public sdk::trace::Recordable
+{
+public:
+  const ZipkinSpan &span() const noexcept { return span_; }
+
+  void SetIds(trace::TraceId trace_id,
+              trace::SpanId span_id,
+              trace::SpanId parent_span_id) noexcept override;
+
+  void SetAttribute(nostd::string_view key,
+                    const opentelemetry::common::AttributeValue &value) noexcept override;
+
+  void AddEvent(nostd::string_view name,
+                core::SystemTimestamp timestamp,
+                const common::KeyValueIterable &attributes) noexcept override;
+
+  void AddLink(const opentelemetry::trace::SpanContext &span_context,
+               const common::KeyValueIterable &attributes) noexcept override;
+
+  void SetStatus(trace::CanonicalCode code, nostd::string_view description) noexcept override;
+
+  void SetName(nostd::string_view name) noexcept override;
+
+  void SetStartTime(opentelemetry::core::SystemTimestamp start_time) noexcept override;
+
+  virtual void SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept override;
+
+  void SetDuration(std::chrono::nanoseconds duration) noexcept override;
+
+private:
+  ZipkinSpan span_;
+};
+}  // namespace zipkin
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE

exporters/zipkin/include/opentelemetry/exporters/zipkin/zipkin_exporter.h

@@ -0,0 +1,97 @@
+#pragma once
+
+#include "opentelemetry/exporters/zipkin/recordable.h"
+#include "opentelemetry/ext/http/client/http_client_factory.h"
+#include "opentelemetry/ext/http/common/url_parser.h"
+#include "opentelemetry/sdk/trace/exporter.h"
+#include "opentelemetry/sdk/trace/span_data.h"
+
+#include "nlohmann/json.hpp"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace zipkin
+{
+
+std::string ZIPKIN_ENDPOINT_DEFAULT = "http://localhost:9411/api/v2/spans";
+
+/**
+ * Struct to hold Zipkin  exporter options.
+ */
+struct ZipkinExporterOptions
+{
+  // The endpoint to export to. By default the OpenTelemetry Collector's default endpoint.
+  std::string endpoint     = ZIPKIN_ENDPOINT_DEFAULT;
+  TransportFormat format   = TransportFormat::JSON;
+  std::string service_name = "default-service";
+  std::string ipv4;
+  std::string ipv6;
+};
+
+namespace trace_sdk   = opentelemetry::sdk::trace;
+namespace http_client = opentelemetry::ext::http::client;
+
+/**
+ * The Zipkin exporter exports span data in JSON format as expected by Zipkin
+ */
+class ZipkinExporter final : public trace_sdk::SpanExporter, public http_client::EventHandler
+{
+public:
+  /**
+   * Create an ZipkinExporter using all default options.
+   */
+  ZipkinExporter();
+
+  /**
+   * Create an ZipkinExporter using the given options.
+   */
+  ZipkinExporter(const ZipkinExporterOptions &options);
+
+  /**
+   * Create a span recordable.
+   * @return a newly initialized Recordable object
+   */
+  std::unique_ptr<trace_sdk::Recordable> MakeRecordable() noexcept override;
+
+  /**
+   * Export a batch of span recordables in JSON format.
+   * @param spans a span of unique pointers to span recordables
+   */
+  trace_sdk::ExportResult Export(
+      const nostd::span<std::unique_ptr<trace_sdk::Recordable>> &spans) noexcept override;
+
+  /**
+   * Shut down the exporter.
+   * @param timeout an optional timeout, default to max.
+   */
+  bool Shutdown(
+      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override
+  {
+    return true;
+  };
+
+  void OnResponse(http_client::Response &response) noexcept override
+  { /*Not required */
+  }
+
+  virtual void OnEvent(http_client::SessionState state,
+                       nostd::string_view msg) noexcept override{/* Not required */};
+
+  virtual void OnConnecting(const http_client::SSLCertificate &) noexcept override{
+      /* Not required */};
+
+private:
+  void InitializeLocalEndpoint();
+
+private:
+  // The configuration options associated with this exporter.
+  bool isShutdown_ = false;
+  std::shared_ptr<http_client::SessionManager> http_session_manager_;
+  nlohmann::json local_end_point_;
+  ZipkinExporterOptions options_;
+  ext::http::common::UrlParser url_parser_;
+};
+}  // namespace zipkin
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE

exporters/zipkin/src/recordable.cc

@@ -0,0 +1,184 @@
+#include "opentelemetry/exporters/zipkin/recordable.h"
+
+#include <iostream>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace zipkin
+{
+
+const int kAttributeValueSize = 14;
+
+void Recordable::SetIds(trace::TraceId trace_id,
+                        trace::SpanId span_id,
+                        trace::SpanId parent_span_id) noexcept
+{
+  char traceid[trace::TraceId::kSize * 2] = {0};
+  trace_id.ToLowerBase16(traceid);
+  char spanid[trace::SpanId::kSize * 2] = {0};
+  span_id.ToLowerBase16(spanid);
+  char parentid[trace::SpanId::kSize * 2] = {0};
+  parent_span_id.ToLowerBase16(parentid);
+  span_["id"]       = std::string(spanid, 16);
+  span_["parentId"] = std::string(parentid, 16);
+  span_["traceId"]  = std::string(traceid, 32);
+}
+
+void PopulateAttribute(nlohmann::json &attribute,
+                       nostd::string_view key,
+                       const opentelemetry::common::AttributeValue &value)
+{
+  // Assert size of variant to ensure that this method gets updated if the variant
+  // definition changes
+  static_assert(
+      nostd::variant_size<opentelemetry::common::AttributeValue>::value == kAttributeValueSize,
+      "AttributeValue contains unknown type");
+
+  // attribute->set_key(key.data(), key.size());
+
+  if (nostd::holds_alternative<bool>(value))
+  {
+    attribute[key.data()] = nostd::get<bool>(value);
+  }
+  else if (nostd::holds_alternative<int>(value))
+  {
+    attribute[key.data()] = nostd::get<int>(value);
+  }
+  else if (nostd::holds_alternative<int64_t>(value))
+  {
+
+    attribute[key.data()] = nostd::get<int64_t>(value);
+  }
+  else if (nostd::holds_alternative<unsigned int>(value))
+  {
+    attribute[key.data()] = nostd::get<unsigned int>(value);
+  }
+  else if (nostd::holds_alternative<uint64_t>(value))
+  {
+    attribute[key.data()] = nostd::get<uint64_t>(value);
+  }
+  else if (nostd::holds_alternative<double>(value))
+  {
+    attribute[key.data()] = nostd::get<double>(value);
+  }
+  else if (nostd::holds_alternative<nostd::string_view>(value))
+  {
+    attribute[key.data()] = nostd::string_view(nostd::get<nostd::string_view>(value).data(),
+                                               nostd::get<nostd::string_view>(value).size());
+  }
+  else if (nostd::holds_alternative<nostd::span<const bool>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const bool>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const int>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const int>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const int64_t>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const int64_t>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const unsigned int>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const unsigned int>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const uint64_t>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const uint64_t>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const double>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const double>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const nostd::string_view>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const nostd::string_view>>(value))
+    {
+      attribute[key.data()].push_back(std::string(val.data(), val.size()));
+    }
+  }
+}
+
+void Recordable::SetAttribute(nostd::string_view key,
+                              const opentelemetry::common::AttributeValue &value) noexcept
+{
+  if (!span_.contains("tags"))
+  {
+    span_["tags"] = nlohmann::json::object();
+  }
+  PopulateAttribute(span_["tags"], key, value);
+}
+
+void Recordable::AddEvent(nostd::string_view name,
+                          core::SystemTimestamp timestamp,
+                          const common::KeyValueIterable &attributes) noexcept
+{
+  nlohmann::json annotations = nlohmann::json::object();  // empty object
+  attributes.ForEachKeyValue([&](nostd::string_view key, common::AttributeValue value) noexcept {
+    PopulateAttribute(annotations, key, value);
+    return true;
+  });
+  span_["annotations"][name.data()]["value"] = annotations;
+  span_["annotations"]["timestamp"] =
+      std::chrono::duration_cast<std::chrono::milliseconds>(timestamp.time_since_epoch()).count();
+}
+
+void Recordable::AddLink(const opentelemetry::trace::SpanContext &span_context,
+                         const common::KeyValueIterable &attributes) noexcept
+{
+  // TODO: Currently not supported by specs:
+  // https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/sdk_exporters/zipkin.md
+}
+
+void Recordable::SetStatus(trace::CanonicalCode code, nostd::string_view description) noexcept
+{
+  span_["tags"]["otel.status_code"] = code;
+  if (description.size())
+    span_["tags"]["otel.status_description"] = description;
+}
+
+void Recordable::SetName(nostd::string_view name) noexcept
+{
+  span_["name"] = name.data();
+}
+
+void Recordable::SetStartTime(opentelemetry::core::SystemTimestamp start_time) noexcept
+{
+  span_["timestamp"] = start_time.time_since_epoch().count();
+}
+
+void Recordable::SetDuration(std::chrono::nanoseconds duration) noexcept
+{
+  span_["duration"] = duration.count();
+}
+
+void Recordable::SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept {}
+}  // namespace zipkin
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE