Unified logging adapter for database operations. More...

#include <logger_adapter.h>

Collaboration diagram for database::integrated::adapters::logger_adapter:

Public Member Functions
	logger_adapter (const db_logger_config &config, logger_backend_type backend_type=logger_backend_type::auto_select)
	Construct logger adapter with configuration.

	~logger_adapter ()
	Destructor - ensures proper shutdown.

	logger_adapter (const logger_adapter &)=delete

logger_adapter &	operator= (const logger_adapter &)=delete

	logger_adapter (logger_adapter &&) noexcept

logger_adapter &	operator= (logger_adapter &&)=delete

common::VoidResult	initialize ()
	Initialize the logger.

common::VoidResult	shutdown ()
	Shutdown the logger gracefully.

bool	is_initialized () const
	Check if logger is initialized.

void	log_query (db_log_level level, const std::string &query, std::chrono::microseconds duration)
	Log a SQL query execution.

void	log_slow_query (const std::string &query, std::chrono::microseconds duration, std::chrono::milliseconds threshold)
	Log a slow query with warning.

void	log_connection_event (const std::string &event, const std::string &details)
	Log a connection pool event.

void	log_transaction (const std::string &operation, bool success, const std::string &details)
	Log a transaction operation.

void	log_pool_event (const std::string &event, std::size_t active, std::size_t idle)
	Log a connection pool state change.

void	log_error (const std::string &operation, const std::string &error_msg, const std::string &sql_state="")
	Log a database error.

void	log (db_log_level level, const std::string &message)
	Generic log message.

void	flush ()
	Flush pending log messages.

Static Private Member Functions
static std::unique_ptr< backends::logger_backend >	create_backend (const db_logger_config &config, logger_backend_type backend_type)
	Create appropriate backend based on type.

Private Attributes
const db_logger_config &	config_

std::unique_ptr< backends::logger_backend >	backend_
	Logger backend implementation.

Detailed Description

Unified logging adapter for database operations.

Provides a consistent logging interface with runtime backend selection. No longer uses conditional compilation - backend is selected at runtime.

Thread Safety: All public methods are thread-safe.

Examples: /home/runner/work/database_system/database_system/database/integrated/core/database_coordinator.h.

Definition at line 108 of file logger_adapter.h.

Constructor & Destructor Documentation

◆ logger_adapter() [1/3]

database::integrated::adapters::logger_adapter::logger_adapter	(	const db_logger_config &	config,
		logger_backend_type	backend_type = logger_backend_type::auto_select )

explicit

Construct logger adapter with configuration.

Parameters

config	Logger configuration settings
backend_type	Backend type to use (default: auto_select)

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 129 of file logger_adapter.cpp.

    : config_(config)
    , backend_(create_backend(config, backend_type))
{
    // Backend is created and potentially initialized (if auto_select)
    // If auto_select didn't initialize, caller must call initialize()
    if (backend_type != logger_backend_type::auto_select)
    {
        // For explicit backend selection, don't auto-initialize
        // Caller must call initialize() explicitly
    }
}

References database::integrated::adapters::auto_select.

◆ ~logger_adapter()

database::integrated::adapters::logger_adapter::~logger_adapter ( )

Destructor - ensures proper shutdown.

Automatically calls shutdown() if still initialized.

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 144 of file logger_adapter.cpp.

{
    if (backend_ && backend_->is_initialized())
    {
        backend_->shutdown();
    }
}

References backend_.

◆ logger_adapter() [2/3]

database::integrated::adapters::logger_adapter::logger_adapter ( const logger_adapter & )

delete

◆ logger_adapter() [3/3]

database::integrated::adapters::logger_adapter::logger_adapter ( logger_adapter && )

defaultnoexcept

Member Function Documentation

◆ create_backend()

std::unique_ptr< backends::logger_backend > database::integrated::adapters::logger_adapter::create_backend	(	const db_logger_config &	config,
		logger_backend_type	backend_type )

staticprivate

Create appropriate backend based on type.

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 75 of file logger_adapter.cpp.

{
    switch (backend_type)
    {
        case logger_backend_type::auto_select:
        {
#ifdef HAVE_COMMON_LOGGER_BACKEND
            // Try common_system backend first
            try
            {
                auto backend = std::make_unique<backends::common_logger_backend>(config);
                auto init_result = backend->initialize();
                if (init_result.is_ok())
                {
                    return backend;
                }
                // If initialization failed, fall back to fallback backend
            }
            catch (...)
            {
                // If common backend construction/init failed, fall back
            }
#endif
            // Fall back to fallback_logger_backend
            return std::make_unique<backends::fallback_logger_backend>(config);
        }
 
        case logger_backend_type::system:
        {
#ifdef HAVE_COMMON_LOGGER_BACKEND
            return std::make_unique<backends::common_logger_backend>(config);
#else
            throw std::runtime_error(
                "common_logger_backend not available (common_system not found)");
#endif
        }
 
        case logger_backend_type::fallback:
            return std::make_unique<backends::fallback_logger_backend>(config);
 
        case logger_backend_type::null:
            return std::make_unique<backends::null_logger_backend>(config);
 
        default:
            return std::make_unique<backends::fallback_logger_backend>(config);
    }
}

