Buffers alerts and sends in batches. More...

#include <alert_notifiers.h>

Inheritance diagram for kcenon::monitoring::buffered_notifier:

Collaboration diagram for kcenon::monitoring::buffered_notifier:

Public Member Functions
	buffered_notifier (std::shared_ptr< alert_notifier > inner, size_t buffer_size=100, std::chrono::milliseconds flush_interval=std::chrono::seconds(30))
	Construct buffered notifier.

std::string	name () const override
	Get notifier name.

common::VoidResult	notify (const alert &a) override
	Send a notification for an alert.

common::VoidResult	notify_group (const alert_group &group) override
	Send a notification for an alert group.

bool	is_ready () const override
	Check if notifier is ready.

common::VoidResult	flush ()
	Flush buffered alerts.

size_t	pending_count () const
	Get current buffer size.

Public Member Functions inherited from kcenon::monitoring::alert_notifier
virtual	~alert_notifier ()=default

Private Member Functions
bool	should_flush () const

common::VoidResult	flush_internal ()

Private Attributes
std::shared_ptr< alert_notifier >	inner_

size_t	buffer_size_

std::chrono::milliseconds	flush_interval_

std::mutex	mutex_

std::vector< alert >	buffer_

std::chrono::steady_clock::time_point	last_flush_

Detailed Description

Buffers alerts and sends in batches.

Collects alerts and sends them in batches either when the buffer is full or when flush is called.

Definition at line 451 of file alert_notifiers.h.

Constructor & Destructor Documentation

◆ buffered_notifier()

kcenon::monitoring::buffered_notifier::buffered_notifier	(	std::shared_ptr< alert_notifier >	inner,
		size_t	buffer_size = 100,
		std::chrono::milliseconds	flush_interval = std::chrono::seconds(30) )

inline

Construct buffered notifier.

Parameters

inner	Inner notifier to use for actual sending
buffer_size	Maximum alerts before auto-flush
flush_interval	Maximum time before auto-flush

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h.

Definition at line 459 of file alert_notifiers.h.

        : inner_(std::move(inner))
        , buffer_size_(buffer_size)
        , flush_interval_(flush_interval)
        , last_flush_(std::chrono::steady_clock::now()) {}

Member Function Documentation

◆ flush()

common::VoidResult kcenon::monitoring::buffered_notifier::flush ( )

inline

Flush buffered alerts.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h.

Definition at line 504 of file alert_notifiers.h.

                             {
        std::lock_guard<std::mutex> lock(mutex_);
        return flush_internal();
    }

References flush_internal(), and mutex_.

Here is the call graph for this function:

◆ flush_internal()

common::VoidResult kcenon::monitoring::buffered_notifier::flush_internal ( )

inlineprivate

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h.

Definition at line 526 of file alert_notifiers.h.

                                      {
        if (buffer_.empty() || !inner_) {
            return common::ok();
        }
 
        // Create a group from buffered alerts
        alert_group group("buffered");
        for (auto& a : buffer_) {
            group.add_alert(std::move(a));
        }
        buffer_.clear();
 
        last_flush_ = std::chrono::steady_clock::now();
 
        return inner_->notify_group(group);
    }

References kcenon::monitoring::alert_group::add_alert(), buffer_, inner_, and last_flush_.

Referenced by flush(), notify(), and notify_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_ready()

bool kcenon::monitoring::buffered_notifier::is_ready ( ) const

inlineoverridevirtual

Check if notifier is ready.

Returns: True if ready to send notifications

Implements kcenon::monitoring::alert_notifier.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h.

Definition at line 497 of file alert_notifiers.h.

                                   {
        return inner_ && inner_->is_ready();
    }

References inner_.

◆ name()

std::string kcenon::monitoring::buffered_notifier::name ( ) const

inlineoverridevirtual

Get notifier name.

Returns: Notifier name

Implements kcenon::monitoring::alert_notifier.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h.

Definition at line 467 of file alert_notifiers.h.

                                    {
        return "buffered:" + (inner_ ? inner_->name() : "none");
    }

References inner_.

◆ notify()

common::VoidResult kcenon::monitoring::buffered_notifier::notify ( const alert & a )

inlineoverridevirtual

Send a notification for an alert.

Parameters

a	Alert to notify about

Returns: Result indicating success or failure

Implements kcenon::monitoring::alert_notifier.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h.

Definition at line 471 of file alert_notifiers.h.

                                                     {
        std::lock_guard<std::mutex> lock(mutex_);
 
        buffer_.push_back(a);
 
        if (should_flush()) {
            return flush_internal();
        }
 
        return common::ok();
    }

References buffer_, flush_internal(), mutex_, and should_flush().

Here is the call graph for this function:

◆ notify_group()

common::VoidResult kcenon::monitoring::buffered_notifier::notify_group ( const alert_group & group )

inlineoverridevirtual

Send a notification for an alert group.

Parameters

group Alert group to notify about

Returns: Result indicating success or failure

Implements kcenon::monitoring::alert_notifier.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h.

Definition at line 483 of file alert_notifiers.h.

                                                                     {
        std::lock_guard<std::mutex> lock(mutex_);
 
        for (const auto& a : group.alerts) {
            buffer_.push_back(a);
        }
 
        if (should_flush()) {
            return flush_internal();
        }
 
        return common::ok();
    }

References kcenon::monitoring::alert_group::alerts, buffer_, flush_internal(), mutex_, and should_flush().

Here is the call graph for this function:

◆ pending_count()

size_t kcenon::monitoring::buffered_notifier::pending_count ( ) const

inline

Get current buffer size.

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h.

Definition at line 512 of file alert_notifiers.h.

                                 {
        std::lock_guard<std::mutex> lock(mutex_);
        return buffer_.size();
    }

References buffer_, and mutex_.

◆ should_flush()

bool kcenon::monitoring::buffered_notifier::should_flush ( ) const

inlineprivate

Examples: /home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/alert/alert_notifiers.h.

Definition at line 518 of file alert_notifiers.h.

                              {
        if (buffer_.size() >= buffer_size_) {
            return true;
        }
        auto now = std::chrono::steady_clock::now();
        return (now - last_flush_) >= flush_interval_;
    }