observer_interface.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <memory>
#include <string>
#include <variant>
#include "metric_types_adapter.h"
#include "../core/result_types.h"
 
namespace kcenon { namespace monitoring {
 
// Forward declarations
class metric_event;
class system_event;
class state_change_event;
 
class metric_event {
public:
    metric_event(const std::string& source, const metric& data)
        : source_(source), metric_data_(data), timestamp_(std::chrono::steady_clock::now()) {}
 
    const std::string& source() const { return source_; }
    const metric& data() const { return metric_data_; }
    std::chrono::steady_clock::time_point timestamp() const { return timestamp_; }
 
private:
    std::string source_;
    metric metric_data_;
    std::chrono::steady_clock::time_point timestamp_;
};
 
class system_event {
public:
    enum class event_type {
        component_started,
        component_stopped,
        error_occurred,
        warning_raised,
        configuration_changed,
        threshold_exceeded
    };
 
    system_event(event_type type, const std::string& component, const std::string& message)
        : type_(type), component_(component), message_(message),
          timestamp_(std::chrono::steady_clock::now()) {}
 
    event_type type() const { return type_; }
    const std::string& component() const { return component_; }
    const std::string& message() const { return message_; }
    std::chrono::steady_clock::time_point timestamp() const { return timestamp_; }
 
private:
    event_type type_;
    std::string component_;
    std::string message_;
    std::chrono::steady_clock::time_point timestamp_;
};
 
class state_change_event {
public:
    enum class state {
        healthy,
        degraded,
        critical,
        unknown
    };
 
    state_change_event(const std::string& component, state old_state, state new_state)
        : component_(component), old_state_(old_state), new_state_(new_state),
          timestamp_(std::chrono::steady_clock::now()) {}
 
    const std::string& component() const { return component_; }
    state old_state() const { return old_state_; }
    state new_state() const { return new_state_; }
    std::chrono::steady_clock::time_point timestamp() const { return timestamp_; }
 
private:
    std::string component_;
    state old_state_;
    state new_state_;
    std::chrono::steady_clock::time_point timestamp_;
};
 
class interface_monitoring_observer {
public:
    virtual ~interface_monitoring_observer() = default;
 
    virtual void on_metric_collected(const metric_event& event) = 0;
 
    virtual void on_event_occurred(const system_event& event) = 0;
 
    virtual void on_system_state_changed(const state_change_event& event) = 0;
};
 
class interface_observable {
public:
    virtual ~interface_observable() = default;
 
    virtual common::VoidResult register_observer(std::shared_ptr<interface_monitoring_observer> observer) = 0;
 
    virtual common::VoidResult unregister_observer(std::shared_ptr<interface_monitoring_observer> observer) = 0;
 
    virtual void notify_metric(const metric_event& event) = 0;
 
    virtual void notify_event(const system_event& event) = 0;
 
    virtual void notify_state_change(const state_change_event& event) = 0;
};
 
} } // namespace kcenon::monitoring