References database::integrated::adapters::auto_select, database::integrated::adapters::fallback, database::integrated::adapters::null, and database::integrated::adapters::system.

◆ flush()

void database::integrated::adapters::logger_adapter::flush ( )

Flush pending log messages.

Forces all buffered log messages to be written immediately. Useful before application exit or critical sections.

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 298 of file logger_adapter.cpp.

{
    if (backend_)
    {
        backend_->flush();
    }
}

References backend_.

Referenced by test_basic_logging(), test_connection_logging(), test_error_logging(), test_log_level_filtering(), test_query_logging(), test_slow_query_detection(), test_thread_safety(), and test_transaction_logging().

Here is the caller graph for this function:

◆ initialize()

common::VoidResult database::integrated::adapters::logger_adapter::initialize ( )

Initialize the logger.

Sets up output writers (console, file) and starts the logger. Must be called before any logging operations.

Returns: VoidResult::ok() on success, error on failure

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 154 of file logger_adapter.cpp.

{
    if (!backend_)
    {
        return common::VoidResult(
            common::error_info{ -1, "Backend not created", "" });
    }
 
    return backend_->initialize();
}

References initialize().

Referenced by initialize(), test_basic_logging(), test_connection_logging(), test_error_logging(), test_initialization(), test_log_level_filtering(), test_query_logging(), test_slow_query_detection(), test_thread_safety(), and test_transaction_logging().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_initialized()

bool database::integrated::adapters::logger_adapter::is_initialized ( ) const

Check if logger is initialized.

Returns: true if initialized and ready to log

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 175 of file logger_adapter.cpp.

{
    return backend_ && backend_->is_initialized();
}

References backend_.

Referenced by test_initialization().

Here is the caller graph for this function:

◆ log()

void database::integrated::adapters::logger_adapter::log	(	db_log_level	level,
		const std::string &	message )

Generic log message.

Parameters

level	Log level
message	Message to log

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 290 of file logger_adapter.cpp.

{
    if (backend_)
    {
        backend_->log(level, message);
    }
}

References backend_.

Referenced by test_basic_logging(), test_log_level_filtering(), and test_thread_safety().

Here is the caller graph for this function:

◆ log_connection_event()

void database::integrated::adapters::logger_adapter::log_connection_event	(	const std::string &	event,
		const std::string &	details )

Log a connection pool event.

Examples: "acquired", "released", "timeout", "health_check"

Parameters

event	Event type (e.g., "acquired", "released")
details	Additional details (e.g., "Pool: main_pool, Priority: high")

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 227 of file logger_adapter.cpp.

{
    if (!backend_)
    {
        return;
    }
 
    std::stringstream ss;
    ss << "Connection event [" << event << "]: " << details;
 
    backend_->log(db_log_level::debug, ss.str());
}

References backend_, and database::integrated::debug.

Referenced by test_connection_logging().

Here is the caller graph for this function:

◆ log_error()

void database::integrated::adapters::logger_adapter::log_error	(	const std::string &	operation,
		const std::string &	error_msg,
		const std::string &	sql_state = "" )

Log a database error.

Parameters

operation	Operation that failed (e.g., "execute_query", "connect")
error_msg	Error message
sql_state	SQL state code (e.g., "08006" for connection failure)

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 272 of file logger_adapter.cpp.

{
    if (!backend_)
    {
        return;
    }
 
    std::stringstream ss;
    ss << "ERROR in " << operation << ": " << error_msg;
    if (!sql_state.empty())
    {
        ss << " (SQL state: " << sql_state << ")";
    }
 
    backend_->log(db_log_level::error, ss.str());
}

References backend_, and database::integrated::error.

Referenced by test_error_logging().

Here is the caller graph for this function:

◆ log_pool_event()

void database::integrated::adapters::logger_adapter::log_pool_event	(	const std::string &	event,
		std::size_t	active,
		std::size_t	idle )

Log a connection pool state change.

Examples: Pool resize, capacity changes

Parameters

event	Event type (e.g., "resized", "shrunk", "health_check_failed")
active	Number of active connections
idle	Number of idle connections

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 258 of file logger_adapter.cpp.

{
    if (!backend_)
    {
        return;
    }
 
    std::stringstream ss;
    ss << "Pool event [" << event << "]: active=" << active << ", idle=" << idle
       << ", total=" << (active + idle);
 
    backend_->log(db_log_level::info, ss.str());
}

References backend_, and database::integrated::info.

Referenced by test_connection_logging().

Here is the caller graph for this function:

◆ log_query()

void database::integrated::adapters::logger_adapter::log_query	(	db_log_level	level,
		const std::string &	query,
		std::chrono::microseconds	duration )

Log a SQL query execution.

