spdlog::sinks::loki_api_sink< Mutex > Class Template Reference

#include <Loki.hpp>

Inheritance diagram for spdlog::sinks::loki_api_sink< Mutex >:

Collaboration diagram for spdlog::sinks::loki_api_sink< Mutex >:

Classes
struct	logInfo_t

Public Member Functions
	loki_api_sink (const std::string &lokiAddress)
	~loki_api_sink ()

Protected Member Functions
void	sink_it_ (const details::log_msg &msg) override
void	flush_ () override

Private Attributes
bool	_lokiAvailable {false}
std::unique_ptr< HTTP >	_connHandler
std::string	_basicInformation
std::vector< struct logInfo_t >	_internalLogBuffer

Detailed Description

template<typename Mutex>
class spdlog::sinks::loki_api_sink< Mutex >

A custom sink for spdlog that sends log messages to a Loki server.

The loki_api_sink class is a custom sink for spdlog that sends log messages to a Loki server. It provides functionality to send log messages to a specified Loki server address. The log messages are sent using HTTP requests.

Template Parameters

Mutex

The type of mutex to use for thread-safety.

Definition at line 24 of file Loki.hpp.

Constructor & Destructor Documentation

loki_api_sink()

template<typename Mutex >

spdlog::sinks::loki_api_sink< Mutex >::loki_api_sink ( const std::string & lokiAddress )

explicit

Constructs a loki_api_sink object with the specified Loki server address.

Parameters

lokiAddress

The address of the Loki server to send log messages to.

Definition at line 19 of file Loki.cpp.

    {
        if (lokiAddress.empty())
        {
            return;
        }
 
        _connHandler = std::make_unique<HTTP>(lokiAddress);
 
        // Pre-allocate buffers
        _internalLogBuffer.push_back({"debug", std::vector<std::pair<std::string, std::string>>()});
        _internalLogBuffer.push_back({"info", std::vector<std::pair<std::string, std::string>>()});
        _internalLogBuffer.push_back({"warn", std::vector<std::pair<std::string, std::string>>()});
        _internalLogBuffer.push_back({"error", std::vector<std::pair<std::string, std::string>>()});
        _internalLogBuffer.push_back({"critical", std::vector<std::pair<std::string, std::string>>()});
 
        // Prepare information (Loki limits maximum number of labels with 15)
        _basicInformation = "";
        _basicInformation += std::string(R"("release_version":"v)") + PROJECT_FULL_REVISION + "\",";
        _basicInformation += std::string(R"("release_date":")") + PROJECT_BUILD_DATE + " " + PROJECT_BUILD_TIME + "\",";
        _basicInformation += std::string(R"("compiler_name":")") + COMPILER_NAME + "\",";
        _basicInformation += std::string(R"("compiler_version":")") + COMPILER_VERSION + "\",";
        _basicInformation += std::string(R"("build":")") + BUILD_TYPE + "\",";
 
        // Parse hostname
        std::array<char, BUFSIZ> hostBuffer{};
        gethostname(hostBuffer.data(), BUFSIZ);
        _basicInformation += std::string(R"("hostname":")") + hostBuffer.data() + "\",";
 
        // Parse CPU information
        const std::string cpuInfoPath = "/proc/cpuinfo";
        std::string word;
 
        findFromFile(cpuInfoPath, "^siblings", word);
        _basicInformation += std::string(R"("cpu_threadcount":")") + word + "\",";
        findFromFile(cpuInfoPath, "^(cpu cores)", word);
        _basicInformation += std::string(R"("cpu_corecount":")") + word + "\",";
        findFromFile(cpuInfoPath, "^(model name)", word);
        _basicInformation += std::string(R"("cpu_model":")") + word + "\",";
        findFromFile(cpuInfoPath, "^vendor_id", word);
        _basicInformation += std::string(R"("cpu_vendorid":")") + word + "\",";
 
        _lokiAvailable = true;
    }

Here is the call graph for this function:

~loki_api_sink()

template<typename Mutex >

spdlog::sinks::loki_api_sink< Mutex >::~loki_api_sink ( )

default

Destroys the loki_api_sink object.

Member Function Documentation

flush_()

template<typename Mutex >

void spdlog::sinks::loki_api_sink< Mutex >::flush_ ( )

overrideprotected

Flushes any buffered log messages.

This function is called by spdlog to flush any buffered log messages. It is overridden from the base_sink class.

Definition at line 81 of file Loki.cpp.

    {
        bool flag = false;
 
        // Prepare JSON
        std::ostringstream sStream;
 
        sStream << "{\"streams\":[";
        for (auto &entry : _internalLogBuffer)
        {
            if (entry.logs.empty())
            {
                continue;
            }
 
            if (flag)
            {
                sStream << ",";
            }
            flag = true;
            sStream << "{\"stream\":{" << _basicInformation + R"("level":")" << entry.level << R"("},"values":[)";
 
            bool subflag = false;
            for (const auto &subentry : entry.logs)
            {
                if (subflag)
                {
                    sStream << ",";
                }
                subflag = true;
                sStream << "[\"" << subentry.first << "\",\"" << subentry.second << "\"]";
            }
            sStream << "]}";
 
            entry.logs.clear();
        }
        sStream << "]}";
 
        if (flag)
        {
            // Send request
            std::string recvData;
            HttpStatus::Code replyCode = HttpStatus::Code::xxx_max;
            _connHandler->sendPOSTRequest("/loki/api/v1/push", sStream.str(), recvData, replyCode);
        }
    }

sink_it_()

template<typename Mutex >

void spdlog::sinks::loki_api_sink< Mutex >::sink_it_ ( const details::log_msg & msg )

overrideprotected

Sends the log message to the Loki server.

This function is called by spdlog to send the log message to the Loki server. It is overridden from the base_sink class.

Parameters

msg	The log message to be sent.

Definition at line 66 of file Loki.cpp.

    {
        if (!_lokiAvailable)
        {
            return;
        }
 
        if (msg.level >= spdlog::level::debug && msg.level <= spdlog::level::critical)
        {
            _internalLogBuffer[static_cast<size_t>(msg.level) - 1].logs.push_back(
                {std::to_string(msg.time.time_since_epoch().count()),
                 std::string(msg.payload.data(), msg.payload.size())});
        }
    }

Member Data Documentation

_basicInformation

template<typename Mutex >

std::string spdlog::sinks::loki_api_sink< Mutex >::_basicInformation

private

Definition at line 60 of file Loki.hpp.

_connHandler

template<typename Mutex >

std::unique_ptr<HTTP> spdlog::sinks::loki_api_sink< Mutex >::_connHandler

private

Definition at line 59 of file Loki.hpp.

_internalLogBuffer

template<typename Mutex >

std::vector<struct logInfo_t> spdlog::sinks::loki_api_sink< Mutex >::_internalLogBuffer

private

Definition at line 66 of file Loki.hpp.

_lokiAvailable

template<typename Mutex >

bool spdlog::sinks::loki_api_sink< Mutex >::_lokiAvailable {false}

private

Definition at line 58 of file Loki.hpp.

{false};

---

The documentation for this class was generated from the following files:

• /__w/Repo-Init/Repo-Init/include/logging/Loki.hpp
• /__w/Repo-Init/Repo-Init/src/logging/Loki.cpp