basic_usage.cpp File Reference

Basic logger usage examples covering core logging functionality. More...

#include <kcenon/logger/core/logger.h>
#include <kcenon/logger/writers/console_writer.h>
#include <kcenon/common/interfaces/logger_interface.h>
#include <thread>
#include <vector>
#include <iostream>
#include <chrono>

Include dependency graph for basic_usage.cpp:

Go to the source code of this file.

Typedefs
using	log_level_type = ci::log_level

Functions
void	basic_logging_example ()
void	multithreaded_logging_example ()
void	log_level_filtering_example ()
void	sync_vs_async_example ()
int	main ()

Detailed Description

Basic logger usage examples covering core logging functionality.

Definition in file basic_usage.cpp.

Typedef Documentation

log_level_type

using log_level_type = ci::log_level

Definition at line 22 of file basic_usage.cpp.

Function Documentation

basic_logging_example()

void basic_logging_example

(

)

Examples

basic_usage.cpp.

Definition at line 31 of file basic_usage.cpp.

                             {
    std::cout << "\n=== Basic Logging Example ===\n" << std::endl;
    
    // Create logger instance
    auto logger_instance = std::make_shared<logger>();
    
    // Add console writer
    logger_instance->add_writer(std::make_unique<console_writer>());
    
    // Start logger (for async mode)
    logger_instance->start();
    
    // Log messages at different levels
    logger_instance->log(log_level_type::trace, std::string("This is a trace message"));
    logger_instance->log(log_level_type::debug, std::string("Debug information here"));
    logger_instance->log(log_level_type::info, std::string("Application started successfully"));
    logger_instance->log(log_level_type::warning, std::string("This is a warning"));
    logger_instance->log(log_level_type::error, std::string("An error occurred!"));
    logger_instance->log(log_level_type::critical, std::string("Critical system failure!"));
 
    // Log with simple message (source_location auto-captured internally)
    logger_instance->log(log_level_type::info, std::string("Message with auto-captured location"));
    
    // Stop and flush
    logger_instance->stop();
}

Referenced by main().

Here is the caller graph for this function:

log_level_filtering_example()

void log_level_filtering_example

(

)

Examples

basic_usage.cpp.

Definition at line 87 of file basic_usage.cpp.

                                   {
    std::cout << "\n=== Log Level Filtering Example ===\n" << std::endl;
    
    auto logger_instance = std::make_shared<logger>();
    logger_instance->add_writer(std::make_unique<console_writer>());
    logger_instance->start();
    
    // Set minimum level to INFO
    logger_instance->set_level(log_level_type::info);
    std::cout << "Minimum level set to INFO\n" << std::endl;
 
    // These won't be logged
    logger_instance->log(log_level_type::trace, std::string("This trace won't show"));
    logger_instance->log(log_level_type::debug, std::string("This debug won't show"));
 
    // These will be logged
    logger_instance->log(log_level_type::info, std::string("This info will show"));
    logger_instance->log(log_level_type::warning, std::string("This warning will show"));
    
    logger_instance->stop();
}

Referenced by main().

Here is the caller graph for this function:

main()

int main

(

)

Definition at line 145 of file basic_usage.cpp.

           {
    try {
        basic_logging_example();
        multithreaded_logging_example();
        log_level_filtering_example();
        sync_vs_async_example();
        
        std::cout << "\n=== All examples completed successfully! ===" << std::endl;
        
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
    
    return 0;
}

References basic_logging_example(), log_level_filtering_example(), multithreaded_logging_example(), and sync_vs_async_example().

Here is the call graph for this function:

multithreaded_logging_example()

void multithreaded_logging_example

(

)

Examples

basic_usage.cpp.

Definition at line 58 of file basic_usage.cpp.

                                     {
    std::cout << "\n=== Multithreaded Logging Example ===\n" << std::endl;
    
    // Create async logger
    auto logger_instance = std::make_shared<logger>(true, 16384); // Larger buffer for MT
    logger_instance->add_writer(std::make_unique<console_writer>());
    logger_instance->start();
    
    // Launch multiple threads
    std::vector<std::thread> threads;
    
    for (int i = 0; i < 4; ++i) {
        threads.emplace_back([logger_instance, i]() {
            for (int j = 0; j < 10; ++j) {
                logger_instance->log(log_level_type::info,
                           "Thread " + std::to_string(i) + " - Message " + std::to_string(j));
                std::this_thread::sleep_for(std::chrono::milliseconds(10));
            }
        });
    }
    
    // Wait for all threads
    for (auto& t : threads) {
        t.join();
    }
    
    logger_instance->stop();
}

Referenced by main().

Here is the caller graph for this function:

sync_vs_async_example()

void sync_vs_async_example

(

)

Examples

basic_usage.cpp.

Definition at line 109 of file basic_usage.cpp.

                             {
    std::cout << "\n=== Sync vs Async Logging Example ===\n" << std::endl;
    
    // Synchronous logger
    std::cout << "Synchronous logging:" << std::endl;
    auto sync_logger = std::make_shared<logger>(false); // sync mode
    sync_logger->add_writer(std::make_unique<console_writer>());
    
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 100; ++i) {
        sync_logger->log(log_level_type::info, "Sync log " + std::to_string(i));
    }
    auto sync_time = std::chrono::high_resolution_clock::now() - start;
    
    // Asynchronous logger
    std::cout << "\nAsynchronous logging:" << std::endl;
    auto async_logger = std::make_shared<logger>(true); // async mode
    async_logger->add_writer(std::make_unique<console_writer>());
    async_logger->start();
    
    start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 100; ++i) {
        async_logger->log(log_level_type::info, "Async log " + std::to_string(i));
    }
    auto async_time = std::chrono::high_resolution_clock::now() - start;
    
    async_logger->stop();
    
    std::cout << "\nSync time: " 
              << std::chrono::duration_cast<std::chrono::microseconds>(sync_time).count() 
              << " µs" << std::endl;
    std::cout << "Async time: " 
              << std::chrono::duration_cast<std::chrono::microseconds>(async_time).count() 
              << " µs" << std::endl;
}

Referenced by main().

Here is the caller graph for this function: