Ostream metric exporter

exporters/ostream/BUILD

@@ -43,8 +43,39 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "ostream_metric_exporter",
+    srcs = [
+        "src/metric_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/ostream/metric_exporter.h",
+    ],
+    strip_include_prefix = "include",
+    tags = [
+        "metrics",
+        "ostream",
+    ],
+    deps = [
+        "//sdk/src/metrics",
+    ],
+)
+
+cc_test(
+    name = "ostream_metric_test",
+    srcs = ["test/ostream_metric_test.cc"],
+    tags = [
+        "ostream",
+        "test",
+    ],
+    deps = [
+        ":ostream_metric_exporter",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
 cc_test(
-    name = "ostream_metrics_test",
+    name = "ostream_metrics_test_deprecated",
     srcs = ["test/ostream_metrics_test.cc"],
     tags = [
         "ostream",

exporters/ostream/include/opentelemetry/exporters/ostream/metric_exporter.h

@@ -0,0 +1,67 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifndef ENABLE_METRICS_PREVIEW
+
+#  include <iostream>
+#  include <string>
+#  include "opentelemetry/common/spin_lock_mutex.h"
+#  include "opentelemetry/nostd/span.h"
+#  include "opentelemetry/sdk/metrics/instruments.h"
+#  include "opentelemetry/sdk/metrics/metric_exporter.h"
+#  include "opentelemetry/sdk/metrics/recordable.h"
+#  include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+
+/**
+ * The OStreamMetricExporter exports record data through an ostream
+ */
+class OStreamMetricExporter final : public opentelemetry::sdk::metrics::MetricExporter
+{
+public:
+  /**
+   * Create an OStreamMetricExporter. This constructor takes in a reference to an ostream that the
+   * export() function will send span data into.
+   * The default ostream is set to stdout
+   */
+  explicit OStreamMetricExporter(std::ostream &sout = std::cout) noexcept;
+
+  /**
+   * Export
+   * @param records a span of unique pointers to metrics data
+   */
+  sdk::common::ExportResult Export(
+      const nostd::span<std::unique_ptr<opentelemetry::sdk::metrics::MetricData>> &records) noexcept
+      override;
+
+  /**
+   * Force flush the exporter.
+   */
+  bool ForceFlush(
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
+
+  /**
+   * Shut down the exporter.
+   * @param timeout an optional timeout, the default timeout of 0 means that no
+   * timeout is applied.
+   * @return return the status of this operation
+   */
+  bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds(0)) noexcept override;
+
+private:
+  std::ostream &sout_;
+  bool is_shutdown_ = false;
+  mutable opentelemetry::common::SpinLockMutex lock_;
+  bool isShutdown() const noexcept;
+  void printPointData(opentelemetry::sdk::metrics::PointType &point_data);
+};
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif

exporters/ostream/src/metric_exporter.cc

@@ -0,0 +1,150 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef ENABLE_METRICS_PREVIEW
+#  include "opentelemetry/exporters/ostream/metric_exporter.h"
+#  include <algorithm>
+#  include "opentelemetry/sdk/metrics/aggregation/default_aggregation.h"
+#  include "opentelemetry/sdk/metrics/aggregation/histogram_aggregation.h"
+#  include "opentelemetry/sdk_config.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+
+OStreamMetricExporter::OStreamMetricExporter(std::ostream &sout) noexcept : sout_(sout) {}
+
+sdk::common::ExportResult OStreamMetricExporter::Export(
+    const nostd::span<std::unique_ptr<opentelemetry::sdk::metrics::MetricData>> &records) noexcept
+{
+  if (isShutdown())
+  {
+    OTEL_INTERNAL_LOG_ERROR("[OStream Metric] Exporting "
+                            << records.size() << " records(s) failed, exporter is shutdown");
+    return sdk::common::ExportResult::kFailure;
+  }
+
+  for (auto &record : records)
+  {
+    sout_ << "{"
+          << "\n  name        : " << record->instrumentation_library_->GetName()
+          << "\n  version     : " << record->instrumentation_library_->GetVersion();
+    printPointData(record->point_data_);
+    sout_ << "\n}\n";
+  }
+  return sdk::common::ExportResult::kSuccess;
+}
+
+template <typename T>
+inline void printVec(std::ostream &os, std::vector<T> &vec)
+{
+  os << '[';
+  if (vec.size() > 1)
+  {
+    std::copy(vec.begin(), vec.end() - 1, std::ostream_iterator<T>(os, ", "));
+  }
+  if (!vec.empty())
+  {
+    os << vec.back();
+  }
+  os << ']';
+}
+
+void OStreamMetricExporter::printPointData(opentelemetry::sdk::metrics::PointType &point_data)
+{
+  if (nostd::holds_alternative<sdk::metrics::SumPointData>(point_data))
+  {
+    auto sum_point_data = nostd::get<sdk::metrics::SumPointData>(point_data);
+    sout_ << "\n  type     : SumPointData";
+    sout_ << "\n  start timestamp     : "
+          << std::to_string(sum_point_data.start_epoch_nanos_.time_since_epoch().count());
+    sout_ << "\n  end timestamp     : "
+          << std::to_string(sum_point_data.end_epoch_nanos_.time_since_epoch().count());
+    sout_ << "\n  value     : ";
+    if (nostd::holds_alternative<double>(sum_point_data.value_))
+    {
+      sout_ << nostd::get<double>(sum_point_data.value_);
+    }
+    else if (nostd::holds_alternative<long>(sum_point_data.value_))
+    {
+      sout_ << nostd::get<long>(sum_point_data.value_);
+    }
+  }
+  else if (nostd::holds_alternative<sdk::metrics::HistogramPointData>(point_data))
+  {
+    auto histogram_point_data = nostd::get<sdk::metrics::HistogramPointData>(point_data);
+    sout_ << "\n  type     : HistogramPointData";
+    sout_ << "\n  timestamp     : "
+          << std::to_string(histogram_point_data.epoch_nanos_.time_since_epoch().count());
+    sout_ << "\n  count     : " << histogram_point_data.count_;
+    sout_ << "\n  sum     : ";
+    if (nostd::holds_alternative<double>(histogram_point_data.sum_))
+    {
+      sout_ << nostd::get<double>(histogram_point_data.sum_);
+    }
+    else if (nostd::holds_alternative<long>(histogram_point_data.sum_))
+    {
+      sout_ << nostd::get<long>(histogram_point_data.sum_);
+    }
+
+    sout_ << "\n  buckets     : ";
+    if (nostd::holds_alternative<std::vector<double>>(histogram_point_data.boundaries_))
+    {
+      auto &double_boundaries = nostd::get<std::vector<double>>(histogram_point_data.boundaries_);
+      printVec(sout_, double_boundaries);
+    }
+    else if (nostd::holds_alternative<std::vector<long>>(histogram_point_data.boundaries_))
+    {
+      auto &long_boundaries = nostd::get<std::vector<long>>(histogram_point_data.boundaries_);
+      printVec(sout_, long_boundaries);
+    }
+
+    sout_ << "\n  counts     : ";
+    printVec(sout_, histogram_point_data.counts_);
+  }
+  else if (nostd::holds_alternative<sdk::metrics::LastValuePointData>(point_data))
+  {
+    auto last_point_data = nostd::get<sdk::metrics::LastValuePointData>(point_data);
+    sout_ << "\n  type     : LastValuePointData";
+    sout_ << "\n  timestamp     : "
+          << std::to_string(last_point_data.epoch_nanos_.time_since_epoch().count())
+          << std::boolalpha << "\n  valid     : " << last_point_data.is_lastvalue_valid_;
+    sout_ << "\n  value     : ";
+    if (nostd::holds_alternative<double>(last_point_data.value_))
+    {
+      sout_ << nostd::get<double>(last_point_data.value_);
+    }
+    else if (nostd::holds_alternative<long>(last_point_data.value_))
+    {
+      sout_ << nostd::get<long>(last_point_data.value_);
+    }
+  }
+  else if (nostd::holds_alternative<sdk::metrics::DropPointData>(point_data))
+  {}
+}
+
+bool OStreamMetricExporter::ForceFlush(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return true;
+}
+
+bool OStreamMetricExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  is_shutdown_ = true;
+  return true;
+}
+
+bool OStreamMetricExporter::isShutdown() const noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return is_shutdown_;
+}
+
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif