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 ()
void	restart ()

Static Public Member Functions
static bool	isRunning ()

Private Member Functions
void	startHandler ()
void	threadFunc () 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 173 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 198 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 82 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 84 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 133 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 94 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 104 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.

restart()

void Tracer::restart

(

)

Check and restart the crashpad_handler process if it is not running

Definition at line 125 of file Tracer.cpp.

{
    if (!isRunning())
    {
        startHandler();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

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 ( )

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())
            {
                // NOTICE: Worked before but currently restarting the handler raises an error
                // due to changes in the crashpad library
                restart();
                spdlog::warn("Crashpad handler restarted");
            }
            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