Tracer Class Reference

#include <Tracer.hpp>

Public Member Functions
	Tracer (std::shared_ptr< std::atomic_flag > checkFlag, std::string serverPath="", std::string serverProxy="", const std::string &crashpadHandlerPath="", const std::string &reportPath="", std::vector< base::FilePath > attachments={})
	Tracer (const Tracer &)=delete
	Copy constructor.
	Tracer (Tracer &&)=delete
	Move constructor.
Tracer &	operator= (Tracer)=delete
	Copy assignment operator.
Tracer &	operator= (Tracer &&)=delete
	Move assignment operator.
	~Tracer ()

Static Public Member Functions
static bool	isRunning ()

Private Member Functions
void	startHandler ()
void	threadFunc () const noexcept

Static Private Member Functions
static bool	checkPidIsRunning (pid_t processId)
static bool	checkSocketIsRunning (int sockId)
static std::string	getSelfExecutableDir ()
static void	dumpSharedLibraryInfo (const std::string &filePath)

Private Attributes
std::unique_ptr< std::thread >	_thread
std::atomic_flag	_shouldStop {false}
std::shared_ptr< std::atomic_flag >	_checkFlag
std::string	_serverPath
std::string	_serverProxy
std::string	_handlerPath
std::map< std::string, std::string >	_annotations
std::vector< base::FilePath >	_attachments
std::string	_reportPath
std::unique_ptr< crashpad::CrashpadClient >	_clientHandler

Detailed Description

Tracer class to handle operations of Crashpad

Definition at line 10 of file Tracer.hpp.

Constructor & Destructor Documentation

Tracer() [1/3]

Tracer::Tracer ( std::shared_ptr< std::atomic_flag > checkFlag, std::string serverPath = "", std::string serverProxy = "", const std::string & crashpadHandlerPath = "", const std::string & reportPath = "", std::vector< base::FilePath > attachments = {} )

explicit

Construct a new Tracer object

Parameters

[in]	checkFlag	Flag to check if the process is running
[in]	serverPath	Remote server address
[in]	serverProxy	Remote server proxy
[in]	reportPath	Path to where dump minidump files
[in]	crashpadHandlerPath	Path to crashpad_handler executable
[in]	attachments	Attachments to add to the minidump

Definition at line 163 of file Tracer.cpp.

    : _checkFlag(std::move(checkFlag)), _serverPath(std::move(serverPath)), _serverProxy(std::move(serverProxy)),
      _attachments(std::move(attachments))
{
    auto selfDir = getSelfExecutableDir();
 
    _handlerPath = crashpadHandlerPath.empty() ? selfDir + "/crashpad_handler" : crashpadHandlerPath;
    _reportPath = reportPath.empty() ? selfDir : reportPath;
    _clientHandler = std::make_unique<crashpad::CrashpadClient>();
 
    _annotations = std::map<std::string, std::string>(
        {{"name", PROJECT_NAME},
         {"version", PROJECT_FULL_REVISION},
         {"build_info", PROJECT_BUILD_DATE + std::string(" ") + PROJECT_BUILD_TIME + std::string(" ") + BUILD_TYPE},
         {"compiler_info", COMPILER_NAME + std::string(" ") + COMPILER_VERSION}});
 
    // Dump shared library information and add as attachment
    dumpSharedLibraryInfo(_reportPath + "/shared_libs.txt");
    _attachments.emplace_back(_reportPath + "/shared_libs.txt");
 
    startHandler();
}

Here is the call graph for this function:

Tracer() [2/3]

Tracer::Tracer ( const Tracer & )

delete

Copy constructor.

Tracer() [3/3]

Tracer::Tracer ( Tracer && )

delete

Move constructor.

~Tracer()

Tracer::~Tracer

(

)

Destroy the Tracer object

Definition at line 188 of file Tracer.cpp.

{
    _shouldStop._M_i = true;
    if (_thread && _thread->joinable())
    {
        _thread->join();
    }
}

Member Function Documentation

checkPidIsRunning()

bool Tracer::checkPidIsRunning ( pid_t processId )

staticprivate

Check if the given process ID is running

Parameters

[in]

processId

The process ID to check

Returns

true if the process is running, false otherwise

Definition at line 80 of file Tracer.cpp.

{ return kill(processId, 0) == 0; }

Here is the caller graph for this function:

checkSocketIsRunning()

bool Tracer::checkSocketIsRunning ( int sockId )

staticprivate

Check if the given socket ID is running

Parameters

[in]

sockId

The socket ID to check

Returns

true if the socket is running, false otherwise

Definition at line 82 of file Tracer.cpp.

{
    int error = 0;
    socklen_t len = sizeof(error);
 
    char buff = 0;
    const int result = getsockopt(sockId, SOL_SOCKET, SO_ERROR, &error, &len);
    return result == 0 && error == 0 && recv(sockId, &buff, 1, MSG_PEEK | MSG_DONTWAIT) != 0;
}

Here is the caller graph for this function:

dumpSharedLibraryInfo()

void Tracer::dumpSharedLibraryInfo ( const std::string & filePath )

staticprivate

Dump shared library information to a file

Parameters

[in]

filePath

File path to dump the information

Definition at line 123 of file Tracer.cpp.

