Log.cpp

/*
** libutil++
** $Id: Log.cpp 1653 2016-02-28 19:54:59Z sella $
** Copyright (c) 2011-2016 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: Log.cpp 1653 2016-02-28 19:54:59Z sella $";

#include "Log.h"
#include "LogException.h"
#include "LogFormat.h"
#include "Process.h"
#include "../Exception.h"

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <syslog.h>
#include <stdarg.h>
#include <assert.h>
#include <string.h>

#include <string>

#define BUFFER_SIZE (64 * 1024)

using namespace sella::util;

const char* Log::LABEL_EMERGENCY = "EMRG";
const char* Log::LABEL_ALERT     = "ALRT";
const char* Log::LABEL_CRITICAL  = "CRIT";
const char* Log::LABEL_ERROR     = "ERRO";
const char* Log::LABEL_WARNING   = "WARN";
const char* Log::LABEL_NOTICE    = "NOTE";
const char* Log::LABEL_INFO      = "INFO";
const char* Log::LABEL_DEBUG     = "DEBG";

Log::shared libutilxx__log __attribute__((init_priority(101)));

Log::Log(const std::string &identifier, int facility, int option, int mask, const LogFormat &format, size_t size) throw (LogException) :
        references(*(new uint64_t(1))),
        everyN(*(new uint64_t(1))),

        identifier(identifier),
        facility(facility),
        option(option),

        syslog(true),
        syslogMask(mask),

        allTraceOptions(false)
{
        pthread_spin_init(&mutex, PTHREAD_PROCESS_PRIVATE);
        this->format = format.clone();
        setLogSize(size);

        if (identifier.empty()) {
                this->identifier = Process::getBaseName();
        }

        ::openlog(this->identifier.c_str(), option, facility);
}

Log::Log(const std::string &file, const LogFormat &format, size_t size) throw (LogException) :
        references(*(new uint64_t(1))),
        everyN(*(new uint64_t(1))),
        identifier(file),
        facility(::open(file.c_str(), O_APPEND|O_CREAT|O_NONBLOCK, S_IRWXU)),
        option(0),

        syslog(false),
        syslogMask(0),

        allTraceOptions(false)
{
        pthread_spin_init(&mutex, PTHREAD_PROCESS_PRIVATE);
        this->format = format.clone();
        setLogSize(size);

        if (this->facility < 0) {
                THROW(LogException, "failed to open file '%s' for logging", file.c_str());
        }
}

Log::Log(const Log &other) throw () :
        references(other.references),
        everyN(other.everyN),

        identifier(other.identifier),
        facility(other.facility),
        option(other.option),

        format(NULL),
        syslog(other.syslog),
        syslogMask(other.syslogMask),
        size(other.size),

        traceOptions(other.traceOptions),
        allTraceOptions(other.allTraceOptions)
{
        pthread_spin_init(&mutex, PTHREAD_PROCESS_PRIVATE);
        this->references += 1;
        this->format = other.format->clone();
}

Log::~Log() throw () {
        if ((--(this->references)) == 0) {
                delete &(this->references);
                delete &(this->everyN);
                delete format;

                if (this->syslog) {
                        closelog();
                } else {
                        close(this->facility);
                }
        }

        pthread_spin_destroy(&mutex);
}

Log& Log::operator=(const Log &other) throw () {
        if (this != &other) {
                pthread_spin_lock(&mutex);

                this->references = other.references;
                this->references += 1;
                this->everyN = other.everyN;

                this->identifier = other.identifier;
                this->facility = other.facility;
                this->option = other.option;

                if (this->format) {
                        delete format;
                }

                this->format = other.format->clone();
                this->syslog = other.syslog;
                this->syslogMask = other.syslogMask;
                this->size = other.size;

                this->traceOptions = other.traceOptions;
                this->allTraceOptions = other.allTraceOptions;

                pthread_spin_unlock(&mutex);
        }
        return *this;
}

const Log::shared Log::shared_ptr(const std::string &identifier, int facility, int option, int mask, const LogFormat &format, size_t size) throw (LogException) {
        return std::make_shared<Log>(identifier, facility, option, mask, format, size);
}

const Log::shared Log::shared_ptr(const std::string &file, const LogFormat &format, size_t size) throw (LogException) {
        return std::make_shared<Log>(file, format, size);
}

const char* Log::priority(int level) throw () {
        switch (LOG_PRI(level)) {
                case Log::LEVEL_EMERGENCY:
                        return Log::LABEL_EMERGENCY;
                case Log::LEVEL_ALERT:
                        return Log::LABEL_ALERT;
                case Log::LEVEL_CRITICAL:
                        return Log::LABEL_CRITICAL;
                case Log::LEVEL_ERROR:
                        return Log::LABEL_ERROR;
                case Log::LEVEL_WARNING:
                        return Log::LABEL_WARNING;
                case Log::LEVEL_NOTICE:
                        return Log::LABEL_NOTICE;
                case Log::LEVEL_INFO:
                        return Log::LABEL_INFO;
                case Log::LEVEL_DEBUG:
                        return Log::LABEL_DEBUG;
        }

        return "UNKN";
}

void Log::setIdentifier(const std::string &identifier) throw () {
        this->identifier = identifier;

        ::openlog(identifier.c_str(), option, facility);
}

void Log::setFacility(int facility) throw () {
        this->facility = facility;

        ::openlog(identifier.c_str(), option, facility);
}

void Log::setOption(int option) throw () {
        this->option = option;

        ::openlog(identifier.c_str(), option, facility);
}

void Log::setFormat(const LogFormat &format) throw () {
        pthread_spin_lock(&mutex);

        if (this->format) {
                delete this->format;
        }

        this->format = format.clone();

        pthread_spin_unlock(&mutex);
}

void Log::setLogLevel(int level, bool on) throw () {
        pthread_spin_lock(&mutex);

        if (on) {
                this->syslogMask |= LOG_MASK(level);
        } else {
                this->syslogMask &= ~LOG_MASK(level);
        }

        pthread_spin_unlock(&mutex);
}

int Log::setLogMask(int mask) throw () {
        pthread_spin_lock(&mutex);

        int prevMask = this->syslogMask;
        this->syslogMask = mask;

        pthread_spin_unlock(&mutex);

        return prevMask;
}

void Log::setLogSize(size_t size) throw () {
        this->size = (size < BUFFER_SIZE) ? size : BUFFER_SIZE;
}

int Log::getLogMask(void) throw () {
        return this->syslogMask;
}

bool Log::isLogMask(int level) throw () {
        return (this->syslogMask & LOG_MASK(level));
}

size_t Log::getLogSize(void) throw () {
        return this->size;
}

void Log::setTraceOption(const std::string &option, bool on) throw () {
        /* No mutex for 'all' to make this signal handler safe. */
        if (option.compare("all") == 0) {
                allTraceOptions = on;

                return;
        }

        pthread_spin_lock(&mutex);

        if (on) {
                traceOptions.insert(option);
        } else {
                traceOptions.erase(option);
        }

        pthread_spin_unlock(&mutex);
}

