mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-06-11 14:33:04 +00:00
328 lines
9.4 KiB
C++
328 lines
9.4 KiB
C++
/**
|
|
* @file SentryWrapper.cpp
|
|
* @brief Sentry crash reporting wrapper implementation for cross-platform support.
|
|
*
|
|
* This implementation provides a unified API for Sentry integration.
|
|
* When SLIC3R_SENTRY is not defined, all functions become no-ops.
|
|
*/
|
|
|
|
#include "SentryWrapper.hpp"
|
|
|
|
#ifdef SLIC3R_SENTRY
|
|
#include "sentry.h"
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
#include <Windows.h>
|
|
#include <shlobj.h>
|
|
#endif
|
|
|
|
#ifdef __APPLE__
|
|
#include <unistd.h>
|
|
#include <mach-o/dyld.h>
|
|
#include <libgen.h>
|
|
#include <string.h>
|
|
#endif
|
|
|
|
#include <cstdlib>
|
|
#include <atomic>
|
|
#include <random>
|
|
#include "common_func/common_func.hpp"
|
|
|
|
namespace Slic3r {
|
|
|
|
#ifdef SLIC3R_SENTRY
|
|
|
|
#define SENTRY_EVENT_TRACE "trace"
|
|
#define SENTRY_EVENT_DEBUG "info"
|
|
#define SENTRY_EVENT_INFO "debug"
|
|
#define SENTRY_EVENT_WARNING "warning"
|
|
#define SENTRY_EVENT_ERROR "error"
|
|
#define SENTRY_EVENT_FATAL "fatal"
|
|
|
|
#define MACHINE_MODULE "Moonraker_Mqtt"
|
|
|
|
#define SENTRY_KEY_LEVEL "level"
|
|
|
|
|
|
|
|
static sentry_value_t on_crash_callback(const sentry_ucontext_t* uctx, sentry_value_t event, void* closure)
|
|
{
|
|
(void) uctx;
|
|
(void) closure;
|
|
|
|
// tell the backend to retain the event
|
|
return event;
|
|
}
|
|
|
|
static sentry_value_t before_send(sentry_value_t event, void* hint, void* data)
|
|
{
|
|
|
|
|
|
sentry_value_t level_val = sentry_value_get_by_key(event, SENTRY_KEY_LEVEL);
|
|
std::string levelName = sentry_value_as_string(level_val);
|
|
|
|
std::string eventLevel = sentry_value_as_string(sentry_value_get_by_key(event, SENTRY_KEY_LEVEL));
|
|
|
|
//module name
|
|
sentry_value_t moduleValue = sentry_value_get_by_key(event, "logger");
|
|
std::string moduleName = sentry_value_as_string(moduleValue);
|
|
|
|
if (MACHINE_MODULE == moduleName)
|
|
{
|
|
srand((unsigned int) time(0));
|
|
int random_num = rand() % 100;
|
|
int randNumber = rand() % 100 + 1;
|
|
if (randNumber < 85)
|
|
{
|
|
sentry_value_decref(event);
|
|
return sentry_value_new_null();
|
|
}
|
|
else
|
|
{
|
|
return event;
|
|
}
|
|
}
|
|
|
|
if (!get_privacy_policy() && levelName == SENTRY_EVENT_TRACE) {
|
|
|
|
sentry_value_decref(event);
|
|
return sentry_value_new_null();
|
|
}
|
|
|
|
if (SENTRY_EVENT_FATAL == eventLevel ||
|
|
SENTRY_EVENT_ERROR == eventLevel ||
|
|
SENTRY_EVENT_TRACE == eventLevel)
|
|
{
|
|
return event;
|
|
}
|
|
else if (SENTRY_EVENT_WARNING == eventLevel)
|
|
{
|
|
srand((unsigned int) time(0));
|
|
int random_num = rand() % 100;
|
|
int randNumber = rand() % 100 + 1;
|
|
if (randNumber > 5)
|
|
{
|
|
sentry_value_decref(event);
|
|
return sentry_value_new_null();
|
|
}
|
|
else
|
|
{
|
|
return event;
|
|
}
|
|
}
|
|
|
|
//info trace debug not report
|
|
sentry_value_decref(event);
|
|
return sentry_value_new_null();
|
|
|
|
}
|
|
|
|
void initSentryEx()
|
|
{
|
|
sentry_options_t* options = sentry_options_new();
|
|
std::string dsn = std::string("https://c74b617c2aedc291444d3a238d23e780@o4508125599563776.ingest.us.sentry.io/4510425163956224");
|
|
{
|
|
#ifdef __APPLE__
|
|
|
|
#elif _WIN32
|
|
|
|
#endif
|
|
sentry_options_set_dsn(options, dsn.c_str());
|
|
std::string handlerDir = "";
|
|
std::string dataBaseDir = "";
|
|
|
|
#ifdef __APPLE__
|
|
|
|
char exe_path[PATH_MAX] = {0};
|
|
uint32_t buf_size = PATH_MAX;
|
|
|
|
if (_NSGetExecutablePath(exe_path, &buf_size) != 0) {
|
|
throw std::runtime_error("Buffer too small for executable path");
|
|
}
|
|
|
|
// Get the directory containing the executable, not the executable path itself
|
|
// Use dirname() to get parent directory (need to copy string as dirname may modify it)
|
|
char exe_path_copy[PATH_MAX];
|
|
strncpy(exe_path_copy, exe_path, PATH_MAX);
|
|
char* exe_dir = dirname(exe_path_copy);
|
|
handlerDir = std::string(exe_dir) + "/crashpad_handler";
|
|
|
|
const char* home_env = getenv("HOME");
|
|
|
|
dataBaseDir = home_env;
|
|
dataBaseDir = dataBaseDir + "/Library/Application Support/Snapmaker_Orca/SentryData";
|
|
#elif _WIN32
|
|
wchar_t exeDir[MAX_PATH];
|
|
::GetModuleFileNameW(nullptr, exeDir, MAX_PATH);
|
|
std::wstring wsExeDir(exeDir);
|
|
int nPos = wsExeDir.find_last_of('\\');
|
|
std::wstring wsDmpDir = wsExeDir.substr(0, nPos + 1);
|
|
std::wstring desDir = wsDmpDir + L"crashpad_handler.exe";
|
|
wsDmpDir += L"dump";
|
|
|
|
auto wstringTostring = [](std::wstring wTmpStr) -> std::string {
|
|
std::string resStr = std::string();
|
|
int len = WideCharToMultiByte(CP_UTF8, 0, wTmpStr.c_str(), -1, nullptr, 0, nullptr, nullptr);
|
|
if (len <= 0)
|
|
return std::string();
|
|
|
|
std::string desStr(len, 0);
|
|
WideCharToMultiByte(CP_UTF8, 0, wTmpStr.c_str(), -1, &desStr[0], len, nullptr, nullptr);
|
|
resStr = desStr;
|
|
|
|
return resStr;
|
|
};
|
|
|
|
handlerDir = wstringTostring(desDir);
|
|
|
|
wchar_t appDataPath[MAX_PATH] = {0};
|
|
auto hr = SHGetFolderPathW(NULL, CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, appDataPath);
|
|
char* path = new char[MAX_PATH];
|
|
size_t pathLength;
|
|
wcstombs_s(&pathLength, path, MAX_PATH, appDataPath, MAX_PATH);
|
|
std::string filePath = path;
|
|
std::string appName = "\\" + std::string("Snapmaker_Orca\\");
|
|
dataBaseDir = filePath + appName;
|
|
#endif
|
|
|
|
if (!handlerDir.empty())
|
|
sentry_options_set_handler_path(options, handlerDir.c_str());
|
|
|
|
if (!dataBaseDir.empty())
|
|
sentry_options_set_database_path(options, dataBaseDir.c_str());
|
|
|
|
#if defined(_DEBUG) || !defined(NDEBUG)
|
|
sentry_options_set_debug(options, 1);
|
|
#else
|
|
sentry_options_set_debug(options, 0);
|
|
#endif
|
|
|
|
// sentry_options_set_environment(options, "develop");
|
|
sentry_options_set_environment(options, "Release");
|
|
|
|
sentry_options_set_auto_session_tracking(options, 0);
|
|
sentry_options_set_symbolize_stacktraces(options, 1);
|
|
sentry_options_set_on_crash(options, on_crash_callback, NULL);
|
|
sentry_options_set_before_send(options, before_send, NULL);
|
|
|
|
sentry_options_set_sample_rate(options, 1.0);
|
|
sentry_options_set_traces_sample_rate(options, 1.0);
|
|
|
|
sentry_init(options);
|
|
sentry_start_session();
|
|
|
|
sentry_set_tag("snapmaker_version", Snapmaker_VERSION);
|
|
|
|
std::string flutterVersion = common::get_flutter_version();
|
|
if (!flutterVersion.empty())
|
|
sentry_set_tag("flutter_version", flutterVersion.c_str());
|
|
|
|
std::string machineID = common::getMachineId();
|
|
if (!machineID.empty())
|
|
sentry_set_tag("machine_id", machineID.c_str());
|
|
|
|
std::string pcName = common::get_pc_name();
|
|
if (!pcName.empty())
|
|
sentry_set_tag("pc_name", pcName.c_str());
|
|
}
|
|
}
|
|
|
|
void exitSentryEx()
|
|
{
|
|
sentry_close();
|
|
}
|
|
void sentryReportLogEx(SENTRY_LOG_LEVEL logLevel,
|
|
const std::string& logContent,
|
|
const std::string& funcModule,
|
|
const std::string& logTagKey,
|
|
const std::string& logTagValue,
|
|
const std::string& logTraceId)
|
|
{
|
|
sentry_level_t sentry_msg_level;
|
|
switch (logLevel)
|
|
{
|
|
case SENTRY_LOG_TRACE:
|
|
sentry_msg_level = SENTRY_LEVEL_TRACE;
|
|
break;
|
|
case SENTRY_LOG_DEBUG:
|
|
sentry_msg_level = SENTRY_LEVEL_DEBUG;
|
|
break;
|
|
case SENTRY_LOG_INFO:
|
|
sentry_msg_level = SENTRY_LEVEL_INFO;
|
|
break;
|
|
case SENTRY_LOG_WARNING:
|
|
sentry_msg_level = SENTRY_LEVEL_WARNING;
|
|
break;
|
|
case SENTRY_LOG_ERROR:
|
|
sentry_msg_level = SENTRY_LEVEL_ERROR;
|
|
break;
|
|
case SENTRY_LOG_FATAL:
|
|
sentry_msg_level = SENTRY_LEVEL_FATAL;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
sentry_value_t event = sentry_value_new_message_event(sentry_msg_level,
|
|
funcModule.c_str(),
|
|
logContent.c_str()
|
|
);
|
|
|
|
sentry_value_t tags = sentry_value_new_object();
|
|
|
|
if (!logTraceId.empty())
|
|
sentry_value_set_by_key(tags, "snapmaker_trace_id", sentry_value_new_string(logTraceId.c_str()));
|
|
|
|
if (SENTRY_LEVEL_TRACE == sentry_msg_level)
|
|
sentry_value_set_by_key(tags, BURY_POINT, sentry_value_new_string("snapmaker_bury_point"));
|
|
|
|
if (!logTagKey.empty())
|
|
sentry_value_set_by_key(tags, logTagKey.c_str(), sentry_value_new_string(logTagValue.c_str()));
|
|
|
|
sentry_value_set_by_key(event, "snapmaker_tags", tags);
|
|
sentry_capture_event(event);
|
|
}
|
|
|
|
|
|
#else // SLIC3R_SENTRY not defined - provide no-op implementations
|
|
|
|
|
|
#endif // SLIC3R_SENTRY
|
|
|
|
void initSentry()
|
|
{
|
|
#ifdef SLIC3R_SENTRY
|
|
initSentryEx();
|
|
#endif
|
|
}
|
|
|
|
void exitSentry()
|
|
{
|
|
#ifdef SLIC3R_SENTRY
|
|
exitSentryEx();
|
|
#endif
|
|
}
|
|
void sentryReportLog(SENTRY_LOG_LEVEL logLevel,
|
|
const std::string& logContent,
|
|
const std::string& funcModule,
|
|
const std::string& logTagKey,
|
|
const std::string& logTagValue,
|
|
const std::string& logTraceId)
|
|
{
|
|
#ifdef SLIC3R_SENTRY
|
|
sentryReportLogEx(logLevel, logContent, funcModule, logTagKey, logTagValue, logTraceId);
|
|
#endif
|
|
}
|
|
|
|
void set_sentry_tags(const std::string& tag_key, const std::string& tag_value)
|
|
{
|
|
#ifdef SLIC3R_SENTRY
|
|
if (!tag_key.empty())
|
|
sentry_set_tag(tag_key.c_str(), tag_value.c_str());
|
|
#endif
|
|
}
|
|
|
|
} // namespace Slic3r
|
|
|