log_parser.cpp

Go to the documentation of this file.

// Splits the log stream into individual messages
// Author: Max Schwarz <max.schwarz@ais.uni-bonn.de>
 
#include "log_parser.h"
 
#include <algorithm>
#include <cstring>
#include <vector>
 
namespace rosmon
{
namespace monitor
{
 
class LogParser::Private
{
public:
        enum class State
        {
                ColorEscape1,
                ColorEscape2,
                ColorEscape3,
 
                RawMsgContent,
 
                TypedMsgContent,
 
                EndEscape1,
                EndEscape2,
                EndEscape3,
                EndEscape4
        };
 
        static LogEvent::Type typeFromColorCode(int code)
        {
                switch(code)
                {
                        case 0: return LogEvent::Type::Info;
                        case 31: return LogEvent::Type::Error;
                        case 32: return LogEvent::Type::Debug;
                        case 33: return LogEvent::Type::Warning;
                }
 
                return LogEvent::Type::Info;
        }
 
        void process(char c, const std::chrono::steady_clock::time_point& time)
        {
                m_buffer.push_back(c);
 
                switch(m_state)
                {
                        case State::ColorEscape1:
                                if(c == '\e')
                                        m_state = State::ColorEscape2;
                                else
                                        m_state = State::RawMsgContent;
 
                                break;
 
                        case State::ColorEscape2:
                                if(c == '[')
                                {
                                        m_state = State::ColorEscape3;
                                        m_colorCode = 0;
                                }
                                else
                                        m_state = State::RawMsgContent;
 
                                break;
 
                        case State::ColorEscape3:
                                if(std::isdigit(c))
                                        m_colorCode = m_colorCode * 10 + (c - '0');
                                else if(c == 'm')
                                {
                                        m_msgBegin = m_buffer.size();
                                        m_msgStartTime = time;
                                        m_state = State::TypedMsgContent;
                                }
                                else
                                        m_state = State::RawMsgContent;
 
                                break;
 
                        case State::TypedMsgContent:
                                if(c == '\e')
                                {
                                        m_msgEnd = m_buffer.size() - 1;
                                        m_state = State::EndEscape1;
                                }
 
                                break;
 
                        case State::EndEscape1:
                                if(c == '[')
                                        m_state = State::EndEscape2;
                                else
                                        m_state = State::TypedMsgContent;
 
                                break;
 
                        case State::EndEscape2:
                                if(c == '0')
                                        m_state = State::EndEscape3;
                                else
                                        m_state = State::TypedMsgContent;
 
                                break;
 
                        case State::EndEscape3:
                                if(c == 'm')
                                        m_state = State::EndEscape4;
                                else
                                        m_state = State::TypedMsgContent;
 
                                break;
 
                        case State::EndEscape4:
                                if(c == '\n')
                                {
                                        std::string msg{m_buffer.data() + m_msgBegin, m_msgEnd - m_msgBegin};
 
                                        if(m_cb)
                                                m_cb(Event{std::move(msg), typeFromColorCode(m_colorCode)});
 
                                        m_state = State::ColorEscape1;
                                        m_buffer.clear();
                                }
                                else
                                        m_state = State::RawMsgContent;
 
                                break;
 
                        case State::RawMsgContent:
                                if(c == '\n')
                                {
                                        std::string msg{m_buffer.data(), m_buffer.size()-1};
 
                                        if(m_cb)
                                                m_cb(Event{std::move(msg), LogEvent::Type::Raw});
 
                                        m_state = State::ColorEscape1;
                                        m_buffer.clear();
                                }
 
                                break;
                }
        }
 
        void checkPending(const std::chrono::steady_clock::time_point& time = std::chrono::steady_clock::now())
        {
                if(m_state == State::RawMsgContent)
                        return;
 
                if(time - m_msgStartTime > std::chrono::milliseconds(250))
                        flush();
        }
 
        void flush()
        {
                if(m_buffer.empty())
                        return;
 
                // Emit completed lines
                while(true)
                {
                        auto it = std::find(m_buffer.begin(), m_buffer.end(), '\n');
                        if(it == m_buffer.end())
                                break;
 
                        std::size_t size = it - m_buffer.begin();
                        std::string msg{m_buffer.data(), size};
 
                        if(m_cb)
                                m_cb(Event{std::move(msg), LogEvent::Type::Raw});
 
                        std::memmove(m_buffer.data(), m_buffer.data() + size + 1, m_buffer.size() - size - 1);
                        m_buffer.resize(m_buffer.size() - size - 1);
                }
 
                m_state = State::ColorEscape1;
        }
 
        State m_state = State::ColorEscape1;
 
        int m_colorCode = 0;
 
        std::vector<char> m_buffer;
 
        std::size_t m_msgBegin = 0;
        std::size_t m_msgEnd = 0;
        std::chrono::steady_clock::time_point m_msgStartTime;
 
        std::function<void(LogParser::Event&&)> m_cb;
};
 
LogParser::LogParser()
 : m_d{new Private}
{
}
 
LogParser::~LogParser()
{
}
 
void LogParser::process(const char* input, std::size_t size, const std::chrono::steady_clock::time_point& time)
{
        for(std::size_t i = 0; i < size; ++i)
                m_d->process(input[i], time);
}
 
void LogParser::setCallback(const std::function<void(Event&&)>& cb)
{
        m_d->m_cb = cb;
}
 
void LogParser::checkPending(const std::chrono::steady_clock::time_point& time)
{
        m_d->checkPending(time);
}
 
void LogParser::flush()
{
        m_d->flush();
}
 
}
}