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