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

80{ 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.

◆ restart()

void Tracer::restart ( )

Check and restart the crashpad_handler process if it is not running

◆ 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.

13{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

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Tracer() [1/3]

◆ Tracer() [2/3]

◆ Tracer() [3/3]

◆ ~Tracer()

Member Function Documentation

◆ checkPidIsRunning()

◆ checkSocketIsRunning()

◆ dumpSharedLibraryInfo()

◆ getSelfExecutableDir()

◆ isRunning()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ restart()

◆ startHandler()

◆ threadFunc()

Member Data Documentation

◆ _annotations

◆ _attachments

◆ _checkFlag

◆ _clientHandler

◆ _handlerPath

◆ _reportPath

◆ _serverPath

◆ _serverProxy

◆ _shouldStop

◆ _thread