[Metrics] New Attribute Processor for Exclude list

Author: nikhilbhatia08

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

@@ -101,6 +101,49 @@ class FilteringAttributesProcessor : public AttributesProcessor
   std::unordered_map<std::string, bool> allowed_attribute_keys_;
 };
 
+/**
+ * FilteringExcludeAttributeProcessor filters by exclude attribute list and drops names if they are
+ * present in the exclude list
+ */
+
+class FilteringExcludeAttributesProcessor : AttributesProcessor
+{
+public:
+  FilteringExcludeAttributesProcessor(std::unordered_map<std::string, bool> &&exclude_list = {})
+      : exclude_list_(std::move(exclude_list))
+  {}
+
+  FilteringExcludeAttributesProcessor(const std::unordered_map<std::string, bool> &exclude_list = {})
+      : exclude_list_(exclude_list)
+  {}
+
+  MetricAttributes process(
+      const opentelemetry::common::KeyValueIterable &attributes) const noexcept override
+  {
+    MetricAttributes result;
+    attributes.ForEachKeyValue(
+        [&](nostd::string_view key, opentelemetry::common::AttributeValue value) noexcept {
+          if (exclude_list_.find(key.data()) == exclude_list_.end())
+          {
+            result.SetAttribute(key, value);
+            return true;
+          }
+          return true;
+        });
+
+    result.UpdateHash();
+    return result;
+  }
+
+  bool isPresent(nostd::string_view key) const noexcept override
+  {
+    return (exclude_list_.find(key.data()) == exclude_list_.end());
+  }
+
+private:
+  std::unordered_map<std::string, bool> exclude_list_;
+};
+
 }  // namespace metrics
 }  // namespace sdk
 OPENTELEMETRY_END_NAMESPACE

sdk/test/metrics/attributes_processor_test.cc

@@ -51,3 +51,40 @@ TEST(AttributesProcessor, FilteringAllAttributesProcessor)
   auto filtered_attributes = attributes_processor.process(iterable);
   EXPECT_EQ(filter.size(), kNumFilterAttributes);
 }
+
+TEST(AttributesProcessor, FilteringExcludeAttributesProcessor)
+{
+  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]}};
+  FilteringExcludeAttributesProcessor 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_TRUE(filter.find(e.first) == filter.end());
+  }
+  EXPECT_EQ(filter.size(), kNumFilterAttributes);
+}
+
+TEST(AttributesProcessor, FilteringExcludeAllAtrributesProcessor)
+{
+  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]}};
+  FilteringExcludeAttributesProcessor 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);
+}