Core alert data structure. More...

#include <alert_types.h>

Collaboration diagram for kcenon::monitoring::alert:

Public Member Functions
	alert ()
	Default constructor.

	alert (std::string alert_name, alert_labels lbl)
	Construct with name and labels.

std::string	fingerprint () const
	Get alert fingerprint for deduplication.

bool	is_active () const
	Check if alert is currently active (pending or firing)

std::chrono::steady_clock::duration	state_duration () const
	Get duration in current state.

std::chrono::steady_clock::duration	firing_duration () const
	Get firing duration (if currently firing)

bool	transition_to (alert_state new_state)
	Transition to a new state.

Public Attributes
std::string	name
	Alert name/identifier.

alert_labels	labels
	Identifying labels.

alert_annotations	annotations
	Descriptive annotations.

alert_severity	severity = alert_severity::warning
	Alert severity level.

alert_state	state = alert_state::inactive
	Current state.

double	value = 0.0
	Current metric value.

std::chrono::steady_clock::time_point	created_at
	When alert was created.

std::chrono::steady_clock::time_point	updated_at
	Last state change.

std::optional< std::chrono::steady_clock::time_point >	started_at
	When firing started.

std::optional< std::chrono::steady_clock::time_point >	resolved_at
	When resolved.

uint64_t	id = 0
	Unique alert ID.

std::string	rule_name
	Name of triggering rule.

std::string	group_key
	Grouping key for dedup.

Static Private Member Functions
static uint64_t	generate_id ()

static bool	is_valid_transition (alert_state from, alert_state to)
	Check if state transition is valid.

Detailed Description

Core alert data structure.

Represents a single alert instance with its current state, metadata, and lifecycle timestamps.

Thread Safety:: This structure is not thread-safe. External synchronization is required when accessed from multiple threads.

Examples: alert_notifiers_example.cpp, alert_pipeline_example.cpp, and event_bus_example.cpp.

Definition at line 185 of file alert_types.h.

Constructor & Destructor Documentation

◆ alert() [1/2]

kcenon::monitoring::alert::alert ( )

inline

Default constructor.

Definition at line 205 of file alert_types.h.

        : created_at(std::chrono::steady_clock::now())
        , updated_at(created_at)
        , id(generate_id()) {}

◆ alert() [2/2]

kcenon::monitoring::alert::alert	(	std::string	alert_name,
		alert_labels	lbl )

inline

Construct with name and labels.

Parameters

alert_name	Alert name
alert_labels	Alert labels

Definition at line 215 of file alert_types.h.

        : name(std::move(alert_name))
        , labels(std::move(lbl))
        , created_at(std::chrono::steady_clock::now())
        , updated_at(created_at)
        , id(generate_id()) {}

Member Function Documentation

◆ fingerprint()

std::string kcenon::monitoring::alert::fingerprint ( ) const

inline

Get alert fingerprint for deduplication.

Returns: Unique fingerprint based on name and labels

Definition at line 226 of file alert_types.h.

                                  {
        return name + "{" + labels.fingerprint() + "}";
    }

References kcenon::monitoring::alert_labels::fingerprint(), labels, and name.

Referenced by kcenon::monitoring::alert_aggregator::add_alert(), kcenon::monitoring::json_alert_formatter::format(), kcenon::monitoring::text_alert_formatter::format(), kcenon::monitoring::alert_deduplicator::is_duplicate(), kcenon::monitoring::alert_inhibitor::is_inhibited(), kcenon::monitoring::alert_deduplicator::mark_seen(), and kcenon::monitoring::alert_template::render().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ firing_duration()

std::chrono::steady_clock::duration kcenon::monitoring::alert::firing_duration ( ) const

inline

Get firing duration (if currently firing)

Returns: Duration since firing started, or zero if not firing

Definition at line 250 of file alert_types.h.

                                                          {
        if (state == alert_state::firing && started_at.has_value()) {
            return std::chrono::steady_clock::now() - *started_at;
        }
        return std::chrono::steady_clock::duration::zero();
    }

References kcenon::monitoring::firing, started_at, and state.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ generate_id()

static uint64_t kcenon::monitoring::alert::generate_id ( )

inlinestaticprivate

Definition at line 281 of file alert_types.h.

                                  {
        static std::atomic<uint64_t> counter{0};
        return counter.fetch_add(1, std::memory_order_relaxed);
    }

References kcenon::monitoring::counter.

◆ is_active()

bool kcenon::monitoring::alert::is_active ( ) const

inline

Check if alert is currently active (pending or firing)

Returns: True if alert is active

Definition at line 234 of file alert_types.h.

                           {
        return state == alert_state::pending || state == alert_state::firing;
    }

References kcenon::monitoring::firing, kcenon::monitoring::pending, and state.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ is_valid_transition()

static bool kcenon::monitoring::alert::is_valid_transition	(	alert_state	from,
		alert_state	to )

inlinestaticprivate

Check if state transition is valid.

Definition at line 289 of file alert_types.h.

                                                                      {
        // All transitions are valid from suppressed (when silence expires)
        if (from == alert_state::suppressed) {
            return true;
        }
 
        // Transition to suppressed is always valid
        if (to == alert_state::suppressed) {
            return true;
        }
 
        switch (from) {
            case alert_state::inactive:
                return to == alert_state::pending;
            case alert_state::pending:
                return to == alert_state::firing || to == alert_state::inactive;
            case alert_state::firing:
                return to == alert_state::resolved;
            case alert_state::resolved:
                return to == alert_state::pending || to == alert_state::inactive;
            default:
                return false;
        }
    }

References kcenon::monitoring::firing, kcenon::monitoring::inactive, kcenon::monitoring::pending, kcenon::monitoring::resolved, and kcenon::monitoring::suppressed.

Referenced by transition_to().

Here is the caller graph for this function:

◆ state_duration()

std::chrono::steady_clock::duration kcenon::monitoring::alert::state_duration ( ) const

inline

Get duration in current state.

Returns: Duration since last state change

Definition at line 242 of file alert_types.h.

                                                         {
        return std::chrono::steady_clock::now() - updated_at;
    }

References updated_at.

Referenced by TEST_F().

Here is the caller graph for this function:

◆ transition_to()

bool kcenon::monitoring::alert::transition_to ( alert_state new_state )

inline

Transition to a new state.

Parameters

new_state The new state

Returns: True if transition was valid

Definition at line 262 of file alert_types.h.

                                              {
        if (!is_valid_transition(state, new_state)) {
            return false;
        }
 
        auto now = std::chrono::steady_clock::now();
        state = new_state;
        updated_at = now;
 
        if (new_state == alert_state::firing && !started_at.has_value()) {
            started_at = now;
        } else if (new_state == alert_state::resolved) {
            resolved_at = now;
        }
 
        return true;
    }