ProcessMetrics Class Reference

#include <ProcessMetrics.hpp>

Classes
struct	_oldCpu
	Structure to store the old CPU times. More...

Public Member Functions
	ProcessMetrics (std::shared_ptr< std::atomic_flag > checkFlag, const std::shared_ptr< prometheus::Registry > &reg)
	ProcessMetrics (const ProcessMetrics &)=delete
	Copy constructor.
	ProcessMetrics (ProcessMetrics &&)=delete
	Move constructor.
ProcessMetrics &	operator= (ProcessMetrics)=delete
	Copy assignment operator.
ProcessMetrics &	operator= (ProcessMetrics &&)=delete
	Move assignment operator.
	~ProcessMetrics ()

Protected Member Functions
double	getCpuUsage ()
std::pair< size_t, size_t >	getDiskIO ()
void	update ()
void	threadRunner () noexcept

Static Protected Member Functions
static long int	getMemoryUsage ()
static long int	getPageFaults ()
static size_t	getThreadCount ()
static size_t	getFileDescriptorCount ()

Static Private Member Functions
static size_t	countDirectoryEntries (const std::string &path)

Private Attributes
std::atomic_flag	_shouldStop {false}
	Flag to stop monitoring.
std::unique_ptr< std::thread >	_thread
	Thread handler.
std::shared_ptr< std::atomic_flag >	_checkFlag
	Runtime check flag.
prometheus::Gauge *	_pInitTime
	Pointer to initialization time gauge.
prometheus::Gauge *	_pCurrentTime
	Pointer to the current time gauge.
prometheus::Gauge *	_pMemory
	Pointer to the memory usage gauge.
prometheus::Gauge *	_pPageFaults
	Pointer to the page faults gauge.
prometheus::Gauge *	_pCpuUsage
	Pointer to the CPU usage gauge.
prometheus::Gauge *	_pDiskRead
	Pointer to the disk read gauge.
prometheus::Gauge *	_pDiskWrite
	Pointer to the disk write gauge.
prometheus::Gauge *	_pThreadCount
	Pointer to the thread count gauge.
prometheus::Gauge *	_pFileDescriptorCount
	Pointer to the file descriptor count gauge.
size_t	_oldReadBytes {0}
	Variable to store the old read bytes.
size_t	_oldWriteBytes {0}
	Variable to store the old write bytes.
clock_t	_oldCpuTime {0}
	Variable to store the old CPU time.

Detailed Description

Class that provides metrics related to the current process.

Definition at line 14 of file ProcessMetrics.hpp.

Constructor & Destructor Documentation

ProcessMetrics() [1/3]

ProcessMetrics::ProcessMetrics	(	std::shared_ptr< std::atomic_flag >	checkFlag,
		const std::shared_ptr< prometheus::Registry > &	reg )

Constructs a ProcessMetrics object.

Parameters

[in]	reg	The Prometheus registry.
[in]	checkFlag	Runtime check flag

Definition at line 122 of file ProcessMetrics.cpp.

    : _checkFlag(std::move(checkFlag))
{
    if (reg == nullptr)
    {
        throw std::invalid_argument("Registry is nullptr");
    }
 
    _pInitTime =
        &prometheus::BuildGauge().Name("init_time").Help("Initialization time of application").Register(*reg).Add({});
    _pCurrentTime =
        &prometheus::BuildGauge().Name("current_time").Help("Current time of application").Register(*reg).Add({});
    _pMemory =
        &prometheus::BuildGauge().Name("memory_usage").Help("Memory usage of application").Register(*reg).Add({});
    _pPageFaults =
        &prometheus::BuildGauge().Name("page_faults").Help("Page faults of application").Register(*reg).Add({});
    _pCpuUsage = &prometheus::BuildGauge().Name("cpu_usage").Help("CPU usage of application").Register(*reg).Add({});
    _pDiskRead = &prometheus::BuildGauge().Name("disk_read").Help("Disk read of application").Register(*reg).Add({});
    _pDiskWrite = &prometheus::BuildGauge().Name("disk_write").Help("Disk write of application").Register(*reg).Add({});
    _pThreadCount =
        &prometheus::BuildGauge().Name("thread_count").Help("Thread count of application").Register(*reg).Add({});
    _pFileDescriptorCount = &prometheus::BuildGauge()
                                 .Name("file_descriptor_count")
                                 .Help("File descriptor count of application")
                                 .Register(*reg)
                                 .Add({});
 
    _pInitTime->SetToCurrentTime();
 
    _thread = std::make_unique<std::thread>(&ProcessMetrics::threadRunner, this);
}

Here is the call graph for this function:

ProcessMetrics() [2/3]

ProcessMetrics::ProcessMetrics ( const ProcessMetrics & )

delete

Copy constructor.

ProcessMetrics() [3/3]

ProcessMetrics::ProcessMetrics ( ProcessMetrics && )

delete

Move constructor.

~ProcessMetrics()

ProcessMetrics::~ProcessMetrics

(

)

Deconstructs a ProcessMetrics object.

Definition at line 155 of file ProcessMetrics.cpp.

{
    _shouldStop.test_and_set();
    if (_thread && _thread->joinable())
    {
        _thread->join();
    }
}

Member Function Documentation

countDirectoryEntries()

size_t ProcessMetrics::countDirectoryEntries ( const std::string & path )

staticprivate

Counts the number of entries in a directory.

Parameters

[in]

path

The path of the directory.

Returns

The number of entries in the directory.

Definition at line 12 of file ProcessMetrics.cpp.

{
    DIR *dir = nullptr;
    size_t count = 0;
    if ((dir = opendir(path.c_str())) != nullptr)
    {
        while (readdir(dir) != nullptr) // NOLINT(concurrency-mt-unsafe)
        {
            ++count;
        }
        closedir(dir);
    }
 
    return count;
}

Here is the caller graph for this function:

getCpuUsage()

double ProcessMetrics::getCpuUsage ( )

protected

Gets the CPU usage of the process.

Returns

The CPU usage as a percentage.

Definition at line 42 of file ProcessMetrics.cpp.

{
    if (_oldCpuTime == 0)
    {
        _oldCpuTime = times(&_oldCpu);
        if (_oldCpuTime == static_cast<clock_t>(-1))
        {
            _oldCpuTime = 0;
        }
        return 0.0;
    }
 
    struct tms nowCpu{};
    auto nowCpuTime = times(&nowCpu);
 
    const double usage = 100.0 * static_cast<double>(nowCpu.tms_utime - _oldCpu.tms_utime) /
                         static_cast<double>(nowCpuTime - _oldCpuTime);
 
    std::swap(_oldCpu, nowCpu);
    std::swap(_oldCpuTime, nowCpuTime);
 
    return usage;
}

Here is the caller graph for this function:

getDiskIO()

std::pair< size_t, size_t > ProcessMetrics::getDiskIO ( )

protected

Gets the disk read and write bytes of the process.

Returns

A pair of the disk read and write bytes.

Definition at line 66 of file ProcessMetrics.cpp.

{
    std::string buffer;
    findFromFile("/proc/self/io", "read_bytes", buffer);
    size_t readBytes = buffer.empty() ? 0 : std::stoull(buffer);
 
    buffer.clear();
    findFromFile("/proc/self/io", "write_bytes", buffer);
    size_t writeBytes = buffer.empty() ? 0 : std::stoull(buffer);
 
    std::pair<size_t, size_t> result = {readBytes - _oldReadBytes, writeBytes - _oldWriteBytes};
 
    std::swap(_oldReadBytes, readBytes);
    std::swap(_oldWriteBytes, writeBytes);
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getFileDescriptorCount()

size_t ProcessMetrics::getFileDescriptorCount ( )

staticprotected

Gets the number of file descriptors in the process.

Returns

The number of file descriptors.

Definition at line 86 of file ProcessMetrics.cpp.

{ return countDirectoryEntries("/proc/self/fd"); }

Here is the call graph for this function:

Here is the caller graph for this function:

getMemoryUsage()

long int ProcessMetrics::getMemoryUsage ( )

staticprotected

Gets the memory usage of the process.

Returns

The memory usage in bytes.

Definition at line 28 of file ProcessMetrics.cpp.

{
    struct rusage r_usage{};
    getrusage(RUSAGE_SELF, &r_usage);
    return r_usage.ru_maxrss; // NOLINT(cppcoreguidelines-pro-type-union-access)
}

Here is the caller graph for this function:

getPageFaults()

long int ProcessMetrics::getPageFaults ( )

staticprotected

Gets the number of page faults of the process.

Returns

The number of page faults.

Definition at line 35 of file ProcessMetrics.cpp.

{
    struct rusage r_usage{};
    getrusage(RUSAGE_SELF, &r_usage);
    return r_usage.ru_majflt; // NOLINT(cppcoreguidelines-pro-type-union-access)
}

Here is the caller graph for this function:

getThreadCount()

size_t ProcessMetrics::getThreadCount ( )

staticprotected

Gets the number of threads in the process.

Returns

The number of threads.

Definition at line 84 of file ProcessMetrics.cpp.

{ return countDirectoryEntries("/proc/self/task"); }

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

ProcessMetrics & ProcessMetrics::operator= ( ProcessMetrics && )

delete

Move assignment operator.

operator=() [2/2]

ProcessMetrics & ProcessMetrics::operator= ( ProcessMetrics )

delete

Copy assignment operator.

threadRunner()

void ProcessMetrics::threadRunner ( )

protectednoexcept

Main thread function

Definition at line 101 of file ProcessMetrics.cpp.

{
    while (!_shouldStop._M_i)
    {
        try
        {
            update();
            if (_checkFlag)
            {
                _checkFlag->test_and_set();
            }
        }
        catch (const std::exception &e)
        {
            spdlog::error("Self monitoring failed: {}", e.what());
        }
 
        std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL_SEC));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void ProcessMetrics::update ( )

protected

Updates the metrics values.

Definition at line 88 of file ProcessMetrics.cpp.

{
    _pCurrentTime->SetToCurrentTime();
    _pMemory->Set(static_cast<double>(getMemoryUsage()));
    _pPageFaults->Set(static_cast<double>(getPageFaults()));
    _pCpuUsage->Set(getCpuUsage());
    auto [diskRead, diskWrite] = getDiskIO();
    _pDiskRead->Set(static_cast<double>(diskRead));
    _pDiskWrite->Set(static_cast<double>(diskWrite));
    _pThreadCount->Set(static_cast<double>(getThreadCount()));
    _pFileDescriptorCount->Set(static_cast<double>(getFileDescriptorCount()));
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_checkFlag

std::shared_ptr<std::atomic_flag> ProcessMetrics::_checkFlag

private

Runtime check flag.

Definition at line 18 of file ProcessMetrics.hpp.

_oldCpuTime

clock_t ProcessMetrics::_oldCpuTime {0}

private

Variable to store the old CPU time.

Definition at line 33 of file ProcessMetrics.hpp.

{0};            

_oldReadBytes

size_t ProcessMetrics::_oldReadBytes {0}

private

Variable to store the old read bytes.

Definition at line 30 of file ProcessMetrics.hpp.

{0};  

_oldWriteBytes

size_t ProcessMetrics::_oldWriteBytes {0}

private

Variable to store the old write bytes.

Definition at line 31 of file ProcessMetrics.hpp.

{0}; 

_pCpuUsage

prometheus::Gauge* ProcessMetrics::_pCpuUsage

private

Pointer to the CPU usage gauge.

Definition at line 24 of file ProcessMetrics.hpp.

_pCurrentTime

prometheus::Gauge* ProcessMetrics::_pCurrentTime

private

Pointer to the current time gauge.

Definition at line 21 of file ProcessMetrics.hpp.

_pDiskRead

prometheus::Gauge* ProcessMetrics::_pDiskRead

private

Pointer to the disk read gauge.

Definition at line 25 of file ProcessMetrics.hpp.

_pDiskWrite

prometheus::Gauge* ProcessMetrics::_pDiskWrite

private

Pointer to the disk write gauge.

Definition at line 26 of file ProcessMetrics.hpp.

_pFileDescriptorCount

prometheus::Gauge* ProcessMetrics::_pFileDescriptorCount

private

Pointer to the file descriptor count gauge.

Definition at line 28 of file ProcessMetrics.hpp.

_pInitTime

prometheus::Gauge* ProcessMetrics::_pInitTime

private

Pointer to initialization time gauge.

Definition at line 20 of file ProcessMetrics.hpp.

_pMemory

prometheus::Gauge* ProcessMetrics::_pMemory

private

Pointer to the memory usage gauge.

Definition at line 22 of file ProcessMetrics.hpp.

_pPageFaults

prometheus::Gauge* ProcessMetrics::_pPageFaults

private

Pointer to the page faults gauge.

Definition at line 23 of file ProcessMetrics.hpp.

_pThreadCount

prometheus::Gauge* ProcessMetrics::_pThreadCount

private

Pointer to the thread count gauge.

Definition at line 27 of file ProcessMetrics.hpp.

_shouldStop

std::atomic_flag ProcessMetrics::_shouldStop {false}

private

Flag to stop monitoring.

Definition at line 16 of file ProcessMetrics.hpp.

{false};          

_thread

std::unique_ptr<std::thread> ProcessMetrics::_thread

private

Thread handler.

Definition at line 17 of file ProcessMetrics.hpp.

---

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

• /__w/Repo-Init/Repo-Init/include/metrics/ProcessMetrics.hpp
• /__w/Repo-Init/Repo-Init/src/metrics/ProcessMetrics.cpp