Add support for sampling.priority. (#94)

* Add support for sampling.priority.

* Upload test logs.

* Fix storing of artifacts.

* Redo CI commands.

* Update OpenTracing CI version.

* Update OT bazel version.

* Add missing mutext.

* Fix propagation tests.

Author: rnburn

WORKSPACE

@@ -3,7 +3,7 @@ workspace(name = "com_lightstep_tracer_cpp")
 git_repository(
     name = "io_opentracing_cpp",
     remote = "https://github.com/opentracing/opentracing-cpp",
-    commit = "f3c1f42601d13504c68e2bc81c60604f0de055dd",
+    commit = "900f9d9297a71ddf4a5dff2051a01493014c07c5",
 )
 
 http_archive(

ci/build_plugin.sh

@@ -2,7 +2,7 @@
 
 set -e
 
-[ -z "${OPENTRACING_VERSION}" ] && export OPENTRACING_VERSION="v1.3.0"
+[ -z "${OPENTRACING_VERSION}" ] && export OPENTRACING_VERSION="v1.4.0"
 [ -z "${GRPC_VERSION}" ] && export GRPC_VERSION="v1.10.0"
 
 # Compile for a portable cpu architecture

ci/install_opentracing.sh

@@ -2,7 +2,7 @@
 
 set -e
 
-[ -z "${OPENTRACING_VERSION}" ] && export OPENTRACING_VERSION="v1.3.0"
+[ -z "${OPENTRACING_VERSION}" ] && export OPENTRACING_VERSION="v1.4.0"
 
 # Build OpenTracing
 cd /

src/lightstep_span.cpp

@@ -1,4 +1,5 @@
 #include "lightstep_span.h"
+#include <opentracing/ext/tags.h>
 #include "utility.h"
 
 using opentracing::SystemTime;
@@ -7,6 +8,13 @@ using opentracing::SteadyClock;
 using opentracing::SteadyTime;
 
 namespace lightstep {
+//------------------------------------------------------------------------------
+// is_sampled
+//------------------------------------------------------------------------------
+static bool is_sampled(const opentracing::Value& value) {
+  return value != opentracing::Value{0} && value != opentracing::Value{0u};
+}
+
 //------------------------------------------------------------------------------
 // ComputeStartTimestamps
 //------------------------------------------------------------------------------
@@ -43,7 +51,7 @@ static bool SetSpanReference(
     const std::pair<opentracing::SpanReferenceType,
                     const opentracing::SpanContext*>& reference,
     std::unordered_map<std::string, std::string>& baggage,
-    collector::Reference& collector_reference) {
+    collector::Reference& collector_reference, bool& sampled) {
   collector_reference.Clear();
   switch (reference.first) {
     case opentracing::SpanReferenceType::ChildOfRef:
@@ -67,6 +75,7 @@ static bool SetSpanReference(
       referenced_context->trace_id());
   collector_reference.mutable_span_context()->set_span_id(
       referenced_context->span_id());
+  sampled = sampled || referenced_context->sampled();
 
   referenced_context->ForeachBaggageItem(
       [&baggage](const std::string& key, const std::string& value) {
@@ -96,24 +105,40 @@ LightStepSpan::LightStepSpan(
   std::unordered_map<std::string, std::string> baggage;
   references_.reserve(options.references.size());
   collector::Reference collector_reference;
+  bool sampled = false;
   for (auto& reference : options.references) {
-    if (!SetSpanReference(logger_, reference, baggage, collector_reference)) {
+    if (!SetSpanReference(logger_, reference, baggage, collector_reference,
+                          sampled)) {
       continue;
     }
     references_.push_back(collector_reference);
   }
 
+  // If there are any span references, sampled should be true if any of the
+  // references are sampled; with no refences, we set sampled to true.
+  if (references_.empty()) {
+    sampled = true;
+  }
+
   // Set tags.
   for (auto& tag : options.tags) {
     tags_[tag.first] = tag.second;
   }
 
+  // If sampling_priority is set, it overrides whatever sampling decision was
+  // derived from the referenced spans.
+  auto sampling_priority_tag = tags_.find(opentracing::ext::sampling_priority);
+  if (sampling_priority_tag != tags_.end()) {
+    sampled = is_sampled(sampling_priority_tag->second);
+  }
+
   // Set opentracing::SpanContext.
   auto trace_id = references_.empty()
                       ? GenerateId()
                       : references_[0].span_context().trace_id();
   auto span_id = GenerateId();
-  span_context_ = LightStepSpanContext{trace_id, span_id, std::move(baggage)};
+  span_context_ =
+      LightStepSpanContext{trace_id, span_id, sampled, std::move(baggage)};
 }
 
 //------------------------------------------------------------------------------
@@ -135,6 +160,11 @@ void LightStepSpan::FinishWithOptions(
     return;
   }
 
+  // If the span isn't sampled do nothing.
+  if (!span_context_.sampled()) {
+    return;
+  }
+
   auto finish_timestamp = options.finish_steady_timestamp;
   if (finish_timestamp == SteadyTime()) {
     finish_timestamp = SteadyClock::now();
@@ -230,6 +260,10 @@ void LightStepSpan::SetTag(opentracing::string_view key,
                            const opentracing::Value& value) noexcept try {
   std::lock_guard<std::mutex> lock_guard{mutex_};
   tags_[key] = value;
+
+  if (key == opentracing::ext::sampling_priority) {
+    span_context_.set_sampled(is_sampled(value));
+  }
 } catch (const std::exception& e) {
   logger_.Error("SetTag failed: ", e.what());
 }

src/lightstep_span_context.cpp

@@ -9,13 +9,22 @@ LightStepSpanContext::LightStepSpanContext(
     std::unordered_map<std::string, std::string>&& baggage) noexcept
     : trace_id_{trace_id}, span_id_{span_id}, baggage_{std::move(baggage)} {}
 
+LightStepSpanContext::LightStepSpanContext(
+    uint64_t trace_id, uint64_t span_id, bool sampled,
+    std::unordered_map<std::string, std::string>&& baggage) noexcept
+    : trace_id_{trace_id},
+      span_id_{span_id},
+      sampled_{sampled},
+      baggage_{std::move(baggage)} {}
+
 //------------------------------------------------------------------------------
 // operator=
 //------------------------------------------------------------------------------
 LightStepSpanContext& LightStepSpanContext::operator=(
     LightStepSpanContext&& other) noexcept {
   trace_id_ = other.trace_id_;
   span_id_ = other.span_id_;
+  sampled_ = other.sampled_;
   baggage_ = std::move(other.baggage_);
   return *this;
 }
@@ -25,7 +34,7 @@ LightStepSpanContext& LightStepSpanContext::operator=(
 //------------------------------------------------------------------------------
 void LightStepSpanContext::set_baggage_item(
     opentracing::string_view key, opentracing::string_view value) noexcept try {
-  std::lock_guard<std::mutex> lock_guard{baggage_mutex_};
+  std::lock_guard<std::mutex> lock_guard{mutex_};
   baggage_.emplace(key, value);
 } catch (const std::exception&) {
   // Drop baggage item upon error.
@@ -36,7 +45,7 @@ void LightStepSpanContext::set_baggage_item(
 //------------------------------------------------------------------------------
 std::string LightStepSpanContext::baggage_item(
     opentracing::string_view key) const {
-  std::lock_guard<std::mutex> lock_guard{baggage_mutex_};
+  std::lock_guard<std::mutex> lock_guard{mutex_};
   auto lookup = baggage_.find(key);
   if (lookup != baggage_.end()) {
     return lookup->second;
@@ -50,11 +59,27 @@ std::string LightStepSpanContext::baggage_item(
 void LightStepSpanContext::ForeachBaggageItem(
     std::function<bool(const std::string& key, const std::string& value)> f)
     const {
-  std::lock_guard<std::mutex> lock_guard{baggage_mutex_};
+  std::lock_guard<std::mutex> lock_guard{mutex_};
   for (const auto& baggage_item : baggage_) {
     if (!f(baggage_item.first, baggage_item.second)) {
       return;
     }
   }
 }
+
+//------------------------------------------------------------------------------
+// sampled
+//------------------------------------------------------------------------------
+bool LightStepSpanContext::sampled() const noexcept {
+  std::lock_guard<std::mutex> lock_guard{mutex_};
+  return sampled_;
+}
+
+//------------------------------------------------------------------------------
+// set_sampled
+//------------------------------------------------------------------------------
+void LightStepSpanContext::set_sampled(bool sampled) noexcept {
+  std::lock_guard<std::mutex> lock_guard{mutex_};
+  sampled_ = sampled;
+}
 }  // namespace lightstep

src/lightstep_span_context.h

@@ -16,6 +16,10 @@ class LightStepSpanContext : public opentracing::SpanContext {
       uint64_t trace_id, uint64_t span_id,
       std::unordered_map<std::string, std::string>&& baggage) noexcept;
 
+  LightStepSpanContext(
+      uint64_t trace_id, uint64_t span_id, bool sampled,
+      std::unordered_map<std::string, std::string>&& baggage) noexcept;
+
   LightStepSpanContext(const LightStepSpanContext&) = delete;
   LightStepSpanContext(LightStepSpanContext&&) = delete;
 
@@ -36,27 +40,31 @@ class LightStepSpanContext : public opentracing::SpanContext {
   template <class Carrier>
   opentracing::expected<void> Inject(
       const PropagationOptions& propagation_options, Carrier& writer) const {
-    std::lock_guard<std::mutex> lock_guard{baggage_mutex_};
+    std::lock_guard<std::mutex> lock_guard{mutex_};
     return InjectSpanContext(propagation_options, writer, trace_id_, span_id_,
-                             baggage_);
+                             sampled_, baggage_);
   }
 
   template <class Carrier>
   opentracing::expected<bool> Extract(
       const PropagationOptions& propagation_options, Carrier& reader) {
-    std::lock_guard<std::mutex> lock_guard{baggage_mutex_};
+    std::lock_guard<std::mutex> lock_guard{mutex_};
     return ExtractSpanContext(propagation_options, reader, trace_id_, span_id_,
-                              baggage_);
+                              sampled_, baggage_);
   }
 
   uint64_t trace_id() const noexcept { return trace_id_; }
   uint64_t span_id() const noexcept { return span_id_; }
 
+  bool sampled() const noexcept;
+  void set_sampled(bool sampled) noexcept;
+
  private:
   uint64_t trace_id_ = 0;
   uint64_t span_id_ = 0;
 
-  mutable std::mutex baggage_mutex_;
+  mutable std::mutex mutex_;
+  bool sampled_ = true;
   std::unordered_map<std::string, std::string> baggage_;
 };
 }  // namespace lightstep