Log.cc

Go to the documentation of this file.

// -*- LSST-C++ -*-
/*
 * LSST Data Management System
 * Copyright 2013-2014 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/>.
 */

// System headers
#include <stdexcept>
#include <stdio.h>
#include <stdlib.h>

// Third-party headers
#include <log4cxx/basicconfigurator.h>
#include <log4cxx/consoleappender.h>
#include <log4cxx/helpers/bytearrayinputstream.h>
#include <log4cxx/logmanager.h>
#include <log4cxx/propertyconfigurator.h>
#include <log4cxx/simplelayout.h>
#include <log4cxx/xml/domconfigurator.h>

// Local headers
#include "lsst/log/Log.h"


// Max message length for varargs/printf style logging
#define MAX_LOG_MSG_LEN 1024


namespace {

// name of the env. variable pointing to logging config file
const char configEnv[] = "LSST_LOG_CONFIG";

/*
 * Logging is configured at global initialization time (though everybody knows this is evil
 * thing to do). What we want to do:
 * - Let user re-configure later with LOG_CONFIG(filename) - this means that we do not
 *   do anything fancy here like initializing from some other file
 * - if LSST_LOG_CONFIG is set to existing file name then we want to configure from
 *   that file but only if user does not call LOG_CONFIG(filename)
 *   - this means that we should leave it to log4cxx to default-configure using that file
 *     name (meaning that we want to set LOG4CXX_CONFIGURATION)
 * - otherwise do basic configuration only
 */
bool init() {
    if (const char* env = getenv(::configEnv)) {
        // check that file actually exists
        if (env[0] and access(env, R_OK) == 0) {
            // prepare for default initialization in log4cxx if
            // user does not do LOG_CONFIG(...)
            ::setenv("LOG4CXX_CONFIGURATION", env, 1);
            return true;
        }
    }
    // do basic configuration only
    log4cxx::BasicConfigurator::configure();
    lsst::log::Log::initLog();

    return true;
}

bool initialized = init();

}


