Metrics SDK: Filtering metrics attributes

sdk/include/opentelemetry/sdk/metrics/view/attributes_processor.h

@@ -11,13 +11,25 @@ namespace metrics
 {
 using MetricAttributes = opentelemetry::sdk::common::AttributeMap;
 
+/**
+ * The AttributesProcessor is responsible for customizing which
+ * attribute(s) are to be reported as metrics dimension(s).
+ */
+
 class AttributesProcessor
 {
 public:
+  // Process the metric instrument attributes.
+  // @returns The processed attributes
   virtual MetricAttributes process(
       const opentelemetry::common::KeyValueIterable &attributes) noexcept = 0;
 };
 
+/**
+ * DefaultAttributesProcessor returns copy of input instrument attributes without
+ * any modification.
+ */
+
 class DefaultAttributesProcessor : public AttributesProcessor
 {
   MetricAttributes process(
@@ -28,6 +40,39 @@ class DefaultAttributesProcessor : public AttributesProcessor
   }
 };
 
+/**
+ * FilteringAttributesProcessor  filters by allowed attribute names and drops any names
+ * that are not in the allow list.
+ */
+
+class FilteringAttributesProcessor : public AttributesProcessor
+{
+public:
+  FilteringAttributesProcessor(
+      const std::unordered_map<std::string, bool> allowed_attribute_keys = {})
+      : allowed_attribute_keys_(std::move(allowed_attribute_keys))
+  {}
+
+  MetricAttributes process(
+      const opentelemetry::common::KeyValueIterable &attributes) noexcept override
+  {
+    MetricAttributes result;
+    attributes.ForEachKeyValue(
+        [&](nostd::string_view key, opentelemetry::common::AttributeValue value) noexcept {
+          if (allowed_attribute_keys_.find(key.data()) != allowed_attribute_keys_.end())
+          {
+            result.SetAttribute(key, value);
+            return true;
+          }
+          return true;
+        });
+    return result;
+  }
+
+private:
+  std::unordered_map<std::string, bool> allowed_attribute_keys_;
+};
+
 }  // namespace metrics
 }  // namespace sdk
 OPENTELEMETRY_END_NAMESPACE

sdk/test/metrics/BUILD

@@ -9,3 +9,14 @@ cc_test(
         "@com_google_googletest//:gtest_main",
     ],
 )
+
+cc_test(
+    name = "attributes_processor_test",
+    srcs = [
+        "attributes_processor_test.cc",
+    ],
+    deps = [
+        "//sdk/src/metrics",
+        "@com_google_googletest//:gtest_main",
+    ],
+)

sdk/test/metrics/CMakeLists.txt

@@ -1,4 +1,5 @@
-foreach(testname meter_provider_sdk_test view_registry_test)
+foreach(testname meter_provider_sdk_test view_registry_test
+                 attributes_processor_test)
   add_executable(${testname} "${testname}.cc")
   target_link_libraries(
     ${testname} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}

sdk/test/metrics/attributes_processor_test.cc

@@ -0,0 +1,49 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef ENABLE_METRICS_PREVIEW
+#  include "opentelemetry/sdk/metrics/view/attributes_processor.h"
+#  include <gtest/gtest.h>
+
+using namespace opentelemetry::sdk::metrics;
+using namespace opentelemetry::common;
+using namespace opentelemetry::sdk::common;
+
+TEST(AttributesProcessor, FilteringAttributesProcessor)
+{
+  const int kNumFilterAttributes               = 3;
+  std::unordered_map<std::string, bool> filter = {
+      {"attr2", true}, {"attr4", true}, {"attr6", true}};
+  const int kNumAttributes              = 6;
+  std::string keys[kNumAttributes]      = {"attr1", "attr2", "attr3", "attr4", "attr5", "attr6"};
+  int values[kNumAttributes]            = {10, 20, 30, 40, 50, 60};
+  std::map<std::string, int> attributes = {{keys[0], values[0]}, {keys[1], values[1]},
+                                           {keys[2], values[2]}, {keys[3], values[3]},
+                                           {keys[4], values[4]}, {keys[5], values[5]}};
+  FilteringAttributesProcessor attributes_processor(filter);
+  opentelemetry::common::KeyValueIterableView<std::map<std::string, int>> iterable(attributes);
+  auto filtered_attributes = attributes_processor.process(iterable);
+  for (auto &e : filtered_attributes)
+  {
+    EXPECT_FALSE(filter.find(e.first) == filter.end());
+  }
+  EXPECT_EQ(filter.size(), kNumFilterAttributes);
+}
+
+TEST(AttributesProcessor, FilteringAllAttributesProcessor)
+{
+  const int kNumFilterAttributes               = 0;
+  std::unordered_map<std::string, bool> filter = {};
+  const int kNumAttributes                     = 6;
+  std::string keys[kNumAttributes]      = {"attr1", "attr2", "attr3", "attr4", "attr5", "attr6"};
+  int values[kNumAttributes]            = {10, 20, 30, 40, 50, 60};
+  std::map<std::string, int> attributes = {{keys[0], values[0]}, {keys[1], values[1]},
+                                           {keys[2], values[2]}, {keys[3], values[3]},
+                                           {keys[4], values[4]}, {keys[5], values[5]}};
+  FilteringAttributesProcessor attributes_processor(filter);
+  opentelemetry::common::KeyValueIterableView<std::map<std::string, int>> iterable(attributes);
+  auto filtered_attributes = attributes_processor.process(iterable);
+  EXPECT_EQ(filter.size(), kNumFilterAttributes);
+}
+
+#endif