monitor_factory_pattern_example.cpp File Reference

Monitor factory and provider pattern examples for Phase 4. More...

#include <kcenon/monitoring/core/performance_monitor.h>
#include <kcenon/monitoring/core/result_types.h>
#include <kcenon/common/interfaces/logger_interface.h>
#include <kcenon/common/interfaces/monitoring_interface.h>
#include <iostream>
#include <memory>
#include <unordered_map>
#include <mutex>
#include <vector>

Include dependency graph for monitor_factory_pattern_example.cpp:

Go to the source code of this file.

Classes
class	monitor_factory
	Monitor factory implementing singleton pattern with DI. More...
class	example_logger
	Simple logger for examples. More...
class	aggregating_monitor
	Example 6: Aggregating monitor pattern. More...

Functions
void	example_1_basic_factory ()
	Example 1: Basic factory pattern.
void	example_2_named_monitors ()
	Example 2: Named monitors via factory.
void	example_3_factory_with_logger ()
	Example 3: Factory with shared logger.
void	example_4_monitor_reuse ()
	Example 4: Monitor reuse via factory.
void	example_5_provider_interface ()
	Example 5: Provider interface usage.
void	example_6_aggregating_pattern ()
void	example_7_factory_lifecycle ()
	Example 7: Factory cleanup and reset.
int	main ()

Detailed Description

Monitor factory and provider pattern examples for Phase 4.

Definition in file monitor_factory_pattern_example.cpp.

Function Documentation

example_1_basic_factory()

void example_1_basic_factory

(

)

Example 1: Basic factory pattern.

Examples

monitor_factory_pattern_example.cpp.

Definition at line 163 of file monitor_factory_pattern_example.cpp.

                               {
    std::cout << "\n=== Example 1: Basic Factory Pattern ===" << std::endl;
 
    auto factory = monitor_factory::instance();
 
    std::cout << "Getting default monitor from factory..." << std::endl;
    auto monitor = factory->get_monitor();
 
    if (monitor) {
        std::cout << "✓ Obtained monitor instance" << std::endl;
 
        monitor->record_metric("test_metric", 42.0);
 
        auto metrics = monitor->get_metrics();
        if (metrics) {
            std::cout << "✓ Monitor has " << metrics.value().metrics.size()
                      << " metrics" << std::endl;
        }
    }
}

References monitor_factory::instance().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_2_named_monitors()

void example_2_named_monitors

(

)

Example 2: Named monitors via factory.

Examples

monitor_factory_pattern_example.cpp.

Definition at line 187 of file monitor_factory_pattern_example.cpp.

                                {
    std::cout << "\n=== Example 2: Named Monitors ===" << std::endl;
 
    auto factory = monitor_factory::instance();
 
    // Create named monitors
    auto web_monitor = factory->create_monitor("web_server");
    auto db_monitor = factory->create_monitor("database");
    auto cache_monitor = factory->create_monitor("cache");
 
    std::cout << "Created 3 named monitors" << std::endl;
 
    // Use monitors
    web_monitor->record_metric("requests", 1000.0);
    db_monitor->record_metric("queries", 500.0);
    cache_monitor->record_metric("hits", 750.0);
 
    // List all monitors
    auto names = factory->list_monitors();
    std::cout << "\nRegistered monitors (" << names.size() << "):" << std::endl;
    for (const auto& name : names) {
        std::cout << "  - " << name << std::endl;
    }
}

References monitor_factory::instance().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_3_factory_with_logger()

void example_3_factory_with_logger

(

)

Example 3: Factory with shared logger.

Examples

monitor_factory_pattern_example.cpp.

Definition at line 215 of file monitor_factory_pattern_example.cpp.

                                     {
    std::cout << "\n=== Example 3: Factory with Shared Logger ===" << std::endl;
 
    auto factory = monitor_factory::instance();
    auto logger = std::make_shared<example_logger>("FACTORY");
 
    // Set shared logger for all monitors
    factory->set_shared_logger(logger);
 
    std::cout << "Shared logger configured for factory" << std::endl;
 
    // All new monitors will automatically use the shared logger
    auto monitor1 = factory->create_monitor("service_a");
    auto monitor2 = factory->create_monitor("service_b");
 
    std::cout << "\nRecording metrics with shared logger..." << std::endl;
    monitor1->record_metric("metric_a", 10.0);
    monitor2->record_metric("metric_b", 20.0);
 
    std::cout << "\nShared logger received " << logger->count()
              << " messages from all monitors" << std::endl;
}

References monitor_factory::instance().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_4_monitor_reuse()

void example_4_monitor_reuse

(

)

Example 4: Monitor reuse via factory.

Examples

monitor_factory_pattern_example.cpp.

Definition at line 241 of file monitor_factory_pattern_example.cpp.

                               {
    std::cout << "\n=== Example 4: Monitor Reuse ===" << std::endl;
 
    auto factory = monitor_factory::instance();
 
    // Create monitor with specific name
    auto monitor1 = factory->create_monitor("shared_monitor");
    monitor1->record_metric("counter", 1.0);
 
    // Get same monitor by name (reuse)
    auto monitor2 = factory->create_monitor("shared_monitor");
 
    // They are the same instance
    std::cout << "Monitor instances "
              << (monitor1 == monitor2 ? "identical ✓" : "different ✗")
              << std::endl;
 
    monitor2->record_metric("counter", 2.0);
 
    // Check metrics
    auto metrics = monitor1->get_metrics();
    if (metrics) {
        std::cout << "Shared monitor has " << metrics.value().metrics.size()
                  << " metrics (accumulated from both uses)" << std::endl;
    }
}

