Add the in-memory metrics exporter.

exporters/memory/BUILD

@@ -60,3 +60,33 @@ cc_test(
         "@com_google_googletest//:gtest_main",
     ],
 )
+
+cc_library(
+    name = "in_memory_metric_exporter",
+    srcs = ["src/in_memory_metric_exporter.cc"],
+    hdrs = ["include/opentelemetry/exporters/memory/in_memory_metric_exporter.h"],
+    strip_include_prefix = "include",
+    tags = [
+        "memory",
+        "test",
+    ],
+    deps = [
+        ":in_memory_data",
+        "//exporters/otlp:otlp_metric_utils",
+        "//sdk/src/metrics",
+        "@com_github_opentelemetry_proto//:metrics_proto_cc",
+    ],
+)
+
+cc_test(
+    name = "in_memory_metric_exporter_test",
+    srcs = ["test/in_memory_metric_exporter_test.cc"],
+    tags = [
+        "memory",
+        "test",
+    ],
+    deps = [
+        ":in_memory_metric_exporter",
+        "@com_google_googletest//:gtest_main",
+    ],
+)

exporters/memory/include/opentelemetry/exporters/memory/in_memory_metric_data.h

@@ -0,0 +1,28 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/exporters/memory/in_memory_data.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace memory
+{
+
+class InMemoryMetricData final : public exporter::memory::InMemoryData<sdk::metrics::MetricData>
+{
+public:
+  /**
+   * @param buffer_size a required value that sets the size of the CircularBuffer
+   */
+  explicit InMemoryMetricData(size_t buffer_size)
+      : exporter::memory::InMemoryData<sdk::metrics::MetricData>(buffer_size)
+  {}
+
+  std::vector<std::unique_ptr<sdk::metrics::MetricData>> GetMetrics() noexcept { return Get(); }
+};
+}  // namespace memory
+}  // namespace exporter

exporters/memory/include/opentelemetry/exporters/memory/in_memory_metric_exporter.h

@@ -0,0 +1,63 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifndef ENABLE_METRICS_PREVIEW
+
+#  include <memory>
+#  include <mutex>
+#  include "opentelemetry/common/spin_lock_mutex.h"
+#  include "opentelemetry/exporters/memory/in_memory_metric_data.h"
+#  include "opentelemetry/sdk/common/circular_buffer.h"
+#  include "opentelemetry/sdk/metrics/data/metric_data.h"
+#  include "opentelemetry/sdk/metrics/instruments.h"
+#  include "opentelemetry/sdk/metrics/metric_exporter.h"
+#  include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+const size_t MAX_BUFFER_SIZE = 100;
+
+/**
+ * The in-memory metrics exporter exports metrics data to the memory.
+ *
+ */
+class InMemoryMetricExporter final : public opentelemetry::sdk::metrics::MetricExporter
+{
+public:
+  /**
+   * Create an InMemoryMetricExporter. The constructor takes the buffer size as the input and
+   * initializes the ring buffer with the given size.
+   *
+   */
+  explicit InMemoryMetricExporter(size_t buffer_size = MAX_BUFFER_SIZE)
+      : data_(new InMemoryMetricData(buffer_size))
+  {}
+
+  sdk::common::ExportResult Export(const sdk::metrics::ResourceMetrics &data) noexcept override;
+
+  bool ForceFlush(
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
+
+  bool Shutdown(
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
+
+  /**
+   * @return Returns a shared pointer to this exporters InMemoryMetricData.
+   */
+  inline InMemoryMetricData &GetData() noexcept { return *data_; }
+
+private:
+  bool isShutdown() const noexcept;
+  bool is_shutdown_ = false;
+  mutable opentelemetry::common::SpinLockMutex lock_;
+
+  std::unique_ptr<InMemoryMetricData> data_ = nullptr;
+};
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif

exporters/memory/src/in_memory_metric_exporter.cc

@@ -0,0 +1,54 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef ENABLE_METRICS_PREVIEW
+
+#  include "opentelemetry/exporters/memory/in_memory_metric_exporter.h"
+#  include "opentelemetry/exporters/otlp/otlp_metric_utils.h"
+#  include "opentelemetry/sdk_config.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+
+sdk::common::ExportResult InMemoryMetricExporter::Export(
+    const sdk::metrics::ResourceMetrics &data) noexcept
+{
+  if (isShutdown())
+  {
+    OTEL_INTERNAL_LOG_ERROR("[InMemory Metric] Exporting "
+                            << data.instrumentation_info_metric_data_.size()
+                            << " records(s) failed, exporter is shutdown");
+    return sdk::common::ExportResult::kFailure;
+  }
+
+  std::unique_ptr<proto::metrics::v1::ResourceMetrics> resource_metrics(
+      new proto::metrics::v1::ResourceMetrics);
+  otlp::OtlpMetricUtils::PopulateResourceMetrics(data, resource_metrics.get());
+  data_->Add(std::move(resource_metrics));
+  return sdk::common::ExportResult::kSuccess;
+}
+
+bool InMemoryMetricExporter::ForceFlush(std::chrono::microseconds timeout) noexcept
+{
+  return true;
+}
+
+bool InMemoryMetricExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  is_shutdown_ = true;
+  return true;
+}
+
+bool InMemoryMetricExporter::isShutdown() const noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return is_shutdown_;
+}
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif