Add CHANGELOG

Author: owent

CHANGELOG.md

@@ -21,6 +21,9 @@ Increment the:
 * [SDK] Implement env var configuration for PeriodicExportingMetricReader
   [#3549](https://github.com/open-telemetry/opentelemetry-cpp/pull/3549)
 
+* [SDK] Add bundle version of utf8_range to validate attributes
+  [#3512](https://github.com/open-telemetry/opentelemetry-cpp/pull/3512)
+
 ## [1.22 2025-07-11]
 
 * [DOC] Udpate link to membership document

sdk/include/opentelemetry/sdk/instrumentationscope/instrumentation_scope.h

@@ -102,9 +102,16 @@ class InstrumentationScope
     result->attributes_.reserve(opentelemetry::nostd::size(arg));
     for (auto &argv : arg)
     {
+      if (!common::AttributeValidator::IsValid(argv.first))
+      {
+        OTEL_INTERNAL_LOG_WARN("[InstrumentationScope] Invalid attribute key "
+                               << std::string{argv.first} << ". This attribute will be ignored.");
+        continue;
+      }
+
       if (!common::AttributeValidator::IsValid(argv.second))
       {
-        OTEL_INTERNAL_LOG_WARN("[InstrumentationScope] Invalid attribute value for: "
+        OTEL_INTERNAL_LOG_WARN("[InstrumentationScope] Invalid attribute value for "
                                << std::string{argv.first} << ". This attribute will be ignored.");
         continue;
       }
@@ -168,9 +175,16 @@ class InstrumentationScope
   void SetAttribute(nostd::string_view key,
                     const opentelemetry::common::AttributeValue &value) noexcept
   {
+    if (!common::AttributeValidator::IsValid(key))
+    {
+      OTEL_INTERNAL_LOG_WARN("[InstrumentationScope] Invalid attribute key "
+                             << std::string{key} << ". This attribute will be ignored.");
+      return;
+    }
+
     if (!common::AttributeValidator::IsValid(value))
     {
-      OTEL_INTERNAL_LOG_WARN("[InstrumentationScope] Invalid attribute value for: "
+      OTEL_INTERNAL_LOG_WARN("[InstrumentationScope] Invalid attribute value for "
                              << std::string{key} << ". This attribute will be ignored.");
       return;
     }

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

@@ -10,6 +10,7 @@
 #include "opentelemetry/common/attribute_value.h"
 #include "opentelemetry/common/key_value_iterable.h"
 #include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/sdk/common/attribute_validity.h"
 #include "opentelemetry/sdk/metrics/state/filtered_ordered_attribute_map.h"
 #include "opentelemetry/version.h"
 
@@ -50,7 +51,8 @@ class DefaultAttributesProcessor : public AttributesProcessor
   MetricAttributes process(
       const opentelemetry::common::KeyValueIterable &attributes) const noexcept override
   {
-    MetricAttributes result(attributes);
+    MetricAttributes result(
+        opentelemetry::sdk::common::KeyValueFilterIterable(attributes, "[Metrics] "));
     return result;
   }
 
@@ -78,7 +80,9 @@ class FilteringAttributesProcessor : public AttributesProcessor
       const opentelemetry::common::KeyValueIterable &attributes) const noexcept override
   {
     MetricAttributes result;
-    attributes.ForEachKeyValue(
+    opentelemetry::sdk::common::KeyValueFilterIterable validate_attributes{attributes,
+                                                                           "[Metrics] "};
+    validate_attributes.ForEachKeyValue(
         [&](nostd::string_view key, opentelemetry::common::AttributeValue value) noexcept {
           if (allowed_attribute_keys_.find(key.data()) != allowed_attribute_keys_.end())
           {

sdk/test/instrumentationscope/instrumentationscope_test.cc

@@ -61,6 +61,21 @@ TEST(InstrumentationScope, CreateInstrumentationScope)
   }
 }
 
+TEST(InstrumentationScope, CreateInstrumentationScopeWithInvalidAttributes)
+{
+  std::string library_name    = "opentelemetry-cpp";
+  std::string library_version = "0.1.0";
+  std::string schema_url      = "https://opentelemetry.io/schemas/1.2.0";
+  uint32_t attrubite_value3[] = {7, 8, 9};
+  auto instrumentation_scope =
+      InstrumentationScope::Create(library_name, library_version, schema_url,
+                                   {{"attribute-key1", "attribute-value"},
+                                    {"invalid-key\xff", "valid-value"},
+                                    {"valid-key", "invalid-value\xff"}});
+
+  EXPECT_EQ(instrumentation_scope->GetAttributes().size(), 1);
+}
+
 TEST(InstrumentationScope, CreateInstrumentationScopeWithLoopForAttributes)
 {
   std::string library_name    = "opentelemetry-cpp";
@@ -195,6 +210,25 @@ TEST(InstrumentationScope, SetAttribute)
   }
 }
 
+TEST(InstrumentationScope, SetInvalidAttribute)
+{
+  std::string library_name    = "opentelemetry-cpp";
+  std::string library_version = "0.1.0";
+  std::string schema_url      = "https://opentelemetry.io/schemas/1.2.0";
+  auto instrumentation_scope =
+      InstrumentationScope::Create(library_name, library_version, schema_url);
+
+  EXPECT_EQ(instrumentation_scope->GetName(), library_name);
+  EXPECT_EQ(instrumentation_scope->GetVersion(), library_version);
+  EXPECT_EQ(instrumentation_scope->GetSchemaURL(), schema_url);
+  EXPECT_EQ(instrumentation_scope->GetAttributes().size(), 0);
+
+  instrumentation_scope->SetAttribute("attribute-key1", "attribute-value");
+  instrumentation_scope->SetAttribute("invalid-key\xff", "valid-value");
+  instrumentation_scope->SetAttribute("valid-key", "invalid-value\xff");
+  EXPECT_EQ(instrumentation_scope->GetAttributes().size(), 1);
+}
+
 TEST(InstrumentationScope, LegacyInstrumentationLibrary)
 {
 

sdk/test/metrics/meter_test.cc

@@ -656,6 +656,50 @@ TEST_F(MeterCreateInstrumentTest, ViewCorrectedDuplicateSyncInstrumentsByDescrip
   });
 }
 
+TEST_F(MeterCreateInstrumentTest, SyncInstrumentWithInvalidAttributes)
+{
+  InstrumentDescriptor descriptor{"my_counter", "desc", "unit", InstrumentType::kCounter,
+                                  InstrumentValueType::kDouble};
+  AddDescriptionCorrectionView(descriptor.name_, descriptor.unit_, descriptor.type_,
+                               descriptor.description_);
+
+  auto counter1 = meter_->CreateDoubleCounter("my_counter", "desc", "unit");
+  counter1->Add(
+      1,
+      {{"key", "value1"}, {"invalid-key\xff", "valid-value"}, {"valid-key", "invalid-value\xff"}});
+
+  metric_reader_ptr_->Collect([this](ResourceMetrics &metric_data) {
+    EXPECT_EQ(metric_data.scope_metric_data_.size(), 1);
+    // only one metric_data object expected after correction with the view
+    EXPECT_EQ(metric_data.scope_metric_data_[0].metric_data_.size(), 1);
+    EXPECT_EQ(metric_data.scope_metric_data_[0].metric_data_[0].point_data_attr_.size(), 1);
+    return true;
+  });
+}
+
+TEST_F(MeterCreateInstrumentTest, AsyncInstrumentWithInvalidAttributes)
+{
+  auto observable_counter1 =
+      meter_->CreateInt64ObservableCounter("observable_counter", "desc", "unit");
+  auto callback1 = [](opentelemetry::metrics::ObserverResult observer, void * /* state */) {
+    auto observer_long =
+        nostd::get<nostd::shared_ptr<opentelemetry::metrics::ObserverResultT<int64_t>>>(observer);
+    observer_long->Observe(12, {{"key", "value1"},
+                                {"invalid-key\xff", "valid-value"},
+                                {"valid-key", "invalid-value\xff"}});
+  };
+
+  observable_counter1->AddCallback(callback1, nullptr);
+
+  metric_reader_ptr_->Collect([this](ResourceMetrics &metric_data) {
+    EXPECT_EQ(metric_data.scope_metric_data_.size(), 1);
+    EXPECT_EQ(metric_data.scope_metric_data_[0].metric_data_.size(), 1);
+    auto &point_data_attr = metric_data.scope_metric_data_[0].metric_data_[0].point_data_attr_;
+    EXPECT_EQ(point_data_attr.size(), 1);
+    return true;
+  });
+}
+
 TEST_F(MeterCreateInstrumentTest, IdenticalAsyncInstruments)
 {
   auto observable_counter1 =