Add methods to Flush and Close a tracer (open-telemetry#45)

* Work on Flush-Close api

* Add Flush & Close

* Add flush and close interface

* Remove return type from Flush-Close

* Fix docs

api/include/opentelemetry/plugin/tracer.h

@@ -65,6 +65,16 @@ class Tracer final : public trace::Tracer, public std::enable_shared_from_this<T
                                               Span{this->shared_from_this(), std::move(span)}};
   }
 
+  void ForceFlushWithMicroseconds(uint64_t timeout) noexcept override
+  {
+    tracer_handle_->tracer().ForceFlushWithMicroseconds(timeout);
+  }
+
+  void CloseWithMicroseconds(uint64_t timeout) noexcept override
+  {
+    tracer_handle_->tracer().CloseWithMicroseconds(timeout);
+  }
+
 private:
   // Note: The order is important here.
   //

api/include/opentelemetry/trace/noop.h

@@ -54,6 +54,10 @@ class NoopTracer final : public Tracer, public std::enable_shared_from_this<Noop
   {
     return nostd::unique_ptr<Span>{new (std::nothrow) NoopSpan{this->shared_from_this()}};
   }
+
+  void ForceFlushWithMicroseconds(uint64_t /*timeout*/) noexcept override {}
+
+  void CloseWithMicroseconds(uint64_t /*timeout*/) noexcept override {}
 };
 
 /**

api/include/opentelemetry/trace/tracer.h

@@ -5,6 +5,8 @@
 #include "opentelemetry/trace/span.h"
 #include "opentelemetry/version.h"
 
+#include <chrono>
+
 OPENTELEMETRY_BEGIN_NAMESPACE
 namespace trace
 {
@@ -23,6 +25,32 @@ class Tracer
    */
   virtual nostd::unique_ptr<Span> StartSpan(nostd::string_view name,
                                             const StartSpanOptions &options = {}) noexcept = 0;
+
+  /**
+   * Force any buffered spans to flush.
+   * @param timeout to complete the flush
+   */
+  template <class Rep, class Period>
+  void ForceFlush(std::chrono::duration<Rep, Period> timeout) noexcept
+  {
+    this->ForceFlushWithMicroseconds(
+        static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::microseconds>(timeout)));
+  }
+
+  virtual void ForceFlushWithMicroseconds(uint64_t timeout) noexcept = 0;
+
+  /**
+   * ForceFlush any buffered spans and stop reporting spans.
+   * @param timeout to complete the flush
+   */
+  template <class Rep, class Period>
+  void Close(std::chrono::duration<Rep, Period> timeout) noexcept
+  {
+    this->CloseWithMicroseconds(
+        static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::microseconds>(timeout)));
+  }
+
+  virtual void CloseWithMicroseconds(uint64_t timeout) noexcept = 0;
 };
 }  // namespace trace
 OPENTELEMETRY_END_NAMESPACE

examples/plugin/plugin/tracer.h

@@ -14,4 +14,8 @@ class Tracer final : public opentelemetry::trace::Tracer,
   opentelemetry::nostd::unique_ptr<opentelemetry::trace::Span> StartSpan(
       opentelemetry::nostd::string_view name,
       const opentelemetry::trace::StartSpanOptions &options) noexcept override;
+
+  void ForceFlushWithMicroseconds(uint64_t /*timeout*/) noexcept override {}
+
+  void CloseWithMicroseconds(uint64_t /*timeout*/) noexcept override {}
 };

sdk/src/trace/tracer.cc

@@ -15,6 +15,16 @@ nostd::unique_ptr<trace_api::Span> Tracer::StartSpan(
   return nostd::unique_ptr<trace_api::Span>{new (std::nothrow)
                                                 Span{this->shared_from_this(), name, options}};
 }
+
+void Tracer::ForceFlushWithMicroseconds(uint64_t timeout) noexcept
+{
+  (void)timeout;
+}
+
+void Tracer::CloseWithMicroseconds(uint64_t timeout) noexcept
+{
+  (void)timeout;
+}
 }  // namespace trace
 }  // namespace sdk
 OPENTELEMETRY_END_NAMESPACE

sdk/src/trace/tracer.h

@@ -24,6 +24,10 @@ class Tracer final : public trace_api::Tracer, public std::enable_shared_from_th
       nostd::string_view name,
       const trace_api::StartSpanOptions &options = {}) noexcept override;
 
+  void ForceFlushWithMicroseconds(uint64_t timeout) noexcept override;
+
+  void CloseWithMicroseconds(uint64_t timeout) noexcept override;
+
 private:
   std::unique_ptr<Recorder> recorder_;
 };