monitoring_integration_example.cpp File Reference

Advanced monitoring integration example for Phase 4. More...

#include <kcenon/logger/core/logger_builder.h>
#include <kcenon/common/interfaces/logger_interface.h>
#include <kcenon/common/interfaces/monitoring_interface.h>
#include <iostream>
#include <memory>
#include <vector>
#include <thread>
#include <chrono>
#include <iomanip>
#include <mutex>
#include <unordered_map>

Include dependency graph for monitoring_integration_example.cpp:

Go to the source code of this file.

Classes
class	aggregating_monitor
	Aggregating monitor that collects metrics from multiple sources. More...

Functions
void	print_metrics_snapshot (const ci::metrics_snapshot &snapshot)
	Print metrics snapshot in formatted way.
void	print_health_result (const ci::health_check_result &health)
	Print health check result.
void	example_1_basic_integration ()
	Example 1: Basic monitor integration with logger.
void	example_2_multiple_loggers ()
	Example 2: Multiple loggers with single monitor.
void	example_3_imonitorable_interface ()
	Example 3: Demonstrating IMonitorable interface.
void	example_4_monitoring_system_simulation ()
	Example 4: Simulating monitoring_system integration.
int	main ()

Detailed Description

Advanced monitoring integration example for Phase 4.

Definition in file monitoring_integration_example.cpp.

Function Documentation

example_1_basic_integration()

void example_1_basic_integration

(

)

Example 1: Basic monitor integration with logger.

Examples

monitoring_integration_example.cpp.

Definition at line 199 of file monitoring_integration_example.cpp.

                                   {
    std::cout << "\n=== Example 1: Basic Monitor Integration ===" << std::endl;
 
    auto monitor = std::make_shared<aggregating_monitor>();
 
    auto logger_result = logger_builder()
        .with_async(false)
        .with_monitoring(monitor)
        .build();
 
    if (!logger_result) {
        std::cerr << "Failed to create logger" << std::endl;
        return;
    }
 
    auto logger_instance = std::shared_ptr<logger>(std::move(logger_result.value()));
 
    // Register logger as monitored component
    // TODO: Implement IMonitorable interface on logger class (Phase 2.2)
    // Currently logger doesn't inherit from IMonitorable
    // monitor->register_component(std::static_pointer_cast<ci::IMonitorable>(logger_instance));
    std::cout << "[Note: logger IMonitorable integration pending Phase 2.2]" << std::endl;
 
    // Perform logging operations
    for (int i = 0; i < 5; ++i) {
        logger_instance->log(ci::log_level::info,
            "Log message " + std::to_string(i + 1));
    }
 
    // Get aggregated metrics
    auto metrics = monitor->get_metrics();
    if (kcenon::common::is_ok(metrics)) {
        print_metrics_snapshot(kcenon::common::get_value(metrics));
    }
 
    // Check aggregated health
    auto health = monitor->check_health();
    if (kcenon::common::is_ok(health)) {
        print_health_result(kcenon::common::get_value(health));
    }
}

References kcenon::logger::logger_builder::build(), kcenon::common::get_value(), kcenon::common::is_ok(), print_health_result(), print_metrics_snapshot(), kcenon::logger::logger_builder::with_async(), and kcenon::logger::logger_builder::with_monitoring().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_2_multiple_loggers()

void example_2_multiple_loggers

(

)

Example 2: Multiple loggers with single monitor.

Examples

monitoring_integration_example.cpp.

