Centralized metrics service for thread pool metrics management. More...

#include <metrics_service.h>

Collaboration diagram for kcenon::thread::metrics::metrics_service:

Public Member Functions
	metrics_service ()
	Default constructor.

	~metrics_service ()=default
	Destructor.

	metrics_service (const metrics_service &)=delete

metrics_service &	operator= (const metrics_service &)=delete

	metrics_service (metrics_service &&)=delete

metrics_service &	operator= (metrics_service &&)=delete

void	record_submission (std::size_t count=1)
	Record task submission(s).

void	record_enqueue (std::size_t count=1)
	Record enqueue operation(s).

void	record_enqueue_with_latency (std::chrono::nanoseconds latency, std::size_t count=1)
	Record enqueue operation with latency measurement.

void	record_execution (std::uint64_t duration_ns, bool success)
	Record task execution completion.

void	record_execution_with_wait_time (std::chrono::nanoseconds duration, std::chrono::nanoseconds wait_time, bool success)
	Record task execution with wait time tracking.

void	record_idle_time (std::uint64_t duration_ns)
	Record idle time.

void	record_queue_depth (std::size_t depth)
	Record current queue depth.

void	record_worker_state (std::size_t worker_id, bool busy, std::uint64_t duration_ns=0)
	Update worker state for per-worker metrics.

void	set_enhanced_metrics_enabled (bool enabled, std::size_t worker_count=0)
	Enable or disable enhanced metrics collection.

bool	is_enhanced_metrics_enabled () const
	Check if enhanced metrics is enabled.

void	update_worker_count (std::size_t count)
	Update the worker count for enhanced metrics.

void	set_active_workers (std::size_t count)
	Set the number of active workers.

const ThreadPoolMetrics &	basic_metrics () const noexcept
	Access basic metrics (read-only reference).

const EnhancedThreadPoolMetrics &	enhanced_metrics () const
	Access enhanced metrics (read-only reference).

EnhancedSnapshot	enhanced_snapshot () const
	Get enhanced metrics snapshot.

std::shared_ptr< ThreadPoolMetrics >	get_basic_metrics () const noexcept
	Get the shared pointer to basic metrics.

void	reset ()
	Reset all metrics to their initial state.

Private Attributes
std::shared_ptr< ThreadPoolMetrics >	basic_metrics_
	Basic metrics collector.

std::shared_ptr< EnhancedThreadPoolMetrics >	enhanced_metrics_
	Enhanced metrics collector.

std::atomic< bool >	enhanced_enabled_ {false}
	Flag indicating if enhanced metrics collection is enabled.

std::mutex	init_mutex_
	Mutex for thread-safe enhanced metrics initialization.

Detailed Description

Centralized metrics service for thread pool metrics management.

This class provides a unified interface for metrics handling, consolidating metrics management that was previously duplicated between thread_pool and thread_worker classes.

Ownership Semantics

thread_pool owns the metrics_service (via shared_ptr)
thread_worker receives a non-owning pointer to the service

Thread Safety

All methods are thread-safe using lock-free atomic operations and internal synchronization.

Performance Characteristics

record_* overhead: < 100ns
Minimal memory footprint due to lazy initialization

Usage Example

// In thread_pool constructor
metrics_service_ = std::make_shared<metrics_service>();
 
// In thread_pool::set_enhanced_metrics_enabled
metrics_service_->set_enhanced_metrics_enabled(true, worker_count);
 
// In thread_worker (non-owning reference)
metrics_service_->record_execution(duration_ns, success);

See also: ThreadPoolMetrics; EnhancedThreadPoolMetrics

Definition at line 60 of file metrics_service.h.

Constructor & Destructor Documentation

◆ metrics_service() [1/3]

kcenon::thread::metrics::metrics_service::metrics_service ( )

Default constructor.

Creates the basic ThreadPoolMetrics immediately. EnhancedThreadPoolMetrics is lazily initialized when enabled.

Definition at line 11 of file metrics_service.cpp.

12 : basic_metrics_(std::make_shared<ThreadPoolMetrics>()) {

13}

kcenon::thread::metrics::metrics_service::basic_metrics_

std::shared_ptr< ThreadPoolMetrics > basic_metrics_

Basic metrics collector.

Definition metrics_service.h:233

◆ ~metrics_service()

kcenon::thread::metrics::metrics_service::~metrics_service ( )

default

Destructor.

◆ metrics_service() [2/3]

kcenon::thread::metrics::metrics_service::metrics_service ( const metrics_service & )

