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

#include <Sentry.hpp>

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

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

Public Member Functions
	sentry_api_sink (const std::string &sentryAddress)
	~sentry_api_sink ()

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

Private Attributes
bool	_sentryAvailable {false}

Detailed Description

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

A sink for sending log messages to a Sentry server.

This sink is used to send log messages to a Sentry server for error tracking and monitoring. It provides an interface for sending log messages and flushing the sink.

Template Parameters

Mutex

The type of mutex to use for thread safety.

Definition at line 20 of file Sentry.hpp.

Constructor & Destructor Documentation

sentry_api_sink()

template<typename Mutex >

spdlog::sinks::sentry_api_sink< Mutex >::sentry_api_sink ( const std::string & sentryAddress )

explicit

Constructs a Sentry API sink with the specified Sentry server address.

Parameters

sentryAddress

The address of the Sentry server.

Definition at line 22 of file Sentry.cpp.

    {
        if (sentryAddress.empty())
        {
            return;
        }
        _sentryAvailable = true;
 
        // Set options
        sentry_options_t *sentryOptions = sentry_options_new();
        sentry_options_set_release(sentryOptions, PROJECT_FULL_REVISION);
        sentry_options_set_dsn(sentryOptions, sentryAddress.c_str());
 
        // Init
        sentry_init(sentryOptions);
 
        // Tags
        sentry_set_tag("compiler.name", COMPILER_NAME);
        sentry_set_tag("compiler.version", COMPILER_VERSION);
        sentry_set_tag("build", BUILD_TYPE);
 
        // Context: Version
        std::string versionBuffer;
        const sentry_value_t versionContext = sentry_value_new_object();
        versionBuffer = "v" + std::string(PROJECT_FULL_REVISION);
        sentry_value_set_by_key(versionContext, PROJECT_NAME, sentry_value_new_string(versionBuffer.c_str()));
        versionBuffer = std::string(PROJECT_BUILD_DATE) + " " + PROJECT_BUILD_TIME;
        sentry_value_set_by_key(versionContext, "Release Date", sentry_value_new_string(versionBuffer.c_str()));
        /* ################################################################################### */
        /* ############################# MAKE MODIFICATIONS HERE ############################# */
        /* ################################################################################### */
 
        /* ################################################################################### */
        /* ################################ END MODIFICATIONS ################################ */
        /* ################################################################################### */
 
        sentry_set_context("Version", versionContext);
 
        // Context: Host
        std::array<char, BUFSIZ> hostBuffer{};
        gethostname(hostBuffer.data(), BUFSIZ);
        const sentry_value_t hostContext = sentry_value_new_object();
        sentry_value_set_by_key(hostContext, "Hostname", sentry_value_new_string(hostBuffer.data()));
 
        // Parse CPU information
        const std::string cpuInfoPath = "/proc/cpuinfo";
        std::string word;
 
        findFromFile(cpuInfoPath, "^siblings", word);
        sentry_value_set_by_key(hostContext, "Thread count", sentry_value_new_string(word.c_str()));
        findFromFile(cpuInfoPath, "^(cpu cores)", word);
        sentry_value_set_by_key(hostContext, "Core count", sentry_value_new_string(word.c_str()));
        findFromFile(cpuInfoPath, "^(model name)", word);
        sentry_value_set_by_key(hostContext, "Model", sentry_value_new_string(word.c_str()));
        findFromFile(cpuInfoPath, "^vendor_id", word);
        sentry_value_set_by_key(hostContext, "Vendor ID", sentry_value_new_string(word.c_str()));
 
        sentry_set_context("Host", hostContext);
 
        // Context: Network
        const sentry_value_t networkContext = sentry_value_new_object();
 
        if (ifaddrs *ifaddr = nullptr; getifaddrs(&ifaddr) != -1)
        {
            // Iterate interfaces
            for (ifaddrs *ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next)
            {
                if (ifa->ifa_addr == nullptr)
                {
                    continue;
                }
 
                switch (ifa->ifa_addr->sa_family)
                {
                case AF_INET:
                    if (((ifa->ifa_flags & IFF_PROMISC) != 0) || ((ifa->ifa_flags & IFF_UP) != 0))
                    {
                        std::array<char, INET_ADDRSTRLEN> host{};
                        inet_ntop(AF_INET, &(reinterpret_cast<sockaddr_in *>(ifa->ifa_addr))->sin_addr, host.data(),
                                  INET_ADDRSTRLEN);
                        sentry_value_set_by_key(networkContext, (std::string(ifa->ifa_name) + ".ipv4").c_str(),
                                                sentry_value_new_string(host.data()));
                    }
                    break;
                case AF_INET6:
                    if (((ifa->ifa_flags & IFF_PROMISC) != 0) || ((ifa->ifa_flags & IFF_UP) != 0))
                    {
                        std::array<char, INET6_ADDRSTRLEN> host{};
                        inet_ntop(AF_INET6, &(reinterpret_cast<sockaddr_in6 *>(ifa->ifa_addr))->sin6_addr, host.data(),
                                  INET6_ADDRSTRLEN);
                        sentry_value_set_by_key(networkContext, (std::string(ifa->ifa_name) + ".ipv6").c_str(),
                                                sentry_value_new_string(host.data()));
                    }
                    break;
                case AF_PACKET:
                    if (((ifa->ifa_flags & IFF_PROMISC) != 0) || ((ifa->ifa_flags & IFF_UP) != 0))
                    {
                        std::array<char, MAC_LEN> host{};
                        const auto *sock = reinterpret_cast<sockaddr_ll *>(ifa->ifa_addr);
                        if (snprintf(host.data(), MAC_LEN, "%02x:%02x:%02x:%02x:%02x:%02x", sock->sll_addr[0],
                                     sock->sll_addr[1], sock->sll_addr[2], sock->sll_addr[3], sock->sll_addr[4],
                                     sock->sll_addr[5]) > 0)
                        {
                            sentry_value_set_by_key(networkContext, (std::string(ifa->ifa_name) + ".mac").c_str(),
                                                    sentry_value_new_string(host.data()));
                        }
                    }
                    break;
                default:
                    break;
                }
            }
            freeifaddrs(ifaddr);
        }
        sentry_set_context("Network", networkContext);
    }

Here is the call graph for this function:

~sentry_api_sink()

template<typename Mutex >

spdlog::sinks::sentry_api_sink< Mutex >::~sentry_api_sink

(

)

Destroys the Sentry API sink.

Definition at line 139 of file Sentry.cpp.

{ sentry_close(); }

Member Function Documentation

flush_()

template<typename Mutex >

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

overrideprotected

Flushes the sink.

This function is called to flush any buffered log messages to the Sentry server.

Definition at line 171 of file Sentry.cpp.

{}

sink_it_()

template<typename Mutex >

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

overrideprotected

Sends the log message to the Sentry server.

This function is called for each log message that needs to be sent to the Sentry server.

Parameters

msg	The log message to be sent.

Definition at line 141 of file Sentry.cpp.

    {
        if (!_sentryAvailable)
        {
            return;
        }
        switch (msg.level)
        {
        case spdlog::level::warn:
            sentry_capture_event(sentry_value_new_message_event(
                SENTRY_LEVEL_WARNING, "main", std::string(msg.payload.data(), msg.payload.size()).c_str()));
            break;
        case spdlog::level::err:
            sentry_capture_event(sentry_value_new_message_event(
                SENTRY_LEVEL_ERROR, "main", std::string(msg.payload.data(), msg.payload.size()).c_str()));
            break;
        case spdlog::level::critical:
            sentry_capture_event(sentry_value_new_message_event(
                SENTRY_LEVEL_FATAL, "main", std::string(msg.payload.data(), msg.payload.size()).c_str()));
            break;
        case spdlog::level::trace:
        case spdlog::level::debug:
        case spdlog::level::info:
        case spdlog::level::off:
            // For lower levels, do nothing for now. But you can easily handle them here.
        default:
            break;
        }
    }

Member Data Documentation

_sentryAvailable

template<typename Mutex >

bool spdlog::sinks::sentry_api_sink< Mutex >::_sentryAvailable {false}

private

Flag indicating if the Sentry server is available.

Definition at line 52 of file Sentry.hpp.

{false}; 

---

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

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