TelnetStats Class Reference

#include <TelnetStats.hpp>

Inheritance diagram for TelnetStats:

Collaboration diagram for TelnetStats:

Public Member Functions
	TelnetStats (const std::shared_ptr< prometheus::Registry > &reg, uint16_t portNumber, const std::string &prependName="")
void	consumeStats (const TelnetSessionStats &stat, bool sessionClosed)
void	consumeStats (const TelnetServerStats &stat)

Private Attributes
prometheus::Family< prometheus::Info > *	_infoFamily
	Information metric family.
prometheus::Gauge *	_activeConnection
	Number of active connections.
prometheus::Counter *	_refusedConnection
	Number of refused connections.
prometheus::Counter *	_totalConnection
	Number of total received connections.
prometheus::Counter *	_totalUploadBytes
	Total uploaded bytes.
prometheus::Counter *	_totalDownloadBytes
	Total downloaded bytes.
prometheus::Summary *	_sessionDuration
	Value of the duration of sessions.
prometheus::Gauge *	_maxSessionDuration
	Maximum duration of sessions.
prometheus::Gauge *	_minSessionDuration
	Minimum duration of sessions.

Additional Inherited Members
Private Member Functions inherited from BaseServerStats
void	initBaseStats (const std::shared_ptr< prometheus::Registry > &reg, const std::string &name)
void	consumeBaseStats (uint64_t succeeded, uint64_t failed, double processingTime)

Detailed Description

Prometheus statistics for Telnet server

Definition at line 33 of file TelnetStats.hpp.

Constructor & Destructor Documentation

TelnetStats()

TelnetStats::TelnetStats	(	const std::shared_ptr< prometheus::Registry > &	reg,
		uint16_t	portNumber,
		const std::string &	prependName = "" )

Construct a new Telnet statistics

Parameters

[in]	reg	Prometheus registry
[in]	portNumber	Telnet server port
[in]	prependName	Prefix for Prometheus stats

Definition at line 11 of file TelnetStats.cpp.

    : BaseServerStats()
{
    if (!reg)
    {
        throw std::invalid_argument("Can't init Telnet statistics. Registry is null");
    }
 
    const auto name = prependName.empty() ? "telnet_" : prependName + "_telnet_";
 
    // Stats from base class
    initBaseStats(reg, name);
 
    // Basic information
    _infoFamily =
        &prometheus::BuildInfo().Name(name.substr(0, name.size() - 1)).Help("Telnet server information").Register(*reg);
 
    _infoFamily->Add({{"server_port", std::to_string(portNumber)}});
    _infoFamily->Add({{"init_time", date::format("%FT%TZ", date::floor<std::chrono::nanoseconds>(
                                                               std::chrono::high_resolution_clock::now()))}});
    _infoFamily->Add({{"performance_unit", "nanoseconds"}});
 
    // Connection stats
    _activeConnection = &prometheus::BuildGauge()
                             .Name(name + "active_connections")
                             .Help("Number of active connections")
                             .Register(*reg)
                             .Add({});
    _refusedConnection = &prometheus::BuildCounter()
                              .Name(name + "refused_connections")
                              .Help("Number of refused connections")
                              .Register(*reg)
                              .Add({});
    _totalConnection = &prometheus::BuildCounter()
                            .Name(name + "received_connections")
                            .Help("Number of received connections")
                            .Register(*reg)
                            .Add({});
 
    // Bandwidth stats
    _totalUploadBytes =
        &prometheus::BuildCounter().Name(name + "uploaded_bytes").Help("Total uploaded bytes").Register(*reg).Add({});
    _totalDownloadBytes = &prometheus::BuildCounter()
                               .Name(name + "downloaded_bytes")
                               .Help("Total downloaded bytes")
                               .Register(*reg)
                               .Add({});
 
    // Session durations
    _sessionDuration = &prometheus::BuildSummary()
                            .Name(name + "session_duration")
                            .Help("Duration of sessions")
                            .Register(*reg)
                            .Add({}, QUANTILE_DEFAULTS);
    _maxSessionDuration = &prometheus::BuildGauge()
                               .Name(name + "maximum_session_duration")
                               .Help("Maximum duration of sessions")
                               .Register(*reg)
                               .Add({});
    _minSessionDuration = &prometheus::BuildGauge()
                               .Name(name + "minimum_session_duration")
                               .Help("Minimum duration of sessions")
                               .Register(*reg)
                               .Add({});
 
    // Set defaults
    _minSessionDuration->Set(std::numeric_limits<int>::max());
}

