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

Publish metric tags

Browse Source
pull/646/head
Michael 5 years ago
parent 7d4126407c
commit 95646d2d87
No known key found for this signature in database
GPG Key ID: 2D51757B47E2434C
13 changed files with 121 additions and 232 deletions
Show Stats Download Patch File Download Diff File

2
llarp/dnsc.cpp
Unescape Escape View File

@ -17,8 +17,6 @@
#include <algorithm> // for std::find_if
#include <stdio.h> // sprintf
#define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
dns_tracker dns_udp_tracker;
/*

2
llarp/handlers/exit.cpp
Unescape Escape View File

@ -28,7 +28,7 @@ namespace llarp
, m_Resolver(std::make_shared< dns::Proxy >(
r->netloop(), r->logic(), r->netloop(), r->logic(), this))
, m_Name(name)
, m_Tun{{0}, 0, {0}, 0, 0, 0, 0, 0, 0, 0}
, m_Tun{{0}, 0, {0}, 0, 0, 0, 0, 0, 0, 0, 0}
, m_LocalResolverAddr("127.0.0.1", 53)
, m_InetToNetwork(name + "_exit_rx", r->netloop(), r->netloop())

4
llarp/messages/link_message.cpp
Unescape Escape View File

@ -95,8 +95,8 @@ namespace llarp
if(!isLIM)
{
const std::string host = "RX_" + RouterID(from->GetPubKey()).ToString();
METRICS_DYNAMIC_INCREMENT(msg->Name(), host.c_str());
metrics::integerTick(msg->Name(), "RX", 1, "id",
RouterID(from->GetPubKey()).ToString());
}
msg->session = from;

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

@ -91,11 +91,11 @@ namespace llarp
return;
}
stream << "\t\t" << taggedRecords.id << " [\n";
stream << "\t\t" << taggedRecords.id << " [";
for(const auto &rec : taggedRecords.data)
{
stream << "\t\t\t";
stream << "\n\t\t\t";
const auto &tags = rec.first;
const auto &record = rec.second;

5
llarp/router/router.cpp
Unescape Escape View File

@ -1393,15 +1393,14 @@ namespace llarp
bool
Router::Sign(Signature &sig, const llarp_buffer_t &buf) const
{
METRICS_TIME_BLOCK("Router", "Sign");
metrics::TimerGuard t("Router", "Sign");
return CryptoManager::instance()->sign(sig, identity(), buf);
}
void
Router::SendTo(RouterID remote, const ILinkMessage *msg, ILinkLayer *selected)
{
const std::string remoteName = "TX_" + remote.ToString();
METRICS_DYNAMIC_INCREMENT(msg->Name(), remoteName.c_str());
metrics::integerTick(msg->Name(), "to", 1, "tx", remote.ToString());
llarp_buffer_t buf(linkmsg_buffer);
if(!msg->BEncode(&buf))

141
llarp/util/metrics.hpp
Unescape Escape View File

@ -3,6 +3,7 @@
#include <util/metrics_types.hpp>
#include <util/metrics_core.hpp>
#include <util/string_view.hpp>
namespace llarp
{
@ -25,6 +26,23 @@ namespace llarp
return manager->registry().publicationType(id, type);
}
};
template < typename... TagVals >
void
integerTick(string_view category, string_view metric, int val,
TagVals&&... tags)
{
if(DefaultManager::instance())
{
CollectorRepo< int >& repository =
DefaultManager::instance()->intCollectorRepo();
IntCollector* collector = repository.defaultCollector(category, metric);
if(collector->id().category()->enabled())
{
collector->tick(val, tags...);
}
}
}
} // namespace metrics
} // namespace llarp
@ -41,86 +59,8 @@ namespace llarp
#define METRICS_UNIQUE_NAME(X) METRICS_NAME_CAT(X, METRICS_UNIQ_NUMBER)
#define METRICS_TIME_BLOCK_IMP(CAT, METRIC, VAR_NAME) \
llarp::metrics::DoubleCollector* VAR_NAME = nullptr; \
if(llarp::metrics::DefaultManager::instance()) \
{ \
using namespace llarp::metrics; \
CollectorRepo< double >& repo = \
DefaultManager::instance()->doubleCollectorRepo(); \
VAR_NAME = repo.defaultCollector((CAT), (METRIC)); \
} \
llarp::metrics::TimerGuard METRICS_UNIQUE_NAME(timer_guard)(VAR_NAME);
#define METRICS_TIME_BLOCK(CAT, METRIC) \
METRICS_TIME_BLOCK_IMP(CAT, METRIC, METRICS_UNIQUE_NAME(time_block))
#define METRICS_IF_CATEGORY_ENABLED_IMP(CAT, NAME) \
static llarp::metrics::CategoryContainer NAME = {false, nullptr, nullptr}; \
if(!NAME.category() && llarp::metrics::DefaultManager::instance()) \
{ \
llarp::metrics::MetricsHelper::initContainer(NAME, CAT); \
} \
if(NAME.enabled())
#define METRICS_IF_CATEGORY_ENABLED(CAT) \
BALM_METRICS_IF_CATEGORY_ENABLED_IMP(CAT, METRICS_UNIQUE_NAME(Container))
// For when the category/metric may change during the program run
#define METRICS_DYNAMIC_INT_UPDATE(CAT, METRIC, VALUE) \
do \
{ \
using namespace llarp::metrics; \
if(DefaultManager::instance()) \
{ \
CollectorRepo< int >& repository = \
DefaultManager::instance()->intCollectorRepo(); \
IntCollector* collector = repository.defaultCollector((CAT), (METRIC)); \
if(collector->id().category()->enabled()) \
{ \
collector->tick((VALUE)); \
} \
} \
} while(false)
// For when the category/metric remain static
#define METRICS_INT_UPDATE(CAT, METRIC, VALUE) \
do \
{ \
using namespace llarp::metrics; \
static CategoryContainer container = {false, nullptr, nullptr}; \
static IntCollector* collector = nullptr; \
if(container.category() == nullptr && DefaultManager::instance()) \
{ \
collector = MetricHelper::getIntCollector(CAT, METRIC); \
MetricHelper::initContainer(container, CAT); \
} \
if(container.enabled()) \
{ \
collector->tick(VALUE); \
} \
} while(false)
#define METRICS_TYPED_INT_UPDATE(CAT, METRIC, VALUE, TYPE) \
do \
{ \
using namespace llarp::metrics; \
static CategoryContainer container = {false, nullptr, nullptr}; \
static IntCollector* collector = nullptr; \
if(container.category() == nullptr && DefaultManager::instance()) \
{ \
collector = MetricHelper::getIntCollector(CAT, METRIC); \
MetricHelper::setType(collector->id(), TYPE); \
MetricHelper::initContainer(container, CAT); \
} \
if(container.enabled()) \
{ \
collector->tick(VALUE); \
} \
} while(false)
// For when the category/metric may change during the program run
#define METRICS_DYNAMIC_UPDATE(CAT, METRIC, VALUE) \
#define METRICS_DYNAMIC_UPDATE(CAT, METRIC, ...) \
do \
{ \
using namespace llarp::metrics; \
@ -132,50 +72,9 @@ namespace llarp
repository.defaultCollector((CAT), (METRIC)); \
if(collector->id().category()->enabled()) \
{ \
collector->tick((VALUE)); \
collector->tick(__VA_ARGS__); \
} \
} \
} while(false)
// For when the category/metric remain static
#define METRICS_UPDATE(CAT, METRIC, VALUE) \
do \
{ \
using namespace llarp::metrics; \
static CategoryContainer container = {false, nullptr, nullptr}; \
static DoubleCollector* collector = nullptr; \
if(container.category() == nullptr && DefaultManager::instance()) \
{ \
collector = MetricHelper::getDoubleCollector(CAT, METRIC); \
MetricHelper::initContainer(container, CAT); \
} \
if(container.enabled()) \
{ \
collector->tick(VALUE); \
} \
} while(false)
#define METRICS_TYPED_UPDATE(CAT, METRIC, VALUE, TYPE) \
do \
{ \
using namespace llarp::metrics; \
static CategoryContainer container = {false, nullptr, nullptr}; \
static DoubleCollector* collector = nullptr; \
if(container.category() == nullptr && DefaultManager::instance()) \
{ \
collector = MetricHelper::getDoubleCollector(CAT, METRIC); \
MetricHelper::setType(collector->id(), TYPE); \
MetricHelper::initContainer(container, CAT); \
} \
if(container.enabled()) \
{ \
collector->tick(VALUE); \
} \
} while(false)
#define METRICS_DYNAMIC_INCREMENT(CAT, METRIC) \
METRICS_DYNAMIC_INT_UPDATE(CAT, METRIC, 1)
#define METRICS_INCREMENT(CAT, METRIC) METRICS_INT_UPDATE(CAT, METRIC, 1)
#endif

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

@ -7,11 +7,11 @@ namespace llarp
namespace metrics
{
std::tuple< Id, bool >
Registry::insert(const char *category, const char *name)
Registry::insert(string_view category, string_view name)
{
// avoid life time issues, putting strings in the stringmem set
const char *cStr = m_stringmem.emplace(category).first->c_str();
const char *nStr = m_stringmem.emplace(name).first->c_str();
string_view cStr = m_stringmem.emplace(category).first->c_str();
string_view nStr = m_stringmem.emplace(name).first->c_str();
NamedCategory namedCategory(cStr, nStr);
const auto it = m_metrics.find(namedCategory);
@ -36,7 +36,7 @@ namespace llarp
}
Id
Registry::add(const char *category, const char *name)
Registry::add(string_view category, string_view name)
{
absl::WriterMutexLock l(&m_mutex);
auto result = insert(category, name);
@ -44,7 +44,7 @@ namespace llarp
}
Id
Registry::get(const char *category, const char *name)
Registry::get(string_view category, string_view name)
{
Id result = findId(category, name);
if(result)
@ -57,11 +57,11 @@ namespace llarp
}
const Category *
Registry::add(const char *category)
Registry::add(string_view category)
{
absl::WriterMutexLock l(&m_mutex);
const char *cStr = m_stringmem.emplace(category).first->c_str();
string_view cStr = m_stringmem.emplace(category).first->c_str();
auto it = m_categories.find(cStr);
if(it == m_categories.end())
{
@ -73,7 +73,7 @@ namespace llarp
}
const Category *
Registry::get(const char *category)
Registry::get(string_view category)
{
const Category *cPtr = findCategory(category);
if(cPtr)
@ -82,7 +82,7 @@ namespace llarp
}
absl::WriterMutexLock l(&m_mutex);
const char *cStr = m_stringmem.emplace(category).first->c_str();
string_view cStr = m_stringmem.emplace(category).first->c_str();
auto it = m_categories.find(cStr);
if(it == m_categories.end())
{
@ -147,7 +147,7 @@ namespace llarp
const FormatSpec *spec = format.specFor(type);
if(spec != nullptr)
{
const char *fmt = m_stringmem.emplace(spec->m_format).first->c_str();
string_view fmt = m_stringmem.emplace(spec->m_format).first->c_str();
fmtPtr->setSpec(type, FormatSpec(spec->m_scale, fmt));
}
}
@ -156,7 +156,7 @@ namespace llarp
}
const Category *
Registry::findCategory(const char *category) const
Registry::findCategory(string_view category) const
{
absl::ReaderMutexLock l(&m_mutex);
auto it = m_categories.find(category);
@ -164,7 +164,7 @@ namespace llarp
}
Id
Registry::findId(const char *category, const char *name) const
Registry::findId(string_view category, string_view name) const
{
absl::ReaderMutexLock l(&m_mutex);
auto it = m_metrics.find(std::make_tuple(category, name));

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

@ -20,7 +20,7 @@ namespace llarp
}
template < typename K, typename V, typename... Args >
void
inline void
packToTagsImpl(Tags &tags, const K &k, const V &v, const Args &... args)
{
static_assert(std::is_convertible< K, Tag >::value, "");
@ -31,7 +31,7 @@ namespace llarp
}
template < typename... Args >
Tags
inline Tags
packToTags(const Args &... args)
{
static_assert(sizeof...(args) % 2 == 0, "");
@ -40,6 +40,13 @@ namespace llarp
return tags;
}
template <>
inline Tags
packToTags< Tags >(const Tags &tags)
{
return tags;
}
template < typename Type >
class Collector
{
@ -263,34 +270,11 @@ namespace llarp
class Registry
{
using NamedCategory = std::tuple< const char *, const char * >;
using NamedCategory = std::tuple< string_view, string_view >;
struct CmpNamedCategory
{
bool
operator()(const NamedCategory &lhs, const NamedCategory &rhs) const
{
int ret = std::strcmp(std::get< 0 >(lhs), std::get< 0 >(rhs));
if(ret == 0)
{
ret = std::strcmp(std::get< 1 >(lhs), std::get< 1 >(rhs));
}
return ret < 0;
}
};
struct StrCmp
{
bool
operator()(const char *lhs, const char *rhs) const
{
return std::strcmp(lhs, rhs) < 0;
}
};
using MetricMap = std::map< NamedCategory, std::shared_ptr< Description >,
CmpNamedCategory >;
using CategoryMap =
std::map< const char *, std::shared_ptr< Category >, StrCmp >;
using MetricMap =
std::map< NamedCategory, std::shared_ptr< Description > >;
using CategoryMap = std::map< string_view, std::shared_ptr< Category > >;
std::set< std::string > m_stringmem GUARDED_BY(m_mutex);
CategoryMap m_categories GUARDED_BY(m_mutex);
@ -303,7 +287,7 @@ namespace llarp
operator=(const Registry &) = delete;
std::tuple< Id, bool >
insert(const char *category, const char *name)
insert(string_view category, string_view name)
EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
public:
@ -312,14 +296,14 @@ namespace llarp
}
Id
add(const char *category, const char *name) LOCKS_EXCLUDED(m_mutex);
add(string_view category, string_view name) LOCKS_EXCLUDED(m_mutex);
Id
get(const char *category, const char *name) LOCKS_EXCLUDED(m_mutex);
get(string_view category, string_view name) LOCKS_EXCLUDED(m_mutex);
const Category *
add(const char *category) LOCKS_EXCLUDED(m_mutex);
add(string_view category) LOCKS_EXCLUDED(m_mutex);
const Category *
get(const char *category);
get(string_view category);
void
enable(const Category *category, bool value);
@ -347,9 +331,9 @@ namespace llarp
}
const Category *
findCategory(const char *category) const;
findCategory(string_view category) const;
Id
findId(const char *category, const char *name) const;
findId(string_view category, string_view name) const;
std::vector< const Category * >
getAll() const;
@ -462,7 +446,7 @@ namespace llarp
}
Collector< Type > *
defaultCollector(const char *category, const char *name)
defaultCollector(string_view category, string_view name)
{
return defaultCollector(m_registry->get(category, name));
}
@ -486,7 +470,7 @@ namespace llarp
}
std::shared_ptr< Collector< Type > >
addCollector(const char *category, const char *name)
addCollector(string_view category, string_view name)
{
return addCollector(m_registry->get(category, name));
}
@ -727,7 +711,7 @@ namespace llarp
/// Add a `publisher` which will receive events for the given
/// `categoryName` only
bool
addPublisher(const char *categoryName,
addPublisher(string_view categoryName,
const std::shared_ptr< Publisher > &publisher)
{
return addPublisher(m_registry.get(categoryName), publisher);
@ -822,7 +806,7 @@ namespace llarp
}
void
enableCategory(const char *categoryName, bool enable = true)
enableCategory(string_view categoryName, bool enable = true)
{
m_registry.enable(m_registry.get(categoryName), enable);
}
@ -846,7 +830,7 @@ namespace llarp
}
std::vector< Publisher * >
publishersForCategory(const char *categoryName) const
publishersForCategory(string_view categoryName) const
{
const Category *category = m_registry.findCategory(categoryName);
return category ? publishersForCategory(category)
@ -928,7 +912,7 @@ namespace llarp
public:
static Collector *
lookup(const char *category, const char *name, Manager *manager = nullptr)
lookup(string_view category, string_view name, Manager *manager = nullptr)
{
manager = DefaultManager::manager(manager);
return manager ? (manager->*repoFunc)().defaultCollector(category, name)
@ -942,7 +926,7 @@ namespace llarp
return manager ? (manager->*repoFunc)().defaultCollector(id) : 0;
}
Metric(const char *category, const char *name, Manager *manager)
Metric(string_view category, string_view name, Manager *manager)
: m_collector(lookup(category, name, manager))
, m_enabled(m_collector ? &m_collector->id().category()->enabledRaw()
: nullptr)
@ -1025,7 +1009,7 @@ namespace llarp
static void
getCollector(Collector **collector, CategoryContainer *container,
const char *category, const char *metric)
string_view category, string_view metric)
{
Manager *manager = DefaultManager::instance();
*collector = (manager->*repoFunc().defaultCollector)(category, metric);
@ -1035,7 +1019,7 @@ namespace llarp
static void
getCollector(Collector **collector, CategoryContainer *container,
const char *category, const char *metric,
string_view category, string_view metric,
Publication::Type type)
{
Manager *manager = DefaultManager::instance();
@ -1054,6 +1038,7 @@ namespace llarp
class TimerGuard
{
private:
Tags m_tags;
util::Stopwatch m_stopwatch;
DoubleCollector *m_collector;
@ -1062,8 +1047,9 @@ namespace llarp
operator=(const TimerGuard &) = delete;
public:
TimerGuard(DoubleMetric *metric)
: m_stopwatch()
template < typename... TagVals >
TimerGuard(DoubleMetric *metric, TagVals &&... tags)
: m_tags(packToTags(tags...))
, m_collector(metric->active() ? metric->collector() : nullptr)
{
if(m_collector)
@ -1072,8 +1058,9 @@ namespace llarp
}
}
TimerGuard(DoubleCollector *collector)
: m_stopwatch()
template < typename... TagVals >
TimerGuard(DoubleCollector *collector, TagVals &&... tags)
: m_tags(packToTags(tags...))
, m_collector(collector && collector->id().category()->enabled()
? collector
: nullptr)
@ -1084,8 +1071,10 @@ namespace llarp
}
}
TimerGuard(const char *category, const char *name, Manager *manager)
: m_stopwatch(), m_collector(nullptr)
template < typename... TagVals >
TimerGuard(string_view category, string_view name,
Manager *manager = nullptr, TagVals &&... tags)
: m_tags(packToTags(tags...)), m_collector(nullptr)
{
DoubleCollector *collector =
DoubleMetric::lookup(category, name, manager);
@ -1097,8 +1086,10 @@ namespace llarp
m_stopwatch.start();
}
}
TimerGuard(const Id &id, Manager *manager)
: m_stopwatch(), m_collector(nullptr)
template < typename... TagVals >
TimerGuard(const Id &id, Manager *manager = nullptr, TagVals &&... tags)
: m_tags(packToTags(tags...)), m_collector(nullptr)
{
DoubleCollector *collector = DoubleMetric::lookup(id, manager);
m_collector = (collector && collector->id().category()->enabled())
@ -1115,7 +1106,7 @@ namespace llarp
if(active())
{
m_stopwatch.stop();
m_collector->tick(absl::ToDoubleSeconds(m_stopwatch.time()));
m_collector->tick(absl::ToDoubleSeconds(m_stopwatch.time()), m_tags);
}
}
@ -1166,7 +1157,7 @@ namespace llarp
}
void
schedule(const char *categoryName, absl::Duration interval)
schedule(string_view categoryName, absl::Duration interval)
{
return schedule(m_manager->registry().get(categoryName), interval);
}
@ -1178,7 +1169,7 @@ namespace llarp
setDefault(absl::Duration interval);
bool
cancel(const char *categoryName)
cancel(string_view categoryName)
{
return cancel(m_manager->registry().get(categoryName));
}
@ -1204,7 +1195,7 @@ namespace llarp
}
absl::optional< absl::Duration >
find(const char *categoryName) const
find(string_view categoryName) const
{
return find(m_manager->registry().get(categoryName));
}

9
llarp/util/metrics_types.cpp
Unescape Escape View File

@ -2,6 +2,8 @@
#include <util/printer.hpp>
#include <absl/strings/str_join.h>
namespace llarp
{
namespace metrics
@ -13,7 +15,8 @@ namespace llarp
static constexpr size_t INIT_SIZE = 32;
char buf[INIT_SIZE] = {0};
int rc = snprintf(buf, INIT_SIZE, format.m_format, data * format.m_scale);
int rc = snprintf(buf, INIT_SIZE, format.m_format.data(),
data * format.m_scale);
if(rc < 0)
{
@ -28,7 +31,7 @@ namespace llarp
}
std::vector< char > vec(rc + 1);
rc = snprintf(vec.data(), vec.size(), format.m_format,
rc = snprintf(vec.data(), vec.size(), format.m_format.data(),
data * format.m_scale);
if(static_cast< size_t >(rc) > vec.size())
@ -127,7 +130,7 @@ namespace llarp
Description::toString() const
{
util::Lock l(&m_mutex);
return m_category->name() + std::string(".") + m_name;
return absl::StrCat(m_category->name(), ".", m_name);
}
std::ostream &

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

@ -52,7 +52,7 @@ namespace llarp
struct FormatSpec
{
float m_scale;
const char *m_format;
string_view m_format;
static constexpr char DEFAULT_FORMAT[] = "%f";
@ -60,7 +60,7 @@ namespace llarp
{
}
constexpr FormatSpec(float scale, const char *format)
constexpr FormatSpec(float scale, string_view format)
: m_scale(scale), m_format(format)
{
}
@ -72,8 +72,8 @@ namespace llarp
inline bool
operator==(const FormatSpec &lhs, const FormatSpec &rhs)
{
return lhs.m_scale == rhs.m_scale
&& std::strcmp(lhs.m_format, rhs.m_format) == 0;
return std::make_tuple(lhs.m_scale, lhs.m_format)
== std::make_tuple(rhs.m_scale, rhs.m_format);
}
struct Format
@ -117,12 +117,12 @@ namespace llarp
/// Represents a category of grouped metrics
class Category
{
const char *m_name;
string_view m_name;
std::atomic_bool m_enabled;
CategoryContainer *m_container;
public:
Category(const char *name, bool enabled = true)
Category(string_view name, bool enabled = true)
: m_name(name), m_enabled(enabled), m_container(nullptr)
{
}
@ -141,7 +141,7 @@ namespace llarp
return m_enabled;
}
const char *
string_view
name() const
{
return m_name;
@ -183,7 +183,7 @@ namespace llarp
mutable util::Mutex m_mutex;
const Category *m_category GUARDED_BY(m_mutex);
const char *m_name GUARDED_BY(m_mutex);
string_view m_name GUARDED_BY(m_mutex);
Publication::Type m_type GUARDED_BY(m_mutex);
std::shared_ptr< Format > m_format GUARDED_BY(m_mutex);
@ -192,7 +192,7 @@ namespace llarp
operator=(const Description &) = delete;
public:
Description(const Category *category, const char *name)
Description(const Category *category, string_view name)
: m_category(category)
, m_name(name)
, m_type(Publication::Type::Unspecified)
@ -214,13 +214,13 @@ namespace llarp
}
void
name(const char *n)
name(string_view n)
{
util::Lock l(&m_mutex);
m_name = n;
}
const char *
string_view
name() const
{
util::Lock l(&m_mutex);
@ -313,14 +313,14 @@ namespace llarp
return m_description->category();
}
const char *
string_view
categoryName() const
{
assert(valid());
return m_description->category()->name();
}
const char *
string_view
metricName() const
{
assert(valid());

13
llarp/utp/session.cpp
Unescape Escape View File

@ -42,8 +42,8 @@ namespace llarp
if(s > 0)
lastSend = parent->Now();
METRICS_DYNAMIC_INT_UPDATE(
"utp.session.tx", RouterID(remoteRC.pubkey).ToString().c_str(), s);
metrics::integerTick("utp.session.tx", "writes", s, "id",
RouterID(remoteRC.pubkey).ToString());
m_TXRate += s;
size_t sz = s;
while(vecq.size() && sz >= vecq.front().iov_len)
@ -133,9 +133,8 @@ namespace llarp
PruneInboundMessages(now);
m_TXRate = 0;
m_RXRate = 0;
METRICS_DYNAMIC_UPDATE("utp.session.sendq",
RouterID(remoteRC.pubkey).ToString().c_str(),
sendq.size());
metrics::integerTick("utp.session.sendq", "size", sendq.size(), "id",
RouterID(remoteRC.pubkey).ToString());
}
/// low level read
@ -146,8 +145,8 @@ namespace llarp
Alive();
m_RXRate += sz;
size_t s = sz;
METRICS_DYNAMIC_INT_UPDATE(
"utp.session.rx", RouterID(remoteRC.pubkey).ToString().c_str(), s);
metrics::integerTick("utp.session.rx", "size", s, "id",
RouterID(remoteRC.pubkey).ToString());
// process leftovers
if(recvBufOffset)
{

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

@ -192,8 +192,8 @@ TEST(MetricsCore, RegistryOps)
ASSERT_TRUE(id.valid()) << id;
ASSERT_NE(nullptr, id.description());
ASSERT_NE(nullptr, id.category());
ASSERT_STREQ(id.metricName(), NAME);
ASSERT_STREQ(id.categoryName(), CATEGORY);
ASSERT_EQ(id.metricName(), NAME);
ASSERT_EQ(id.categoryName(), CATEGORY);
ASSERT_TRUE(id.category()->enabled());
// Attempt to find the id.
@ -218,7 +218,7 @@ TEST(MetricsCore, RegistryOps)
const Category *NEW_CAT = registry.add("NewCategory");
ASSERT_NE(nullptr, NEW_CAT);
ASSERT_STREQ("NewCategory", NEW_CAT->name());
ASSERT_EQ("NewCategory", NEW_CAT->name());
ASSERT_TRUE(NEW_CAT->enabled());
}
@ -232,7 +232,7 @@ TEST(MetricsCore, RegistryOps)
const Category *cat = registry.add(CATEGORY);
ASSERT_NE(nullptr, cat);
ASSERT_STREQ(cat->name(), CATEGORY);
ASSERT_EQ(cat->name(), CATEGORY);
ASSERT_TRUE(cat->enabled());
ASSERT_EQ(nullptr, registry.add(CATEGORY));
@ -241,8 +241,8 @@ TEST(MetricsCore, RegistryOps)
Id id = registry.add(CATEGORY, "Metric");
ASSERT_TRUE(id.valid());
ASSERT_EQ(cat, id.category());
ASSERT_STREQ(id.categoryName(), CATEGORY);
ASSERT_STREQ(id.metricName(), "Metric");
ASSERT_EQ(id.categoryName(), CATEGORY);
ASSERT_EQ(id.metricName(), "Metric");
ASSERT_EQ(i + 1, registry.metricCount());
ASSERT_EQ(i + 1, registry.categoryCount());
@ -494,7 +494,7 @@ TEST(MetricsCore, ManagerCollectSample1)
WithinWindow(window, absl::Milliseconds(10)))
<< group;
const char *name = group.records()[0].id.categoryName();
string_view name = group.records()[0].id.categoryName();
for(const auto &record : group.records())
{
ASSERT_THAT(record, RecordCatEq(name, 1u, 1, 1, 1));

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

@ -62,11 +62,11 @@ TEST(MetricsTypes, Format)
ASSERT_EQ(nullptr, format.specFor(metrics::Publication::Type::Avg));
auto ptr = format.specFor(metrics::Publication::Type::Total);
ASSERT_NE(nullptr, ptr);
ASSERT_STREQ("%0.3f", ptr->m_format);
ASSERT_EQ("%0.3f", ptr->m_format);
ASSERT_DOUBLE_EQ(2.0, ptr->m_scale);
ptr = format.specFor(metrics::Publication::Type::Max);
ASSERT_NE(nullptr, ptr);
ASSERT_STREQ("%0.2f", ptr->m_format);
ASSERT_EQ("%0.2f", ptr->m_format);
ASSERT_DOUBLE_EQ(1.0, ptr->m_scale);
format.clear();

Write Preview
Loading…
Cancel
Save