void Log::setTraceOption(const std::vector<std::string> &options, bool on) throw () {
        setTraceOptions(options, on);
}

void Log::setTraceOption(const std::list<std::string> &options, bool on) throw () {
        setTraceOptions(options, on);
}

void Log::setTraceOptions(const std::vector<std::string> &options, bool on) throw () {
        for (auto it = options.cbegin(); it != options.cend(); ++it) {
                setTraceOption(*it, on);
        }
}

void Log::setTraceOptions(const std::list<std::string> &options, bool on) throw () {
        for (auto it = options.cbegin(); it != options.cend(); ++it) {
                setTraceOption(*it, on);
        }
}

bool Log::isTraceOption(const char* option) throw () {
        assert(option);

        /* Thread safe operations. */
        if (allTraceOptions) {
                return true;
        } else if (traceOptions.empty()) {
                return false;
        }

        pthread_spin_lock(&mutex);

        if (traceOptions.find(option) == traceOptions.end()) {
                pthread_spin_unlock(&mutex);

                return false;
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::isTraceOption(const std::string &option) throw () {
        /* Thread safe operations. */
        if (allTraceOptions) {
                return true;
        } else if (traceOptions.empty()) {
                return false;
        }

        pthread_spin_lock(&mutex);

        if (traceOptions.find(option) == traceOptions.end()) {
                pthread_spin_unlock(&mutex);

                return false;
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::isTraceOption(const std::vector<std::string> &options) throw () {
        for (auto &&o: options) {
                if (isTraceOption(o)) {
                        return true;
                }
        }

        return false;
}

bool Log::isTraceOption(const std::list<std::string> &options) throw () {
        for (auto &&o: options) {
                if (isTraceOption(o)) {
                        return true;
                }
        }

        return false;
}

bool Log::hasTraceOptions(void) throw () {
        return (allTraceOptions || traceOptions.empty());
}

void Log::clearTraceOptions(void) throw () {
        pthread_spin_lock(&mutex);

        allTraceOptions = false;
        traceOptions.clear();

        pthread_spin_unlock(&mutex);
}

bool Log::isTime(time_t &next, int sec) throw () {
        time_t now = time(NULL);

        if (time(NULL) >= next) {
                next = now + sec;

                return true;
        }

        return false;
}

bool Log::incEveryN(uint64_t n) throw () {
        pthread_spin_lock(&mutex);

        bool result = (everyN++ % n == 0);

        pthread_spin_unlock(&mutex);

        return result;
}

bool Log::incFirstN(uint64_t n) throw () {
        pthread_spin_lock(&mutex);

        bool result = (everyN++ <= n);

        pthread_spin_unlock(&mutex);

        return result;
}

void Log::resetEveryN(void) throw () {
        pthread_spin_lock(&mutex);

        this->everyN = 0;

        pthread_spin_unlock(&mutex);
}

bool Log::trace(const char *option, const char *func, const char *file, int line, const char *format, ...) throw () {
        int                     level = Log::LEVEL_INFO;
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        gettimeofday(&stamp, NULL);

        if (format == NULL) {
                buffer[0] = '\0';
        } else {
                va_start(arguments, format);
                vsnprintf(buffer, sizeof(buffer), format, arguments);
                va_end(arguments);
        }

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, option, buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(facility|level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::trace(std::string &option, const char *func, const char *file, int line, const char *format, ...) throw () {
        int                     level = Log::LEVEL_INFO;
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        gettimeofday(&stamp, NULL);

        if (format == NULL) {
                buffer[0] = '\0';
        } else {
                va_start(arguments, format);
                vsnprintf(buffer, sizeof(buffer), format, arguments);
                va_end(arguments);
        }

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, option.c_str(), buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(facility|level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::trace(const char *option, const char *func, const char *file, int line, const std::string &format, ...) throw () {
        int                     level = Log::LEVEL_INFO;
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        gettimeofday(&stamp, NULL);

        va_start(arguments, format);
        vsnprintf(buffer, sizeof(buffer), format.c_str(), arguments);
        va_end(arguments);

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, option, buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(facility|level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::trace(std::string &option, const char *func, const char *file, int line, const std::string &format, ...) throw () {
        int                     level = Log::LEVEL_INFO;
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        gettimeofday(&stamp, NULL);

        va_start(arguments, format);
        vsnprintf(buffer, sizeof(buffer), format.c_str(), arguments);
        va_end(arguments);

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, option.c_str(), buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(facility|level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::trace(const std::vector<std::string> &options, const char *func, const char *file, int line, const char *format, ...) throw () {
        std::string ops;
        va_list arguments;
        char buffer[BUFFER_SIZE];

        for (auto &&o: options) {
                ops.append(o);
                ops.push_back(',');
        }

        ops.pop_back();

        if (format == NULL) {
                buffer[0] = '\0';
        } else {
                va_start(arguments, format);
                vsnprintf(buffer, sizeof(buffer), format, arguments);
                va_end(arguments);
        }

        return trace(ops, func, file, line, buffer);
}

bool Log::trace(const std::vector<std::string> &options, const char *func, const char *file, int line, const std::string &format, ...) throw () {
        std::string ops;
        va_list arguments;
        char buffer[BUFFER_SIZE];

        for (auto &&o: options) {
                ops.append(o);
                ops.push_back(',');
        }

        ops.pop_back();

        va_start(arguments, format);
        vsnprintf(buffer, sizeof(buffer), format.c_str(), arguments);
        va_end(arguments);

        return trace(ops, func, file, line, buffer);
}

bool Log::trace(const std::list<std::string> &options, const char *func, const char *file, int line, const char *format, ...) throw () {
        std::string ops;
        va_list arguments;
        char buffer[BUFFER_SIZE];

        for (auto &&o: options) {
                ops.append(o);
                ops.push_back(',');
        }

        ops.pop_back();

        if (format == NULL) {
                buffer[0] = '\0';
        } else {
                va_start(arguments, format);
                vsnprintf(buffer, sizeof(buffer), format, arguments);
                va_end(arguments);
        }

        return trace(ops, func, file, line, buffer);
}

bool Log::trace(const std::list<std::string> &options, const char *func, const char *file, int line, const std::string &format, ...) throw () {
        std::string ops;
        va_list arguments;
        char buffer[BUFFER_SIZE];

        for (auto &&o: options) {
                ops.append(o);
                ops.push_back(',');
        }

        ops.pop_back();

        va_start(arguments, format);
        vsnprintf(buffer, sizeof(buffer), format.c_str(), arguments);
        va_end(arguments);

        return trace(ops, func, file, line, buffer);
}

bool Log::write(int facility, int level, const char *func, const char *file, int line, const sella::Exception &e, const std::string &format, ...) throw () {
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        if (!isLogMask(level)) {
                return false;
        }

        gettimeofday(&stamp, NULL);

        if (format.empty()) {
                strncpy(buffer, "Exception", sizeof(buffer));
        } else {
                va_start(arguments, format);
                vsnprintf(buffer, sizeof(buffer), format.c_str(), arguments);
                va_end(arguments);
        }

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, e, buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(facility|level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::write(int facility, int level, const char *func, const char *file, int line, const std::string &format, ...) throw () {
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        if (!isLogMask(level)) {
                return false;
        }

        gettimeofday(&stamp, NULL);

        va_start(arguments, format);
        vsnprintf(buffer, sizeof(buffer), format.c_str(), arguments);
        va_end(arguments);

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(facility|level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::write(int level, const char *func, const char *file, int line, const sella::Exception &e) throw () {
        struct timeval  stamp;

        if (!isLogMask(level)) {
                return false;
        }

        gettimeofday(&stamp, NULL);

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, e, NULL);

        if (this->syslog) {
                resize(text);
                ::syslog(level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::write(int level, const char *func, const char *file, int line, const sella::Exception &e, const std::string &format, ...) throw () {
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        if (!isLogMask(level)) {
                return false;
        }

        gettimeofday(&stamp, NULL);

        if (format.empty()) {
                strncpy(buffer, "Exception", sizeof(buffer));
        } else {
                va_start(arguments, format);
                vsnprintf(buffer, sizeof(buffer), format.c_str(), arguments);
                va_end(arguments);
        }

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, e, buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::write(int level, const char *func, const char *file, int line, const std::string &format, ...) throw () {
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        if (!isLogMask(level)) {
                return false;
        }

        gettimeofday(&stamp, NULL);

        va_start(arguments, format);
        vsnprintf(buffer, sizeof(buffer), format.c_str(), arguments);
        va_end(arguments);

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::write(int facility, int level, const char *func, const char *file, int line, const sella::Exception &e, const char *format, ...) throw () {
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        if (!isLogMask(level)) {
                return false;
        }

        gettimeofday(&stamp, NULL);

        if (format == NULL) {
                buffer[0] = '\0';
        } else if (format[0] == '\0') {
                strncpy(buffer, "Exception", sizeof(buffer));
        } else {
                va_start(arguments, format);
                vsnprintf(buffer, sizeof(buffer), format, arguments);
                va_end(arguments);
        }

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, e, buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(facility|level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::write(int facility, int level, const char *func, const char *file, int line, const char *format, ...) throw () {
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        if (!isLogMask(level)) {
                return false;
        }

        gettimeofday(&stamp, NULL);

        if (format == NULL) {
                buffer[0] = '\0';
        } else {
                va_start(arguments, format);
                vsnprintf(buffer, sizeof(buffer), format, arguments);
                va_end(arguments);
        }

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(facility|level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::write(int level, const char *func, const char *file, int line, const sella::Exception &e, const char *format, ...) throw () {
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        if (!isLogMask(level)) {
                return false;
        }

        gettimeofday(&stamp, NULL);

        if (format == NULL) {
                buffer[0] = '\0';
        } else if (format[0] == '\0') {
                strncpy(buffer, "Exception", sizeof(buffer));
        } else {
                va_start(arguments, format);
                vsnprintf(buffer, sizeof(buffer), format, arguments);
                va_end(arguments);
        }

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, e, buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

bool Log::write(int level, const char *func, const char *file, int line, const char *format, ...) throw () {
        va_list         arguments;
        char                    buffer[BUFFER_SIZE];
        struct timeval  stamp;

        if (!isLogMask(level)) {
                return false;
        }

        gettimeofday(&stamp, NULL);

        if (format == NULL) {
                buffer[0] = '\0';
        } else {
                va_start(arguments, format);
                vsnprintf(buffer, sizeof(buffer), format, arguments);
                va_end(arguments);
        }

        pthread_spin_lock(&mutex);

        std::string     text = this->format->format(level, this->format->format(stamp).c_str(), func, file, line, buffer);

        if (this->syslog) {
                resize(text);
                ::syslog(level, "%s", text.c_str());
        } else {
                ssize_t c; (void) c; // Suppress warning

                c = ::write(this->facility, text.c_str(), text.size());
                c = ::write(this->facility, "\n", 1);
        }

        pthread_spin_unlock(&mutex);

        return true;
}

void Log::resize(std::string &text) throw () {
        if (text.size() > size) {
                text.resize(size);
        }
}

Log::shared& Log::instance(const std::string &identifier) {
        static Log::shared logger = Log::shared_ptr(identifier, LOG_LOCAL0, Log::WithStderrOption);

        return logger;
}

/*
** vim: noet ts=3 sw=3
*/