Log.h

Go to the documentation of this file.

// -*- lsst-c++ -*-

/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 * 
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the LSST License Statement and 
 * the GNU General Public License along with this program.  If not, 
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
 
#ifndef LSST_PEX_LOG_H
#define LSST_PEX_LOG_H

#include "lsst/daf/base/PropertySet.h"
#include "lsst/pex/logging/LogRecord.h"
#include "lsst/pex/logging/LogDestination.h"
#include "lsst/pex/logging/threshold/Memory.h"

#include <vector>
#include <list>
#include <cstdarg>
#include <boost/shared_ptr.hpp>

// If the compiler does not support attributes, disable them
#ifndef __GNUC__
#   define  __attribute__(x)
#endif
// Tell the compiler that a function takes a printf-style format string
// and varargs; it can then warn if the args don't match the format string.
// The "fmt" and "start" args are the positions of the format string and
// the start of the varargs; +1 for C++ member functions.
#define ATTRIB_FORMAT(fmt,start) __attribute__ ((format(printf,fmt,start)))

namespace lsst {
namespace pex {
namespace logging {

class Log {
public:

    static const int DEBUG;

    static const int INFO;

    static const int WARN;

    static const int INHERIT_THRESHOLD;

    static const int FATAL;

    Log(const int threshold=INFO, const std::string& name="");

    Log(const std::list<boost::shared_ptr<LogDestination> >& destinations, 
        const lsst::daf::base::PropertySet& preamble,
        const std::string& name="", const int threshold=INFO,
        bool defaultShowAll=false);

    Log(const Log& parent, const std::string& childName, 
        int threshold=INHERIT_THRESHOLD);

    Log(const Log& that);

    virtual ~Log();

    Log& operator=(const Log& that);

    const std::string& getName() const { return _name; }

    int getThreshold() const { 
        return ((_threshold > INHERIT_THRESHOLD || _name.length() == 0) 
                       ? _threshold
                       : _thresholds->getThresholdFor(_name) );
    }

    void setThreshold(int threshold) { 
        _threshold = threshold;
        _thresholds->setThresholdFor(_name, threshold);
    } 

    bool sends(int importance) const { return (importance >= getThreshold()); }

    void resetThreshold() { setThreshold(INHERIT_THRESHOLD); }

    void setThresholdFor(const std::string& name, int threshold);

    int getThresholdFor(const std::string& name) const;

    bool willShowAll() const { 
        return 
            (_myShowAll.get()) ? *_myShowAll 
                               : ((_defShowAll.get()) ? *_defShowAll : false);
    } 

    void setShowAll(bool yesno) {  
        if (_myShowAll.get()) 
            *_myShowAll = yesno;
        else
            _myShowAll.reset(new bool(yesno));
    }

    void resetShowAll() {  
        if (_defShowAll.get() == _myShowAll.get()) 
            *_myShowAll = false;
        else
            _myShowAll.reset();  
    }

    template <class T>
    void addPreambleProperty(const std::string& name, const T& val);

    template <class T>
    void setPreambleProperty(const std::string& name, const T& val);

    Log *createChildLog(const std::string& childName, 
                        int threshold=INHERIT_THRESHOLD) const;

    void log(int importance, const std::string& message, 
             const lsst::daf::base::PropertySet& properties);

    template <class T>
    void log(int importance, const std::string& message, 
             const std::string& name, const T& val);

    template <class T>
    void log(int importance, const std::string& message, 
             const RecordProperty<T>& prop);

    void log(int importance, const std::string& message);

    void log(int importance, const boost::format& message) {
        log(importance, message.str());
    }

#define LEVELF(fname, lev)                                          \
    void fname(const std::string& message,                          \
               const lsst::daf::base::PropertySet& properties) {    \
        log(lev, message, properties);                              \
    }                                                               \
    template <class T>                                              \
    void fname(const std::string& message,                          \
               const std::string& name, const T& val) {             \
        log<T>(lev, message, name, val);                            \
    }                                                               \
    template <class T>                                              \
    void fname(const std::string& message,                          \
               const RecordProperty<T>& prop) {                     \
        log<T>(lev, message, prop);                                 \
    }                                                               \
    void fname(const std::string& message) {                        \
        log(lev, message);                                          \
    }                                                               \
    void fname(const boost::format& message) {                      \
        log(lev, message);                                          \
    }
    LEVELF(logdebug, DEBUG)
    LEVELF(info    , INFO )
    LEVELF(warn    , WARN )
    LEVELF(fatal   , FATAL)
#undef LEVELF