References monitor_factory::instance().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_5_provider_interface()

void example_5_provider_interface

(

)

Example 5: Provider interface usage.

Examples

monitor_factory_pattern_example.cpp.

Definition at line 271 of file monitor_factory_pattern_example.cpp.

                                    {
    std::cout << "\n=== Example 5: IMonitorProvider Interface ===" << std::endl;
 
    // Use factory through IMonitorProvider interface
    std::shared_ptr<IMonitorProvider> provider = monitor_factory::instance();
 
    std::cout << "Using factory via IMonitorProvider interface" << std::endl;
 
    auto monitor = provider->get_monitor();
    if (monitor) {
        std::cout << "✓ Retrieved monitor through provider interface" << std::endl;
 
        monitor->record_metric("provider_test", 99.0);
 
        auto health = monitor->check_health();
        if (health) {
            std::cout << "✓ Monitor health: "
                      << to_string(health.value().status) << std::endl;
        }
    }
 
    auto named = provider->create_monitor("provider_created");
    if (named) {
        std::cout << "✓ Created named monitor through provider" << std::endl;
    }
}

References monitor_factory::instance(), and kcenon::monitoring::to_string().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_6_aggregating_pattern()

void example_6_aggregating_pattern

(

)

Examples

monitor_factory_pattern_example.cpp.

Definition at line 374 of file monitor_factory_pattern_example.cpp.

                                     {
    std::cout << "\n=== Example 6: Aggregating Monitor Pattern ===" << std::endl;
 
    auto factory = monitor_factory::instance();
    auto aggregator = std::make_shared<aggregating_monitor>();
 
    // Create multiple monitors and add to aggregator
    auto mon1 = factory->create_monitor("service_1");
    auto mon2 = factory->create_monitor("service_2");
    auto mon3 = factory->create_monitor("service_3");
 
    aggregator->add_monitor(mon1);
    aggregator->add_monitor(mon2);
    aggregator->add_monitor(mon3);
 
    std::cout << "Aggregator managing " << aggregator->monitor_count()
              << " monitors" << std::endl;
 
    // Record to aggregator - broadcasts to all
    aggregator->record_metric("broadcast_metric", 100.0);
 
    std::cout << "\nMetric broadcasted to all monitors" << std::endl;
 
    // Get combined metrics
    auto metrics = aggregator->get_metrics();
    if (metrics) {
        std::cout << "Combined metrics count: "
                  << metrics.value().metrics.size() << std::endl;
    }
}

References monitor_factory::instance().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

example_7_factory_lifecycle()

void example_7_factory_lifecycle

(

)

Example 7: Factory cleanup and reset.

Examples

monitor_factory_pattern_example.cpp.

Definition at line 408 of file monitor_factory_pattern_example.cpp.

                                   {
    std::cout << "\n=== Example 7: Factory Lifecycle Management ===" << std::endl;
 
    auto factory = monitor_factory::instance();
 
    std::cout << "Initial monitor count: " << factory->monitor_count() << std::endl;
 
    // Create some monitors
    factory->create_monitor("temp_1");
    factory->create_monitor("temp_2");
 
    std::cout << "After creation: " << factory->monitor_count() << std::endl;
 
    // Reset factory
    factory->reset();
 
    std::cout << "After reset: " << factory->monitor_count() << std::endl;
    std::cout << "✓ Factory lifecycle managed successfully" << std::endl;
}

References monitor_factory::instance().

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 428 of file monitor_factory_pattern_example.cpp.

           {
    std::cout << "========================================================" << std::endl;
    std::cout << "Monitor Factory Pattern Examples (Phase 4)" << std::endl;
    std::cout << "Advanced DI Patterns for Monitoring System" << std::endl;
    std::cout << "========================================================" << std::endl;
 
    try {
        example_1_basic_factory();
        example_2_named_monitors();
        example_3_factory_with_logger();
        example_4_monitor_reuse();
        example_5_provider_interface();
        example_6_aggregating_pattern();
        example_7_factory_lifecycle();
 
        std::cout << "\n========================================================" << std::endl;
        std::cout << "All factory pattern examples completed!" << std::endl;
        std::cout << "Key Patterns Demonstrated:" << std::endl;
        std::cout << "  ✓ Singleton factory pattern" << std::endl;
        std::cout << "  ✓ Named monitor management" << std::endl;
        std::cout << "  ✓ Shared logger injection" << std::endl;
        std::cout << "  ✓ Monitor reuse and lifecycle" << std::endl;
        std::cout << "  ✓ IMonitorProvider interface" << std::endl;
        std::cout << "  ✓ Aggregating monitor pattern" << 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_factory(), example_2_named_monitors(), example_3_factory_with_logger(), example_4_monitor_reuse(), example_5_provider_interface(), example_6_aggregating_pattern(), and example_7_factory_lifecycle().

Here is the call graph for this function: