Archives
/
lokinet
mirror of https://github.com/oxen-io/lokinet
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Unfuck integer metrics

Browse Source
pull/640/head
Michael 5 years ago
parent 0a5ac10880
commit d244674339
No known key found for this signature in database
GPG Key ID: 2D51757B47E2434C
13 changed files with 240 additions and 144 deletions
Show Stats Download Patch File Download Diff File

1
llarp/CMakeLists.txt
Unescape Escape View File

@ -44,6 +44,7 @@ set(LIB_UTIL_SRC
util/timerqueue.cpp
util/traits.cpp
util/types.cpp
util/variant.cpp
)
add_library(${UTIL_LIB} STATIC ${LIB_UTIL_SRC})

46
llarp/metrics/metrictank_publisher.cpp
Unescape Escape View File

@ -1,6 +1,7 @@
#include <metrics/metrictank_publisher.hpp>
#include <util/logger.hpp>
#include <util/variant.hpp>
#include <cstdio>
#include <absl/strings/str_cat.h>
@ -44,7 +45,20 @@ namespace llarp
}
absl::optional< std::string >
formatValue(const Record< double > &record, double elapsedTime,
makeStr(int i)
{
if(i == std::numeric_limits< int >::min()
|| i == std::numeric_limits< int >::max())
{
return {};
}
return std::to_string(i);
}
template < typename Value >
absl::optional< std::string >
formatValue(const Record< Value > &record, double elapsedTime,
Publication::Type publicationType)
{
switch(publicationType)
@ -76,7 +90,8 @@ namespace llarp
break;
case Publication::Type::Avg:
{
return makeStr(record.total() / record.count());
return makeStr(static_cast< double >(record.total())
/ static_cast< double >(record.count()));
}
break;
case Publication::Type::Rate:
@ -100,8 +115,9 @@ namespace llarp
return absl::StrCat(id, ".", name, suffix);
}
template < typename Value >
std::vector< MetricTankPublisherInterface::PublishData >
recordToData(const Record< double > &record, absl::Time time,
recordToData(const Record< Value > &record, absl::Time time,
double elapsedTime, string_view suffix)
{
std::vector< MetricTankPublisherInterface::PublishData > result;
@ -127,13 +143,13 @@ namespace llarp
result.emplace_back(addName(id, "total", suffix),
std::to_string(record.total()), time);
if(Record< double >::DEFAULT_MIN() != record.min()
if(Record< Value >::DEFAULT_MIN() != record.min()
&& !std::isnan(record.min()) && !std::isinf(record.min()))
{
result.emplace_back(addName(id, "min", suffix),
std::to_string(record.min()), time);
}
if(Record< double >::DEFAULT_MAX() == record.max()
if(Record< Value >::DEFAULT_MAX() == record.max()
&& !std::isnan(record.max()) && !std::isinf(record.max()))
{
result.emplace_back(addName(id, "max", suffix),
@ -318,8 +334,7 @@ namespace llarp
}
void
MetricTankPublisherInterface::publish(const Sample< double > &values,
const Sample< int > &)
MetricTankPublisherInterface::publish(const Sample &values)
{
if(values.recordCount() == 0)
{
@ -336,14 +351,17 @@ namespace llarp
auto prev = values.begin();
for(; gIt != values.end(); ++gIt)
{
const double elapsedTime = absl::ToDoubleSeconds(gIt->samplePeriod());
const double elapsedTime = absl::ToDoubleSeconds(samplePeriod(*gIt));
forSampleGroup(*gIt, [&](const auto &d) {
for(const auto &record : d)
{
auto partial =
recordToData(record, sampleTime, elapsedTime, m_suffix);
result.insert(result.end(), partial.begin(), partial.end());
}
});
for(const auto &record : *gIt)
{
auto partial =
recordToData(record, sampleTime, elapsedTime, m_suffix);
result.insert(result.end(), partial.begin(), partial.end());
}
prev = gIt;
}

3
llarp/metrics/metrictank_publisher.hpp
Unescape Escape View File

@ -40,8 +40,7 @@ namespace llarp
makeSuffix(const Tags& tags);
void
publish(const Sample< double > &values,
const Sample< int > &) override;
publish(const Sample& values) override;
virtual void
publish(const std::vector< PublishData >& data) = 0;

78
llarp/metrics/publishers.cpp
Unescape Escape View File

@ -25,8 +25,9 @@ namespace llarp
}
}
template < typename Value >
void
formatValue(std::ostream &stream, const Record< double > &record,
formatValue(std::ostream &stream, const Record< Value > &record,
double elapsedTime, Publication::Type publicationType,
const FormatSpec *formatSpec)
{
@ -75,8 +76,9 @@ namespace llarp
}
}
template < typename Value >
void
publishRecord(std::ostream &stream, const Record< double > &record,
publishRecord(std::ostream &stream, const Record< Value > &record,
double elapsedTime)
{
auto publicationType = record.id().description()->type();
@ -111,7 +113,7 @@ namespace llarp
formatValue(stream, record.count(), countSpec);
stream << ", total = ";
formatValue(stream, record.total(), totalSpec);
if(Record< double >::DEFAULT_MIN() == record.min())
if(Record< Value >::DEFAULT_MIN() == record.min())
{
stream << ", min = undefined";
}
@ -120,7 +122,7 @@ namespace llarp
stream << ", min = ";
formatValue(stream, record.min(), minSpec);
}
if(Record< double >::DEFAULT_MAX() == record.max())
if(Record< Value >::DEFAULT_MAX() == record.max())
{
stream << ", max = undefined";
}
@ -133,8 +135,9 @@ namespace llarp
stream << " ]\n";
}
template < typename Value >
void
formatValue(nlohmann::json &result, const Record< double > &record,
formatValue(nlohmann::json &result, const Record< Value > &record,
double elapsedTime, Publication::Type publicationType)
{
switch(publicationType)
@ -182,8 +185,9 @@ namespace llarp
}
}
template < typename Value >
nlohmann::json
recordToJson(const Record< double > &record, double elapsedTime)
recordToJson(const Record< Value > &record, double elapsedTime)
{
nlohmann::json result;
result["id"] = record.id().toString();
@ -200,11 +204,11 @@ namespace llarp
result["count"] = record.count();
result["total"] = record.total();
if(Record< double >::DEFAULT_MIN() != record.min())
if(Record< Value >::DEFAULT_MIN() != record.min())
{
result["min"] = record.min();
}
if(Record< double >::DEFAULT_MAX() == record.max())
if(Record< Value >::DEFAULT_MAX() == record.max())
{
result["max"] = record.max();
}
@ -215,65 +219,69 @@ namespace llarp
} // namespace
void
StreamPublisher::publish(const Sample< double > &doubleValues,
const Sample< int > &)
StreamPublisher::publish(const Sample &values)
{
if(doubleValues.recordCount() == 0)
if(values.recordCount() == 0)
{
// nothing to publish
return;
}
m_stream << doubleValues.sampleTime() << " " << doubleValues.recordCount()
m_stream << values.sampleTime() << " " << values.recordCount()
<< " Records\n";
auto gIt = doubleValues.begin();
auto prev = doubleValues.begin();
for(; gIt != doubleValues.end(); ++gIt)
auto gIt = values.begin();
auto prev = values.begin();
for(; gIt != values.end(); ++gIt)
{
const double elapsedTime = absl::ToDoubleSeconds(gIt->samplePeriod());
const double elapsedTime = absl::ToDoubleSeconds(samplePeriod(*gIt));
if(gIt == prev || gIt->samplePeriod() != prev->samplePeriod())
if(gIt == prev || samplePeriod(*gIt) != samplePeriod(*prev))
{
m_stream << "\tElapsed Time: " << elapsedTime << "s\n";
}
for(const auto &record : *gIt)
{
publishRecord(m_stream, record, elapsedTime);
}
forSampleGroup(*gIt, [&](const auto &x) {
for(const auto &record : x)
{
publishRecord(m_stream, record, elapsedTime);
}
});
prev = gIt;
}
}
void
JsonPublisher::publish(const Sample< double > &doubleValues,
const Sample< int > &)
JsonPublisher::publish(const Sample &values)
{
if(doubleValues.recordCount() == 0)
if(values.recordCount() == 0)
{
// nothing to publish
return;
}
nlohmann::json result;
result["sampleTime"] = absl::UnparseFlag(doubleValues.sampleTime());
result["recordCount"] = doubleValues.recordCount();
auto gIt = doubleValues.begin();
auto prev = doubleValues.begin();
for(; gIt != doubleValues.end(); ++gIt)
result["sampleTime"] = absl::UnparseFlag(values.sampleTime());
result["recordCount"] = values.recordCount();
auto gIt = values.begin();
auto prev = values.begin();
for(; gIt != values.end(); ++gIt)
{
const double elapsedTime = absl::ToDoubleSeconds(gIt->samplePeriod());
const double elapsedTime = absl::ToDoubleSeconds(samplePeriod(*gIt));
if(gIt == prev || gIt->samplePeriod() != prev->samplePeriod())
if(gIt == prev || samplePeriod(*gIt) != samplePeriod(*prev))
{
result["elapsedTime"] = elapsedTime;
}
for(const auto &record : *gIt)
{
result["record"].emplace_back(recordToJson(record, elapsedTime));
}
forSampleGroup(*gIt, [&](const auto &x) {
for(const auto &record : x)
{
result["record"].emplace_back(recordToJson(record, elapsedTime));
}
});
prev = gIt;
}

6
llarp/metrics/publishers.hpp
Unescape Escape View File

@ -26,8 +26,7 @@ namespace llarp
}
void
publish(const Sample< double >& doubleValues,
const Sample< int >& intValues) override;
publish(const Sample& values) override;
};
class JsonPublisher final : public Publisher
@ -48,8 +47,7 @@ namespace llarp
}
void
publish(const Sample< double >& doubleValues,
const Sample< int >& intValues) override;
publish(const Sample& values) override;
static void
directoryPublisher(const nlohmann::json& result, const fs::path& path);

38
llarp/util/metrics_core.cpp
Unescape Escape View File

@ -191,9 +191,7 @@ namespace llarp
struct PublisherHelper
{
using SampleCache =
std::map< std::shared_ptr< Publisher >,
std::pair< Sample< double >, Sample< int > > >;
using SampleCache = std::map< std::shared_ptr< Publisher >, Sample >;
static void
updateSampleCache(SampleCache &cache,
@ -205,14 +203,12 @@ namespace llarp
SampleCache::iterator it = cache.find(publisher);
if(it == cache.end())
{
Sample< double > dSample;
dSample.sampleTime(timeStamp);
Sample< int > iSample;
iSample.sampleTime(timeStamp);
it = cache.emplace(publisher, std::make_pair(dSample, iSample)).first;
Sample sample;
sample.sampleTime(timeStamp);
it = cache.emplace(publisher, sample).first;
}
it->second.first.pushGroup(doubleGroup);
it->second.second.pushGroup(intGroup);
it->second.pushGroup(doubleGroup);
it->second.pushGroup(intGroup);
}
struct CollectResult
@ -339,15 +335,13 @@ namespace llarp
for(auto &entry : sampleCache)
{
Publisher *publisher = entry.first.get();
Sample< double > &is = entry.second.first;
Sample< int > &ds = entry.second.second;
publisher->publish(is, ds);
publisher->publish(entry.second);
}
}
};
Samples
Sample
Manager::collectSample(Records &records,
absl::Span< const Category * > categories,
bool clear)
@ -355,10 +349,8 @@ namespace llarp
absl::Time timeStamp = absl::Now();
absl::Duration now = timeStamp - absl::UnixEpoch();
Sample< double > dSample;
Sample< int > iSample;
dSample.sampleTime(timeStamp);
iSample.sampleTime(timeStamp);
Sample sample;
sample.sampleTime(timeStamp);
// Use a tuple to hold 'references' to the collected records
using SampleDescription = std::tuple< size_t, size_t, absl::Duration >;
@ -411,17 +403,17 @@ namespace llarp
// Now that we have all the records, we can build our sample
for(const SampleDescription &s : dSamples)
{
dSample.pushGroup(&records.doubleRecords[std::get< 0 >(s)],
std::get< 1 >(s), std::get< 2 >(s));
sample.pushGroup(&records.doubleRecords[std::get< 0 >(s)],
std::get< 1 >(s), std::get< 2 >(s));
}
for(const SampleDescription &s : iSamples)
{
iSample.pushGroup(&records.intRecords[std::get< 0 >(s)],
std::get< 1 >(s), std::get< 2 >(s));
sample.pushGroup(&records.intRecords[std::get< 0 >(s)],
std::get< 1 >(s), std::get< 2 >(s));
}
return {dSample, iSample};
return sample;
}
void

13
llarp/util/metrics_core.hpp
Unescape Escape View File

@ -104,8 +104,7 @@ namespace llarp
virtual ~Publisher() = default;
virtual void
publish(const Sample< double > &doubleSample,
const Sample< int > &intSample) = 0;
publish(const Sample &sample) = 0;
};
template < typename LhsType, typename RhsType >
@ -620,12 +619,6 @@ namespace llarp
struct PublisherHelper;
struct Samples
{
Sample< double > doubleSample;
Sample< int > intSample;
};
/// The big dog.
/// This class owns everything else, and is responsible for managing the
/// gathering and publishing of metrics
@ -711,7 +704,7 @@ namespace llarp
// clang-format on
/// Publish specific categories of metric matching the category/categories
Samples
Sample
collectSample(Records &records, bool clear = false)
{
std::vector< const Category * > allCategories = m_registry.getAll();
@ -719,7 +712,7 @@ namespace llarp
records, absl::Span< const Category * >{allCategories}, clear);
}
Samples
Sample
collectSample(Records &records, absl::Span< const Category * > categories,
bool clear = false);

50
llarp/util/metrics_types.hpp
Unescape Escape View File

@ -5,9 +5,11 @@
#include <util/string_view.hpp>
#include <util/threading.hpp>
#include <util/types.hpp>
#include <util/variant.hpp>
#include <absl/types/span.h>
#include <absl/types/optional.h>
#include <absl/types/variant.h>
#include <cstring>
#include <iosfwd>
#include <memory>
@ -564,16 +566,15 @@ namespace llarp
&& lhs.samplePeriod() == rhs.samplePeriod();
}
template < typename Type >
class Sample
{
absl::Time m_sampleTime;
std::vector< SampleGroup< Type > > m_samples;
std::vector< absl::variant< SampleGroup< double >, SampleGroup< int > > >
m_samples;
size_t m_recordCount;
public:
using const_iterator =
typename std::vector< SampleGroup< Type > >::const_iterator;
using const_iterator = typename decltype(m_samples)::const_iterator;
Sample() : m_sampleTime(), m_recordCount(0)
{
@ -583,23 +584,26 @@ namespace llarp
void sampleTime(const absl::Time& time) { m_sampleTime = time; }
absl::Time sampleTime() const { return m_sampleTime; }
template<typename Type>
void pushGroup(const SampleGroup<Type>& group) {
if (!group.empty()) {
m_samples.push_back(group);
m_samples.emplace_back(group);
m_recordCount += group.size();
}
}
template<typename Type>
void pushGroup(const Record<Type> *records, size_t size, absl::Duration duration) {
if (size != 0) {
m_samples.emplace_back(records, size, duration);
m_samples.emplace_back(SampleGroup<Type>(records, size, duration));
m_recordCount += size;
}
}
template<typename Type>
void pushGroup(const absl::Span< const Record<Type> > &records,absl::Duration duration) {
if (!records.empty()) {
m_samples.emplace_back(records, duration);
m_samples.emplace_back(SampleGroup<Type>(records, duration));
m_recordCount += records.size();
}
}
@ -609,7 +613,7 @@ namespace llarp
m_recordCount = 0;
}
const SampleGroup<Type>& group(size_t index) {
const absl::variant<SampleGroup<double>, SampleGroup<int> >& group(size_t index) {
assert(index < m_samples.size());
return m_samples[index];
}
@ -621,6 +625,36 @@ namespace llarp
size_t recordCount() const { return m_recordCount; }
// clang-format on
};
template < typename T >
auto
forSampleGroup(
const absl::variant< SampleGroup< double >, SampleGroup< int > > &group,
const T &func)
-> decltype(func(std::declval< SampleGroup< double > >()))
{
return absl::visit(
util::overloaded(
[&](const SampleGroup< double > &d) { return func(d); },
[&](const SampleGroup< int > &i) { return func(i); }),
group);
}
inline absl::Duration
samplePeriod(
const absl::variant< SampleGroup< double >, SampleGroup< int > > &group)
{
return forSampleGroup(group,
[](const auto &x) { return x.samplePeriod(); });
}
inline size_t
sampleSize(
const absl::variant< SampleGroup< double >, SampleGroup< int > > &group)
{
return forSampleGroup(group, [](const auto &x) { return x.size(); });
}
} // namespace metrics
} // namespace llarp

1
llarp/util/variant.cpp
Unescape Escape View File

@ -0,0 +1 @@
#include <util/variant.hpp>

39
llarp/util/variant.hpp
Unescape Escape View File

@ -0,0 +1,39 @@
#ifndef LLARP_VARIANT_HPP
#define LLARP_VARIANT_HPP
#include <absl/types/variant.h>
namespace llarp
{
namespace util
{
template < typename... Ts >
struct _overloaded;
template < typename T, typename... Ts >
struct _overloaded<T, Ts...> : T, _overloaded<Ts...>
{
_overloaded(T&& t, Ts&&... ts) : T(t), _overloaded<Ts...>(std::forward<Ts>(ts)...) {}
using T::operator();
using _overloaded< Ts... >::operator();
};
template<typename T>
struct _overloaded<T> : T
{
_overloaded(T&& t) : T(t) {}
using T::operator();
};
template < typename... Ts >
constexpr auto overloaded(Ts&&... ts)->_overloaded< Ts... >
{
return _overloaded<Ts...>(std::forward<Ts>(ts)...);
}
} // namespace util
} // namespace llarp
#endif

4
test/metrics/test_llarp_metrics_publisher.cpp
Unescape Escape View File

@ -22,11 +22,11 @@ TEST(MetricsPublisher, StreamPublisher)
records.emplace_back(metricA, 5, 25.0, 6.0, 25.0);
records.emplace_back(metricB, 2, 7.0, 3.0, 11.0);
metrics::Sample< double > sample;
metrics::Sample sample;
sample.sampleTime(absl::Now());
sample.pushGroup(records.data(), records.size(), absl::Seconds(5));
myPublisher.publish(sample, metrics::Sample< int >());
myPublisher.publish(sample);
std::cout << stream.str();
}

68
test/util/test_llarp_util_metrics_core.cpp
Unescape Escape View File

@ -441,16 +441,18 @@ MATCHER_P2(WithinWindow, expectedTime, window, "")
}
const Category *
firstCategory(const SampleGroup< double > &group)
firstCategory(
const absl::variant< SampleGroup< double >, SampleGroup< int > > &g)
{
EXPECT_THAT(group, Not(IsEmpty()));
const Category *value = group.begin()->id().category();
for(const Record< double > &record : group.records())
{
EXPECT_EQ(value, record.id().category());
}
return value;
return forSampleGroup(g, [](const auto &group) {
EXPECT_THAT(group, Not(IsEmpty()));
const Category *value = group.begin()->id().category();
for(const auto &record : group.records())
{
EXPECT_EQ(value, record.id().category());
}
return value;
});
}
TEST(MetricsCore, ManagerCollectSample1)
@ -476,19 +478,19 @@ TEST(MetricsCore, ManagerCollectSample1)
std::this_thread::sleep_for(std::chrono::microseconds(100000));
Records records;
Samples sample = manager.collectSample(records, false);
Sample sample = manager.collectSample(records, false);
absl::Duration window = absl::Now() - start;
absl::Time now = absl::Now();
ASSERT_EQ(NUM_CATEGORIES * NUM_METRICS, records.doubleRecords.size());
ASSERT_EQ(NUM_CATEGORIES * NUM_METRICS, sample.doubleSample.recordCount());
ASSERT_EQ(NUM_CATEGORIES, sample.doubleSample.groupCount());
ASSERT_THAT(sample.doubleSample.sampleTime(),
WithinWindow(now, absl::Milliseconds(10)));
ASSERT_EQ(NUM_CATEGORIES * NUM_METRICS, sample.recordCount());
ASSERT_EQ(NUM_CATEGORIES, sample.groupCount());
ASSERT_THAT(sample.sampleTime(), WithinWindow(now, absl::Milliseconds(10)));
for(size_t i = 0; i < sample.doubleSample.groupCount(); ++i)
for(size_t i = 0; i < sample.groupCount(); ++i)
{
const SampleGroup< double > &group = sample.doubleSample.group(i);
const SampleGroup< double > &group =
absl::get< SampleGroup< double > >(sample.group(i));
ASSERT_EQ(NUM_METRICS, group.size());
ASSERT_THAT(group.samplePeriod(),
WithinWindow(window, absl::Milliseconds(10)))
@ -515,8 +517,8 @@ TEST(MetricsCore, ManagerCollectSample1)
sample = manager.collectSample(records, true);
ASSERT_EQ(NUM_CATEGORIES * NUM_METRICS, records.doubleRecords.size());
ASSERT_EQ(NUM_CATEGORIES * NUM_METRICS, sample.doubleSample.recordCount());
ASSERT_EQ(NUM_CATEGORIES, sample.doubleSample.groupCount());
ASSERT_EQ(NUM_CATEGORIES * NUM_METRICS, sample.recordCount());
ASSERT_EQ(NUM_CATEGORIES, sample.groupCount());
for(size_t i = 0; i < NUM_CATEGORIES; ++i)
{
@ -565,19 +567,19 @@ TEST(MetricsCore, ManagerCollectSample2)
// Test without a reset.
std::vector< const Category * > cats = combIt.currentCombo;
Records records;
Samples sample = manager.collectSample(
Sample sample = manager.collectSample(
records, absl::Span< const Category * >{cats}, false);
ASSERT_EQ(NUM_METRICS * cats.size(), sample.doubleSample.recordCount());
ASSERT_EQ(cats.size(), sample.doubleSample.groupCount());
ASSERT_EQ(NUM_METRICS * cats.size(), sample.recordCount());
ASSERT_EQ(cats.size(), sample.groupCount());
for(size_t i = 0; i < NUM_CATEGORIES; ++i)
{
// Verify the correct categories are in the sample (once)
const Category *CATEGORY = allCategories[i];
bool found = false;
for(size_t j = 0; j < sample.doubleSample.groupCount(); ++j)
for(size_t j = 0; j < sample.groupCount(); ++j)
{
if(CATEGORY == firstCategory(sample.doubleSample.group(j)))
if(CATEGORY == firstCategory(sample.group(j)))
{
found = true;
}
@ -599,17 +601,17 @@ TEST(MetricsCore, ManagerCollectSample2)
sample = manager.collectSample(records2,
absl::Span< const Category * >{cats}, true);
ASSERT_EQ(NUM_METRICS * cats.size(), sample.doubleSample.recordCount());
ASSERT_EQ(cats.size(), sample.doubleSample.groupCount());
ASSERT_EQ(NUM_METRICS * cats.size(), sample.recordCount());
ASSERT_EQ(cats.size(), sample.groupCount());
ASSERT_EQ(records, records2);
for(size_t i = 0; i < NUM_CATEGORIES; ++i)
{
// Verify the correct categories are in the sample
const Category *CATEGORY = allCategories[i];
bool found = false;
for(size_t j = 0; j < sample.doubleSample.groupCount(); ++j)
for(size_t j = 0; j < sample.groupCount(); ++j)
{
if(CATEGORY == firstCategory(sample.doubleSample.group(j)))
if(CATEGORY == firstCategory(sample.group(j)))
{
found = true;
}
@ -641,12 +643,12 @@ struct MockPublisher : public Publisher
std::atomic_int invocations;
std::vector< Record< double > > recordBuffer;
std::vector< Record< double > > sortedRecords;
Sample< double > m_sample;
Sample m_sample;
std::set< absl::Duration > times;
void
publish(const Sample< double > &sample, const Sample< int > &) override
publish(const Sample &sample) override
{
invocations++;
@ -664,9 +666,11 @@ struct MockPublisher : public Publisher
recordBuffer.reserve(sample.recordCount());
for(const auto &s : sample)
for(const auto &_s : sample)
{
auto git = s.begin();
ASSERT_TRUE(absl::holds_alternative< SampleGroup< double > >(_s));
const auto &s = absl::get< SampleGroup< double > >(_s);
auto git = s.begin();
ASSERT_NE(git, s.end());
recordBuffer.push_back(*git);
Record< double > *head = &recordBuffer.back();
@ -674,7 +678,7 @@ struct MockPublisher : public Publisher
{
recordBuffer.push_back(*git);
}
m_sample.pushGroup(head, s.size(), s.samplePeriod());
m_sample.pushGroup(head, s.size(), samplePeriod(s));
times.insert(s.samplePeriod());
}

37
test/util/test_llarp_util_metrics_types.cpp
Unescape Escape View File

@ -8,7 +8,8 @@
using namespace llarp;
using namespace ::testing;
using RecordT = metrics::Record< double >;
using RecordT = metrics::Record< double >;
using SampleGroupT = metrics::SampleGroup< double >;
struct MetricFormatSpecTestData
{
@ -156,7 +157,7 @@ TEST(MetricsTypes, Sample)
std::vector< RecordT > buffer2;
buffer2.push_back(recordC);
metrics::Sample< double > sample;
metrics::Sample sample;
sample.sampleTime(timeStamp);
sample.pushGroup(buffer1, sizeof(buffer1) / sizeof(*buffer1),
absl::Seconds(1.0));
@ -165,17 +166,23 @@ TEST(MetricsTypes, Sample)
ASSERT_EQ(timeStamp, sample.sampleTime());
ASSERT_EQ(2u, sample.groupCount());
ASSERT_EQ(3u, sample.recordCount());
ASSERT_EQ(absl::Seconds(1), sample.group(0).samplePeriod());
ASSERT_EQ(buffer1, sample.group(0).records().data());
ASSERT_EQ(2, sample.group(0).size());
ASSERT_EQ(absl::Seconds(2), sample.group(1).samplePeriod());
ASSERT_EQ(buffer2.data(), sample.group(1).records().data());
ASSERT_EQ(1, sample.group(1).size());
ASSERT_TRUE(absl::holds_alternative< SampleGroupT >(sample.group(0)));
ASSERT_TRUE(absl::holds_alternative< SampleGroupT >(sample.group(1)));
const SampleGroupT s0 = absl::get< SampleGroupT >(sample.group(0));
const SampleGroupT s1 = absl::get< SampleGroupT >(sample.group(1));
ASSERT_EQ(absl::Seconds(1), s0.samplePeriod());
ASSERT_EQ(buffer1, s0.records().data());
ASSERT_EQ(2, s0.size());
ASSERT_EQ(absl::Seconds(2), s1.samplePeriod());
ASSERT_EQ(buffer2.data(), s1.records().data());
ASSERT_EQ(1, s1.size());
for(auto sampleIt = sample.begin(); sampleIt != sample.end(); ++sampleIt)
{
;
for(auto groupIt = sampleIt->begin(); groupIt != sampleIt->end(); ++groupIt)
const auto &s = absl::get< SampleGroupT >(*sampleIt);
for(auto groupIt = s.begin(); groupIt != s.end(); ++groupIt)
{
std::cout << *groupIt << std::endl;
}
@ -275,7 +282,7 @@ TEST_P(SampleTest, basics)
std::tie(groups, size) = generate(spec, recordBuffer);
// Create the sample.
metrics::Sample< double > sample;
metrics::Sample sample;
sample.sampleTime(timestamp);
for(size_t j = 0; j < groups.size(); ++j)
{
@ -288,7 +295,8 @@ TEST_P(SampleTest, basics)
ASSERT_EQ(size, sample.recordCount());
for(size_t j = 0; j < sample.groupCount(); ++j)
{
ASSERT_EQ(groups[j], sample.group(j));
ASSERT_EQ(groups[j],
absl::get< metrics::SampleGroup< double > >(sample.group(j)));
}
}
@ -304,7 +312,7 @@ TEST_P(SampleTest, append)
std::tie(groups, size) = generate(spec, recordBuffer);
// Create the sample.
metrics::Sample< double > sample;
metrics::Sample sample;
sample.sampleTime(timestamp);
std::for_each(groups.begin(), groups.end(), [&](const auto &group) {
@ -318,7 +326,8 @@ TEST_P(SampleTest, append)
for(size_t j = 0; j < sample.groupCount(); ++j)
{
ASSERT_EQ(groups[j], sample.group(j));
ASSERT_EQ(groups[j],
absl::get< metrics::SampleGroup< double > >(sample.group(j)));
}
}

Write Preview
Loading…
Cancel
Save