apply propagated skip-analysis status to segment context and span creation (#48)

* apply propagated sampling status to segment context and span creation

* improve test

* always sampling

* always sampling and introduce skipanalysis

Author: Shikugawa

README.md

@@ -107,8 +107,7 @@ to avoid undefined behavior.
 SegmentContextPtr current_segment = createSegmentContext(config);
 CurrentSegmentSpanPtr current_span = current_segment->createCurrentSegmentRootSpan();
 
-current_span->startSpan();
-current_span->setOperationName("sample_workload");
+current_span->startSpan("sample_workload");
 current_span->endSpan();
 
 tracer->sendSegment(std::move(current_segment));

cpp2sky/propagation.h

@@ -27,7 +27,7 @@ class SpanContext {
    * Get the status of sample on SKyWalking.
    * It indicates whether current context should send or not.
    */
-  virtual bool mustSend() const = 0;
+  virtual bool sample() const = 0;
 
   /**
    * Get parent's trace ID. This value must be unique globally.

cpp2sky/segment_context.h

@@ -34,12 +34,6 @@ class CurrentSegmentSpan {
    */
   virtual SpanObject createSpanObject() = 0;
 
-  /**
-   * Get sampling status. If true, spans belongs to this segment will be sent to
-   * OAP.
-   */
-  virtual bool samplingStatus() const = 0;
-
   /**
    * Get span ID.
    */
@@ -114,9 +108,11 @@ class CurrentSegmentSpan {
   /**
    * Set start time to calculate execution time.
    */
-  virtual void startSpan() = 0;
-  virtual void startSpan(TimePoint<SystemTime> current_time) = 0;
-  virtual void startSpan(TimePoint<SteadyTime> current_time) = 0;
+  virtual void startSpan(std::string operation_name) = 0;
+  virtual void startSpan(std::string operation_name,
+                         TimePoint<SystemTime> current_time) = 0;
+  virtual void startSpan(std::string operation_name,
+                         TimePoint<SteadyTime> current_time) = 0;
 
   /**
    * Set end time to calculate execution time.
@@ -125,16 +121,6 @@ class CurrentSegmentSpan {
   virtual void endSpan(TimePoint<SystemTime> current_time) = 0;
   virtual void endSpan(TimePoint<SteadyTime> current_time) = 0;
 
-  /**
-   * Set operation name for this span (lvalue)
-   */
-  virtual void setOperationName(const std::string& operation_name) = 0;
-
-  /**
-   * Set operation name for this span (rvalue)
-   */
-  virtual void setOperationName(std::string&& operation_name) = 0;
-
   /**
    * Set peer address for this span (lvalue)
    */
@@ -160,31 +146,27 @@ class CurrentSegmentSpan {
   /**
    * If error had caused on this span, This should be called.
    */
-  virtual void errorOccured() = 0;
+  virtual void setErrorStatus() = 0;
 
   /**
    * Determine whether to skip the analysis of this span. If we'd like to skip
    * analysis, this should be called.
    */
-  virtual void skipAnalysis() = 0;
-
-  /**
-   * Set tag to current span. (lvalue)
-   */
-  virtual void addTag(const std::string& key, const std::string& value) = 0;
+  virtual void setSkipAnalysis() = 0;
 
   /**
-   * Set tag to current span. (rvalue)
+   * Set tag to current span.
    */
-  virtual void addTag(std::string&& key, std::string&& value) = 0;
+  virtual void addTag(std::string key, std::string value) = 0;
 
   /**
    * Add log related with current span.
-   * @param set_time To determine whether to set actual time or not.
-   * This value is introduced for unit-test.
    */
-  virtual void addLog(const std::string& key, const std::string& value,
-                      bool set_time = true) = 0;
+  virtual void addLog(std::string key, std::string value) = 0;
+  virtual void addLog(std::string key, std::string value,
+                      TimePoint<SystemTime> current_time) = 0;
+  virtual void addLog(std::string key, std::string value,
+                      TimePoint<SteadyTime> current_time) = 0;
 
   /**
    * Set component ID.
@@ -195,11 +177,6 @@ class CurrentSegmentSpan {
    * This span had finished or not.
    */
   virtual bool finished() const = 0;
-
-  /**
-   * Change sampling status. If true, it will be sampled.
-   */
-  virtual void setSamplingStatus(bool do_sample) = 0;
 };
 
 using CurrentSegmentSpanPtr = std::shared_ptr<CurrentSegmentSpan>;
@@ -259,21 +236,32 @@ class SegmentContext {
    * Generate sw8 value to send SegmentRef.
    * @param parent Parent span that belongs to current segment.
    * @param target_address Target address to send request. For more detail:
-   * @param sample If false, it means this trace shouldn't need to be sampled
-   * and send to backend.
    * https://github.com/apache/skywalking-data-collect-protocol/blob/master/language-agent/Tracing.proto#L97-L101
    */
+  virtual std::string createSW8HeaderValue(
+      CurrentSegmentSpanPtr parent, const std::string& target_address) = 0;
   virtual std::string createSW8HeaderValue(CurrentSegmentSpanPtr parent,
-                                           std::string& target_address,
-                                           bool sample = true) = 0;
-  virtual std::string createSW8HeaderValue(CurrentSegmentSpanPtr parent,
-                                           std::string&& target_address,
-                                           bool sample = true) = 0;
+                                           std::string&& target_address) = 0;
+  // If you don't specify parent span, stored to current segment, it will be
+  // selected newest span as parent span.
+  virtual std::string createSW8HeaderValue(
+      const std::string& target_address) = 0;
+  virtual std::string createSW8HeaderValue(std::string&& target_address) = 0;
 
   /**
    * Generate Apache SkyWalking native segment object.
    */
   virtual SegmentObject createSegmentObject() = 0;
+
+  /**
+   * If called, all spans belongs to this segment will be skipped analysis.
+   */
+  virtual void setSkipAnalysis() = 0;
+
+  /**
+   * Whether belonging span can be skipped analysis or not.
+   */
+  virtual bool skipAnalysis() = 0;
 };
 
 using SegmentContextPtr = std::shared_ptr<SegmentContext>;

example/sample.cc

@@ -47,8 +47,7 @@ int main() {
     auto current_span = current_segment->createCurrentSegmentRootSpan();
 
     // 4. Set info
-    current_span->startSpan();
-    current_span->setOperationName("/ping");
+    current_span->startSpan("/ping");
     current_span->endSpan();
 
     // 5. Send span data

example/sample_client.cc

@@ -45,8 +45,7 @@ int main() {
   auto current_span = current_segment->createCurrentSegmentRootSpan();
 
   // 4. Set info
-  current_span->startSpan();
-  current_span->setOperationName("/ping");
+  current_span->startSpan("/ping");
 
   httplib::Client cli("remote", 8082);
   httplib::Headers headers = {

source/propagation_impl.cc

@@ -61,7 +61,8 @@ SpanContextImpl::SpanContextImpl(std::string_view header_value) {
         "Invalid span context format. sample field must be 0 or 1.");
   }
 
-  must_send_ = fields[0] == "1" ? true : false;
+  // Sampling is always true
+  sample_ = true;
   trace_id_ = Base64::decodeWithoutPadding(std::string_view(fields[1]));
   trace_segment_id_ = Base64::decodeWithoutPadding(std::string_view(fields[2]));
   span_id_ = std::stoi(fields[3]);

source/propagation_impl.h

@@ -26,7 +26,7 @@ class SpanContextImpl : public SpanContext {
  public:
   SpanContextImpl(std::string_view header_value);
 
-  bool mustSend() const override { return must_send_; }
+  bool sample() const override { return sample_; }
   const std::string& traceId() const override { return trace_id_; }
   const std::string& traceSegmentId() const override {
     return trace_segment_id_;
@@ -42,7 +42,7 @@ class SpanContextImpl : public SpanContext {
  private:
   // Based on
   // https://github.com/apache/skywalking/blob/master/docs/en/protocols/Skywalking-Cross-Process-Propagation-Headers-Protocol-v3.md
-  bool must_send_ = false;
+  bool sample_ = true;
   std::string trace_id_;
   std::string trace_segment_id_;
   int32_t span_id_;

source/segment_context_impl.cc

@@ -16,6 +16,7 @@
 
 #include <string>
 
+#include "cpp2sky/exception.h"
 #include "cpp2sky/time.h"
 #include "language-agent/Tracing.pb.h"
 #include "source/utils/base64.h"
@@ -40,6 +41,7 @@ SpanObject CurrentSegmentSpanImpl::createSpanObject() {
   obj.set_componentid(component_id_);
   obj.set_iserror(is_error_);
   obj.set_peer(peer_);
+  obj.set_skipanalysis(skip_analysis_);
 
   auto parent_span = parent_segment_context_.parentSpanContext();
   // Inject request parent to the current segment.
@@ -68,39 +70,51 @@ SpanObject CurrentSegmentSpanImpl::createSpanObject() {
     *entry = log;
   }
 
-  if (parent_segment_context_.parentSpanContextExtension() != nullptr) {
-    if (parent_segment_context_.parentSpanContextExtension()->tracingMode() ==
-        TracingMode::Skip) {
-      obj.set_skipanalysis(true);
-    }
-  }
   return obj;
 }
 
-void CurrentSegmentSpanImpl::addLog(const std::string& key,
-                                    const std::string& value, bool set_time) {
+void CurrentSegmentSpanImpl::addLog(std::string key, std::string value) {
+  assert(!finished_);
+  auto now = TimePoint<SystemTime>();
+  addLog(key, value, now);
+}
+
+void CurrentSegmentSpanImpl::addLog(std::string key, std::string value,
+                                    TimePoint<SystemTime> current_time) {
   assert(!finished_);
   Log l;
-  if (set_time) {
-    // SystemTimePoint now = SystemTime::now();
-    // l.set_time(millisecondsFromEpoch(now));
-  }
+  l.set_time(current_time.fetch());
   auto* entry = l.add_data();
   entry->set_key(key);
   entry->set_value(value);
   logs_.emplace_back(l);
 }
 
-void CurrentSegmentSpanImpl::startSpan() {
+void CurrentSegmentSpanImpl::addLog(std::string key, std::string value,
+                                    TimePoint<SteadyTime> current_time) {
+  assert(!finished_);
+  Log l;
+  l.set_time(current_time.fetch());
+  auto* entry = l.add_data();
+  entry->set_key(key);
+  entry->set_value(value);
+  logs_.emplace_back(l);
+}
+
+void CurrentSegmentSpanImpl::startSpan(std::string operation_name) {
   auto now = TimePoint<SystemTime>();
-  startSpan(now);
+  startSpan(operation_name, now);
 }
 
-void CurrentSegmentSpanImpl::startSpan(TimePoint<SystemTime> current_time) {
+void CurrentSegmentSpanImpl::startSpan(std::string operation_name,
+                                       TimePoint<SystemTime> current_time) {
+  operation_name_ = operation_name;
   start_time_ = current_time.fetch();
 }
 
-void CurrentSegmentSpanImpl::startSpan(TimePoint<SteadyTime> current_time) {
+void CurrentSegmentSpanImpl::startSpan(std::string operation_name,
+                                       TimePoint<SteadyTime> current_time) {
+  operation_name_ = operation_name;
   start_time_ = current_time.fetch();
 }
 
@@ -170,6 +184,10 @@ CurrentSegmentSpanPtr SegmentContextImpl::createCurrentSegmentSpan(
   }
   // It supports only HTTP request tracing.
   current_span->setSpanLayer(SpanLayer::Http);
+  if (should_skip_analysis_) {
+    current_span->setSkipAnalysis();
+  }
+
   spans_.push_back(current_span);
   return current_span;
 }
@@ -180,16 +198,33 @@ CurrentSegmentSpanPtr SegmentContextImpl::createCurrentSegmentRootSpan() {
 }
 
 std::string SegmentContextImpl::createSW8HeaderValue(
-    CurrentSegmentSpanPtr parent_span, std::string& target_address,
-    bool sample) {
-  std::string header_value;
+    CurrentSegmentSpanPtr parent_span, const std::string& target_address) {
   if (parent_span == nullptr) {
-    return header_value;
+    if (spans_.empty()) {
+      throw TracerException(
+          "Can't create propagation header because current segment has no "
+          "valid span.");
+    }
+    return encodeSpan(spans_.back(), target_address);
   }
+  return encodeSpan(parent_span, target_address);
+}
+
+std::string SegmentContextImpl::createSW8HeaderValue(
+    CurrentSegmentSpanPtr parent_span, std::string&& target_address) {
+  return createSW8HeaderValue(parent_span, target_address);
+}
+
+std::string SegmentContextImpl::encodeSpan(CurrentSegmentSpanPtr parent_span,
+                                           const std::string& target_address) {
+  assert(parent_span);
+  std::string header_value;
+
   auto parent_spanid = std::to_string(parent_span->spanId());
   auto endpoint = spans_.front()->operationName();
 
-  header_value += sample ? "1-" : "0-";
+  // always send to OAP
+  header_value += "1-";
   header_value += Base64::encode(trace_id_) + "-";
   header_value += Base64::encode(trace_segment_id_) + "-";
   header_value += parent_spanid + "-";
@@ -201,12 +236,6 @@ std::string SegmentContextImpl::createSW8HeaderValue(
   return header_value;
 }
 
-std::string SegmentContextImpl::createSW8HeaderValue(
-    CurrentSegmentSpanPtr parent_span, std::string&& target_address,
-    bool sample) {
-  return createSW8HeaderValue(parent_span, target_address, sample);
-}
-
 SegmentObject SegmentContextImpl::createSegmentObject() {
   SegmentObject obj;
   obj.set_traceid(trace_id_);
@@ -226,9 +255,8 @@ SegmentContextFactoryImpl::SegmentContextFactoryImpl(const TracerConfig& cfg)
     : service_name_(cfg.service_name()), instance_name_(cfg.instance_name()) {}
 
 SegmentContextPtr SegmentContextFactoryImpl::create() {
-  auto context = std::make_unique<SegmentContextImpl>(
-      service_name_, instance_name_, random_generator_);
-  return context;
+  return std::make_unique<SegmentContextImpl>(service_name_, instance_name_,
+                                              random_generator_);
 }
 
 SegmentContextPtr SegmentContextFactoryImpl::create(
@@ -239,9 +267,13 @@ SegmentContextPtr SegmentContextFactoryImpl::create(
 
 SegmentContextPtr SegmentContextFactoryImpl::create(
     SpanContextPtr span_context, SpanContextExtensionPtr ext_span_context) {
-  return std::make_unique<SegmentContextImpl>(service_name_, instance_name_,
-                                              span_context, ext_span_context,
-                                              random_generator_);
+  auto context = std::make_unique<SegmentContextImpl>(
+      service_name_, instance_name_, span_context, ext_span_context,
+      random_generator_);
+  if (ext_span_context->tracingMode() == TracingMode::Skip) {
+    context->setSkipAnalysis();
+  }
+  return context;
 }
 
 }  // namespace cpp2sky