[SDK] custom hash and equality for attribute processor

sdk/include/opentelemetry/sdk/common/custom_hash_equality.h

@@ -0,0 +1,157 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstddef>
+#include <cstring>
+#include <string>
+
+#include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace common
+{
+/**
+ *
+ * FNV Hashing Utilities
+ *
+ * Implements FNV-1a hashing algorithm for 32-bit and 64-bit types.
+ *
+ * - FNV (Fowler–Noll–Vo) is a simple, fast, and widely used non-cryptographic hash.
+ * - FNV-1a is the recommended variant because it mixes input bits better.
+ * - We parameterize by type size (4 = 32-bit, 8 = 64-bit).
+ */
+
+// Forward declaration for FNV prime constants
+template <typename Ty, size_t Size>
+struct FnvPrime;
+
+// Specialization for 32-bit
+template <typename Ty>
+struct FnvPrime<Ty, 4>
+{
+  static constexpr Ty value = static_cast<Ty>(0x01000193U);
+};
+
+// Specialization for 64-bit
+template <typename Ty>
+struct FnvPrime<Ty, 8>
+{
+  static constexpr Ty value = static_cast<Ty>(0x100000001b3ULL);
+};
+
+// Forward declaration for FNV offset basis constants
+template <typename Ty, size_t Size>
+struct FnvOffset;
+
+// Specialization for 32-bit
+template <typename Ty>
+struct FnvOffset<Ty, 4>
+{
+  // 32-bit offset basis
+  static constexpr Ty value = static_cast<Ty>(0x811C9DC5U);
+
+  static constexpr Ty Fix(Ty hval) noexcept { return hval; }
+};
+
+// Specialization for 64-bit
+template <typename Ty>
+struct FnvOffset<Ty, 8>
+{
+  // 64-bit offset basis
+  static constexpr Ty value = static_cast<Ty>(0xCBF29CE484222325ULL);
+
+  // Fix function: mix upper and lower bits for better distribution
+  static constexpr Ty Fix(Ty hval) noexcept { return hval ^ (hval >> 32); }
+};
+
+/**
+ * FNV-1a hash function
+ *
+ * @tparam Ty  Hash integer type (std::size_t, uint32_t, uint64_t, etc.)
+ * @param buf  Pointer to the input buffer
+ * @param len  Length of the buffer
+ * @param hval Starting hash value (defaults to offset basis)
+ * @return     Computed hash
+ */
+template <typename Ty>
+inline Ty Fnv1a(const void *buf, size_t len, Ty hval = FnvOffset<Ty, sizeof(Ty)>::value) noexcept
+{
+  const unsigned char *bp = reinterpret_cast<const unsigned char *>(buf);
+  const unsigned char *be = bp + len;
+  Ty prime                = FnvPrime<Ty, sizeof(Ty)>::value;
+
+  while (bp < be)
+  {
+    hval ^= static_cast<Ty>(*bp++);
+    hval *= prime;
+  }
+  return FnvOffset<Ty, sizeof(Ty)>::Fix(hval);
+}
+
+/**
+ * Hash and equality for nostd::string_view, enabling safe use in unordered_map
+ * without requiring null termination.
+ */
+
+struct StringViewHash
+{
+#if defined(OPENTELEMETRY_STL_VERSION)
+#  if OPENTELEMETRY_STL_VERSION >= 2020
+  using is_transparent = void;
+#  endif
+#endif
+
+  std::size_t operator()(const std::string &s) const noexcept
+  {
+    return Fnv1a<std::size_t>(s.data(), s.size());
+  }
+
+  std::size_t operator()(opentelemetry::nostd::string_view sv) const noexcept
+  {
+    return Fnv1a<std::size_t>(sv.data(), sv.size());
+  }
+};
+
+struct StringViewEqual
+{
+#if defined(OPENTELEMETRY_STL_VERSION)
+#  if OPENTELEMETRY_STL_VERSION >= 2020
+  using is_transparent = void;
+#  endif
+#endif
+
+  template <typename Lhs, typename Rhs>
+  bool operator()(const Lhs &lhs, const Rhs &rhs) const noexcept
+  {
+    opentelemetry::nostd::string_view lsv(lhs);
+    opentelemetry::nostd::string_view rsv(rhs);
+
+    return lsv.size() == rsv.size() && std::memcmp(lsv.data(), rsv.data(), lsv.size()) == 0;
+  }
+};
+
+/**
+ * Cross-platform heterogeneous lookup wrapper.
+ * Falls back to std::string construction on libc++ (macOS) and pre-c++20,
+ * but uses direct lookup on libstdc++ (Linux).
+ */
+
+template <typename MapType>
+inline auto find_hetero(MapType &&map, opentelemetry::nostd::string_view key)
+{
+#if defined(_LIBCPP_VERSION) || \
+    (!defined(OPENTELEMETRY_STL_VERSION) || OPENTELEMETRY_STL_VERSION < 2020)
+  return map.find(std::string(key));
+#else
+  // libstdc++ + C++20: heterogeneous lookup works
+  return map.find(key);
+#endif
+}
+}  // namespace common
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

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

