Bring back SpanExporter::ExportForTesting. (#137)

- Make StdoutExporter take an ostream.

- Make stdout_exporter_test faster (no sleep) and check that
  the added annotation appears in the output.

Author: g-easy

opencensus/exporters/trace/stdout/internal/stdout_exporter.cc

@@ -25,23 +25,28 @@
 namespace opencensus {
 namespace exporters {
 namespace trace {
+namespace {
+
+class Handler : public ::opencensus::trace::exporter::SpanExporter::Handler {
+ public:
+  Handler(std::ostream* stream) : stream_(stream) {}
 
-class StdoutExporter::Handler
-    : public ::opencensus::trace::exporter::SpanExporter::Handler {
   void Export(const std::vector<::opencensus::trace::exporter::SpanData>& spans)
-      override;
+      override {
+    for (const auto& span : spans) {
+      *stream_ << span.DebugString() << "\n";
+    }
+  }
+
+ private:
+  std::ostream* stream_;
 };
 
-void StdoutExporter::Handler::Export(
-    const std::vector<::opencensus::trace::exporter::SpanData>& spans) {
-  for (const auto& span : spans) {
-    std::cout << span.DebugString() << "\n";
-  }
-}
+}  // namespace
 
-void StdoutExporter::Register() {
+void StdoutExporter::Register(std::ostream* stream) {
   ::opencensus::trace::exporter::SpanExporter::RegisterHandler(
-      absl::make_unique<Handler>());
+      absl::make_unique<Handler>(stream));
 }
 
 }  // namespace trace

opencensus/exporters/trace/stdout/internal/stdout_exporter_test.cc

@@ -14,36 +14,51 @@
 
 #include "opencensus/exporters/trace/stdout/stdout_exporter.h"
 
+#include <iostream>
+#include <sstream>
+
 #include "absl/time/clock.h"
+#include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include "opencensus/trace/exporter/span_exporter.h"
 #include "opencensus/trace/internal/local_span_store.h"
 #include "opencensus/trace/span.h"
 
 namespace opencensus {
-namespace exporters {
 namespace trace {
+namespace exporter {
+
+class SpanExporterTestPeer {
+ public:
+  static constexpr auto& ExportForTesting = SpanExporter::ExportForTesting;
+};
+
+}  // namespace exporter
+}  // namespace trace
+}  // namespace opencensus
+
 namespace {
 
-TEST(TraceExporterTest, ExportTrace) {
-  StdoutExporter::Register();
+using ::testing::HasSubstr;
+
+TEST(StdoutExporterTest, Export) {
+  std::stringstream s;
+  ::opencensus::exporters::trace::StdoutExporter::Register(&s);
   static ::opencensus::trace::AlwaysSampler sampler;
   ::opencensus::trace::StartSpanOptions opts = {&sampler};
 
   auto span1 = ::opencensus::trace::Span::StartSpan("Span1", nullptr, opts);
-  absl::SleepFor(absl::Milliseconds(100));
   auto span2 = ::opencensus::trace::Span::StartSpan("Span2", &span1, opts);
-  absl::SleepFor(absl::Milliseconds(200));
   auto span3 = ::opencensus::trace::Span::StartSpan("Span3", &span2, opts);
-  absl::SleepFor(absl::Milliseconds(300));
+  span3.AddAnnotation("Needle.");
   span3.End();
   span2.End();
   span1.End();
 
-  // Wait for exporter.
-  absl::SleepFor(absl::Milliseconds(5200));
+  opencensus::trace::exporter::SpanExporterTestPeer::ExportForTesting();
+  const std::string str = s.str();
+  std::cout << str;
+  EXPECT_THAT(str, HasSubstr("Needle."));
 }
 
 }  // namespace
-}  // namespace trace
-}  // namespace exporters
-}  // namespace opencensus

opencensus/exporters/trace/stdout/stdout_exporter.h

@@ -15,16 +15,16 @@
 #ifndef OPENCENSUS_EXPORTERS_TRACE_STDOUT_STDOUT_EXPORTER_H_
 #define OPENCENSUS_EXPORTERS_TRACE_STDOUT_STDOUT_EXPORTER_H_
 
+#include <iostream>
+
 namespace opencensus {
 namespace exporters {
 namespace trace {
 
 class StdoutExporter {
  public:
-  static void Register();
-
- private:
-  class Handler;
+  StdoutExporter() = delete;
+  static void Register(std::ostream* stream = &std::cout);
 };
 
 }  // namespace trace

opencensus/trace/exporter/span_exporter.h

@@ -24,13 +24,11 @@ namespace opencensus {
 namespace trace {
 namespace exporter {
 
-class SpanExporterImpl;
-
-// SpanExporter tracks Exporters. Thread-safe.
+// SpanExporter allows Exporters to register. Thread-safe.
 class SpanExporter final {
  public:
   // Handlers allow different tracing services to export recorded data for
-  // sampled spans in their own format. The exporter should provide a static
+  // sampled spans in their own format. Every exporter must provide a static
   // Register() method that takes any arguments needed by the exporter (e.g. a
   // URL to export to) and calls SpanExporter::RegisterHandler itself.
   class Handler {
@@ -41,6 +39,12 @@ class SpanExporter final {
 
   // This should only be called by Handler's Register() method.
   static void RegisterHandler(std::unique_ptr<Handler> handler);
+
+ private:
+  friend class SpanExporterTestPeer;
+
+  // Forces an export, only for testing purposes.
+  static void ExportForTesting();
 };
 
 }  // namespace exporter

opencensus/trace/internal/span_exporter.cc

@@ -23,10 +23,16 @@ namespace opencensus {
 namespace trace {
 namespace exporter {
 
+// static
 void SpanExporter::RegisterHandler(std::unique_ptr<Handler> handler) {
   SpanExporterImpl::Get()->RegisterHandler(std::move(handler));
 }
 
+// static
+void SpanExporter::ExportForTesting() {
+  SpanExporterImpl::Get()->ExportForTesting();
+}
+
 }  // namespace exporter
 }  // namespace trace
 }  // namespace opencensus

opencensus/trace/internal/span_exporter_impl.cc

@@ -64,7 +64,7 @@ bool SpanExporterImpl::IsBufferFull() const {
 
 void SpanExporterImpl::RunWorkerLoop() {
   std::vector<opencensus::trace::exporter::SpanData> span_data_;
-  std::vector<std::shared_ptr<opencensus::trace::SpanImpl>> spans_copy_;
+  std::vector<std::shared_ptr<opencensus::trace::SpanImpl>> batch_;
   // Thread loops forever.
   // TODO: Add in shutdown mechanism.
   absl::Time next_forced_export_time = absl::Now() + interval_;
@@ -79,13 +79,13 @@ void SpanExporterImpl::RunWorkerLoop() {
       if (spans_.empty()) {
         continue;
       }
-      std::swap(spans_copy_, spans_);
+      std::swap(batch_, spans_);
     }
-    for (const auto& span : spans_copy_) {
+    for (const auto& span : batch_) {
       span_data_.emplace_back(span->ToSpanData());
     }
+    batch_.clear();
     Export(span_data_);
-    spans_copy_.clear();
     span_data_.clear();
   }
 }
@@ -98,6 +98,19 @@ void SpanExporterImpl::Export(const std::vector<SpanData>& span_data) {
   }
 }
 
+void SpanExporterImpl::ExportForTesting() {
+  std::vector<opencensus::trace::exporter::SpanData> span_data_;
+  std::vector<std::shared_ptr<opencensus::trace::SpanImpl>> batch_;
+  {
+    absl::MutexLock l(&span_mu_);
+    std::swap(batch_, spans_);
+  }
+  for (const auto& span : batch_) {
+    span_data_.emplace_back(span->ToSpanData());
+  }
+  Export(span_data_);
+}
+
 }  // namespace exporter
 }  // namespace trace
 }  // namespace opencensus

opencensus/trace/internal/span_exporter_impl.h

@@ -49,6 +49,7 @@ class SpanExporterImpl {
   // SpanData will take place at a later time via the background thread. This
   // is intended to be called at the Span::End().
   void AddSpan(const std::shared_ptr<opencensus::trace::SpanImpl>& span_impl);
+
   // Registers a handler with the exporter. This is intended to be done at
   // initialization.
   void RegisterHandler(std::unique_ptr<SpanExporter::Handler> handler);
@@ -63,13 +64,16 @@ class SpanExporterImpl {
   SpanExporterImpl& operator=(const SpanExporterImpl&) = delete;
   SpanExporterImpl& operator=(SpanExporterImpl&&) = delete;
   friend class Span;
+  friend class SpanExporter;  // For ExportForTesting() only.
 
   void StartExportThread() EXCLUSIVE_LOCKS_REQUIRED(handler_mu_);
   void RunWorkerLoop();
 
   // Calls all registered handlers and exports the spans contained in span_data.
   void Export(const std::vector<SpanData>& span_data);
 
+  // Only for testing purposes: runs the export on the current thread and
+  // returns when complete.
   void ExportForTesting();
 
   // Returns true if the spans_ buffer has filled up.