db_log.h

Go to the documentation of this file.

// Copyright (C) 2018-2026 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef DB_LOG_H
#define DB_LOG_H
 
#include <log/macros.h>
 
#include <map>
#include <mutex>
#include <list>

 
namespace isc {
namespace db {


extern const int DB_DBG_TRACE_DETAIL;


extern isc::log::Logger database_logger;

enum DbMessageID {
    DB_INVALID_ACCESS,
 
    PGSQL_INITIAL_CONNECTION_FAIL,
    PGSQL_INITIALIZE_SCHEMA,
    PGSQL_NO_INIT_NO_ADMIN,
    PGSQL_NO_INIT_NO_PASSWORD,
    PGSQL_NO_INIT_READONLY,
    PGSQL_DEALLOC_ERROR,
    PGSQL_FATAL_ERROR,
    PGSQL_START_TRANSACTION,
    PGSQL_COMMIT,
    PGSQL_ROLLBACK,
    PGSQL_CREATE_SAVEPOINT,
    PGSQL_ROLLBACK_SAVEPOINT,
    PGSQL_TCP_USER_TIMEOUT_UNSUPPORTED,
 
    MYSQL_INITIAL_CONNECTION_FAIL,
    MYSQL_INITIALIZE_SCHEMA,
    MYSQL_NO_INIT_NO_ADMIN,
    MYSQL_NO_INIT_NO_PASSWORD,
    MYSQL_NO_INIT_READONLY,
    MYSQL_FATAL_ERROR,
    MYSQL_START_TRANSACTION,
    MYSQL_COMMIT,
    MYSQL_ROLLBACK,
};


class DbLogger {
public:
    typedef std::map<DbMessageID, isc::log::MessageID> MessageMap;

    DbLogger(isc::log::Logger& logger, const MessageMap& map)
        : logger_(logger), map_(map) {
    }

    const isc::log::MessageID& translateMessage(const DbMessageID& id) const;

    isc::log::Logger& logger_;

    const MessageMap& map_;
};

typedef std::list<DbLogger> DbLoggerStack;

extern DbLoggerStack db_logger_stack;

extern std::mutex db_logger_mutex;

void checkDbLoggerStack();

enum log_type_t {
    fatal,
    error,
    warn,
    info,
    debug,
};

template <log_type_t log_type>
struct DB_LOG {
    DB_LOG(DbMessageID const message_id, int const debug_level = 0) {
        std::lock_guard<std::mutex> lock(isc::db::db_logger_mutex);
        isc::db::checkDbLoggerStack();
        if (isEnabled()) {
            formatter_ = formatter(message_id, debug_level);
        }
    }

    template <typename T, typename... Args>
    DB_LOG& arg(T first, Args... args) {
        formatter_.arg(first);
        return arg(args...);
    }

    DB_LOG& arg() {
        return *this;
    }
 
private:
    isc::log::Logger::Formatter
    formatter(DbMessageID const message_id, int const debug_level = 0);

    bool isEnabled(int const debug_level = 0) const;

    isc::log::Logger::Formatter formatter_;
};

struct DB_LOG_FATAL : DB_LOG<fatal> {
    DB_LOG_FATAL(DbMessageID const message_id) : DB_LOG(message_id) {
    }
};
 
struct DB_LOG_ERROR : DB_LOG<error> {
    DB_LOG_ERROR(DbMessageID const message_id) : DB_LOG(message_id) {
    }
};
 
struct DB_LOG_WARN : DB_LOG<warn> {
    DB_LOG_WARN(DbMessageID const message_id) : DB_LOG(message_id) {
    }
};
 
struct DB_LOG_INFO : DB_LOG<info> {
    DB_LOG_INFO(DbMessageID const message_id) : DB_LOG(message_id) {
    }
};
 
struct DB_LOG_DEBUG : DB_LOG<debug> {
    DB_LOG_DEBUG(int const debug_level, DbMessageID const message_id)
        : DB_LOG(message_id, debug_level) {
    }
};


extern const db::DbLogger::MessageMap db_message_map;

extern db::DbLogger db_logger_translator;
 
} // namespace db
} // namespace isc
 
#endif // DB_LOG_H