@@ -3,13 +3,15 @@
 
 #pragma once
 
+#include <cstring>
 #include <string>
 #include <unordered_map>
 #include <utility>
 
 #include "opentelemetry/common/attribute_value.h"
 #include "opentelemetry/common/key_value_iterable.h"
 #include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/sdk/common/custom_hash_equality.h"
 #include "opentelemetry/sdk/metrics/state/filtered_ordered_attribute_map.h"
 #include "opentelemetry/version.h"
 
@@ -18,6 +20,7 @@ namespace sdk
 {
 namespace metrics
 {
+
 using MetricAttributes = opentelemetry::sdk::metrics::FilteredOrderedAttributeMap;
 
 /**
@@ -65,12 +68,19 @@ class DefaultAttributesProcessor : public AttributesProcessor
 class FilteringAttributesProcessor : public AttributesProcessor
 {
 public:
-  FilteringAttributesProcessor(std::unordered_map<std::string, bool> &&allowed_attribute_keys = {})
+  FilteringAttributesProcessor(
+      std::unordered_map<std::string,
+                         bool,
+                         opentelemetry::sdk::common::StringViewHash,
+                         opentelemetry::sdk::common::StringViewEqual> &&allowed_attribute_keys = {})
       : allowed_attribute_keys_(std::move(allowed_attribute_keys))
   {}
 
-  FilteringAttributesProcessor(
-      const std::unordered_map<std::string, bool> &allowed_attribute_keys = {})
+  FilteringAttributesProcessor(const std::unordered_map<std::string,
+                                                        bool,
+                                                        opentelemetry::sdk::common::StringViewHash,
+                                                        opentelemetry::sdk::common::StringViewEqual>
+                                   &allowed_attribute_keys = {})
       : allowed_attribute_keys_(allowed_attribute_keys)
   {}
 
@@ -80,7 +90,8 @@ class FilteringAttributesProcessor : public AttributesProcessor
     MetricAttributes result;
     attributes.ForEachKeyValue(
         [&](nostd::string_view key, opentelemetry::common::AttributeValue value) noexcept {
-          if (allowed_attribute_keys_.find(std::string(key)) != allowed_attribute_keys_.end())
+          if (opentelemetry::sdk::common::find_hetero(allowed_attribute_keys_, key) !=
+              allowed_attribute_keys_.end())
           {
             result.SetAttribute(key, value);
             return true;
@@ -94,11 +105,16 @@ class FilteringAttributesProcessor : public AttributesProcessor
 
   bool isPresent(nostd::string_view key) const noexcept override
   {
-    return (allowed_attribute_keys_.find(std::string(key)) != allowed_attribute_keys_.end());
+    return (opentelemetry::sdk::common::find_hetero(allowed_attribute_keys_, key) !=
+            allowed_attribute_keys_.end());
   }
 
 private:
-  std::unordered_map<std::string, bool> allowed_attribute_keys_;
+  std::unordered_map<std::string,
+                     bool,
+                     opentelemetry::sdk::common::StringViewHash,
+                     opentelemetry::sdk::common::StringViewEqual>
+      allowed_attribute_keys_;
 };
 
 /**
@@ -109,12 +125,19 @@ class FilteringAttributesProcessor : public AttributesProcessor
 class FilteringExcludeAttributesProcessor : public AttributesProcessor
 {
 public:
-  FilteringExcludeAttributesProcessor(std::unordered_map<std::string, bool> &&exclude_list = {})
+  FilteringExcludeAttributesProcessor(
+      std::unordered_map<std::string,
+                         bool,
+                         opentelemetry::sdk::common::StringViewHash,
+                         opentelemetry::sdk::common::StringViewEqual> &&exclude_list = {})
       : exclude_list_(std::move(exclude_list))
   {}
 
   FilteringExcludeAttributesProcessor(
-      const std::unordered_map<std::string, bool> &exclude_list = {})
+      const std::unordered_map<std::string,
+                               bool,
+                               opentelemetry::sdk::common::StringViewHash,
+                               opentelemetry::sdk::common::StringViewEqual> &exclude_list = {})
       : exclude_list_(exclude_list)
   {}
 
@@ -124,7 +147,7 @@ class FilteringExcludeAttributesProcessor : public AttributesProcessor
     MetricAttributes result;
     attributes.ForEachKeyValue(
         [&](nostd::string_view key, opentelemetry::common::AttributeValue value) noexcept {
-          if (exclude_list_.find(std::string(key)) == exclude_list_.end())
+          if (opentelemetry::sdk::common::find_hetero(exclude_list_, key) == exclude_list_.end())
           {
             result.SetAttribute(key, value);
             return true;
@@ -138,11 +161,15 @@ class FilteringExcludeAttributesProcessor : public AttributesProcessor
 
   bool isPresent(nostd::string_view key) const noexcept override
   {
-    return (exclude_list_.find(std::string(key)) == exclude_list_.end());
+    return (opentelemetry::sdk::common::find_hetero(exclude_list_, key) == exclude_list_.end());
   }
 
 private:
-  std::unordered_map<std::string, bool> exclude_list_;
+  std::unordered_map<std::string,
+                     bool,
+                     opentelemetry::sdk::common::StringViewHash,
+                     opentelemetry::sdk::common::StringViewEqual>
+      exclude_list_;
 };
 
 }  // namespace metrics

sdk/test/metrics/attributes_processor_benchmark.cc

@@ -8,6 +8,7 @@
 #include <utility>
 
 #include "opentelemetry/common/key_value_iterable_view.h"
+#include "opentelemetry/sdk/common/custom_hash_equality.h"
 #include "opentelemetry/sdk/metrics/view/attributes_processor.h"
 
 using namespace opentelemetry::sdk::metrics;

sdk/test/metrics/attributes_processor_test.cc

@@ -8,7 +8,7 @@
 #include <utility>
 
 #include "opentelemetry/common/key_value_iterable_view.h"
-#include "opentelemetry/sdk/common/attribute_utils.h"
+#include "opentelemetry/sdk/common/custom_hash_equality.h"
 #include "opentelemetry/sdk/metrics/view/attributes_processor.h"
 
 using namespace opentelemetry::sdk::metrics;
@@ -17,9 +17,10 @@ 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 kNumFilterAttributes = 3;
+  std::unordered_map<std::string, bool, opentelemetry::sdk::common::StringViewHash,
+                     opentelemetry::sdk::common::StringViewEqual>
+      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};
@@ -38,9 +39,11 @@ TEST(AttributesProcessor, FilteringAttributesProcessor)
 
 TEST(AttributesProcessor, FilteringAllAttributesProcessor)
 {
-  const int kNumFilterAttributes               = 0;
-  std::unordered_map<std::string, bool> filter = {};
-  const int kNumAttributes                     = 6;
+  const int kNumFilterAttributes = 0;
+  std::unordered_map<std::string, bool, opentelemetry::sdk::common::StringViewHash,
+                     opentelemetry::sdk::common::StringViewEqual>
+      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]},
@@ -54,8 +57,9 @@ TEST(AttributesProcessor, FilteringAllAttributesProcessor)
 
 TEST(AttributesProcessor, FilteringExcludeAttributesProcessor)
 {
-  std::unordered_map<std::string, bool> filter = {
-      {"attr2", true}, {"attr4", true}, {"attr6", true}};
+  std::unordered_map<std::string, bool, opentelemetry::sdk::common::StringViewHash,
+                     opentelemetry::sdk::common::StringViewEqual>
+      filter                            = {{"attr2", true}, {"attr4", true}, {"attr6", true}};
   const int kNumAttributes              = 7;
   std::string keys[kNumAttributes]      = {"attr1", "attr2", "attr3", "attr4",
                                            "attr5", "attr6", "attr7"};
@@ -76,8 +80,10 @@ TEST(AttributesProcessor, FilteringExcludeAttributesProcessor)
 
 TEST(AttributesProcessor, FilteringExcludeAllAttributesProcessor)
 {
-  std::unordered_map<std::string, bool> filter = {};
-  const int kNumAttributes                     = 6;
+  std::unordered_map<std::string, bool, opentelemetry::sdk::common::StringViewHash,
+                     opentelemetry::sdk::common::StringViewEqual>
+      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]},