delete

◆ metrics_service() [3/3]

kcenon::thread::metrics::metrics_service::metrics_service ( metrics_service && )

delete

Member Function Documentation

◆ basic_metrics()

const ThreadPoolMetrics & kcenon::thread::metrics::metrics_service::basic_metrics ( ) const

nodiscardnoexcept

Access basic metrics (read-only reference).

Returns: Reference to ThreadPoolMetrics.

Definition at line 112 of file metrics_service.cpp.

                                                                       {
    return *basic_metrics_;
}

References basic_metrics_.

◆ enhanced_metrics()

const EnhancedThreadPoolMetrics & kcenon::thread::metrics::metrics_service::enhanced_metrics ( ) const

nodiscard

Access enhanced metrics (read-only reference).

Returns: Reference to EnhancedThreadPoolMetrics.

Exceptions

std::runtime_error if enhanced metrics is not enabled.

Definition at line 116 of file metrics_service.cpp.

                                                                         {
    if (!enhanced_metrics_) {
        throw std::runtime_error(
            "Enhanced metrics is not enabled. "
            "Call set_enhanced_metrics_enabled(true) first.");
    }
    return *enhanced_metrics_;
}

References enhanced_metrics_.

◆ enhanced_snapshot()

EnhancedSnapshot kcenon::thread::metrics::metrics_service::enhanced_snapshot ( ) const

nodiscard

Get enhanced metrics snapshot.

Returns: EnhancedSnapshot with all current metric values.

Returns empty snapshot if enhanced metrics is not enabled.

Definition at line 125 of file metrics_service.cpp.

                                                          {
    if (!enhanced_enabled_.load(std::memory_order_acquire) || !enhanced_metrics_) {
        return EnhancedSnapshot{};
    }
    return enhanced_metrics_->snapshot();
}

References enhanced_enabled_, and enhanced_metrics_.

◆ get_basic_metrics()

std::shared_ptr< ThreadPoolMetrics > kcenon::thread::metrics::metrics_service::get_basic_metrics ( ) const

nodiscardnoexcept

Get the shared pointer to basic metrics.

Returns: Shared pointer to ThreadPoolMetrics.

Used by thread_worker for direct metrics recording.

Definition at line 132 of file metrics_service.cpp.

                                                                                   {
    return basic_metrics_;
}

References basic_metrics_.

◆ is_enhanced_metrics_enabled()

bool kcenon::thread::metrics::metrics_service::is_enhanced_metrics_enabled ( ) const

nodiscard

Check if enhanced metrics is enabled.

Returns: True if enhanced metrics collection is enabled.

Definition at line 96 of file metrics_service.cpp.

                                                        {
    return enhanced_enabled_.load(std::memory_order_acquire);
}

References enhanced_enabled_.

◆ operator=() [1/2]

metrics_service & kcenon::thread::metrics::metrics_service::operator= ( const metrics_service & )

delete

◆ operator=() [2/2]

metrics_service & kcenon::thread::metrics::metrics_service::operator= ( metrics_service && )

delete

◆ record_enqueue()

void kcenon::thread::metrics::metrics_service::record_enqueue ( std::size_t count = 1 )

Record enqueue operation(s).

Parameters

count Number of tasks enqueued (default: 1).

Definition at line 25 of file metrics_service.cpp.

                                                    {
    basic_metrics_->record_enqueue(count);
}

References basic_metrics_.

◆ record_enqueue_with_latency()

void kcenon::thread::metrics::metrics_service::record_enqueue_with_latency	(	std::chrono::nanoseconds	latency,
		std::size_t	count = 1 )

Record enqueue operation with latency measurement.

Parameters

latency	Time taken to enqueue the task.
count	Number of tasks enqueued (default: 1).

Used when enhanced metrics are enabled to track enqueue latency histogram.

Definition at line 29 of file metrics_service.cpp.

                     {
    basic_metrics_->record_enqueue(count);
 
    if (enhanced_enabled_.load(std::memory_order_relaxed) && enhanced_metrics_) {
        // Distribute latency across batch items for more accurate per-job tracking
        auto per_item_latency = latency / static_cast<long>(count);
        for (std::size_t i = 0; i < count; ++i) {
            enhanced_metrics_->record_enqueue(per_item_latency);
        }
    }
}

References basic_metrics_, enhanced_enabled_, enhanced_metrics_, and kcenon::thread::latency.

◆ record_execution()

void kcenon::thread::metrics::metrics_service::record_execution	(	std::uint64_t	duration_ns,
		bool	success )

