logger.cpp

Go to the documentation of this file.

// Logs all output to a log file for the run
// Author: Max Schwarz <max.schwarz@uni-bonn.de>
 
#include "logger.h"
#include "fmt/format.h"
 
#include <array>
#include <cerrno>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <stdexcept>
#include <iterator>
 
#include <sys/time.h>
 
#include <fmt/format.h>
 
#include <syslog.h>
 
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
 
namespace rosmon
{
 
namespace
{
        int prioFromEventType(LogEvent::Type type)
        {
                switch(type)
                {
                        case LogEvent::Type::Error: return 3;
                        case LogEvent::Type::Warning: return 4;
                        case LogEvent::Type::Info: return 6;
                        case LogEvent::Type::Raw: return 6;
                        case LogEvent::Type::Debug: return 7;
                }
 
                return 6;
        }
}
 
FileLogger::FileLogger(const std::string& path, bool flush)
 : m_flush{flush}
{
        m_flush = flush;
        m_file = fopen(path.c_str(), "ae");
        if(!m_file)
        {
                throw std::runtime_error(fmt::format(
                        "Could not open log file: {}", strerror(errno)
                ));
        }
}
 
FileLogger::~FileLogger()
{
        if(m_file)
                fclose(m_file);
}
 
void FileLogger::log(const LogEvent& event)
{
        struct timeval tv;
        memset(&tv, 0, sizeof(tv));
        gettimeofday(&tv, nullptr);
 
        struct tm btime;
        memset(&btime, 0, sizeof(tv));
        localtime_r(&tv.tv_sec, &btime);
 
        char timeString[100];
        strftime(timeString, sizeof(timeString), "%a %F %T", &btime);
 
        unsigned int len = event.message.length();
        while(len != 0 && (event.message[len-1] == '\n' || event.message[len-1] == '\r'))
                len--;
 
        fmt::print(m_file, "{}.{:03d}: {:>20}: ",
                timeString, tv.tv_usec / 1000,
                event.source.c_str()
        );
        fwrite(event.message.c_str(), 1, len, m_file);
        fputc('\n', m_file);
 
        if(m_flush)
                fflush(m_file);
}
 
 
SyslogLogger::SyslogLogger(const std::string& launchFileName)
{
        m_tag = fmt::format("rosmon@{}", launchFileName);
        openlog(m_tag.c_str(), 0, LOG_USER);
}
 
void SyslogLogger::log(const LogEvent& event)
{
        syslog(prioFromEventType(event.type), "%20s: %s", event.source.c_str(), event.message.c_str());
}
 
 
SystemdLogger::SystemdLogger(const std::string& launchFileName)
 : m_launchFileName{launchFileName}
{
        m_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
        if(m_fd < 0)
                throw std::runtime_error{fmt::format("Could not create socket: {}", strerror(errno))};
 
        int size = 8*1024*1024;
        if(setsockopt(m_fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size)) < 0)
                perror("WARNING: Could not increase SO_SNDBUF size");
 
        sockaddr_un addr{};
        addr.sun_family = AF_UNIX;
        strncpy(addr.sun_path, "/run/systemd/journal/socket", sizeof(addr.sun_path)-1);
 
        if(connect(m_fd, reinterpret_cast<const sockaddr*>(&addr), sizeof(addr)) != 0)
                throw NotAvailable{fmt::format("Systemd Journal not available: {}", strerror(errno))};
}
 
SystemdLogger::~SystemdLogger()
{
        if(m_fd >= 0)
                close(m_fd);
}
 
void SystemdLogger::log(const LogEvent& event)
{
        fmt::memory_buffer buffer;
 
        fmt::format_to(std::back_inserter(buffer),
                "PRIORITY={}\n"
                "ROSMON_LAUNCH_FILE={}\n"
                "ROSMON_NODE={}\n"
                "SYSLOG_IDENTIFIER=rosmon@{}\n",
                prioFromEventType(event.type),
                m_launchFileName,
                event.source,
                m_launchFileName
        );
 
        std::string msg = fmt::format("{}: {}", event.source, event.message);
 
        if(msg.find('\n') == std::string::npos)
                fmt::format_to(std::back_inserter(buffer), "MESSAGE={}\n", msg);
        else
        {
                buffer.append(std::string{"MESSAGE\n"});
                std::array<uint8_t, 8> size;
                uint64_t sizeInt = msg.length();
                for(int i = 0; i < 8; ++i)
                {
                        size[i] = sizeInt & 0xFF;
                        sizeInt >>= 8;
                }
 
                buffer.append(size);
                buffer.append(msg);
                buffer.append(std::string{"\n"});
        }
 
        if(write(m_fd, buffer.data(), buffer.size()) < 0)
                fprintf(stderr, "Could not write to systemd log: %s\n", strerror(errno));
}
 
}