Automatically sanitizes the query (removes passwords, truncates if long). If duration exceeds slow_query_threshold, automatically logs as slow query.

Parameters

level	Log level (typically info or debug)
query	SQL query string (will be sanitized)
duration	Query execution time

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 184 of file logger_adapter.cpp.

{
    if (!backend_)
    {
        return;
    }
 
    // Sanitize query
    std::string safe_query = sanitize_query(query);
 
    // Format message
    std::stringstream ss;
    ss << "Query executed in " << duration.count() << "μs: " << safe_query;
 
    backend_->log(level, ss.str());
 
    // Check for slow query
    auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
    if (config_.log_slow_queries && duration_ms > config_.slow_query_threshold)
    {
        log_slow_query(query, duration, config_.slow_query_threshold);
    }
}

References backend_, config_, database::integrated::db_logger_config::log_slow_queries, log_slow_query(), and database::integrated::db_logger_config::slow_query_threshold.

Referenced by test_query_logging(), and test_slow_query_detection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ log_slow_query()

void database::integrated::adapters::logger_adapter::log_slow_query	(	const std::string &	query,
		std::chrono::microseconds	duration,
		std::chrono::milliseconds	threshold )

Log a slow query with warning.

Called automatically by log_query() when threshold exceeded, but can also be called manually.

Parameters

query	SQL query string
duration	Actual execution time
threshold	Configured slow query threshold

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 209 of file logger_adapter.cpp.

{
    if (!backend_)
    {
        return;
    }
 
    std::string safe_query = sanitize_query(query);
 
    std::stringstream ss;
    ss << "SLOW QUERY detected (threshold: " << threshold.count() << "ms, actual: "
       << std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()
       << "ms): " << safe_query;
 
    backend_->log(db_log_level::warning, ss.str());
}

References backend_, and database::integrated::warning.

Referenced by log_query(), and test_slow_query_detection().

Here is the caller graph for this function:

◆ log_transaction()

void database::integrated::adapters::logger_adapter::log_transaction	(	const std::string &	operation,
		bool	success,
		const std::string &	details )

Log a transaction operation.

Parameters

operation	Transaction operation (e.g., "begin", "commit", "rollback")
success	Whether operation succeeded
details	Additional details (e.g., isolation level, error message)

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 240 of file logger_adapter.cpp.

{
    if (!backend_)
    {
        return;
    }
 
    std::stringstream ss;
    ss << "Transaction " << operation << " " << (success ? "SUCCESS" : "FAILED");
    if (!details.empty())
    {
        ss << ": " << details;
    }
 
    backend_->log(success ? db_log_level::info : db_log_level::error, ss.str());
}

References backend_, database::integrated::error, database::integrated::info, and database::success.

Referenced by test_transaction_logging().

Here is the caller graph for this function:

◆ operator=() [1/2]

logger_adapter & database::integrated::adapters::logger_adapter::operator= ( const logger_adapter & )

delete

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

◆ operator=() [2/2]

logger_adapter & database::integrated::adapters::logger_adapter::operator= ( logger_adapter && )

delete

◆ shutdown()

common::VoidResult database::integrated::adapters::logger_adapter::shutdown ( )

Shutdown the logger gracefully.

Flushes all pending logs and closes files. Safe to call multiple times.

Returns: VoidResult::ok() on success, error on failure

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 165 of file logger_adapter.cpp.

{
    if (!backend_)
    {
        return common::ok();
    }
 
    return backend_->shutdown();
}

References backend_, and common::ok().

Referenced by test_basic_logging(), test_connection_logging(), test_error_logging(), test_initialization(), test_log_level_filtering(), test_query_logging(), test_slow_query_detection(), test_thread_safety(), and test_transaction_logging().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ backend_

std::unique_ptr<backends::logger_backend> database::integrated::adapters::logger_adapter::backend_

private

Logger backend implementation.

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 259 of file logger_adapter.h.

Referenced by flush(), is_initialized(), log(), log_connection_event(), log_error(), log_pool_event(), log_query(), log_slow_query(), log_transaction(), shutdown(), and ~logger_adapter().

◆ config_

const db_logger_config& database::integrated::adapters::logger_adapter::config_

private

Examples: /home/runner/work/database_system/database_system/database/integrated/adapters/logger_adapter.h.

Definition at line 258 of file logger_adapter.h.

Referenced by log_query().

The documentation for this class was generated from the following files:

database/integrated/adapters/logger_adapter.h
database/integrated/adapters/logger_adapter.cpp

Public Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ logger_adapter() [1/3]

◆ ~logger_adapter()

◆ logger_adapter() [2/3]

◆ logger_adapter() [3/3]

Member Function Documentation

◆ create_backend()

◆ flush()

◆ initialize()

◆ is_initialized()

◆ log()

◆ log_connection_event()

◆ log_error()

◆ log_pool_event()

◆ log_query()

◆ log_slow_query()

◆ log_transaction()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ shutdown()

Member Data Documentation

◆ backend_

◆ config_