Definition at line 244 of file monitoring_integration_example.cpp.

                                  {
    std::cout << "\n=== Example 2: Multiple Loggers, Single Monitor ===" << std::endl;
 
    auto monitor = std::make_shared<aggregating_monitor>();
 
    // Create multiple logger instances
    auto logger1_result = logger_builder()
        .with_async(false)
        .with_monitoring(monitor)
        .build();
 
    auto logger2_result = logger_builder()
        .with_async(false)
        .with_monitoring(monitor)
        .build();
 
    if (!logger1_result || !logger2_result) {
        std::cerr << "Failed to create loggers" << std::endl;
        return;
    }
 
    auto logger1 = std::shared_ptr<logger>(std::move(logger1_result.value()));
    auto logger2 = std::shared_ptr<logger>(std::move(logger2_result.value()));
 
    // Register both loggers
    // TODO: Implement IMonitorable interface on logger class (Phase 2.2)
    // monitor->register_component(std::static_pointer_cast<ci::IMonitorable>(logger1));
    // monitor->register_component(std::static_pointer_cast<ci::IMonitorable>(logger2));
    std::cout << "[Note: logger IMonitorable integration pending Phase 2.2]" << std::endl;
 
    // Both loggers use the same monitor
    logger1->log(ci::log_level::info, std::string("Message from logger 1"));
    logger2->log(ci::log_level::warning, std::string("Message from logger 2"));
    logger1->log(ci::log_level::error, std::string("Error from logger 1"));
 
    std::cout << "\nMonitor tracks " << monitor->get_component_count()
              << " components" << std::endl;
 
    // Get combined metrics
    auto metrics = monitor->get_metrics();
    if (kcenon::common::is_ok(metrics)) {
        std::cout << "Combined metrics from all loggers:" << std::endl;
        print_metrics_snapshot(kcenon::common::get_value(metrics));
    }
}

References kcenon::logger::logger_builder::build(), kcenon::common::get_value(), kcenon::common::is_ok(), print_metrics_snapshot(), kcenon::logger::logger_builder::with_async(), and kcenon::logger::logger_builder::with_monitoring().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_3_imonitorable_interface()

void example_3_imonitorable_interface

(

)

Example 3: Demonstrating IMonitorable interface.

Examples

monitoring_integration_example.cpp.

Definition at line 293 of file monitoring_integration_example.cpp.

                                        {
    std::cout << "\n=== Example 3: IMonitorable Interface ===" << std::endl;
 
    auto monitor = std::make_shared<aggregating_monitor>();
 
    auto logger_result = logger_builder()
        .with_async(false)
        .with_monitoring(monitor)
        .build();
 
    if (!logger_result) return;
 
    auto logger_instance = std::shared_ptr<logger>(std::move(logger_result.value()));
 
    // Cast to IMonitorable to demonstrate interface usage
    if (auto monitorable = std::dynamic_pointer_cast<ci::IMonitorable>(logger_instance)) {
        std::cout << "Logger component name: "
                  << monitorable->get_component_name() << std::endl;
 
        // Perform operations
        logger_instance->log(ci::log_level::info, std::string("Test message 1"));
        logger_instance->log(ci::log_level::info, std::string("Test message 2"));
 
        // Get monitoring data directly from logger
        auto data = monitorable->get_monitoring_data();
        if (kcenon::common::is_ok(data)) {
            std::cout << "\nDirect monitoring data from logger:" << std::endl;
            print_metrics_snapshot(kcenon::common::get_value(data));
        }
 
        // Health check directly from logger
        auto health = monitorable->health_check();
        if (kcenon::common::is_ok(health)) {
            std::cout << "\nDirect health check from logger:" << std::endl;
            print_health_result(kcenon::common::get_value(health));
        }
    }
}

References kcenon::logger::logger_builder::build(), kcenon::common::get_value(), kcenon::common::is_ok(), print_health_result(), print_metrics_snapshot(), kcenon::logger::logger_builder::with_async(), and kcenon::logger::logger_builder::with_monitoring().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_4_monitoring_system_simulation()

void example_4_monitoring_system_simulation

(

)

Example 4: Simulating monitoring_system integration.

Examples

monitoring_integration_example.cpp.

