1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0
#ifndef ENABLE_METRICS_PREVIEW
# include "opentelemetry/sdk/metrics/state/async_metric_storage.h"
# include "opentelemetry/common/key_value_iterable_view.h"
# include "opentelemetry/sdk/metrics/instruments.h"
# include "opentelemetry/sdk/metrics/meter_context.h"
# include "opentelemetry/sdk/metrics/metric_exporter.h"
# include "opentelemetry/sdk/metrics/metric_reader.h"
# include "opentelemetry/sdk/metrics/observer_result.h"
# include "opentelemetry/sdk/metrics/state/metric_collector.h"
# include <gtest/gtest.h>
# include <vector>
using namespace opentelemetry::sdk::metrics;
using namespace opentelemetry::sdk::instrumentationlibrary;
using namespace opentelemetry::sdk::resource;
using namespace opentelemetry::sdk::metrics;
using namespace opentelemetry::common;
using M = std::map<std::string, std::string>;
class MockCollectorHandle : public CollectorHandle
{
public:
MockCollectorHandle(AggregationTemporality temp) : temporality(temp) {}
AggregationTemporality GetAggregationTemporality() noexcept override { return temporality; }
private:
AggregationTemporality temporality;
};
class WritableMetricStorageTestFixture : public ::testing::TestWithParam<AggregationTemporality>
{};
class MeasurementFetcher
{
public:
static void Fetcher(opentelemetry::metrics::ObserverResult<long> &observer_result,
void * /*state*/)
{
fetch_count++;
if (fetch_count == 1)
{
observer_result.Observe(20l, {{"RequestType", "GET"}});
observer_result.Observe(10l, {{"RequestType", "PUT"}});
number_of_get += 20l;
number_of_put += 10l;
}
else if (fetch_count == 2)
{
observer_result.Observe(40l, {{"RequestType", "GET"}});
observer_result.Observe(20l, {{"RequestType", "PUT"}});
number_of_get += 40l;
number_of_put += 20l;
}
}
static void init_values()
{
fetch_count = 0;
number_of_get = 0;
number_of_put = 0;
}
static size_t fetch_count;
static long number_of_get;
static long number_of_put;
static const size_t number_of_attributes = 2; // GET , PUT
};
size_t MeasurementFetcher::fetch_count;
long MeasurementFetcher::number_of_get;
long MeasurementFetcher::number_of_put;
const size_t MeasurementFetcher::number_of_attributes;
TEST_P(WritableMetricStorageTestFixture, TestAggregation)
{
MeasurementFetcher::init_values();
AggregationTemporality temporality = GetParam();
InstrumentDescriptor instr_desc = {"name", "desc", "1unit", InstrumentType::kObservableCounter,
InstrumentValueType::kLong};
auto sdk_start_ts = std::chrono::system_clock::now();
// Some computation here
auto collection_ts = std::chrono::system_clock::now() + std::chrono::seconds(5);
std::shared_ptr<CollectorHandle> collector(new MockCollectorHandle(temporality));
std::vector<std::shared_ptr<CollectorHandle>> collectors;
collectors.push_back(collector);
size_t count_attributes = 0;
long value = 0;
MeasurementFetcher measurement_fetcher;
opentelemetry::sdk::metrics::AsyncMetricStorage<long> storage(instr_desc, AggregationType::kSum,
MeasurementFetcher::Fetcher,
new DefaultAttributesProcessor());
storage.Collect(collector.get(), collectors, sdk_start_ts, collection_ts,
[&](const MetricData data) {
for (auto data_attr : data.point_data_attr_)
{
auto data = opentelemetry::nostd::get<SumPointData>(data_attr.point_data);
if (opentelemetry::nostd::get<std::string>(
data_attr.attributes.find("RequestType")->second) == "GET")
{
EXPECT_EQ(opentelemetry::nostd::get<long>(data.value_),
MeasurementFetcher::number_of_get);
}
else if (opentelemetry::nostd::get<std::string>(
data_attr.attributes.find("RequestType")->second) == "PUT")
{
EXPECT_EQ(opentelemetry::nostd::get<long>(data.value_),
MeasurementFetcher::number_of_put);
}
count_attributes++;
}
return true;
});
EXPECT_EQ(MeasurementFetcher::number_of_attributes, count_attributes);
}
INSTANTIATE_TEST_SUITE_P(WritableMetricStorageTestLong,
WritableMetricStorageTestFixture,
::testing::Values(AggregationTemporality::kCumulative,
AggregationTemporality::kDelta));
#endif
|
