log/logger.h

Go to the documentation of this file.

// Copyright (C) 2011-2025 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 LOGGER_H
#define LOGGER_H
 
#include <atomic>
#include <cstdlib>
#include <cstring>
#include <mutex>
#include <string>
 
#include <exceptions/exceptions.h>
#include <log/logger_level.h>
#include <log/message_types.h>
#include <log/log_formatter.h>
#include <log/output_option.h>
 
namespace isc {
namespace log {
 
namespace interprocess {
// Forward declaration to hide implementation details from normal
// applications.
class InterprocessSync;
}

 
class LoggerImpl;   // Forward declaration of the implementation class

class BadInterprocessSync : public isc::Exception {
public:
    BadInterprocessSync(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what)
    {}
};

class LoggerNameError : public isc::Exception {
public:
    LoggerNameError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what)
    {}
};

class LoggerNameNull : public isc::Exception {
public:
    LoggerNameNull(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what)
    {}
};

class LoggingNotInitialized : public isc::Exception {
public:
    LoggingNotInitialized(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what)
    {}
};

 
class Logger {
public:
    static const size_t MAX_LOGGER_NAME_SIZE = 31;

    Logger(const char* name) : loggerptr_(0), initialized_(false) {
 
        // Validate the name of the logger.
        if (name) {
            // Name not null, is it too short or too long?
            size_t namelen = std::strlen(name);
            if ((namelen == 0) || (namelen > MAX_LOGGER_NAME_SIZE)) {
                isc_throw(LoggerNameError, "'" << name << "' is not a valid "
                          << "name for a logger: valid names must be between 1 "
                          << "and " << MAX_LOGGER_NAME_SIZE << " characters in "
                          << "length");
            }
        } else {
            isc_throw(LoggerNameNull, "logger names may not be null");
        }
 
        // Do the copy, ensuring a trailing null in all cases.
        std::strncpy(name_, name, MAX_LOGGER_NAME_SIZE);
        name_[MAX_LOGGER_NAME_SIZE] = '\0';
    }

    virtual ~Logger();

    static std::string getVersion();

    typedef isc::log::Formatter<Logger> Formatter;

    virtual std::string getName();

    virtual void setSeverity(isc::log::Severity severity, int dbglevel = 1);

    virtual isc::log::Severity getSeverity();

    virtual isc::log::Severity getEffectiveSeverity();

    virtual int getDebugLevel();

    virtual int getEffectiveDebugLevel();

    virtual bool isDebugEnabled(int dbglevel = MIN_DEBUG_LEVEL);

    virtual bool isInfoEnabled();

    virtual bool isWarnEnabled();

    virtual bool isErrorEnabled();

    virtual bool isFatalEnabled();

    Formatter debug(int dbglevel, const MessageID& ident);

    Formatter info(const MessageID& ident);

    Formatter warn(const MessageID& ident);

    Formatter error(const MessageID& ident);

    Formatter fatal(const MessageID& ident);

    void setInterprocessSync(isc::log::interprocess::InterprocessSync* sync);

    bool hasAppender(OutputOption::Destination const destination);

    bool operator==(Logger& other);
 
private:
    friend class isc::log::Formatter<Logger>;

    void output(const Severity& severity, const std::string& message);

    Logger(const Logger&);

    Logger& operator=(const Logger&);

    LoggerImpl* getLoggerPtr();

    void initLoggerImpl();

    LoggerImpl* loggerptr_;

    char name_[MAX_LOGGER_NAME_SIZE + 1];

    std::mutex mutex_;

    std::atomic<bool> initialized_;
};
 
} // namespace log
} // namespace isc
 
 
#endif // LOGGER_H