Merge branch 'jaeger-propagator' of github.com:seemk/opentelemetry-cp…

…p into jaeger-propagator

docs/public/conf.py

@@ -44,8 +44,15 @@
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
+ "breathe",
 ]
 
+breathe_projects = {
+ "OpenTelemetry C++ API": "../../api/docs/doxyoutput/xml"
+}
+
+breathe_default_project = "OpenTelemetry C++ API"
+
 primary_domain = "cpp"
 
 higlight_language = "cpp"

exporters/zipkin/src/recordable.cc

@@ -191,7 +191,8 @@ void Recordable::SetName(nostd::string_view name) noexcept
 
 void Recordable::SetStartTime(opentelemetry::core::SystemTimestamp start_time) noexcept
 {
- span_["timestamp"] = start_time.time_since_epoch().count();
+ span_["timestamp"] =
+ std::chrono::duration_cast<std::chrono::microseconds>(start_time.time_since_epoch()).count();
 }
 
 void Recordable::SetDuration(std::chrono::nanoseconds duration) noexcept

sdk/include/opentelemetry/sdk/trace/sampler.h

@@ -5,6 +5,7 @@
 #include "opentelemetry/trace/span_context.h"
 #include "opentelemetry/trace/span_context_kv_iterable.h"
 #include "opentelemetry/trace/trace_id.h"
+#include "opentelemetry/trace/trace_state.h"
 #include "opentelemetry/version.h"
 
 #include <map>
@@ -41,6 +42,8 @@ struct SamplingResult
  Decision decision;
  // A set of span Attributes that will also be added to the Span. Can be nullptr.
  std::unique_ptr<const std::map<std::string, opentelemetry::common::AttributeValue>> attributes;
+ // The tracestate used by the span.
+ nostd::shared_ptr<opentelemetry::trace::TraceState> trace_state;
 };
 
 /**
@@ -61,7 +64,7 @@ class Sampler
  * @param name the name of the new Span.
  * @param spanKind the trace_api::SpanKind of the Span.
  * @param attributes list of AttributeValue with their keys.
- * @param links TODO: Collection of links that will be associated with the Span to be created.
+ * @param links Collection of links that will be associated with the Span to be created.
  * @return sampling result whether span should be sampled or not.
  * @since 0.1.0
  */

sdk/include/opentelemetry/sdk/trace/samplers/always_off.h

@@ -20,14 +20,21 @@ class AlwaysOffSampler : public Sampler
  * @return Returns DROP always
  */
  SamplingResult ShouldSample(
- const trace_api::SpanContext & /*parent_context*/,
+ const trace_api::SpanContext &parent_context,
  trace_api::TraceId /*trace_id*/,
  nostd::string_view /*name*/,
  trace_api::SpanKind /*span_kind*/,
  const opentelemetry::common::KeyValueIterable & /*attributes*/,
  const trace_api::SpanContextKeyValueIterable & /*links*/) noexcept override
  {
- return {Decision::DROP, nullptr};
+ if (!parent_context.IsValid())
+ {
+ return {Decision::DROP, nullptr, opentelemetry::trace::TraceState::GetDefault()};
+ }
+ else
+ {
+ return {Decision::DROP, nullptr, parent_context.trace_state()};
+ }
  }
 
  /**

sdk/include/opentelemetry/sdk/trace/samplers/always_on.h

@@ -19,14 +19,21 @@ class AlwaysOnSampler : public Sampler
  * @return Always return Decision RECORD_AND_SAMPLE
  */
  inline SamplingResult ShouldSample(
- const trace_api::SpanContext & /*parent_context*/,
+ const trace_api::SpanContext &parent_context,
  trace_api::TraceId /*trace_id*/,
  nostd::string_view /*name*/,
  trace_api::SpanKind /*span_kind*/,
  const opentelemetry::common::KeyValueIterable & /*attributes*/,
  const trace_api::SpanContextKeyValueIterable & /*links*/) noexcept override
  {
- return {Decision::RECORD_AND_SAMPLE, nullptr};
+ if (!parent_context.IsValid())
+ {
+ return {Decision::RECORD_AND_SAMPLE, nullptr, opentelemetry::trace::TraceState::GetDefault()};
+ }
+ else
+ {
+ return {Decision::RECORD_AND_SAMPLE, nullptr, parent_context.trace_state()};
+ }
  }
 
  /**

sdk/src/trace/samplers/parent.cc

@@ -28,10 +28,10 @@ SamplingResult ParentBasedSampler::ShouldSample(
  // If parent exists:
  if (parent_context.IsSampled())
  {
- return {Decision::RECORD_AND_SAMPLE, nullptr};
+ return {Decision::RECORD_AND_SAMPLE, nullptr, parent_context.trace_state()};
  }
 
- return {Decision::DROP, nullptr};
+ return {Decision::DROP, nullptr, parent_context.trace_state()};
 }
 
 nostd::string_view ParentBasedSampler::GetDescription() const noexcept

sdk/src/trace/span.cc

@@ -64,7 +64,9 @@ Span::Span(std::shared_ptr<Tracer> &&tracer,
  const trace_api::SpanContextKeyValueIterable &links,
  const trace_api::StartSpanOptions &options,
  const trace_api::SpanContext &parent_span_context,
- const opentelemetry::sdk::resource::Resource &resource) noexcept
+ const opentelemetry::sdk::resource::Resource &resource,
+ const nostd::shared_ptr<opentelemetry::trace::TraceState> trace_state,
+ const bool sampled) noexcept
  : tracer_{std::move(tracer)},
  processor_{processor},
  recordable_{processor_->MakeRecordable()},
@@ -93,10 +95,13 @@ Span::Span(std::shared_ptr<Tracer> &&tracer,
  recordable_->SetIds(trace_id, span_id, trace_api::SpanId());
  }
 
- span_context_ = std::unique_ptr<trace_api::SpanContext>(
- new trace_api::SpanContext(trace_id, span_id, trace_api::TraceFlags(), false,
- is_parent_span_valid ? parent_span_context.trace_state()
- : trace_api::TraceState::GetDefault()));
+ span_context_ = std::unique_ptr<trace_api::SpanContext>(new trace_api::SpanContext(
+ trace_id, span_id,
+ sampled ? trace_api::TraceFlags{trace_api::TraceFlags::kIsSampled} : trace_api::TraceFlags{},
+ false,
+ trace_state ? trace_state
+ : is_parent_span_valid ? parent_span_context.trace_state()
+ : trace_api::TraceState::GetDefault()));
 
  attributes.ForEachKeyValue(
  [&](nostd::string_view key, opentelemetry::common::AttributeValue value) noexcept {

sdk/src/trace/span.h

@@ -15,14 +15,17 @@ namespace trace_api = opentelemetry::trace;
 class Span final : public trace_api::Span
 {
 public:
- explicit Span(std::shared_ptr<Tracer> &&tracer,
- std::shared_ptr<SpanProcessor> processor,
- nostd::string_view name,
- const opentelemetry::common::KeyValueIterable &attributes,
- const trace_api::SpanContextKeyValueIterable &links,
- const trace_api::StartSpanOptions &options,
- const trace_api::SpanContext &parent_span_context,
- const opentelemetry::sdk::resource::Resource &resource) noexcept;
+ Span(std::shared_ptr<Tracer> &&tracer,
+ std::shared_ptr<SpanProcessor> processor,
+ nostd::string_view name,
+ const opentelemetry::common::KeyValueIterable &attributes,
+ const trace_api::SpanContextKeyValueIterable &links,
+ const trace_api::StartSpanOptions &options,
+ const trace_api::SpanContext &parent_span_context,
+ const opentelemetry::sdk::resource::Resource &resource,
+ const nostd::shared_ptr<opentelemetry::trace::TraceState> trace_state =
+ trace_api::TraceState::GetDefault(),
+ const bool sampled = false) noexcept;
 
  ~Span() override;
 

sdk/src/trace/tracer.cc

@@ -73,9 +73,9 @@ nostd::shared_ptr<trace_api::Span> Tracer::StartSpan(
  }
  else
  {
- auto span = nostd::shared_ptr<trace_api::Span>{
- new (std::nothrow) Span{this->shared_from_this(), processor_.load(), name, attributes,
-  links, options, parent, resource_}};
+ auto span = nostd::shared_ptr<trace_api::Span>{new (std::nothrow) Span{
+ this->shared_from_this(), processor_.load(), name, attributes, links, options, parent,
+ resource_, sampling_result.trace_state, true}};
 
  // if the attributes is not nullptr, add attributes to the span.
  if (sampling_result.attributes)

sdk/test/trace/always_off_sampler_test.cc

@@ -27,6 +27,7 @@ TEST(AlwaysOffSampler, ShouldSample)
 
  ASSERT_EQ(Decision::DROP, sampling_result.decision);
  ASSERT_EQ(nullptr, sampling_result.attributes);
+ ASSERT_EQ("", sampling_result.trace_state->ToHeader());
 }
 
 TEST(AlwaysOffSampler, GetDescription)

sdk/test/trace/always_on_sampler_test.cc

@@ -34,6 +34,7 @@ TEST(AlwaysOnSampler, ShouldSample)
 
  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
  ASSERT_EQ(nullptr, sampling_result.attributes);
+ ASSERT_EQ("", sampling_result.trace_state->ToHeader());
 
  // Test with a valid trace id and empty parent context
  sampling_result = sampler.ShouldSample(
@@ -44,6 +45,7 @@ TEST(AlwaysOnSampler, ShouldSample)
 
  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result.decision);
  ASSERT_EQ(nullptr, sampling_result.attributes);
+ ASSERT_EQ("", sampling_result.trace_state->ToHeader());
 }
 
 TEST(AlwaysOnSampler, GetDescription)

sdk/test/trace/parent_sampler_test.cc

@@ -31,9 +31,11 @@ TEST(ParentBasedSampler, ShouldSample)
 
  opentelemetry::common::KeyValueIterableView<M> view{m1};
  trace_api::SpanContextKeyValueIterableView<L> links{l1};
- trace_api::SpanContext parent_context_sampled(trace_id, span_id, trace_api::TraceFlags{1}, false);
+ auto trace_state = opentelemetry::trace::TraceState::FromHeader("congo=t61rcWkgMzE");
+ trace_api::SpanContext parent_context_sampled(trace_id, span_id, trace_api::TraceFlags{1}, false,
+ trace_state);
  trace_api::SpanContext parent_context_nonsampled(trace_id, span_id, trace_api::TraceFlags{0},
- false);
+ false, trace_state);
 
  // Case 1: Parent doesn't exist. Return result of delegateSampler()
  auto sampling_result = sampler_off.ShouldSample(trace_api::SpanContext::GetInvalid(), trace_id,
@@ -43,16 +45,20 @@ TEST(ParentBasedSampler, ShouldSample)
 
  ASSERT_EQ(Decision::DROP, sampling_result.decision);
  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result2.decision);
+ ASSERT_EQ("", sampling_result.trace_state->ToHeader());
+ ASSERT_EQ("", sampling_result2.trace_state->ToHeader());
 
  // Case 2: Parent exists and SampledFlag is true
  auto sampling_result3 =
  sampler_off.ShouldSample(parent_context_sampled, trace_id, "", span_kind, view, links);
  ASSERT_EQ(Decision::RECORD_AND_SAMPLE, sampling_result3.decision);
+ ASSERT_EQ("congo=t61rcWkgMzE", sampling_result3.trace_state->ToHeader());
 
  // Case 3: Parent exists and SampledFlag is false
  auto sampling_result4 =
  sampler_on.ShouldSample(parent_context_nonsampled, trace_id, "", span_kind, view, links);
  ASSERT_EQ(Decision::DROP, sampling_result4.decision);
+ ASSERT_EQ("congo=t61rcWkgMzE", sampling_result4.trace_state->ToHeader());
 }
 
 TEST(ParentBasedSampler, GetDescription)

sdk/test/trace/tracer_test.cc

@@ -19,6 +19,7 @@ using opentelemetry::common::KeyValueIterableView;
 using opentelemetry::exporter::memory::InMemorySpanData;
 using opentelemetry::exporter::memory::InMemorySpanExporter;
 using opentelemetry::trace::SpanContext;
+using opentelemetry::trace::TraceFlags;
 
 /**
  * A mock sampler that returns non-empty sampling results attributes.
@@ -563,3 +564,51 @@ TEST(Tracer, ExpectParent)
  EXPECT_EQ(spandata_first->GetSpanId(), spandata_second->GetParentSpanId());
  EXPECT_EQ(spandata_second->GetSpanId(), spandata_third->GetParentSpanId());
 }
+
+TEST(Tracer, ExpectParentWithValidSpanContext)
+{
+ std::unique_ptr<InMemorySpanExporter> exporter(new InMemorySpanExporter());
+ std::shared_ptr<InMemorySpanData> span_data = exporter->GetData();
+ auto tracer = initTracer(std::move(exporter));
+ auto spans = span_data.get()->GetSpans();
+
+ ASSERT_EQ(0, spans.size());
+
+ // produce valid SpanContext with pseudo span and trace Id.
+ uint8_t span_id_buf[trace_api::SpanId::kSize] = {
+ 1,
+ };
+ trace_api::SpanId span_id{span_id_buf};
+ uint8_t trace_id_buf[trace_api::TraceId::kSize] = {
+ 2,
+ };
+ trace_api::TraceId trace_id{trace_id_buf};
+
+ trace_api::StartSpanOptions options;
+ options.parent = SpanContext(trace_id, span_id, TraceFlags{TraceFlags::kIsSampled}, true);
+
+ auto span_first = tracer->StartSpan("span 1", options);
+
+ EXPECT_EQ(span_first->GetContext().trace_flags().IsSampled(), true);
+
+ options.parent = span_first->GetContext();
+ auto span_second = tracer->StartSpan("span 2", options);
+ EXPECT_EQ(span_second->GetContext().trace_flags().IsSampled(), true);
+
+ options.parent = span_second->GetContext();
+ auto span_third = tracer->StartSpan("span 3", options);
+ EXPECT_EQ(span_third->GetContext().trace_flags().IsSampled(), true);
+
+ span_third->End();
+ span_second->End();
+ span_first->End();
+
+ spans = span_data->GetSpans();
+ ASSERT_EQ(3, spans.size());
+ auto spandata_first = std::move(spans.at(2));
+ auto spandata_second = std::move(spans.at(1));
+ auto spandata_third = std::move(spans.at(0));
+
+ EXPECT_EQ(spandata_first->GetSpanId(), spandata_second->GetParentSpanId());
+ EXPECT_EQ(spandata_second->GetSpanId(), spandata_third->GetParentSpanId());
+}