Record task execution completion.

Parameters

duration_ns	Execution duration in nanoseconds.
success	Whether the task completed successfully.

Definition at line 43 of file metrics_service.cpp.

                                                                            {
    basic_metrics_->record_execution(duration_ns, success);
 
    if (enhanced_enabled_.load(std::memory_order_relaxed) && enhanced_metrics_) {
        enhanced_metrics_->record_execution(
            std::chrono::nanoseconds{duration_ns}, success);
    }
}

References basic_metrics_, enhanced_enabled_, enhanced_metrics_, and kcenon::thread::success.

◆ record_execution_with_wait_time()

void kcenon::thread::metrics::metrics_service::record_execution_with_wait_time	(	std::chrono::nanoseconds	duration,
		std::chrono::nanoseconds	wait_time,
		bool	success )

Record task execution with wait time tracking.

Parameters

duration	Execution duration.
wait_time	Time the task waited in queue.
success	Whether the task completed successfully.

Used when enhanced metrics are enabled.

Definition at line 52 of file metrics_service.cpp.

                  {
    basic_metrics_->record_execution(
        static_cast<std::uint64_t>(duration.count()), success);
 
    if (enhanced_enabled_.load(std::memory_order_relaxed) && enhanced_metrics_) {
        enhanced_metrics_->record_execution(duration, success);
        enhanced_metrics_->record_wait_time(wait_time);
    }
}

References basic_metrics_, enhanced_enabled_, enhanced_metrics_, and kcenon::thread::success.

◆ record_idle_time()

void kcenon::thread::metrics::metrics_service::record_idle_time ( std::uint64_t duration_ns )

Record idle time.

Parameters

duration_ns Idle duration in nanoseconds.

Definition at line 65 of file metrics_service.cpp.

                                                              {
    basic_metrics_->record_idle_time(duration_ns);
}

References basic_metrics_.

◆ record_queue_depth()

void kcenon::thread::metrics::metrics_service::record_queue_depth ( std::size_t depth )

Record current queue depth.

Parameters

depth The current number of tasks in the queue.

Definition at line 69 of file metrics_service.cpp.

                                                        {
    if (enhanced_enabled_.load(std::memory_order_relaxed) && enhanced_metrics_) {
        enhanced_metrics_->record_queue_depth(depth);
    }
}

References enhanced_enabled_, and enhanced_metrics_.

◆ record_submission()

void kcenon::thread::metrics::metrics_service::record_submission ( std::size_t count = 1 )

Record task submission(s).

Parameters

count Number of tasks submitted (default: 1).

Definition at line 15 of file metrics_service.cpp.

                                                       {
    basic_metrics_->record_submission(count);
 
    if (enhanced_enabled_.load(std::memory_order_relaxed) && enhanced_metrics_) {
        for (std::size_t i = 0; i < count; ++i) {
            enhanced_metrics_->record_submission();
        }
    }
}

References basic_metrics_, enhanced_enabled_, and enhanced_metrics_.

◆ record_worker_state()

void kcenon::thread::metrics::metrics_service::record_worker_state	(	std::size_t	worker_id,
		bool	busy,
		std::uint64_t	duration_ns = 0 )

Update worker state for per-worker metrics.

Parameters

worker_id	The worker's identifier.
busy	Whether the worker is currently busy.
duration_ns	Duration in the previous state.

Definition at line 75 of file metrics_service.cpp.

                             {
    if (enhanced_enabled_.load(std::memory_order_relaxed) && enhanced_metrics_) {
        enhanced_metrics_->record_worker_state(worker_id, busy, duration_ns);
    }
}

References enhanced_enabled_, and enhanced_metrics_.

◆ reset()

void kcenon::thread::metrics::metrics_service::reset ( )

Reset all metrics to their initial state.

Resets both basic and enhanced metrics (if enabled).

Definition at line 136 of file metrics_service.cpp.

                            {
    basic_metrics_->reset();
    if (enhanced_metrics_) {
        enhanced_metrics_->reset();
    }
}

References basic_metrics_, and enhanced_metrics_.

◆ set_active_workers()

void kcenon::thread::metrics::metrics_service::set_active_workers ( std::size_t count )

Set the number of active workers.

Parameters

count Number of currently active workers.

Definition at line 106 of file metrics_service.cpp.

                                                        {
    if (enhanced_metrics_) {
        enhanced_metrics_->set_active_workers(count);
    }
}

References enhanced_metrics_.

◆ set_enhanced_metrics_enabled()

void kcenon::thread::metrics::metrics_service::set_enhanced_metrics_enabled	(	bool	enabled,
		std::size_t	worker_count = 0 )

Enable or disable enhanced metrics collection.

Parameters

enabled	True to enable enhanced metrics.
worker_count	Number of workers to track (for initialization).

When enabled for the first time, initializes EnhancedThreadPoolMetrics. Subsequent calls only toggle the enabled flag.

Definition at line 84 of file metrics_service.cpp.

                                                                                       {
    if (enabled && !enhanced_metrics_) {
        std::scoped_lock<std::mutex> lock(init_mutex_);
        // Double-check after acquiring lock
        if (!enhanced_metrics_) {
            enhanced_metrics_ = std::make_shared<EnhancedThreadPoolMetrics>(worker_count);
            enhanced_metrics_->set_active_workers(worker_count);
        }
    }
    enhanced_enabled_.store(enabled, std::memory_order_release);
}

References enhanced_enabled_, enhanced_metrics_, and init_mutex_.

◆ update_worker_count()

void kcenon::thread::metrics::metrics_service::update_worker_count ( std::size_t count )

Update the worker count for enhanced metrics.

Parameters

count New number of workers.

Call this when the thread pool scales up or down.

Definition at line 100 of file metrics_service.cpp.

                                                         {
    if (enhanced_metrics_) {
        enhanced_metrics_->update_worker_count(count);
    }
}

References enhanced_metrics_.

Member Data Documentation

◆ basic_metrics_

std::shared_ptr<ThreadPoolMetrics> kcenon::thread::metrics::metrics_service::basic_metrics_

private

Basic metrics collector.

Always initialized; provides core metrics functionality.

Definition at line 233 of file metrics_service.h.

Referenced by basic_metrics(), get_basic_metrics(), record_enqueue(), record_enqueue_with_latency(), record_execution(), record_execution_with_wait_time(), record_idle_time(), record_submission(), and reset().

◆ enhanced_enabled_

std::atomic<bool> kcenon::thread::metrics::metrics_service::enhanced_enabled_ {false}

private

Flag indicating if enhanced metrics collection is enabled.

Definition at line 245 of file metrics_service.h.

245{false};

Referenced by enhanced_snapshot(), is_enhanced_metrics_enabled(), record_enqueue_with_latency(), record_execution(), record_execution_with_wait_time(), record_queue_depth(), record_submission(), record_worker_state(), and set_enhanced_metrics_enabled().

◆ enhanced_metrics_

std::shared_ptr<EnhancedThreadPoolMetrics> kcenon::thread::metrics::metrics_service::enhanced_metrics_

private

Enhanced metrics collector.

Lazily initialized when enhanced metrics is first enabled.

Definition at line 240 of file metrics_service.h.

Referenced by enhanced_metrics(), enhanced_snapshot(), record_enqueue_with_latency(), record_execution(), record_execution_with_wait_time(), record_queue_depth(), record_submission(), record_worker_state(), reset(), set_active_workers(), set_enhanced_metrics_enabled(), and update_worker_count().

◆ init_mutex_

std::mutex kcenon::thread::metrics::metrics_service::init_mutex_

mutableprivate

Mutex for thread-safe enhanced metrics initialization.

Definition at line 250 of file metrics_service.h.

Referenced by set_enhanced_metrics_enabled().

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

include/kcenon/thread/metrics/metrics_service.h
src/metrics/metrics_service.cpp

Public Member Functions

Private Attributes

Detailed Description

Ownership Semantics

Thread Safety

Performance Characteristics

Usage Example

Constructor & Destructor Documentation

◆ metrics_service() [1/3]

◆ ~metrics_service()

◆ metrics_service() [2/3]

◆ metrics_service() [3/3]

Member Function Documentation

◆ basic_metrics()

◆ enhanced_metrics()

◆ enhanced_snapshot()

◆ get_basic_metrics()

◆ is_enhanced_metrics_enabled()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ record_enqueue()

◆ record_enqueue_with_latency()

◆ record_execution()

◆ record_execution_with_wait_time()

◆ record_idle_time()

◆ record_queue_depth()

◆ record_submission()

◆ record_worker_state()

◆ reset()

◆ set_active_workers()

◆ set_enhanced_metrics_enabled()

◆ update_worker_count()

Member Data Documentation

◆ basic_metrics_

◆ enhanced_enabled_

◆ enhanced_metrics_

◆ init_mutex_