namespace lsst {
namespace log {

// Log class

log4cxx::LoggerPtr Log::defaultLogger = log4cxx::Logger::getRootLogger();

void Log::initLog() {
    // Default logger initially set to root logger
    defaultLogger = log4cxx::Logger::getRootLogger();
}

void Log::configure() {
    // TODO: does resetConfiguration() remove existing appenders?
    log4cxx::BasicConfigurator::resetConfiguration();

    // if LSST_LOG_CONFIG is set then use that file
    if (const char* env = getenv(::configEnv)) {
        if (env[0] and access(env, R_OK) == 0) {
            configure(env);
            return;
        }
    }

    // Do basic configuration (only if not configured already?)
    log4cxx::LoggerPtr rootLogger = log4cxx::Logger::getRootLogger();
    if (rootLogger->getAllAppenders().size() == 0) {
        log4cxx::BasicConfigurator::configure();
    }
    initLog();
}

std::string getFileExtension(std::string const& filename) {
    size_t dotpos = filename.find_last_of(".");
    if (dotpos == std::string::npos) {
      return "";
    }
    return filename.substr(dotpos, filename.size() - dotpos);
}

void Log::configure(std::string const& filename) {
    // TODO: does resetConfiguration() remove existing appenders?
    log4cxx::BasicConfigurator::resetConfiguration();
    if (getFileExtension(filename).compare(".xml") == 0) {
        log4cxx::xml::DOMConfigurator::configure(filename);
    } else {
        log4cxx::PropertyConfigurator::configure(filename);
    }
    initLog();
}

void Log::configure_prop(std::string const& properties) {
    std::vector<unsigned char> data(properties.begin(), properties.end());
    log4cxx::helpers::InputStreamPtr inStream(new log4cxx::helpers::ByteArrayInputStream(data));
    log4cxx::helpers::Properties prop;
    prop.load(inStream);
    log4cxx::PropertyConfigurator::configure(prop);
    initLog();
}

std::string Log::getDefaultLoggerName() {
    std::string name = defaultLogger->getName();
    if (name == "root") {
        name.clear();
    }
    return name;
}

log4cxx::LoggerPtr Log::getLogger(log4cxx::LoggerPtr logger) {
    return logger;
}

log4cxx::LoggerPtr Log::getLogger(std::string const& loggername) {
    if (loggername.empty()){
        return defaultLogger;
    } else {
        return log4cxx::Logger::getLogger(loggername);
    }
}

void Log::pushContext(std::string const& name) {
    // can't handle empty names
    if (name.empty()) {
        throw std::invalid_argument("lsst::log::Log::pushContext(): "
                "empty context name is not allowed");
    }
    // we do not allow multi-level context (logger1.logger2)
    if (name.find('.') != std::string::npos) {
        throw std::invalid_argument("lsst::log::Log::pushContext(): "
                "multi-level contexts are not allowed: " + name);
    }

    // Construct new default logger name
    std::string newName = defaultLogger->getName();
    if (newName == "root") {
        newName = name;
    } else {
        newName += ".";
        newName += name;
    }
    // Update defaultLogger
    defaultLogger = log4cxx::Logger::getLogger(newName);
}

void Log::popContext() {
    // switch to parent logger, this assumes that loggers are not
    // re-parented between calls to push and pop
    log4cxx::LoggerPtr parent = defaultLogger->getParent();
    // root logger does not have parent, stay at root instead
    if (parent) {
        defaultLogger = parent;
    }
}

void Log::MDC(std::string const& key, std::string const& value) {
    log4cxx::MDC::put(key, value);
}

void Log::MDCRemove(std::string const& key) {
    log4cxx::MDC::remove(key);
}

void Log::setLevel(log4cxx::LoggerPtr logger, int level) {
    logger->setLevel(log4cxx::Level::toLevel(level));
}

void Log::setLevel(std::string const& loggername, int level) {
    setLevel(getLogger(loggername), level);
}

int Log::getLevel(log4cxx::LoggerPtr logger) {
    log4cxx::LevelPtr level = logger->getLevel();
    int levelno = -1;
    if (level != NULL) {
        levelno = level->toInt();
    }
    return levelno;
}

int Log::getLevel(std::string const& loggername) {
    return getLevel(getLogger(loggername));
}

bool Log::isEnabledFor(log4cxx::LoggerPtr logger, int level) {
    if (logger->isEnabledFor(log4cxx::Level::toLevel(level))) {
        return true;
    } else {
        return false;
    }
}

bool Log::isEnabledFor(std::string const& loggername, int level) {
    return isEnabledFor(getLogger(loggername), level);
}

void Log::vlog(log4cxx::LoggerPtr logger,   
               log4cxx::LevelPtr level,     
               std::string const& filename, 
               std::string const& funcname, 
               unsigned int lineno,         
               char const* fmt,             
               va_list args                 
              ) {
    char msg[MAX_LOG_MSG_LEN];
    vsnprintf(msg, MAX_LOG_MSG_LEN, fmt, args);
    logger->forcedLog(level, msg, log4cxx::spi::LocationInfo(filename.c_str(),
                                                             funcname.c_str(),
                                                             lineno));
}

void Log::log(std::string const& loggername, 
              log4cxx::LevelPtr level,       
              std::string const& filename,   
              std::string const& funcname,   
              unsigned int lineno,           
              char const* fmt,               
              ...                            
             ) {
    va_list args;
    va_start(args, fmt);
    vlog(getLogger(loggername), level, filename, funcname, lineno, fmt, args);
}

void Log::log(log4cxx::LoggerPtr logger,   
              log4cxx::LevelPtr level,     
              std::string const& filename, 
              std::string const& funcname, 
              unsigned int lineno,         
              char const* fmt,             
              ...                          
             ) {
    va_list args;
    va_start(args, fmt);
    vlog(logger, level, filename, funcname, lineno, fmt, args);
}

}} // namespace lsst::log