0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-12-25 06:53:58 +01:00
construct/include/ircd/stats.h

343 lines
8.1 KiB
C++

// The Construct
//
// Copyright (C) The Construct Developers, Authors & Contributors
// Copyright (C) 2016-2020 Jason Volk <jason@zemos.net>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice is present in all copies. The
// full license for this software is available in the LICENSE file.
#pragma once
#define HAVE_IRCD_STATS_H
/// Statistics & Metrics
///
/// This is a central collection of registered items each representing a
/// counter or metric of some kind. To collect items of various types we orient
/// the collection around an abstract item<void> template class. To keep things
/// simple, the abstract instance holds a typeinfo provided by the derived
/// instance. User can then downcast the item<void> to a derived template.
///
/// There are two levels in the class hierarchy under the abstract root
/// item<void>. The next level is a pointer-to-value such that the item
/// registers the location of an existing value. This is useful for
/// incorporating external values in existing structures into this collection
/// non-intrusively; for example in third-party libraries etc.
///
/// The next derived level after this is where the item instance itself
/// roots (contains) the value and its parent class at the pointer-level points
/// down to the derived class. This is a convenience for developers so that
/// extern values don't have to be created separately for every stats item.
/// Note that when this subsystem works abstractly with items, it considers the
/// pointer-level templates to be the principal level of derivation; in other
/// words there is no reason to downcast to a value-level template when working
/// with this system, and every value-level template must have a matching
/// pointer-level parent.
namespace ircd::stats
{
IRCD_EXCEPTION(ircd::error, error)
IRCD_EXCEPTION(error, not_found)
IRCD_PANICKING(error, invalid)
// Abstract item
template<class T = void> struct item;
template<> struct item<void>;
// Category item
template<class T> struct ptr_item;
template<class T> struct int_item;
// Pointer-to-value items
template<> struct item<uint64_t *>;
template<> struct item<uint32_t *>;
template<> struct item<uint16_t *>;
template<> struct item<int64_t *>;
template<> struct item<int32_t *>;
template<> struct item<int16_t *>;
template<> struct item<nanoseconds *>;
template<> struct item<microseconds *>;
template<> struct item<milliseconds *>;
template<> struct item<seconds *>;
// Value-carrying items
template<> struct item<uint64_t>;
template<> struct item<uint32_t>;
template<> struct item<uint16_t>;
template<> struct item<int64_t>;
template<> struct item<int32_t>;
template<> struct item<int16_t>;
template<> struct item<nanoseconds>;
template<> struct item<microseconds>;
template<> struct item<milliseconds>;
template<> struct item<seconds>;
extern const size_t NAME_MAX_LEN;
extern std::vector<item<void> *> items;
string_view string(const mutable_buffer &, const item<void> &);
std::ostream &operator<<(std::ostream &, const item<void> &);
}
/// Abstract stats item.
///
/// This object contains type information about its derived class. There is no
/// known use for constructing this on its own without a derived item.
///
/// Feature information must contain a 'name' string. It is advised that this
/// is appropriately namespaced i.e "ircd.net.socket.xxx" and when third-party
/// values are gathered i.e "rocksdb.xxx." such that the entire map of items
/// can be serialized into a single JSON object tree.
///
/// Feature information can also contain a 'desc' string describing more about
/// the value to administrators and developers.
template<>
struct ircd::stats::item<void>
{
std::type_index type {typeid(void)};
json::strung feature;
json::string name;
public:
// Access features
string_view operator[](const string_view &key) const noexcept;
virtual bool operator!() const = 0;
item() = default;
item(const std::type_index &, const json::members &);
item(item &&) = delete;
item(const item &) = delete;
virtual ~item() noexcept;
};
/// Abstract pointer item
template<class T>
struct ircd::stats::ptr_item
:item<void>
{
T *val {nullptr};
public:
bool operator!() const override
{
return !val || *val == T{0};
}
operator const T &() const
{
assert(val);
return *val;
}
operator T &()
{
assert(val);
return *val;
}
ptr_item &operator=(const T &val) &
{
static_cast<T &>(*this) = val;
return *this;
}
ptr_item(T *const &val, const json::members &feature)
:item<void>{typeid(T *), feature}
,val{val}
{}
ptr_item() = default;
};
/// Abstract value item
template<class T>
struct ircd::stats::int_item
:ptr_item<T>
{
T val {0};
public:
operator const T &() const noexcept
{
return val;
}
operator T &() noexcept
{
return val;
}
int_item &operator=(const T &val) &
{
static_cast<T &>(*this) = val;
return *this;
}
int_item(const json::members &feature)
:ptr_item<T>{std::addressof(this->val), feature}
,val{0}
{}
int_item() = default;
};
template<>
struct ircd::stats::item<uint64_t *>
:ptr_item<uint64_t>
{
using ptr_item<uint64_t>::ptr_item;
using ptr_item<uint64_t>::operator=;
};
template<>
struct ircd::stats::item<uint64_t>
:int_item<uint64_t>
{
using int_item<uint64_t>::int_item;
using int_item<uint64_t>::operator=;
};
template<>
struct ircd::stats::item<int64_t *>
:ptr_item<int64_t>
{
using ptr_item<int64_t>::ptr_item;
using ptr_item<int64_t>::operator=;
};
template<>
struct ircd::stats::item<int64_t>
:int_item<int64_t>
{
using int_item<int64_t>::int_item;
using int_item<int64_t>::operator=;
};
template<>
struct ircd::stats::item<uint32_t *>
:ptr_item<uint32_t>
{
using ptr_item<uint32_t>::ptr_item;
using ptr_item<uint32_t>::operator=;
};
template<>
struct ircd::stats::item<uint32_t>
:int_item<uint32_t>
{
using int_item<uint32_t>::int_item;
using int_item<uint32_t>::operator=;
};
template<>
struct ircd::stats::item<int32_t *>
:ptr_item<int32_t>
{
using ptr_item<int32_t>::ptr_item;
using ptr_item<int32_t>::operator=;
};
template<>
struct ircd::stats::item<int32_t>
:int_item<int32_t>
{
using int_item<int32_t>::int_item;
using int_item<int32_t>::operator=;
};
template<>
struct ircd::stats::item<uint16_t *>
:ptr_item<uint16_t>
{
using ptr_item<uint16_t>::ptr_item;
using ptr_item<uint16_t>::operator=;
};
template<>
struct ircd::stats::item<uint16_t>
:int_item<uint16_t>
{
using int_item<uint16_t>::int_item;
using int_item<uint16_t>::operator=;
};
template<>
struct ircd::stats::item<int16_t *>
:ptr_item<int16_t>
{
using ptr_item<int16_t>::ptr_item;
using ptr_item<int16_t>::operator=;
};
template<>
struct ircd::stats::item<int16_t>
:int_item<int16_t>
{
using int_item<int16_t>::int_item;
using int_item<int16_t>::operator=;
};
template<>
struct ircd::stats::item<ircd::nanoseconds *>
:ptr_item<nanoseconds>
{
using ptr_item<nanoseconds>::ptr_item;
using ptr_item<nanoseconds>::operator=;
};
template<>
struct ircd::stats::item<ircd::nanoseconds>
:int_item<nanoseconds>
{
using int_item<nanoseconds>::int_item;
using int_item<nanoseconds>::operator=;
};
template<>
struct ircd::stats::item<ircd::microseconds *>
:ptr_item<microseconds>
{
using ptr_item<microseconds>::ptr_item;
using ptr_item<microseconds>::operator=;
};
template<>
struct ircd::stats::item<ircd::microseconds>
:int_item<microseconds>
{
using int_item<microseconds>::int_item;
using int_item<microseconds>::operator=;
};
template<>
struct ircd::stats::item<ircd::milliseconds *>
:ptr_item<milliseconds>
{
using ptr_item<milliseconds>::ptr_item;
using ptr_item<milliseconds>::operator=;
};
template<>
struct ircd::stats::item<ircd::milliseconds>
:int_item<milliseconds>
{
using int_item<milliseconds>::int_item;
using int_item<milliseconds>::operator=;
};
template<>
struct ircd::stats::item<ircd::seconds *>
:ptr_item<seconds>
{
using ptr_item<seconds>::ptr_item;
using ptr_item<seconds>::operator=;
};
template<>
struct ircd::stats::item<ircd::seconds>
:int_item<seconds>
{
using int_item<seconds>::int_item;
using int_item<seconds>::operator=;
};