ceph/src/jaegertracing/opentelemetry-cpp/sdk/test/metrics/async_metric_storage_test.cc

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