log/logger.h

Go to the documentation of this file.

// Copyright (C) 2011-2015 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 <cassert>
#include <cstdlib>
#include <string>
#include <cstring>

#include <boost/static_assert.hpp>

#include <exceptions/exceptions.h>
#include <log/logger_level.h>
#include <log/message_types.h>
#include <log/log_formatter.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_(NULL) {

        // Validate the name of the logger.
        if (name == NULL) {
            isc_throw(LoggerNameNull, "logger names may not be null");

        } else {
            // 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");
            }
        }

        // The checks above and the assertion below ensure that the contents of
        // "name" plus a trailing null will fit into the space allocated for
        // "name_".
        BOOST_STATIC_ASSERT(MAX_LOGGER_NAME_SIZE < sizeof(name_));

        // 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 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() {
        if (!loggerptr_) {
            initLoggerImpl();
        }
        return (loggerptr_);
    }

    void initLoggerImpl();

    LoggerImpl* loggerptr_;                  
    char        name_[MAX_LOGGER_NAME_SIZE + 1]; 
};

} // namespace log
} // namespace isc


#endif // LOGGER_H