Definition at line 335 of file monitoring_integration_example.cpp.

                                              {
    std::cout << "\n=== Example 4: Monitoring System Integration Simulation ===" << std::endl;
    std::cout << "Note: This demonstrates how logger_system and monitoring_system" << std::endl;
    std::cout << "      interact via interfaces without circular dependencies" << std::endl;
 
    // Simulate monitoring_system providing a monitor
    std::shared_ptr<ci::IMonitor> monitor = std::make_shared<aggregating_monitor>();
 
    // Logger receives monitor through DI
    auto logger_result = logger_builder()
        .with_async(true)  // Async mode for realistic scenario
        .with_monitoring(monitor)
        .build();
 
    if (!logger_result) return;
 
    auto logger_instance = std::shared_ptr<logger>(std::move(logger_result.value()));
 
    std::cout << "\nPhase 1: Logger operates and reports to monitor" << std::endl;
 
    // Simulate application activity
    for (int i = 0; i < 10; ++i) {
        logger_instance->log(ci::log_level::info,
            "Application event " + std::to_string(i + 1));
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
 
    // Give async logger time to flush
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
 
    std::cout << "\nPhase 2: Monitoring system queries metrics" << std::endl;
 
    // Monitoring system can query the monitor
    auto metrics = monitor->get_metrics();
    if (kcenon::common::is_ok(metrics)) {
        std::cout << "Monitoring system received metrics:" << std::endl;
        print_metrics_snapshot(kcenon::common::get_value(metrics));
    }
 
    // Monitoring system can check logger health through IMonitorable
    if (auto monitorable = std::dynamic_pointer_cast<ci::IMonitorable>(logger_instance)) {
        auto health = monitorable->health_check();
        if (kcenon::common::is_ok(health)) {
            std::cout << "\nLogger health status:" << std::endl;
            print_health_result(kcenon::common::get_value(health));
        }
    }
 
    std::cout << "\n✓ Integration successful without circular dependencies" << std::endl;
}

References kcenon::logger::logger_builder::build(), kcenon::common::get_value(), kcenon::common::is_ok(), print_health_result(), print_metrics_snapshot(), kcenon::logger::logger_builder::with_async(), and kcenon::logger::logger_builder::with_monitoring().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main

(

)

Definition at line 386 of file monitoring_integration_example.cpp.

           {
    std::cout << "============================================================" << std::endl;
    std::cout << "Logger-Monitor Integration Examples (Phase 4)" << std::endl;
    std::cout << "Demonstrating loose coupling via common_system interfaces" << std::endl;
    std::cout << "============================================================" << std::endl;
 
    try {
        example_1_basic_integration();
        example_2_multiple_loggers();
        example_3_imonitorable_interface();
        example_4_monitoring_system_simulation();
 
        std::cout << "\n============================================================" << std::endl;
        std::cout << "All integration examples completed successfully!" << std::endl;
        std::cout << "============================================================" << std::endl;
 
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
 
    return 0;
}

References example_1_basic_integration(), example_2_multiple_loggers(), example_3_imonitorable_interface(), and example_4_monitoring_system_simulation().

Here is the call graph for this function:

print_health_result()

void print_health_result

(

const ci::health_check_result &

health

)

Print health check result.

Examples

monitoring_integration_example.cpp.

Definition at line 177 of file monitoring_integration_example.cpp.

                                                              {
    std::cout << "\n--- Health Check ---" << std::endl;
    std::cout << "Status: " << ci::to_string(health.status) << std::endl;
    std::cout << "Message: " << health.message << std::endl;
 
    if (!health.metadata.empty()) {
        std::cout << "Component Status:" << std::endl;
        for (const auto& [key, value] : health.metadata) {
            if (key.rfind("component_status:", 0) == 0) {
                std::cout << "  - " << key.substr(std::string("component_status:").size())
                          << ": " << value << std::endl;
            }
        }
    }
 
    std::cout << "Check duration: "
              << health.check_duration.count() << "ms" << std::endl;
}

References kcenon::logger::size.

Referenced by example_1_basic_integration(), example_3_imonitorable_interface(), and example_4_monitoring_system_simulation().

Here is the caller graph for this function:

print_metrics_snapshot()

void print_metrics_snapshot

(

const ci::metrics_snapshot &

snapshot

)

Print metrics snapshot in formatted way.

Examples

monitoring_integration_example.cpp.

Definition at line 160 of file monitoring_integration_example.cpp.

                                                                {
    std::cout << "\n--- Metrics Snapshot ---" << std::endl;
    std::cout << "Source: " << snapshot.source_id << std::endl;
    std::cout << "Captured at: "
              << std::chrono::system_clock::to_time_t(snapshot.capture_time)
              << std::endl;
    std::cout << "Metrics:" << std::endl;
 
    for (const auto& metric : snapshot.metrics) {
        std::cout << "  " << std::setw(30) << std::left << metric.name
                  << ": " << metric.value << std::endl;
    }
}

Referenced by example_1_basic_integration(), example_2_multiple_loggers(), example_3_imonitorable_interface(), and example_4_monitoring_system_simulation().

Here is the caller graph for this function: