syslogstream.h

Go to the documentation of this file.

#ifndef __syslogstream_h__
#define __syslogstream_h__
 
#include <iostream>
#include <fstream>
#include <syslog.h>
#include <vector>
 
namespace logstream {
    enum class level {
        emerg = LOG_EMERG,
        alert = LOG_ALERT,
        crit = LOG_CRIT,
        err = LOG_ERR,
        warning = LOG_WARNING,
        notice = LOG_NOTICE,
        info = LOG_INFO,
        debug = LOG_DEBUG
    };
    class namedLevel {
        std::string name;
        level Level;
        namedLevel(const std::string&aName, level aLevel): name(aName), Level(aLevel) {}
        static const std::vector<namedLevel>& getNameList() {
#define mapItem(s) {#s,static_cast<level>(LOG_##s)}
            static decltype(getNameList()) nameList {
                mapItem(EMERG), mapItem(ALERT), mapItem(CRIT),
                mapItem(ERR), mapItem(WARNING),
                mapItem(NOTICE), mapItem(INFO),
                mapItem(DEBUG)
            };
#undef mapItem
            return nameList;
        }
      public:
        static level getLevelByName(const std::string& aName) {
            for (const auto& l : getNameList()) {
                if (l.name == aName) {
                    return l.Level;
                }
            }
            throw std::runtime_error("unknown level name " + aName);
        }
        static const std::string& getNameByLevel(level aLevel) {
            for (const auto& l : getNameList()) {
                if (l.Level == aLevel) {
                    return l.name;
                }
            }
            throw std::runtime_error("illegal level");
        }
    };
 
 
    class syslogbuf : public std::streambuf {
      protected:
 
        int overflow(int c = EOF) override {
            if (c == '\n' || !c || c == EOF) {
                if (message.size() != 0) {
                    syslog(static_cast<int>(currentLevel), "%s\n",
                           message.c_str());
                    currentLevel = defaultLevel;
                }
                message.clear();
                if (c == EOF) {
                    return !c;
                }
                return c;
            }
            message.push_back(c);
            return c;
        }
        std::string message;
        level defaultLevel;
        level currentLevel;
 
      public:
        ~syslogbuf() override {
            overflow();
        };
        syslogbuf(const std::string& aLevel):
            defaultLevel(namedLevel::getLevelByName(aLevel)),
            currentLevel(defaultLevel) {};
        void setLevel(level aLevel) {
            currentLevel = aLevel;
        }
    };
 
    class logstream : public std::ostream {
      protected:
        syslogbuf buffer;
      public:
        logstream(const std::string& aLevel) : std::ostream(&buffer), buffer(aLevel) {}
        void setLevel(level aLevel) {
            buffer.setLevel(aLevel);
        }
    };
 
    class provider {
        std::ostream *stream;
        std::ostream& defaultStream;
      public:
        provider(const std::string& name, std::ostream& aDefaultStream = std::cout) :
            defaultStream(name == "std::cerr" ? std::cerr : aDefaultStream) {
            if (name.empty() || name == "std::cerr") {
                stream = &defaultStream;
            } else if (name.compare(0, 6, "syslog") == 0) {
                auto defaultLevel = name.substr(6);
                if (defaultLevel.empty()) {
                    defaultLevel = "INFO";
                } else {
                    defaultLevel.erase(0, 1);
                }
                stream = new logstream(defaultLevel);
            } else {
                stream = new std::ofstream(name, std::ios::out | std::ios::ate);
            }
        }
        ~provider() {
            if (stream != &defaultStream) {
                delete stream;
            }
        }
        std::ostream& getStream() {
            return *stream;
        }
    };
} // end of logstream namespace
inline std::ostream& operator<<(std::ostream& stream, const logstream::level& aLevel) {
    auto logStream = dynamic_cast<logstream::logstream*>(&stream);
    if (logStream != nullptr) {
        logStream->setLevel(aLevel);
    } else {
        stream << logstream::namedLevel::getNameByLevel(aLevel);
        stream << ": ";
    }
    return stream;
}
#endif