{
    // Open the output file
    std::ofstream ofile(filePath);
    if (!ofile.is_open())
    {
        throw std::invalid_argument("Can't open file: " + filePath);
    }
 
    // Get the shared library information
    std::ifstream maps("/proc/self/maps");
 
    std::string line;
    while (std::getline(maps, line))
    {
        // The format of each line is: address perms offset dev inode pathname
        // We only care about the address and the pathname, which are the first and last fields
        std::istringstream iss(line);
        std::string address;
        std::string perms;
        std::string offset;
        std::string dev;
        std::string inode;
        std::string pathname;
        iss >> address >> perms >> offset >> dev >> inode >> pathname;
 
        // We only want the shared libraries, which have the .so extension and the read and execute permissions
        if (pathname.find(".so") != std::string::npos && perms.find("r-x") != std::string::npos)
        {
            // The address field is in the form of start-end, we only need the start address
            const std::string start = address.substr(0, address.find('-'));
 
            // Convert the start address from hexadecimal string to unsigned long
            const unsigned long addr = std::stoul(start, nullptr, 16);
 
            ofile << pathname << " " << addr << '\n';
        }
    }
}

Here is the caller graph for this function:

getSelfExecutableDir()

std::string Tracer::getSelfExecutableDir ( )

inlinestaticprivate

Get the executable directory of the current application

Returns

The executable directory path

Definition at line 92 of file Tracer.cpp.

{
    std::array<char, FILENAME_MAX> pathBuffer{'\0'};
    auto bytes = readlink("/proc/self/exe", pathBuffer.data(), sizeof(pathBuffer));
 
    auto path = std::string(pathBuffer.data(), bytes == -1 ? 0 : static_cast<size_t>(bytes));
    auto lastDelimPos = path.find_last_of('/');
    return (lastDelimPos == std::string::npos) ? "" : path.substr(0, lastDelimPos);
}

Here is the caller graph for this function:

isRunning()

bool Tracer::isRunning ( )

staticnodiscard

Check if the crashpad_handler process is running

Returns

true if the crashpad_handler is running, false otherwise

Definition at line 102 of file Tracer.cpp.

{
    int sockId{-1};
    pid_t processId{-1};
 
    if (!crashpad::CrashpadClient::GetHandlerSocket(&sockId, &processId))
    {
        return false;
    }
 
    if (sockId >= 0 && !checkSocketIsRunning(sockId))
    {
        return false;
    }
    if (processId > 0 && !checkPidIsRunning(processId))
    {
        return false;
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

Tracer & Tracer::operator= ( Tracer && )

delete

Move assignment operator.

operator=() [2/2]

Tracer & Tracer::operator= ( Tracer )

delete

Copy assignment operator.

startHandler()

void Tracer::startHandler ( )

private

Start the crashpad handler process

Definition at line 22 of file Tracer.cpp.

{
    // Path to crashpad executable
    const base::FilePath handler(_handlerPath);
 
    // Must be writable or crashpad_handler will crash
    const base::FilePath reportsDir(_reportPath);
    const base::FilePath metricsDir(_reportPath);
 
    // Initialize Crashpad database
    auto database = crashpad::CrashReportDatabase::Initialize(reportsDir);
    if (database == nullptr)
    {
        throw std::ios_base::failure("Can't initialize crash report database");
    }
 
    // Enable automated crash uploads
    auto *settings = database->GetSettings();
    if (settings == nullptr)
    {
        throw std::ios_base::failure("Can't get crash report database settings");
    }
    settings->SetUploadsEnabled(true);
 
    // Start crash handler
    if (!_clientHandler->StartHandler(handler, reportsDir, metricsDir, _serverPath, _serverProxy, _annotations,
                                      {"--no-rate-limit"}, true, false, _attachments))
    {
        throw std::ios_base::failure("Can't start crash handler");
    }
 
    _thread = std::make_unique<std::thread>(&Tracer::threadFunc, this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

threadFunc()

void Tracer::threadFunc ( ) const

privatenoexcept

Thread function to check and restart the crashpad handler process

Definition at line 56 of file Tracer.cpp.

{
    while (!_shouldStop._M_i)
    {
        try
        {
            if (!isRunning())
            {
                spdlog::info("Crashpad handler closed");
                return;
            }
            if (_checkFlag)
            {
                _checkFlag->test_and_set();
            }
        }
        catch (const std::exception &e)
        {
            spdlog::error("Crashpad failed: {}", e.what());
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_INTERVAL_MS));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_annotations

std::map<std::string, std::string> Tracer::_annotations

private

Definition at line 19 of file Tracer.hpp.

_attachments

std::vector<base::FilePath> Tracer::_attachments

private

Definition at line 20 of file Tracer.hpp.

_checkFlag

std::shared_ptr<std::atomic_flag> Tracer::_checkFlag

private

Definition at line 14 of file Tracer.hpp.

_clientHandler

std::unique_ptr<crashpad::CrashpadClient> Tracer::_clientHandler

private

Definition at line 22 of file Tracer.hpp.

_handlerPath

std::string Tracer::_handlerPath

private

Definition at line 18 of file Tracer.hpp.

_reportPath

std::string Tracer::_reportPath

private

Definition at line 21 of file Tracer.hpp.

_serverPath

std::string Tracer::_serverPath

private

Definition at line 16 of file Tracer.hpp.

_serverProxy

std::string Tracer::_serverProxy

private

Definition at line 17 of file Tracer.hpp.

_shouldStop

std::atomic_flag Tracer::_shouldStop {false}

private

Definition at line 13 of file Tracer.hpp.

{false};

_thread

std::unique_ptr<std::thread> Tracer::_thread

private

Definition at line 12 of file Tracer.hpp.

---

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

• /__w/Repo-Init/Repo-Init/include/utils/Tracer.hpp
• /__w/Repo-Init/Repo-Init/src/utils/Tracer.cpp