log_formatter.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 LOG_FORMATTER_H
#define LOG_FORMATTER_H

#include <cstddef>
#include <string>
#include <iostream>

#include <exceptions/exceptions.h>
#include <boost/lexical_cast.hpp>
#include <log/logger_level.h>

namespace isc {
namespace log {


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



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


void
checkExcessPlaceholders(std::string* message, unsigned int placeholder);

void
replacePlaceholder(std::string* message, const std::string& replacement,
                   const unsigned placeholder);

template<class Logger> class Formatter {
private:
    mutable Logger* logger_;

    Severity severity_;

    std::string* message_;

    unsigned nextPlaceholder_;


public:
    Formatter(const Severity& severity = NONE, std::string* message = NULL,
              Logger* logger = NULL) :
        logger_(logger), severity_(severity), message_(message),
        nextPlaceholder_(0)
    {
    }

    Formatter(const Formatter& other) :
        logger_(other.logger_), severity_(other.severity_),
        message_(other.message_), nextPlaceholder_(other.nextPlaceholder_)
    {
        other.logger_ = NULL;
    }

    //
    ~ Formatter() {
        if (logger_) {
            try {
                checkExcessPlaceholders(message_, ++nextPlaceholder_);
                logger_->output(severity_, *message_);
            } catch (...) {
                // Catch and ignore all exceptions here.
            }
            delete message_;
        }
    }

    Formatter& operator =(const Formatter& other) {
        if (&other != this) {
            logger_ = other.logger_;
            severity_ = other.severity_;
            message_ = other.message_;
            nextPlaceholder_ = other.nextPlaceholder_;
            other.logger_ = NULL;
        }

        return *this;
    }

    template<class Arg> Formatter& arg(const Arg& value) {
        if (logger_) {
            try {
                return (arg(boost::lexical_cast<std::string>(value)));
            } catch (const boost::bad_lexical_cast& ex) {
                // The formatting of the log message got wrong, we don't want
                // to output it.
                deactivate();
                // A bad_lexical_cast during a conversion to a string is
                // *extremely* unlikely to fail.  However, there is nothing
                // in the documentation that rules it out, so we need to handle
                // it.  As it is a potentially very serious problem, throw the
                // exception detailing the problem with as much information as
                // we can.  (Note that this does not include 'value' -
                // boost::lexical_cast failed to convert it to a string, so an
                // attempt to do so here would probably fail as well.)
                isc_throw(FormatFailure, "bad_lexical_cast in call to "
                          "Formatter::arg(): " << ex.what());
            }
        } else {
            return (*this);
        }
    }

    Formatter& arg(const std::string& arg) {
        if (logger_) {
            // Note that this method does a replacement and returns the
            // modified string. If there are multiple invocations of arg() (e.g.
            // logger.info(msgid).arg(xxx).arg(yyy)...), each invocation
            // operates on the string returned by the previous one. This
            // sequential operation means that if we had a message like "%1 %2",
            // and called .arg("%2").arg(42), we would get "42 42"; the first
            // call replaces the %1" with "%2" and the second replaces all
            // occurrences of "%2" with 42. (Conversely, the sequence
            // .arg(42).arg("%1") would return "42 %1" - there are no recursive
            // replacements).
            try {
                replacePlaceholder(message_, arg, ++nextPlaceholder_ );
            }
            catch (...) {
                // Something went wrong here, the log message is broken, so
                // we don't want to output it, nor we want to check all the
                // placeholders were used (because they won't be).
                deactivate();
                throw;
            }
        }
        return (*this);
    }

    void deactivate() {
        if (logger_) {
            delete message_;
            message_ = NULL;
            logger_ = NULL;
        }
    }
};

}
}

#endif