Remove record_events from public API for now. (#78)

This is in preparation for changing how SpanStores work.

Author: g-easy

opencensus/trace/examples/span_example.cc

@@ -51,13 +51,6 @@ TEST(SpanExample, AlwaysSample) {
   span.End();
 }
 
-TEST(SpanExample, RecordEvents) {
-  auto span = ::opencensus::trace::Span::StartSpan(
-      "MyRootSpan", /*parent=*/nullptr,
-      {/*sampler=*/nullptr, /*record_events=*/true});
-  span.End();
-}
-
 void PretendCallback(::opencensus::trace::Span&& s) {
   s.AddAnnotation("Performing work.");
   s.End();

opencensus/trace/internal/local_span_store_test.cc

@@ -34,8 +34,8 @@ namespace {
 
 TEST(LocalSpanStoreTest, GetSummary) {
   exporter::LocalSpanStoreImplTestPeer::ClearForTesting();
-  auto span = Span::StartSpan("SpanName", /*parent=*/nullptr,
-                              {nullptr, /*record_events=*/true});
+  static AlwaysSampler sampler;
+  auto span = Span::StartSpan("SpanName", /*parent=*/nullptr, {&sampler});
   span.AddAnnotation("Annotation");
   span.End();
 

opencensus/trace/internal/span.cc

@@ -93,8 +93,8 @@ class SpanGenerator {
     }
     SpanContext context(trace_id, span_id, trace_options);
     SpanImpl* impl = nullptr;
-    if (trace_options.IsSampled() || options.record_events) {
-      // Only Spans that are recording are backed by a SpanImpl.
+    if (trace_options.IsSampled()) {
+      // Only Spans that are sampled are backed by a SpanImpl.
       impl =
           new SpanImpl(context, TraceConfigImpl::Get()->current_trace_params(),
                        name, parent_span_id, has_remote_parent);

opencensus/trace/internal/span_test.cc

@@ -46,24 +46,14 @@ class SpanTestPeer {
 
 namespace {
 
-constexpr bool kRecordEvents = true;
-
 TEST(SpanTest, SampledSpan) {
   AlwaysSampler sampler;
   auto span = Span::StartSpan("MySpan", /*parent=*/nullptr, {&sampler});
   EXPECT_TRUE(span.IsSampled());
   EXPECT_TRUE(span.IsRecording()) << "Sampled spans must be recording.";
 }
 
-TEST(SpanTest, RecordingButNotSampledSpan) {
-  NeverSampler sampler;
-  auto span =
-      Span::StartSpan("MySpan", /*parent=*/nullptr, {&sampler, kRecordEvents});
-  EXPECT_FALSE(span.IsSampled());
-  EXPECT_TRUE(span.IsRecording());
-}
-
-TEST(SpanTest, NotRecordingAndNotSampledSpan) {
+TEST(SpanTest, NotSampledSpan) {
   NeverSampler sampler;
   auto span = Span::StartSpan("MySpan", /*parent=*/nullptr, {&sampler});
   EXPECT_FALSE(span.IsSampled());
@@ -84,8 +74,8 @@ TEST(SpanTest, ChildInheritsSamplingFromParent) {
 }
 
 TEST(SpanTest, AddAttributesLastValueWins) {
-  auto span =
-      Span::StartSpan("SpanName", /*parent=*/nullptr, {nullptr, kRecordEvents});
+  AlwaysSampler sampler;
+  auto span = Span::StartSpan("SpanName", /*parent=*/nullptr, {&sampler});
   span.AddAttributes({{"key", "value1"},
                       {"key", 123},
                       {"another_key", "another_value"},
@@ -100,8 +90,8 @@ TEST(SpanTest, AddAttributesLastValueWins) {
 }
 
 TEST(SpanTest, AddAttributesWithArrayAndVector) {
-  auto span =
-      Span::StartSpan("SpanName", /*parent=*/nullptr, {nullptr, kRecordEvents});
+  AlwaysSampler sampler;
+  auto span = Span::StartSpan("SpanName", /*parent=*/nullptr, {&sampler});
   std::array<std::pair<absl::string_view, AttributeValueRef>, 3>
       attributes_array = {
           {{"str_key", "value1"}, {"int_key", 123}, {"bool_key", true}}};
@@ -119,8 +109,8 @@ TEST(SpanTest, AddAttributesWithArrayAndVector) {
 }
 
 TEST(SpanTest, AddAnnotationLastAttributeWins) {
-  auto span =
-      Span::StartSpan("SpanName", /*parent=*/nullptr, {nullptr, kRecordEvents});
+  AlwaysSampler sampler;
+  auto span = Span::StartSpan("SpanName", /*parent=*/nullptr, {&sampler});
   span.AddAnnotation("Annotation text.", {{"key", "value1"},
                                           {"key", 123},
                                           {"another_key", "another_value"},
@@ -144,13 +134,12 @@ TEST(SpanTest, AddAnnotationLastAttributeWins) {
 }
 
 TEST(SpanTest, ParentLinksFromOptions) {
-  auto parent0 =
-      Span::StartSpan("Parent0", /*parent=*/nullptr, {nullptr, kRecordEvents});
-  auto parent1 =
-      Span::StartSpan("Parent1", /*parent=*/nullptr, {nullptr, kRecordEvents});
-  auto span = Span::StartSpan("MyRootSpan",
-                              /*parent=*/nullptr,
-                              {nullptr, kRecordEvents, {&parent0, &parent1}});
+  AlwaysSampler sampler;
+  auto parent0 = Span::StartSpan("Parent0", /*parent=*/nullptr, {&sampler});
+  auto parent1 = Span::StartSpan("Parent1", /*parent=*/nullptr, {&sampler});
+  auto span =
+      Span::StartSpan("MyRootSpan",
+                      /*parent=*/nullptr, {&sampler, {&parent0, &parent1}});
   // Check that StartSpan added parent links to span.
   {
     auto data = SpanTestPeer::ToSpanData(&span);
@@ -185,7 +174,7 @@ TEST(SpanTest, FullSpanTest) {
   auto parent = Span::StartSpan("parent");
   auto related_span =
       Span::StartSpan("RelatedSpan", /*parent=*/nullptr, {&sampler});
-  StartSpanOptions opts = {&sampler, kRecordEvents, {&related_span}};
+  StartSpanOptions opts = {&sampler, {&related_span}};
   auto span = ::opencensus::trace::Span::StartSpan("MyRootSpan", &parent, opts);
   auto child = Span::StartSpan("child", &span);
 

opencensus/trace/span.h

@@ -50,13 +50,9 @@ using AttributesRef =
 
 // Options for Starting a Span.
 struct StartSpanOptions {
-  StartSpanOptions(
-      Sampler* sampler = nullptr,  // Default Sampler.
-      bool record_events = false,  // Only record events if the Span is sampled.
-      const std::vector<Span*>& parent_links = {})
-      : sampler(sampler),
-        record_events(record_events),
-        parent_links(parent_links) {}
+  StartSpanOptions(Sampler* sampler = nullptr,  // Default Sampler.
+                   const std::vector<Span*>& parent_links = {})
+      : sampler(sampler), parent_links(parent_links) {}
 
   // The Sampler to use. It must remain valid for the duration of the
   // StartSpan() call. If nullptr, use the default Sampler from TraceConfig.
@@ -65,11 +61,6 @@ struct StartSpanOptions {
   // All sampled Spans record events.
   const Sampler* sampler;
 
-  // This option can be used to request recording of events for non-sampled
-  // Spans. Spans that record events show up in the RunningSpanStore and
-  // LocalSpanStore in the running process.
-  const bool record_events;
-
   // Pointers to Spans in *other Traces* that are parents of this Span. They
   // must remain valid for the duration of the StartSpan() call.
   const std::vector<Span*> parent_links;