From 095da8d49d386cd158ece311a700177536c8a515 Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Mon, 13 Oct 2025 01:40:36 +0530 Subject: [PATCH 1/5] [Metrics] Perform async Re-Aggregation when Spatial Attributes are dropped --- .../sdk/metrics/observer_result.h | 26 ++- .../sdk/metrics/state/async_metric_storage.h | 40 ++++- .../state/measurement_attributes_map.h | 157 ++++++++++++++++++ .../sdk/metrics/state/metric_storage.h | 17 +- .../sdk/metrics/state/multi_metric_storage.h | 11 +- sdk/src/metrics/meter.cc | 8 +- sdk/src/metrics/state/observable_registry.cc | 4 +- sdk/test/metrics/async_metric_storage_test.cc | 42 +++-- sdk/test/metrics/observer_result_test.cc | 7 +- sdk/test/metrics/sum_aggregation_test.cc | 121 ++++++++++++++ 10 files changed, 379 insertions(+), 54 deletions(-) create mode 100644 sdk/include/opentelemetry/sdk/metrics/state/measurement_attributes_map.h diff --git a/sdk/include/opentelemetry/sdk/metrics/observer_result.h b/sdk/include/opentelemetry/sdk/metrics/observer_result.h index cc60cf5f64..14d89d0242 100644 --- a/sdk/include/opentelemetry/sdk/metrics/observer_result.h +++ b/sdk/include/opentelemetry/sdk/metrics/observer_result.h @@ -10,6 +10,7 @@ #include "opentelemetry/metrics/observer_result.h" #include "opentelemetry/nostd/string_view.h" #include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" +#include "opentelemetry/sdk/metrics/state/measurement_attributes_map.h" #include "opentelemetry/sdk/metrics/view/attributes_processor.h" #include "opentelemetry/version.h" @@ -22,7 +23,7 @@ template class ObserverResultT final : public opentelemetry::metrics::ObserverResultT { public: - explicit ObserverResultT(const AttributesProcessor *attributes_processor = nullptr) + explicit ObserverResultT(std::shared_ptr attributes_processor = nullptr) : attributes_processor_(attributes_processor) {} @@ -30,24 +31,33 @@ class ObserverResultT final : public opentelemetry::metrics::ObserverResultT void Observe(T value) noexcept override { - data_[MetricAttributes{{}, attributes_processor_}] = value; + std::unordered_map empty; + data_[empty] += value; } void Observe(T value, const opentelemetry::common::KeyValueIterable &attributes) noexcept override { - data_[MetricAttributes{attributes, attributes_processor_}] = - value; // overwrites the previous value if present + std::unordered_map attr_map; + attributes.ForEachKeyValue( + [&](nostd::string_view key, opentelemetry::common::AttributeValue val) noexcept { + attr_map.emplace(key, val); + return true; + }); + data_[attr_map] += value; // overwrites the previous value if present } - const std::unordered_map &GetMeasurements() + const MeasurementAttributes &GetMeasurements() { return data_; } + + std::shared_ptr GetAttributesProcessor() const noexcept { - return data_; + return attributes_processor_; } private: - std::unordered_map data_; - const AttributesProcessor *attributes_processor_; + MeasurementAttributes data_; + std::shared_ptr attributes_processor_; }; + } // namespace metrics } // namespace sdk diff --git a/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h b/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h index 968de7aa82..d52dac8c46 100644 --- a/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h +++ b/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h @@ -17,9 +17,11 @@ # include "opentelemetry/sdk/metrics/exemplar/reservoir.h" #endif +#include "opentelemetry/common/key_value_iterable_view.h" #include "opentelemetry/sdk/metrics/instruments.h" #include "opentelemetry/sdk/metrics/observer_result.h" #include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" +#include "opentelemetry/sdk/metrics/state/measurement_attributes_map.h" #include "opentelemetry/sdk/metrics/state/metric_collector.h" #include "opentelemetry/sdk/metrics/state/metric_storage.h" #include "opentelemetry/sdk/metrics/state/temporal_metric_storage.h" @@ -36,6 +38,7 @@ class AsyncMetricStorage : public MetricStorage, public AsyncWritableMetricStora public: AsyncMetricStorage(InstrumentDescriptor instrument_descriptor, const AggregationType aggregation_type, + std::shared_ptr attributes_processor, #ifdef ENABLE_METRICS_EXEMPLAR_PREVIEW ExemplarFilterType exempler_filter_type, nostd::shared_ptr &&exemplar_reservoir, @@ -48,6 +51,7 @@ class AsyncMetricStorage : public MetricStorage, public AsyncWritableMetricStora std::make_unique(aggregation_config_->cardinality_limit_)), delta_hash_map_( std::make_unique(aggregation_config_->cardinality_limit_)), + attributes_processor_(std::move(attributes_processor)), #ifdef ENABLE_METRICS_EXEMPLAR_PREVIEW exemplar_filter_type_(exempler_filter_type), exemplar_reservoir_(exemplar_reservoir), @@ -95,26 +99,45 @@ class AsyncMetricStorage : public MetricStorage, public AsyncWritableMetricStora } } - void RecordLong( - const std::unordered_map &measurements, - opentelemetry::common::SystemTimestamp observation_time) noexcept override + void RecordLong(const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, + opentelemetry::common::SystemTimestamp observation_time) noexcept override { if (instrument_descriptor_.value_type_ != InstrumentValueType::kLong) { return; } - Record(measurements, observation_time); + std::unordered_map mp = + std::move(ConvertMeasurementsToMetricAttributes(measurements, observation_time)); + Record(mp, observation_time); } - void RecordDouble( - const std::unordered_map &measurements, - opentelemetry::common::SystemTimestamp observation_time) noexcept override + void RecordDouble(const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, + opentelemetry::common::SystemTimestamp observation_time) noexcept override { if (instrument_descriptor_.value_type_ != InstrumentValueType::kDouble) { return; } - Record(measurements, observation_time); + std::unordered_map mp = + std::move(ConvertMeasurementsToMetricAttributes(measurements, observation_time)); + Record(mp, observation_time); + } + + template + std::unordered_map + ConvertMeasurementsToMetricAttributes( + const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, + opentelemetry::common::SystemTimestamp observation_time) noexcept + { + std::unordered_map mp; + for (auto &measurement : measurements) + { + opentelemetry::common::KeyValueIterableView< + std::unordered_map> + kv_view{measurement.first}; + mp[MetricAttributes{kv_view, attributes_processor_.get()}] += measurement.second; + } + return mp; } bool Collect(CollectorHandle *collector, @@ -144,6 +167,7 @@ class AsyncMetricStorage : public MetricStorage, public AsyncWritableMetricStora const AggregationConfig *aggregation_config_; std::unique_ptr cumulative_hash_map_; std::unique_ptr delta_hash_map_; + std::shared_ptr attributes_processor_; opentelemetry::common::SpinLockMutex hashmap_lock_; #ifdef ENABLE_METRICS_EXEMPLAR_PREVIEW ExemplarFilterType exemplar_filter_type_; diff --git a/sdk/include/opentelemetry/sdk/metrics/state/measurement_attributes_map.h b/sdk/include/opentelemetry/sdk/metrics/state/measurement_attributes_map.h new file mode 100644 index 0000000000..4f3a27dcfc --- /dev/null +++ b/sdk/include/opentelemetry/sdk/metrics/state/measurement_attributes_map.h @@ -0,0 +1,157 @@ +// Copyright The OpenTelemetry Authors +// SPDX-License-Identifier: Apache-2.0 + +#pragma once + +#include +#include +#include +#include + +#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" + +OPENTELEMETRY_BEGIN_NAMESPACE +namespace sdk +{ +namespace metrics +{ + +// Hash function for AttributeValue (int and string only) +struct AttributeValueHash +{ + size_t operator()(const opentelemetry::common::AttributeValue &value) const noexcept + { + if (nostd::holds_alternative(value)) + { + return std::hash{}(nostd::get(value)); + } + else if (nostd::holds_alternative(value)) + { + return std::hash{}(nostd::get(value)); + } + else if (nostd::holds_alternative(value)) + { + return std::hash{}(nostd::string_view(nostd::get(value))); + } + else if (nostd::holds_alternative(value)) + { + return std::hash{}(nostd::get(value)); + } + + return 0; // fallback for other types + } +}; + +// Equality function for AttributeValue (int and string only) +struct AttributeValueEqual +{ + bool operator()(const opentelemetry::common::AttributeValue &a, + const opentelemetry::common::AttributeValue &b) const noexcept + { + if (a.index() != b.index()) + { + return false; + } + + // Compare int32_t + if (nostd::holds_alternative(a)) + { + return nostd::get(a) == nostd::get(b); + } + // Compare int64_t + else if (nostd::holds_alternative(a)) + { + return nostd::get(a) == nostd::get(b); + } + // Compare const char* + else if (nostd::holds_alternative(a)) + { + return nostd::string_view(nostd::get(a)) == + nostd::string_view(nostd::get(b)); + } + // Compare string_view + else if (nostd::holds_alternative(a)) + { + return nostd::get(a) == nostd::get(b); + } + + return false; + } +}; + +// Hash function for unordered_map of key-value pairs +// This Custom Hash is only applied to strings and int for now +struct AttributeMapHash +{ + size_t operator()( + const std::unordered_map &map) + const noexcept + { + size_t hash = 0; + AttributeValueHash value_hasher; + + for (const auto &pair : map) + { + // Combine key hash + size_t key_hash = std::hash{}(pair.first); + hash ^= key_hash + 0x9e3779b9 + (hash << 6) + (hash >> 2); + + // Combine value hash + size_t value_hash = value_hasher(pair.second); + hash ^= value_hash + 0x9e3779b9 + (hash << 6) + (hash >> 2); + } + + return hash; + } +}; + +// Equality function for unordered_map of key-value pairs +// This Custom Equal is only applied to strings and int for now +struct AttributeMapEqual +{ + bool operator()( + const std::unordered_map &a, + const std::unordered_map &b) + const noexcept + { + if (a.size() != b.size()) + { + return false; + } + + AttributeValueEqual value_equal; + + for (const auto &pair_a : a) + { + auto it = b.find(pair_a.first); + if (it == b.end()) + { + return false; // key not found in b + } + + // Compare values + if (!value_equal(pair_a.second, it->second)) + { + return false; + } + } + + return true; + } +}; + +template +using MeasurementAttributes = std::unordered_map< + std::unordered_map, + T, + AttributeMapHash, + AttributeMapEqual>; + +} // namespace metrics +} // namespace sdk +OPENTELEMETRY_END_NAMESPACE diff --git a/sdk/include/opentelemetry/sdk/metrics/state/metric_storage.h b/sdk/include/opentelemetry/sdk/metrics/state/metric_storage.h index 26adc37c08..a50b4e0433 100644 --- a/sdk/include/opentelemetry/sdk/metrics/state/metric_storage.h +++ b/sdk/include/opentelemetry/sdk/metrics/state/metric_storage.h @@ -13,6 +13,7 @@ #include "opentelemetry/sdk/metrics/data/metric_data.h" #include "opentelemetry/sdk/metrics/instruments.h" #include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" +#include "opentelemetry/sdk/metrics/state/measurement_attributes_map.h" #include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE @@ -73,11 +74,11 @@ class AsyncWritableMetricStorage /* Records a batch of measurements */ virtual void RecordLong( - const std::unordered_map &measurements, + const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, opentelemetry::common::SystemTimestamp observation_time) noexcept = 0; virtual void RecordDouble( - const std::unordered_map &measurements, + const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, opentelemetry::common::SystemTimestamp observation_time) noexcept = 0; }; @@ -119,14 +120,14 @@ class NoopWritableMetricStorage : public SyncWritableMetricStorage class NoopAsyncWritableMetricStorage : public AsyncWritableMetricStorage { public: - void RecordLong(const std::unordered_map - & /* measurements */, - opentelemetry::common::SystemTimestamp /* observation_time */) noexcept override + void RecordLong( + const opentelemetry::sdk::metrics::MeasurementAttributes & /* measurements */, + opentelemetry::common::SystemTimestamp /* observation_time */) noexcept override {} - void RecordDouble(const std::unordered_map - & /* measurements */, - opentelemetry::common::SystemTimestamp /* observation_time */) noexcept override + void RecordDouble( + const opentelemetry::sdk::metrics::MeasurementAttributes & /* measurements */, + opentelemetry::common::SystemTimestamp /* observation_time */) noexcept override {} }; diff --git a/sdk/include/opentelemetry/sdk/metrics/state/multi_metric_storage.h b/sdk/include/opentelemetry/sdk/metrics/state/multi_metric_storage.h index 2a77b2f856..03bd5c25b7 100644 --- a/sdk/include/opentelemetry/sdk/metrics/state/multi_metric_storage.h +++ b/sdk/include/opentelemetry/sdk/metrics/state/multi_metric_storage.h @@ -12,6 +12,7 @@ #include "opentelemetry/common/timestamp.h" #include "opentelemetry/context/context.h" #include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" +#include "opentelemetry/sdk/metrics/state/measurement_attributes_map.h" #include "opentelemetry/sdk/metrics/state/metric_storage.h" #include "opentelemetry/sdk/metrics/view/attributes_processor.h" #include "opentelemetry/version.h" @@ -80,9 +81,8 @@ class AsyncMultiMetricStorage : public AsyncWritableMetricStorage storages_.push_back(storage); } - void RecordLong( - const std::unordered_map &measurements, - opentelemetry::common::SystemTimestamp observation_time) noexcept override + void RecordLong(const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, + opentelemetry::common::SystemTimestamp observation_time) noexcept override { for (auto &s : storages_) { @@ -90,9 +90,8 @@ class AsyncMultiMetricStorage : public AsyncWritableMetricStorage } } - void RecordDouble( - const std::unordered_map &measurements, - opentelemetry::common::SystemTimestamp observation_time) noexcept override + void RecordDouble(const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, + opentelemetry::common::SystemTimestamp observation_time) noexcept override { for (auto &s : storages_) { diff --git a/sdk/src/metrics/meter.cc b/sdk/src/metrics/meter.cc index d7974d7590..3b64f6f949 100644 --- a/sdk/src/metrics/meter.cc +++ b/sdk/src/metrics/meter.cc @@ -588,7 +588,7 @@ std::unique_ptr Meter::RegisterAsyncMetricStorage( , exemplar_filter_type #endif - ](const View &view) { + ](const View &view) -> bool { auto view_instr_desc = instrument_descriptor; if (!view.GetName().empty()) { @@ -612,12 +612,14 @@ std::unique_ptr Meter::RegisterAsyncMetricStorage( { WarnOnDuplicateInstrument(GetInstrumentationScope(), storage_registry_, view_instr_desc); async_storage = std::shared_ptr(new AsyncMetricStorage( - view_instr_desc, view.GetAggregationType(), + view_instr_desc, view.GetAggregationType(), view.GetAttributesProcessor() #ifdef ENABLE_METRICS_EXEMPLAR_PREVIEW + , exemplar_filter_type, GetExemplarReservoir(view.GetAggregationType(), view.GetAggregationConfig(), - view_instr_desc), + view_instr_desc) #endif + , view.GetAggregationConfig())); storage_registry_.insert({view_instr_desc, async_storage}); } diff --git a/sdk/src/metrics/state/observable_registry.cc b/sdk/src/metrics/state/observable_registry.cc index d8d6afb01b..60e9117e6d 100644 --- a/sdk/src/metrics/state/observable_registry.cc +++ b/sdk/src/metrics/state/observable_registry.cc @@ -84,7 +84,7 @@ void ObservableRegistry::Observe(opentelemetry::common::SystemTimestamp collecti if (value_type == InstrumentValueType::kDouble) { nostd::shared_ptr> ob_res( - new opentelemetry::sdk::metrics::ObserverResultT(&default_attribute_processor)); + new opentelemetry::sdk::metrics::ObserverResultT()); callback_wrap->callback(ob_res, callback_wrap->state); storage->RecordDouble( static_cast *>(ob_res.get()) @@ -94,7 +94,7 @@ void ObservableRegistry::Observe(opentelemetry::common::SystemTimestamp collecti else { nostd::shared_ptr> ob_res( - new opentelemetry::sdk::metrics::ObserverResultT(&default_attribute_processor)); + new opentelemetry::sdk::metrics::ObserverResultT()); callback_wrap->callback(ob_res, callback_wrap->state); storage->RecordLong( static_cast *>(ob_res.get()) diff --git a/sdk/test/metrics/async_metric_storage_test.cc b/sdk/test/metrics/async_metric_storage_test.cc index 380ddd0564..a7cb0b9a77 100644 --- a/sdk/test/metrics/async_metric_storage_test.cc +++ b/sdk/test/metrics/async_metric_storage_test.cc @@ -24,6 +24,7 @@ #include "opentelemetry/sdk/metrics/state/async_metric_storage.h" #include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" #include "opentelemetry/sdk/metrics/state/filtered_ordered_attribute_map.h" +#include "opentelemetry/sdk/metrics/state/measurement_attributes_map.h" #include "opentelemetry/sdk/metrics/state/metric_collector.h" #ifdef ENABLE_METRICS_EXEMPLAR_PREVIEW @@ -67,22 +68,25 @@ TEST_P(WritableMetricStorageTestFixture, TestAggregation) std::shared_ptr collector(new MockCollectorHandle(temporality)); std::vector> collectors; collectors.push_back(collector); + std::unique_ptr attrproc{ + new opentelemetry::sdk::metrics::DefaultAttributesProcessor()}; opentelemetry::sdk::metrics::AsyncMetricStorage storage( - instr_desc, AggregationType::kSum, + instr_desc, AggregationType::kSum, std::move(attrproc), #ifdef ENABLE_METRICS_EXEMPLAR_PREVIEW ExemplarFilterType::kAlwaysOff, ExemplarReservoir::GetNoExemplarReservoir(), #endif nullptr); - int64_t get_count1 = 20; - int64_t put_count1 = 10; - std::unordered_map measurements1 = { + int64_t get_count1 = 20; + int64_t put_count1 = 10; + opentelemetry::sdk::metrics::MeasurementAttributes measurements1 = { {{{"RequestType", "GET"}}, get_count1}, {{{"RequestType", "PUT"}}, put_count1}}; storage.RecordLong(measurements1, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); storage.Collect( collector.get(), collectors, sdk_start_ts, collection_ts, [&](const MetricData &metric_data) { + EXPECT_EQ(metric_data.point_data_attr_.size(), 2); for (const auto &data_attr : metric_data.point_data_attr_) { const auto &data = opentelemetry::nostd::get(data_attr.point_data); @@ -96,6 +100,8 @@ TEST_P(WritableMetricStorageTestFixture, TestAggregation) { EXPECT_EQ(opentelemetry::nostd::get(data.value_), put_count1); } + // EXPECT_EQ(opentelemetry::nostd::get(data.value_), get_count1 + put_count1); + // EXPECT_EQ(data_attr.attributes.size(), 10); } return true; }); @@ -104,7 +110,7 @@ TEST_P(WritableMetricStorageTestFixture, TestAggregation) int64_t get_count2 = 50; int64_t put_count2 = 70; - std::unordered_map measurements2 = { + opentelemetry::sdk::metrics::MeasurementAttributes measurements2 = { {{{"RequestType", "GET"}}, get_count2}, {{{"RequestType", "PUT"}}, put_count2}}; storage.RecordLong(measurements2, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); @@ -163,15 +169,18 @@ TEST_P(WritableMetricStorageTestUpDownFixture, TestAggregation) std::vector> collectors; collectors.push_back(collector); + std::unique_ptr attrproc{ + new opentelemetry::sdk::metrics::DefaultAttributesProcessor()}; + opentelemetry::sdk::metrics::AsyncMetricStorage storage( - instr_desc, AggregationType::kDefault, + instr_desc, AggregationType::kDefault, std::move(attrproc), #ifdef ENABLE_METRICS_EXEMPLAR_PREVIEW ExemplarFilterType::kAlwaysOff, ExemplarReservoir::GetNoExemplarReservoir(), #endif nullptr); - int64_t get_count1 = 20; - int64_t put_count1 = 10; - std::unordered_map measurements1 = { + int64_t get_count1 = 20; + int64_t put_count1 = 10; + opentelemetry::sdk::metrics::MeasurementAttributes measurements1 = { {{{"RequestType", "GET"}}, get_count1}, {{{"RequestType", "PUT"}}, put_count1}}; storage.RecordLong(measurements1, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); @@ -201,7 +210,7 @@ TEST_P(WritableMetricStorageTestUpDownFixture, TestAggregation) int64_t get_count2 = -50; int64_t put_count2 = -70; - std::unordered_map measurements2 = { + opentelemetry::sdk::metrics::MeasurementAttributes measurements2 = { {{{"RequestType", "GET"}}, get_count2}, {{{"RequestType", "PUT"}}, put_count2}}; storage.RecordLong(measurements2, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); @@ -259,15 +268,18 @@ TEST_P(WritableMetricStorageTestObservableGaugeFixture, TestAggregation) std::vector> collectors; collectors.push_back(collector); + std::unique_ptr attrproc{ + new opentelemetry::sdk::metrics::DefaultAttributesProcessor()}; + opentelemetry::sdk::metrics::AsyncMetricStorage storage( - instr_desc, AggregationType::kLastValue, + instr_desc, AggregationType::kLastValue, std::move(attrproc), #ifdef ENABLE_METRICS_EXEMPLAR_PREVIEW ExemplarFilterType::kAlwaysOff, ExemplarReservoir::GetNoExemplarReservoir(), #endif nullptr); - int64_t freq_cpu0 = 3; - int64_t freq_cpu1 = 5; - std::unordered_map measurements1 = { + int64_t freq_cpu0 = 3; + int64_t freq_cpu1 = 5; + opentelemetry::sdk::metrics::MeasurementAttributes measurements1 = { {{{"CPU", "0"}}, freq_cpu0}, {{{"CPU", "1"}}, freq_cpu1}}; storage.RecordLong(measurements1, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); @@ -294,7 +306,7 @@ TEST_P(WritableMetricStorageTestObservableGaugeFixture, TestAggregation) freq_cpu0 = 6; freq_cpu1 = 8; - std::unordered_map measurements2 = { + opentelemetry::sdk::metrics::MeasurementAttributes measurements2 = { {{{"CPU", "0"}}, freq_cpu0}, {{{"CPU", "1"}}, freq_cpu1}}; storage.RecordLong(measurements2, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); diff --git a/sdk/test/metrics/observer_result_test.cc b/sdk/test/metrics/observer_result_test.cc index 5f6e7fe3b2..8ed11bde59 100644 --- a/sdk/test/metrics/observer_result_test.cc +++ b/sdk/test/metrics/observer_result_test.cc @@ -16,9 +16,10 @@ using namespace opentelemetry::sdk::metrics; TEST(ObserverResult, BasicTests) { - const AttributesProcessor *attributes_processor = new DefaultAttributesProcessor(); + std::shared_ptr attrproc{ + new opentelemetry::sdk::metrics::DefaultAttributesProcessor()}; - ObserverResultT observer_result(attributes_processor); + ObserverResultT observer_result(attrproc); observer_result.Observe(10); observer_result.Observe(20); @@ -37,6 +38,4 @@ TEST(ObserverResult, BasicTests) observer_result.Observe( 40, opentelemetry::common::KeyValueIterableView>(m2)); EXPECT_EQ(observer_result.GetMeasurements().size(), 3); - - delete attributes_processor; } diff --git a/sdk/test/metrics/sum_aggregation_test.cc b/sdk/test/metrics/sum_aggregation_test.cc index 5c29fe43e8..1307726011 100644 --- a/sdk/test/metrics/sum_aggregation_test.cc +++ b/sdk/test/metrics/sum_aggregation_test.cc @@ -27,6 +27,7 @@ #include "opentelemetry/sdk/metrics/instruments.h" #include "opentelemetry/sdk/metrics/meter_provider.h" #include "opentelemetry/sdk/metrics/metric_reader.h" +#include "opentelemetry/sdk/metrics/observer_result.h" #include "opentelemetry/sdk/metrics/push_metric_exporter.h" #include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" #include "opentelemetry/sdk/metrics/view/attributes_processor.h" @@ -322,6 +323,126 @@ TEST(CounterToSumFilterAttributes, Double) }); } +TEST(CounterToSumFilterAttributes, DoubleObservable) +{ + MeterProvider mp; + auto m = mp.GetMeter("meter2", "version2", "schema2"); + std::string instrument_unit = "ms"; + std::string instrument_name = "counter2"; + std::string instrument_desc = "counter metrics2"; + + opentelemetry::sdk::metrics::FilterAttributeMap allowedattr; + + std::unique_ptr attrproc{ + new opentelemetry::sdk::metrics::FilteringAttributesProcessor(allowedattr)}; + + std::shared_ptr dummy_aggregation_config{ + new opentelemetry::sdk::metrics::AggregationConfig}; + std::unique_ptr exporter(new MockMetricExporter()); + std::shared_ptr reader{new MockMetricReader(std::move(exporter))}; + mp.AddMetricReader(reader); + + std::unique_ptr view{new View("view2", "view2_description", AggregationType::kSum, + dummy_aggregation_config, std::move(attrproc))}; + std::unique_ptr instrument_selector{ + new InstrumentSelector(InstrumentType::kObservableCounter, instrument_name, instrument_unit)}; + std::unique_ptr meter_selector{new MeterSelector("meter2", "version2", "schema2")}; + mp.AddView(std::move(instrument_selector), std::move(meter_selector), std::move(view)); + + auto c = m->CreateDoubleObservableCounter(instrument_name, instrument_desc, instrument_unit); + c->AddCallback( + [](opentelemetry::metrics::ObserverResult result, void * /*state */) { + auto observer_double = + nostd::get>>(result); + observer_double->Observe(10, {{"version", 1}}); + observer_double->Observe(20, {{"version", 2}}); + }, + nullptr); + + reader->Collect([&](ResourceMetrics &rm) { + for (const ScopeMetrics &smd : rm.scope_metric_data_) + { + EXPECT_EQ(1, smd.metric_data_.size()); + for (const MetricData &md : smd.metric_data_) + { + EXPECT_EQ(1, md.point_data_attr_.size()); + EXPECT_EQ( + 30.0, + opentelemetry::nostd::get( + opentelemetry::nostd::get(md.point_data_attr_[0].point_data).value_)); + EXPECT_EQ(0, md.point_data_attr_[0].attributes.size()); + EXPECT_EQ(md.point_data_attr_[0].attributes.end(), + md.point_data_attr_[0].attributes.find("version")); + } + } + return true; + }); +} + +TEST(CounterToSumFilterAttributes, LongObservable) +{ + MeterProvider mp; + auto m = mp.GetMeter("meter2", "version2", "schema2"); + std::string instrument_unit = "ms"; + std::string instrument_name = "counter2"; + std::string instrument_desc = "counter metrics2"; + + opentelemetry::sdk::metrics::FilterAttributeMap allowedattr; + allowedattr["attr1"] = true; + std::unique_ptr attrproc{ + new opentelemetry::sdk::metrics::FilteringAttributesProcessor(allowedattr)}; + + std::shared_ptr dummy_aggregation_config{ + new opentelemetry::sdk::metrics::AggregationConfig}; + std::unique_ptr exporter(new MockMetricExporter()); + std::shared_ptr reader{new MockMetricReader(std::move(exporter))}; + mp.AddMetricReader(reader); + + std::unique_ptr view{new View("view2", "view2_description", AggregationType::kSum, + dummy_aggregation_config, std::move(attrproc))}; + std::unique_ptr instrument_selector{ + new InstrumentSelector(InstrumentType::kObservableCounter, instrument_name, instrument_unit)}; + std::unique_ptr meter_selector{new MeterSelector("meter2", "version2", "schema2")}; + mp.AddView(std::move(instrument_selector), std::move(meter_selector), std::move(view)); + + auto c = m->CreateInt64ObservableCounter(instrument_name, instrument_desc, instrument_unit); + c->AddCallback( + [](opentelemetry::metrics::ObserverResult result, void * /*state */) { + auto observer_int64 = + nostd::get>>(result); + observer_int64->Observe(10, {{"attr1", "val1"}, {"attr2", "val2"}}); + observer_int64->Observe(20, {{"attr1", "val1"}}); + observer_int64->Observe(5, {{"attr3", "val1"}, {"attr2", "val2"}}); + }, + nullptr); + + reader->Collect([&](ResourceMetrics &rm) { + for (const ScopeMetrics &smd : rm.scope_metric_data_) + { + EXPECT_EQ(1, smd.metric_data_.size()); + for (const MetricData &md : smd.metric_data_) + { + EXPECT_EQ(2, md.point_data_attr_.size()); + EXPECT_EQ( + 30, + opentelemetry::nostd::get( + opentelemetry::nostd::get(md.point_data_attr_[0].point_data).value_)); + EXPECT_EQ( + 5, + opentelemetry::nostd::get( + opentelemetry::nostd::get(md.point_data_attr_[1].point_data).value_)); + EXPECT_EQ(1, md.point_data_attr_[0].attributes.size()); + EXPECT_NE(md.point_data_attr_[0].attributes.end(), + md.point_data_attr_[0].attributes.find("attr1")); + EXPECT_EQ(0, md.point_data_attr_[1].attributes.size()); + EXPECT_EQ(md.point_data_attr_[1].attributes.end(), + md.point_data_attr_[1].attributes.find("attr1")); + } + } + return true; + }); +} + TEST(CounterToSumFilterAttributesWithCardinalityLimit, Double) { MeterProvider mp; From c48f6e1231809aad94a309e295914fe71aa2241b Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Mon, 13 Oct 2025 09:36:57 +0530 Subject: [PATCH 2/5] iwyu fix and minor changes --- .../opentelemetry/sdk/metrics/observer_result.h | 16 +++------------- .../sdk/metrics/state/async_metric_storage.h | 6 +++--- sdk/test/metrics/async_metric_storage_test.cc | 6 +----- sdk/test/metrics/observer_result_test.cc | 7 +------ sdk/test/metrics/sum_aggregation_test.cc | 4 +++- 5 files changed, 11 insertions(+), 28 deletions(-) diff --git a/sdk/include/opentelemetry/sdk/metrics/observer_result.h b/sdk/include/opentelemetry/sdk/metrics/observer_result.h index 14d89d0242..9bf430a339 100644 --- a/sdk/include/opentelemetry/sdk/metrics/observer_result.h +++ b/sdk/include/opentelemetry/sdk/metrics/observer_result.h @@ -3,15 +3,13 @@ #pragma once -#include +#include #include "opentelemetry/common/attribute_value.h" #include "opentelemetry/common/key_value_iterable.h" #include "opentelemetry/metrics/observer_result.h" #include "opentelemetry/nostd/string_view.h" -#include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" #include "opentelemetry/sdk/metrics/state/measurement_attributes_map.h" -#include "opentelemetry/sdk/metrics/view/attributes_processor.h" #include "opentelemetry/version.h" OPENTELEMETRY_BEGIN_NAMESPACE @@ -23,9 +21,7 @@ template class ObserverResultT final : public opentelemetry::metrics::ObserverResultT { public: - explicit ObserverResultT(std::shared_ptr attributes_processor = nullptr) - : attributes_processor_(attributes_processor) - {} + explicit ObserverResultT() = default; ~ObserverResultT() override = default; @@ -43,19 +39,13 @@ class ObserverResultT final : public opentelemetry::metrics::ObserverResultT attr_map.emplace(key, val); return true; }); - data_[attr_map] += value; // overwrites the previous value if present + data_[attr_map] += value; } const MeasurementAttributes &GetMeasurements() { return data_; } - std::shared_ptr GetAttributesProcessor() const noexcept - { - return attributes_processor_; - } - private: MeasurementAttributes data_; - std::shared_ptr attributes_processor_; }; } // namespace metrics diff --git a/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h b/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h index d52dac8c46..8488e6f04b 100644 --- a/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h +++ b/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h @@ -107,7 +107,7 @@ class AsyncMetricStorage : public MetricStorage, public AsyncWritableMetricStora return; } std::unordered_map mp = - std::move(ConvertMeasurementsToMetricAttributes(measurements, observation_time)); + ConvertMeasurementsToMetricAttributes(measurements, observation_time); Record(mp, observation_time); } @@ -119,7 +119,7 @@ class AsyncMetricStorage : public MetricStorage, public AsyncWritableMetricStora return; } std::unordered_map mp = - std::move(ConvertMeasurementsToMetricAttributes(measurements, observation_time)); + ConvertMeasurementsToMetricAttributes(measurements, observation_time); Record(mp, observation_time); } @@ -127,7 +127,7 @@ class AsyncMetricStorage : public MetricStorage, public AsyncWritableMetricStora std::unordered_map ConvertMeasurementsToMetricAttributes( const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, - opentelemetry::common::SystemTimestamp observation_time) noexcept + opentelemetry::common::SystemTimestamp /* observation_time */) noexcept { std::unordered_map mp; for (auto &measurement : measurements) diff --git a/sdk/test/metrics/async_metric_storage_test.cc b/sdk/test/metrics/async_metric_storage_test.cc index a7cb0b9a77..0196333d3a 100644 --- a/sdk/test/metrics/async_metric_storage_test.cc +++ b/sdk/test/metrics/async_metric_storage_test.cc @@ -22,17 +22,13 @@ #include "opentelemetry/sdk/metrics/export/metric_producer.h" #include "opentelemetry/sdk/metrics/instruments.h" #include "opentelemetry/sdk/metrics/state/async_metric_storage.h" -#include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" -#include "opentelemetry/sdk/metrics/state/filtered_ordered_attribute_map.h" #include "opentelemetry/sdk/metrics/state/measurement_attributes_map.h" #include "opentelemetry/sdk/metrics/state/metric_collector.h" +#include "opentelemetry/sdk/metrics/view/attributes_processor.h" #ifdef ENABLE_METRICS_EXEMPLAR_PREVIEW -# include "opentelemetry/sdk/metrics/data/exemplar_data.h" # include "opentelemetry/sdk/metrics/exemplar/filter_type.h" # include "opentelemetry/sdk/metrics/exemplar/reservoir.h" -#else -# include "opentelemetry/sdk/metrics/view/attributes_processor.h" #endif using namespace opentelemetry::sdk::metrics; diff --git a/sdk/test/metrics/observer_result_test.cc b/sdk/test/metrics/observer_result_test.cc index 8ed11bde59..6aeb9e3ad2 100644 --- a/sdk/test/metrics/observer_result_test.cc +++ b/sdk/test/metrics/observer_result_test.cc @@ -10,16 +10,11 @@ #include "opentelemetry/common/key_value_iterable_view.h" #include "opentelemetry/sdk/metrics/observer_result.h" -#include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" -#include "opentelemetry/sdk/metrics/view/attributes_processor.h" using namespace opentelemetry::sdk::metrics; TEST(ObserverResult, BasicTests) { - std::shared_ptr attrproc{ - new opentelemetry::sdk::metrics::DefaultAttributesProcessor()}; - - ObserverResultT observer_result(attrproc); + ObserverResultT observer_result; observer_result.Observe(10); observer_result.Observe(20); diff --git a/sdk/test/metrics/sum_aggregation_test.cc b/sdk/test/metrics/sum_aggregation_test.cc index 1307726011..16dd8da894 100644 --- a/sdk/test/metrics/sum_aggregation_test.cc +++ b/sdk/test/metrics/sum_aggregation_test.cc @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -15,6 +16,7 @@ #include "opentelemetry/context/context.h" #include "opentelemetry/metrics/meter.h" #include "opentelemetry/metrics/sync_instruments.h" +#include "opentelemetry/metrics/async_instruments.h" #include "opentelemetry/nostd/function_ref.h" #include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/nostd/string_view.h" @@ -27,7 +29,7 @@ #include "opentelemetry/sdk/metrics/instruments.h" #include "opentelemetry/sdk/metrics/meter_provider.h" #include "opentelemetry/sdk/metrics/metric_reader.h" -#include "opentelemetry/sdk/metrics/observer_result.h" +#include "opentelemetry/metrics/observer_result.h" #include "opentelemetry/sdk/metrics/push_metric_exporter.h" #include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" #include "opentelemetry/sdk/metrics/view/attributes_processor.h" From 5487b028cc9ca33aeb780c274f892de16980476d Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Mon, 13 Oct 2025 10:52:15 +0530 Subject: [PATCH 3/5] format and iwyu fix --- sdk/test/metrics/async_metric_storage_test.cc | 2 -- sdk/test/metrics/observer_result_test.cc | 1 - sdk/test/metrics/sum_aggregation_test.cc | 6 +++--- 3 files changed, 3 insertions(+), 6 deletions(-) diff --git a/sdk/test/metrics/async_metric_storage_test.cc b/sdk/test/metrics/async_metric_storage_test.cc index 0196333d3a..3549d798d2 100644 --- a/sdk/test/metrics/async_metric_storage_test.cc +++ b/sdk/test/metrics/async_metric_storage_test.cc @@ -96,8 +96,6 @@ TEST_P(WritableMetricStorageTestFixture, TestAggregation) { EXPECT_EQ(opentelemetry::nostd::get(data.value_), put_count1); } - // EXPECT_EQ(opentelemetry::nostd::get(data.value_), get_count1 + put_count1); - // EXPECT_EQ(data_attr.attributes.size(), 10); } return true; }); diff --git a/sdk/test/metrics/observer_result_test.cc b/sdk/test/metrics/observer_result_test.cc index 6aeb9e3ad2..4d467eff24 100644 --- a/sdk/test/metrics/observer_result_test.cc +++ b/sdk/test/metrics/observer_result_test.cc @@ -5,7 +5,6 @@ #include #include #include -#include #include #include "opentelemetry/common/key_value_iterable_view.h" diff --git a/sdk/test/metrics/sum_aggregation_test.cc b/sdk/test/metrics/sum_aggregation_test.cc index 16dd8da894..ddc8a5b8cd 100644 --- a/sdk/test/metrics/sum_aggregation_test.cc +++ b/sdk/test/metrics/sum_aggregation_test.cc @@ -3,10 +3,10 @@ #include #include +#include #include #include #include -#include #include #include #include @@ -14,9 +14,10 @@ #include "opentelemetry/common/macros.h" #include "opentelemetry/context/context.h" +#include "opentelemetry/metrics/async_instruments.h" #include "opentelemetry/metrics/meter.h" +#include "opentelemetry/metrics/observer_result.h" #include "opentelemetry/metrics/sync_instruments.h" -#include "opentelemetry/metrics/async_instruments.h" #include "opentelemetry/nostd/function_ref.h" #include "opentelemetry/nostd/shared_ptr.h" #include "opentelemetry/nostd/string_view.h" @@ -29,7 +30,6 @@ #include "opentelemetry/sdk/metrics/instruments.h" #include "opentelemetry/sdk/metrics/meter_provider.h" #include "opentelemetry/sdk/metrics/metric_reader.h" -#include "opentelemetry/metrics/observer_result.h" #include "opentelemetry/sdk/metrics/push_metric_exporter.h" #include "opentelemetry/sdk/metrics/state/attributes_hashmap.h" #include "opentelemetry/sdk/metrics/view/attributes_processor.h" From 36d47c2952a4c69ec299b547cdc5a33ffb435ee0 Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Mon, 13 Oct 2025 13:38:06 +0530 Subject: [PATCH 4/5] Measurements name change --- .../sdk/metrics/observer_result.h | 4 +-- .../sdk/metrics/state/async_metric_storage.h | 6 ++-- .../state/measurement_attributes_map.h | 2 +- .../sdk/metrics/state/metric_storage.h | 20 ++++++------- .../sdk/metrics/state/multi_metric_storage.h | 4 +-- sdk/test/metrics/async_metric_storage_test.cc | 28 +++++++++---------- 6 files changed, 30 insertions(+), 34 deletions(-) diff --git a/sdk/include/opentelemetry/sdk/metrics/observer_result.h b/sdk/include/opentelemetry/sdk/metrics/observer_result.h index 9bf430a339..827f371368 100644 --- a/sdk/include/opentelemetry/sdk/metrics/observer_result.h +++ b/sdk/include/opentelemetry/sdk/metrics/observer_result.h @@ -42,10 +42,10 @@ class ObserverResultT final : public opentelemetry::metrics::ObserverResultT data_[attr_map] += value; } - const MeasurementAttributes &GetMeasurements() { return data_; } + const Measurements &GetMeasurements() { return data_; } private: - MeasurementAttributes data_; + Measurements data_; }; } // namespace metrics diff --git a/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h b/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h index 8488e6f04b..a9ddde3ec2 100644 --- a/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h +++ b/sdk/include/opentelemetry/sdk/metrics/state/async_metric_storage.h @@ -99,7 +99,7 @@ class AsyncMetricStorage : public MetricStorage, public AsyncWritableMetricStora } } - void RecordLong(const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, + void RecordLong(const opentelemetry::sdk::metrics::Measurements &measurements, opentelemetry::common::SystemTimestamp observation_time) noexcept override { if (instrument_descriptor_.value_type_ != InstrumentValueType::kLong) @@ -111,7 +111,7 @@ class AsyncMetricStorage : public MetricStorage, public AsyncWritableMetricStora Record(mp, observation_time); } - void RecordDouble(const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, + void RecordDouble(const opentelemetry::sdk::metrics::Measurements &measurements, opentelemetry::common::SystemTimestamp observation_time) noexcept override { if (instrument_descriptor_.value_type_ != InstrumentValueType::kDouble) @@ -126,7 +126,7 @@ class AsyncMetricStorage : public MetricStorage, public AsyncWritableMetricStora template std::unordered_map ConvertMeasurementsToMetricAttributes( - const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, + const opentelemetry::sdk::metrics::Measurements &measurements, opentelemetry::common::SystemTimestamp /* observation_time */) noexcept { std::unordered_map mp; diff --git a/sdk/include/opentelemetry/sdk/metrics/state/measurement_attributes_map.h b/sdk/include/opentelemetry/sdk/metrics/state/measurement_attributes_map.h index 4f3a27dcfc..82b6d549ac 100644 --- a/sdk/include/opentelemetry/sdk/metrics/state/measurement_attributes_map.h +++ b/sdk/include/opentelemetry/sdk/metrics/state/measurement_attributes_map.h @@ -146,7 +146,7 @@ struct AttributeMapEqual }; template -using MeasurementAttributes = std::unordered_map< +using Measurements = std::unordered_map< std::unordered_map, T, AttributeMapHash, diff --git a/sdk/include/opentelemetry/sdk/metrics/state/metric_storage.h b/sdk/include/opentelemetry/sdk/metrics/state/metric_storage.h index a50b4e0433..0df7499ccd 100644 --- a/sdk/include/opentelemetry/sdk/metrics/state/metric_storage.h +++ b/sdk/include/opentelemetry/sdk/metrics/state/metric_storage.h @@ -73,13 +73,11 @@ class AsyncWritableMetricStorage virtual ~AsyncWritableMetricStorage() = default; /* Records a batch of measurements */ - virtual void RecordLong( - const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, - opentelemetry::common::SystemTimestamp observation_time) noexcept = 0; + virtual void RecordLong(const opentelemetry::sdk::metrics::Measurements &measurements, + opentelemetry::common::SystemTimestamp observation_time) noexcept = 0; - virtual void RecordDouble( - const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, - opentelemetry::common::SystemTimestamp observation_time) noexcept = 0; + virtual void RecordDouble(const opentelemetry::sdk::metrics::Measurements &measurements, + opentelemetry::common::SystemTimestamp observation_time) noexcept = 0; }; class NoopMetricStorage : public MetricStorage @@ -120,14 +118,12 @@ class NoopWritableMetricStorage : public SyncWritableMetricStorage class NoopAsyncWritableMetricStorage : public AsyncWritableMetricStorage { public: - void RecordLong( - const opentelemetry::sdk::metrics::MeasurementAttributes & /* measurements */, - opentelemetry::common::SystemTimestamp /* observation_time */) noexcept override + void RecordLong(const opentelemetry::sdk::metrics::Measurements & /* measurements */, + opentelemetry::common::SystemTimestamp /* observation_time */) noexcept override {} - void RecordDouble( - const opentelemetry::sdk::metrics::MeasurementAttributes & /* measurements */, - opentelemetry::common::SystemTimestamp /* observation_time */) noexcept override + void RecordDouble(const opentelemetry::sdk::metrics::Measurements & /* measurements */, + opentelemetry::common::SystemTimestamp /* observation_time */) noexcept override {} }; diff --git a/sdk/include/opentelemetry/sdk/metrics/state/multi_metric_storage.h b/sdk/include/opentelemetry/sdk/metrics/state/multi_metric_storage.h index 03bd5c25b7..5a8c232571 100644 --- a/sdk/include/opentelemetry/sdk/metrics/state/multi_metric_storage.h +++ b/sdk/include/opentelemetry/sdk/metrics/state/multi_metric_storage.h @@ -81,7 +81,7 @@ class AsyncMultiMetricStorage : public AsyncWritableMetricStorage storages_.push_back(storage); } - void RecordLong(const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, + void RecordLong(const opentelemetry::sdk::metrics::Measurements &measurements, opentelemetry::common::SystemTimestamp observation_time) noexcept override { for (auto &s : storages_) @@ -90,7 +90,7 @@ class AsyncMultiMetricStorage : public AsyncWritableMetricStorage } } - void RecordDouble(const opentelemetry::sdk::metrics::MeasurementAttributes &measurements, + void RecordDouble(const opentelemetry::sdk::metrics::Measurements &measurements, opentelemetry::common::SystemTimestamp observation_time) noexcept override { for (auto &s : storages_) diff --git a/sdk/test/metrics/async_metric_storage_test.cc b/sdk/test/metrics/async_metric_storage_test.cc index 3549d798d2..7019a2a103 100644 --- a/sdk/test/metrics/async_metric_storage_test.cc +++ b/sdk/test/metrics/async_metric_storage_test.cc @@ -73,9 +73,9 @@ TEST_P(WritableMetricStorageTestFixture, TestAggregation) ExemplarFilterType::kAlwaysOff, ExemplarReservoir::GetNoExemplarReservoir(), #endif nullptr); - int64_t get_count1 = 20; - int64_t put_count1 = 10; - opentelemetry::sdk::metrics::MeasurementAttributes measurements1 = { + int64_t get_count1 = 20; + int64_t put_count1 = 10; + opentelemetry::sdk::metrics::Measurements measurements1 = { {{{"RequestType", "GET"}}, get_count1}, {{{"RequestType", "PUT"}}, put_count1}}; storage.RecordLong(measurements1, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); @@ -104,7 +104,7 @@ TEST_P(WritableMetricStorageTestFixture, TestAggregation) int64_t get_count2 = 50; int64_t put_count2 = 70; - opentelemetry::sdk::metrics::MeasurementAttributes measurements2 = { + opentelemetry::sdk::metrics::Measurements measurements2 = { {{{"RequestType", "GET"}}, get_count2}, {{{"RequestType", "PUT"}}, put_count2}}; storage.RecordLong(measurements2, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); @@ -172,9 +172,9 @@ TEST_P(WritableMetricStorageTestUpDownFixture, TestAggregation) ExemplarFilterType::kAlwaysOff, ExemplarReservoir::GetNoExemplarReservoir(), #endif nullptr); - int64_t get_count1 = 20; - int64_t put_count1 = 10; - opentelemetry::sdk::metrics::MeasurementAttributes measurements1 = { + int64_t get_count1 = 20; + int64_t put_count1 = 10; + opentelemetry::sdk::metrics::Measurements measurements1 = { {{{"RequestType", "GET"}}, get_count1}, {{{"RequestType", "PUT"}}, put_count1}}; storage.RecordLong(measurements1, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); @@ -204,7 +204,7 @@ TEST_P(WritableMetricStorageTestUpDownFixture, TestAggregation) int64_t get_count2 = -50; int64_t put_count2 = -70; - opentelemetry::sdk::metrics::MeasurementAttributes measurements2 = { + opentelemetry::sdk::metrics::Measurements measurements2 = { {{{"RequestType", "GET"}}, get_count2}, {{{"RequestType", "PUT"}}, put_count2}}; storage.RecordLong(measurements2, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); @@ -271,10 +271,10 @@ TEST_P(WritableMetricStorageTestObservableGaugeFixture, TestAggregation) ExemplarFilterType::kAlwaysOff, ExemplarReservoir::GetNoExemplarReservoir(), #endif nullptr); - int64_t freq_cpu0 = 3; - int64_t freq_cpu1 = 5; - opentelemetry::sdk::metrics::MeasurementAttributes measurements1 = { - {{{"CPU", "0"}}, freq_cpu0}, {{{"CPU", "1"}}, freq_cpu1}}; + int64_t freq_cpu0 = 3; + int64_t freq_cpu1 = 5; + opentelemetry::sdk::metrics::Measurements measurements1 = {{{{"CPU", "0"}}, freq_cpu0}, + {{{"CPU", "1"}}, freq_cpu1}}; storage.RecordLong(measurements1, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); @@ -300,8 +300,8 @@ TEST_P(WritableMetricStorageTestObservableGaugeFixture, TestAggregation) freq_cpu0 = 6; freq_cpu1 = 8; - opentelemetry::sdk::metrics::MeasurementAttributes measurements2 = { - {{{"CPU", "0"}}, freq_cpu0}, {{{"CPU", "1"}}, freq_cpu1}}; + opentelemetry::sdk::metrics::Measurements measurements2 = {{{{"CPU", "0"}}, freq_cpu0}, + {{{"CPU", "1"}}, freq_cpu1}}; storage.RecordLong(measurements2, opentelemetry::common::SystemTimestamp(std::chrono::system_clock::now())); storage.Collect( From 880567f3dcfaaf9878303b81f727b18ebc558f8e Mon Sep 17 00:00:00 2001 From: nikhilbhatia08 Date: Wed, 15 Oct 2025 07:59:00 +0530 Subject: [PATCH 5/5] resolve merge conflicts --- sdk/src/metrics/state/observable_registry.cc | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/sdk/src/metrics/state/observable_registry.cc b/sdk/src/metrics/state/observable_registry.cc index 086b7cc8d1..025e263f25 100644 --- a/sdk/src/metrics/state/observable_registry.cc +++ b/sdk/src/metrics/state/observable_registry.cc @@ -126,13 +126,6 @@ void ObservableRegistry::CleanupCallback(opentelemetry::metrics::ObservableInstr } else { - nostd::shared_ptr> ob_res( - new opentelemetry::sdk::metrics::ObserverResultT()); - callback_wrap->callback(ob_res, callback_wrap->state); - storage->RecordDouble( - static_cast *>(ob_res.get()) - ->GetMeasurements(), - collection_ts); ++it; } } @@ -151,13 +144,6 @@ class ObserverResultTAdapter : public opentelemetry::metrics::ObserverResultT { if (inner) { - nostd::shared_ptr> ob_res( - new opentelemetry::sdk::metrics::ObserverResultT()); - callback_wrap->callback(ob_res, callback_wrap->state); - storage->RecordLong( - static_cast *>(ob_res.get()) - ->GetMeasurements(), - collection_ts); inner->Observe(value); } }