Here is the call graph for this function:

Member Function Documentation

consumeStats() [1/2]

void TelnetStats::consumeStats

(

const TelnetServerStats &

stat

)

Updates statistics with server values

Parameters

[in]

stat

Statistics values from server

Definition at line 105 of file TelnetStats.cpp.

{
    // Connection stats
    _activeConnection->Set(static_cast<double>(stat.activeConnectionCtr));
    _refusedConnection->Increment(static_cast<double>(stat.refusedConnectionCtr));
    _totalConnection->Increment(static_cast<double>(stat.acceptedConnectionCtr));
 
    // Performance stats if there is an active connection
    if (stat.activeConnectionCtr > 0)
    {
        consumeBaseStats(0, 0, static_cast<double>((stat.processingTimeEnd - stat.processingTimeStart).count()));
    }
}

Here is the call graph for this function:

consumeStats() [2/2]

void TelnetStats::consumeStats	(	const TelnetSessionStats &	stat,
		bool	sessionClosed )

Updates statistics with session values

Parameters

[in]	stat	Statistics values from session
[in]	sessionClosed	True if the provided session is closed

Definition at line 81 of file TelnetStats.cpp.

{
    consumeBaseStats(stat.successCmdCtr, stat.failCmdCtr, 0);
 
    _totalUploadBytes->Increment(static_cast<double>(stat.uploadBytes));
    _totalDownloadBytes->Increment(static_cast<double>(stat.downloadBytes));
 
    if (sessionClosed)
    {
        // Session durations
        const auto sessionTime = static_cast<double>(
            std::chrono::duration_cast<std::chrono::seconds>(stat.disconnectTime - stat.connectTime).count());
        _sessionDuration->Observe(sessionTime);
        if (sessionTime < _minSessionDuration->Value())
        {
            _minSessionDuration->Set(sessionTime);
        }
        if (sessionTime > _maxSessionDuration->Value())
        {
            _maxSessionDuration->Set(sessionTime);
        }
    }
}

Here is the call graph for this function:

Member Data Documentation

_activeConnection

prometheus::Gauge* TelnetStats::_activeConnection

private

Number of active connections.

Definition at line 36 of file TelnetStats.hpp.

_infoFamily

prometheus::Family<prometheus::Info>* TelnetStats::_infoFamily

private

Information metric family.

Definition at line 35 of file TelnetStats.hpp.

_maxSessionDuration

prometheus::Gauge* TelnetStats::_maxSessionDuration

private

Maximum duration of sessions.

Definition at line 42 of file TelnetStats.hpp.

_minSessionDuration

prometheus::Gauge* TelnetStats::_minSessionDuration

private

Minimum duration of sessions.

Definition at line 43 of file TelnetStats.hpp.

_refusedConnection

prometheus::Counter* TelnetStats::_refusedConnection

private

Number of refused connections.

Definition at line 37 of file TelnetStats.hpp.

_sessionDuration

prometheus::Summary* TelnetStats::_sessionDuration

private

Value of the duration of sessions.

Definition at line 41 of file TelnetStats.hpp.

_totalConnection

prometheus::Counter* TelnetStats::_totalConnection

private

Number of total received connections.

Definition at line 38 of file TelnetStats.hpp.

_totalDownloadBytes

prometheus::Counter* TelnetStats::_totalDownloadBytes

private

Total downloaded bytes.

Definition at line 40 of file TelnetStats.hpp.

_totalUploadBytes

prometheus::Counter* TelnetStats::_totalUploadBytes

private

Total uploaded bytes.

Definition at line 39 of file TelnetStats.hpp.

---

The documentation for this class was generated from the following files:

• /__w/Repo-Init/Repo-Init/include/telnet/TelnetStats.hpp
• /__w/Repo-Init/Repo-Init/src/telnet/TelnetStats.cpp