log/logger.h

Go to the documentation of this file.

// Copyright (C) 2011-2022 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;
}
namespace interprocess {…}
 
 
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)
    {}
    BadInterprocessSync(const char* file, size_t line, const char* what) : {…}
};
class BadInterprocessSync : public isc::Exception {…};
 
class LoggerNameError : public isc::Exception {
public:
    LoggerNameError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what)
    {}
    LoggerNameError(const char* file, size_t line, const char* what) : {…}
};
class LoggerNameError : public isc::Exception {…};
 
class LoggerNameNull : public isc::Exception {
public:
    LoggerNameNull(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what)
    {}
    LoggerNameNull(const char* file, size_t line, const char* what) : {…}
};
class LoggerNameNull : public isc::Exception {…};
 
class LoggingNotInitialized : public isc::Exception {
public:
    LoggingNotInitialized(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what)
    {}
    LoggingNotInitialized(const char* file, size_t line, const char* what) : {…}
};
class LoggingNotInitialized : public isc::Exception {…};
 
 
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';
    }
    Logger(const char* name) : loggerptr_(0), initialized_(false) {…}
 
    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_;
};
class Logger {…};
 
} // namespace log
} // namespace isc
 
 
#endif // LOGGER_H