cartographer/cartographer_grpc/metrics/prometheus/metrics_test.cc

149 lines
5.1 KiB
C++

/*
* Copyright 2018 The Cartographer Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "cartographer/metrics/family_factory.h"
#include "cartographer/metrics/register.h"
#include "cartographer_grpc/metrics/prometheus/family_factory.h"
#include "glog/logging.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "prometheus/exposer.h"
namespace cartographer_grpc {
namespace metrics {
namespace prometheus {
namespace {
static auto* kCounter = cartographer::metrics::Counter::Null();
static auto* kGauge = cartographer::metrics::Gauge::Null();
static auto* kScoresMetric = cartographer::metrics::Histogram::Null();
const char kLabelKey[] = "kind";
const char kLabelValue[] = "score";
const std::array<double, 5> kObserveScores = {{-1, 0.11, 0.2, 0.5, 2}};
class Algorithm {
public:
static void RegisterMetrics(cartographer::metrics::FamilyFactory* factory) {
auto boundaries = cartographer::metrics::Histogram::FixedWidth(0.05, 20);
auto* scores_family = factory->NewHistogramFamily(
"/algorithm/scores", "Scores achieved", boundaries);
kScoresMetric = scores_family->Add({{kLabelKey, kLabelValue}});
}
void Run() {
for (double score : kObserveScores) {
kScoresMetric->Observe(score);
}
}
};
TEST(MetricsTest, CollectCounter) {
FamilyFactory factory;
auto* counter_family = factory.NewCounterFamily("/test/hits", "Hits");
kCounter = counter_family->Add({{kLabelKey, kLabelValue}});
kCounter->Increment();
kCounter->Increment(5);
double expected_value = 1 + 5;
std::vector<::io::prometheus::client::MetricFamily> collected;
{
std::shared_ptr<::prometheus::Collectable> collectable;
CHECK(collectable = factory.GetCollectable().lock());
collected = collectable->Collect();
}
ASSERT_EQ(collected.size(), 1);
ASSERT_EQ(collected[0].metric_size(), 1);
EXPECT_THAT(
collected[0].metric(0).label(),
testing::AllOf(
testing::ElementsAre(testing::Property(
&io::prometheus::client::LabelPair::name, kLabelKey)),
testing::ElementsAre(testing::Property(
&io::prometheus::client::LabelPair::value, kLabelValue))));
EXPECT_THAT(collected[0].metric(0).counter().value(),
testing::DoubleEq(expected_value));
}
TEST(MetricsTest, CollectGauge) {
FamilyFactory factory;
auto* gauge_family =
factory.NewGaugeFamily("/test/queue/length", "Length of some queue");
kGauge = gauge_family->Add({{kLabelKey, kLabelValue}});
kGauge->Increment();
kGauge->Increment(5);
kGauge->Decrement();
kGauge->Decrement(2);
double expected_value = 1 + 5 - 1 - 2;
std::vector<::io::prometheus::client::MetricFamily> collected;
{
std::shared_ptr<::prometheus::Collectable> collectable;
CHECK(collectable = factory.GetCollectable().lock());
collected = collectable->Collect();
}
ASSERT_EQ(collected.size(), 1);
ASSERT_EQ(collected[0].metric_size(), 1);
EXPECT_THAT(
collected[0].metric(0).label(),
testing::AllOf(
testing::ElementsAre(testing::Property(
&io::prometheus::client::LabelPair::name, kLabelKey)),
testing::ElementsAre(testing::Property(
&io::prometheus::client::LabelPair::value, kLabelValue))));
EXPECT_THAT(collected[0].metric(0).gauge().value(),
testing::DoubleEq(expected_value));
}
TEST(MetricsTest, CollectHistogram) {
FamilyFactory registry;
Algorithm::RegisterMetrics(&registry);
Algorithm algorithm;
algorithm.Run();
std::vector<::io::prometheus::client::MetricFamily> collected;
{
std::shared_ptr<::prometheus::Collectable> collectable;
CHECK(collectable = registry.GetCollectable().lock());
collected = collectable->Collect();
}
ASSERT_EQ(collected.size(), 1);
ASSERT_EQ(collected[0].metric_size(), 1);
EXPECT_THAT(
collected[0].metric(0).label(),
testing::AllOf(
testing::ElementsAre(testing::Property(
&io::prometheus::client::LabelPair::name, kLabelKey)),
testing::ElementsAre(testing::Property(
&io::prometheus::client::LabelPair::value, kLabelValue))));
EXPECT_THAT(collected[0].metric(0).histogram().sample_count(),
testing::Eq(kObserveScores.size()));
EXPECT_EQ(collected[0].metric(0).histogram().bucket(0).cumulative_count(), 1);
}
TEST(MetricsTest, RunExposerServer) {
FamilyFactory registry;
Algorithm::RegisterMetrics(&registry);
cartographer::metrics::RegisterAllMetrics(&registry);
::prometheus::Exposer exposer("0.0.0.0:9100");
exposer.RegisterCollectable(registry.GetCollectable());
Algorithm algorithm;
algorithm.Run();
}
} // namespace
} // namespace prometheus
} // namespace metrics
} // namespace cartographer_grpc