    void format(int importance, const char *fmt, ...)
    ATTRIB_FORMAT(3, 4);

#define LEVELF(fname, lev)                                     \
    void fname(const char* fmt, ...)                           \
        ATTRIB_FORMAT(2, 3) {                                  \
        if (lev < getThreshold()) return;                      \
        va_list ap;                                            \
        va_start(ap, fmt);                                     \
        _format(lev, fmt, ap);                                 \
        va_end(ap);                                            \
    }

    LEVELF(debugf , DEBUG)
    LEVELF(infof  , INFO )
    LEVELF(warnf  , WARN )
    LEVELF(fatalf , FATAL)

#undef LEVELF

    void send(const LogRecord& record);

    void addDestination(std::ostream& destination, int threshold);

    void addDestination(std::ostream &destination, int threshold, 
                        const boost::shared_ptr<LogFormatter> &formatter);

    void addDestination(const boost::shared_ptr<LogDestination> &destination) {
        _destinations.push_back(destination);
    }

    const lsst::daf::base::PropertySet& getPreamble() { return *_preamble; }

    void markPersistent() { _preamble->markPersistent(); }

    static Log& getDefaultLog();

    static void createDefaultLog(
        const std::list<boost::shared_ptr<LogDestination> >& destinations, 
        const lsst::daf::base::PropertySet& preamble,
        const std::string& name="", const int threshold=INFO);

    static void closeDefaultLog();

    void printThresholds(std::ostream& out) {
        _thresholds->printThresholds(out);
    }

    void reset() { _thresholds->forgetAllNames(); }

protected:
    static Log *defaultLog;

    static void setDefaultLog(Log* deflog);

    static const std::string _sep;

    void _send(int threshold, int importance, const char *fmt, va_list ap);

    void _format(int importance, const char* fmt, va_list ap);

private:
    void completePreamble();

    int _threshold;
    boost::shared_ptr<bool> _defShowAll;
    boost::shared_ptr<bool> _myShowAll;
    std::string _name;

protected: 
    boost::shared_ptr<threshold::Memory> _thresholds;

    std::list<boost::shared_ptr<LogDestination> > _destinations;

    lsst::daf::base::PropertySet::Ptr _preamble;
};

template <class T>
void Log::addPreambleProperty(const std::string& name, const T& val) {
    _preamble->add<T>(name, val);
}

template <class T>
void Log::setPreambleProperty(const std::string& name, const T& val) {
    _preamble->set<T>(name, val);
}
        
template <class T>
void Log::log(int importance, const std::string& message, 
              const std::string& name, const T& val) {

    int threshold = getThreshold();
    if (importance < threshold)
        return;
    LogRecord rec(threshold, importance, *_preamble, willShowAll());
    rec.addComment(message);
    rec.addProperty(name, val);
    send(rec);
}

template <class T>
void Log::log(int importance, const std::string& message, 
         const RecordProperty<T>& prop) 
{
    log(importance, message, prop.name, prop.value);
}


class LogRec : public LogRecord {
public:

    LogRec(Log& log, int importance) 
        : LogRecord(log.getThreshold(), importance, log.getPreamble()), 
          _sent(false), _log(&log)
    { }

    LogRec(const LogRec& that) 
        : LogRecord(that), _sent(false), _log(that._log) 
    { }

    virtual ~LogRec();

    LogRec& operator=(const LogRec& that) {
        LogRecord::operator=(that);
        _log = that._log;
        return *this;
    }

    enum Manip { 
        endr 
    };

    LogRec& operator<<(const std::string& comment); /* {
        addComment(comment);
        return *this;
    }  */

    LogRec& operator<<(const boost::format& comment) {
        addComment(comment);
        return *this;
    }

    template <class T>
    LogRec& operator<<(const RecordProperty<T>& prop) {
        addProperty(prop.name, prop.value);
        return *this;
    }

    LogRec& operator<<(const lsst::daf::base::PropertySet& props) {
        addProperties(props);
        return *this;
    }

    LogRec& operator<<(Manip signal) {
        if (_send) {
            switch (signal) {
            case endr:
                _log->send(*this);
                _sent = true;
                break;
            default:
                ;
            }
        }
        return *this;
    }

private:
    bool _sent;
    Log *_log;
};

typedef LogRec Rec;

}}}     // end lsst::pex::logging

#undef ATTRIB_FORMAT

#endif  // end LSST_PEX_LOG_H