log.cpp

Go to the documentation of this file.

// Copyright (c) 2013-2025  Made to Order Software Corp.  All Rights Reserved
//
// https://snapwebsites.org/project/cppthread
// contact@m2osw.com
//
// 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 2 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 GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
// self
//
#include    "cppthread/log.h"
 
#include    "cppthread/exception.h"
 
 
// C++
//
#include    <cstring>
#include    <iostream>
 
 
// last include
//
#include    <snapdev/poison.h>
 
 
 
namespace cppthread
{
 
 
extern void create_system_mutex();
 
 
logger      log;
 
 
namespace
{
 
 
log_callback        g_log_callback = nullptr;
 
 
pthread_mutex_t     g_log_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 
bool                g_log_locked = false;
 
 
bool                g_log_recursive_initialized = false;
 
 
pthread_mutex_t     g_log_recursive_mutex;
 
 
} // no name namespace
 
 
 
void set_log_callback(log_callback callback)
{
    pthread_mutex_lock(&g_log_mutex);
    g_log_callback = callback;
    pthread_mutex_unlock(&g_log_mutex);
}
 
 
logger::logger()
{
    try
    {
        create_system_mutex();
    }
    catch(...)
    {
        std::cerr << "fatal: could not create system mutex."
                  << std::endl;
        std::terminate();
    }
}
 
 
void logger::lock()
{
    int err(pthread_mutex_lock(&g_log_mutex));
    if(err != 0)
    {
        std::cerr << "fatal: the mutex lock in cppthread::logger::lock() generated error #"
                  << err
                  << std::endl;
        pthread_mutex_unlock(&g_log_mutex);
        std::terminate();
    }
 
    if(!g_log_recursive_initialized)
    {
        g_log_recursive_initialized = true;
 
        pthread_mutexattr_t mattr;
        err = pthread_mutexattr_init(&mattr);
        if(err != 0)
        {
            std::cerr << "fatal: a mutex attribute structure could not be initialized, error #"
                      << err
                      << std::endl;
            pthread_mutex_unlock(&g_log_mutex);
            std::terminate();
        }
        err = pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
        if(err != 0)
        {
            std::cerr << "fatal: a mutex attribute structure type could not be setup, error #"
                      << err
                      << std::endl;
            pthread_mutex_unlock(&g_log_mutex);
            std::terminate();
        }
        err = pthread_mutex_init(&g_log_recursive_mutex, &mattr);
        if(err != 0)
        {
            std::cerr << "fatal: a mutex structure could not be initialized, error #"
                      << err
                      << std::endl;
            pthread_mutex_unlock(&g_log_mutex);
            std::terminate();
        }
        err = pthread_mutexattr_destroy(&mattr);
        if(err != 0)
        {
            std::cerr << "fatal: a mutex attribute structure could not be destroyed, error #"
                      << err
                      << std::endl;
            pthread_mutex_unlock(&g_log_mutex);
            std::terminate();
        }
    }
    err = pthread_mutex_unlock(&g_log_mutex);
    if(err != 0)
    {
        std::cerr << "fatal: a mutex unlock generated error #"
                  << err
                  << std::endl;
        std::terminate();
    }
 
    // we have to lock only once so we use a flag to know whether we're
    // already locked, if so, we unlock immediately (but we still have
    // one lock in place)
    //
    err = pthread_mutex_lock(&g_log_recursive_mutex);
    if(err != 0)
    {
        std::cerr << "fatal: a mutex lock generated error #"
                  << err
                  << std::endl;
        std::terminate();
    }
 
    if(g_log_locked)
    {
        // it was already locked, so unlock (i.e. we only want to keep one
        // lock turned on at a time)
        //
        err = pthread_mutex_unlock(&g_log_recursive_mutex);
        if(err != 0)
        {
            std::cerr << "fatal: a mutex unlock generated error #"
                      << err
                      << std::endl;
            std::terminate();
        }
    }
    else
    {
        g_log_locked = true;
    }
}
 
 
void logger::unlock()
{
    if(!g_log_locked)
    {
        std::cerr << "fatal: logger::unlock() called with g_log_locked == false"
                  << std::endl;
        std::terminate();
    }
 
    g_log_locked = false;
 
    int err(pthread_mutex_unlock(&g_log_recursive_mutex));
    if(err != 0)
    {
        std::cerr << "fatal: a mutex unlock generated error #"
                  << err
                  << std::endl;
        pthread_mutex_unlock(&g_log_recursive_mutex);
        std::terminate();
    }
}
 
 
logger & logger::operator << (log_level_t const & level)
{
    if(level < log_level_t::debug
    || level > log_level_t::fatal)
    {
        throw invalid_log_level(
                      "unknown log level ("
                    + std::to_string(static_cast<int>(level))
                    + ").");
    }
 
    lock();
    if(f_log.tellp() != 0)
    {
        unlock();
        throw invalid_log_level("log level specified when logger buffer is not empty.");
    }
    f_level = level;
    ++f_counters[static_cast<int>(level)];
    return *this;
}
 
 
logger & logger::operator << (logger & (*func)(logger &))
{
    func(*this);
    return *this;
}
 
 
void logger::reset_counters()
{
    std::memset(f_counters, 0, sizeof(f_counters));
}
 
 
std::uint32_t logger::get_counter(log_level_t level) const
{
    if(level < log_level_t::debug
    || level > log_level_t::fatal)
    {
        throw invalid_log_level(
                      "unknown log level ("
                    + std::to_string(static_cast<int>(level))
                    + ").");
    }
 
    return f_counters[static_cast<int>(level)];
}
 
 
std::uint32_t logger::get_errors() const
{
    return f_counters[static_cast<int>(log_level_t::error)]
         + f_counters[static_cast<int>(log_level_t::fatal)];
}
 
 
std::uint32_t logger::get_warnings() const
{
    return f_counters[static_cast<int>(log_level_t::warning)];
}
 
 
logger & logger::end()
{
    // the logger is still locked at this point so:
    // 1. capture a copy of the data
    // 2. reset the message for next time
    // 3. unlock
    // 4. display the message or call the callback
    //
    log_callback callback;
    log_level_t level;
    std::string msg;
    try
    {
        callback = g_log_callback;
        level = f_level;
        msg = f_log.str();
        f_log.str(std::string());
        unlock();
    }
    catch(...)
    {
        unlock();
        throw;
    }
 
    if(callback != nullptr)
    {
        callback(level, msg);
    }
    else if(level >= log_level_t::info)
    {
        // the std::cerr requires a lock when multiple << are used
        // so instead create one string with the entire message first
        // including the newline
        //
        msg = to_string(level) + ": " + msg + "\n";
        std::cerr << msg;
    }
 
    return *this;
}
 
 
std::string to_string(log_level_t level)
{
    switch(level)
    {
    case log_level_t::debug:
        return "debug";
 
    case log_level_t::info:
        return "info";
 
    case log_level_t::warning:
        return "warning";
 
    case log_level_t::error:
        return "error";
 
    case log_level_t::fatal:
        return "fatal";
 
    case log_level_t::LOG_LEVEL_SIZE:
        break;
 
    }
 
    throw invalid_error("unknown log level ("
                                 + std::to_string(static_cast<int>(level))
                                 + ")");
}
 
 
} // namespace cppthread
// vim: ts=4 sw=4 et