juli/OrcaSlicer
1
1
Fork 0
mirror of https://github.com/OrcaSlicer/OrcaSlicer.git synced 2026-07-27 04:42:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

feature add sentry for catch crash on win (#50)

Browse Source 
* feature add sentry for soft catch dmp

* feature add cli upload pdb to sentry server

* feature add flag for control sentry to use

* fix  flag not effect on src/makefile

* feature unzip for dmp file to upload sentry server

* feature remove test code

* feature add api for function report log to server

* feature update the soft version
This commit is contained in:
Alves
2025-12-05 09:19:32 +08:00
committed by GitHub
parent b28f1f2de4
commit b0b7890c9e
17 changed files with 599 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/CMakeLists.txt
View File

@@ -115,7 +115,7 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/dev-utils/platform/msw/Snapmaker_Orca
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/dev-utils/platform/msw/Snapmaker_Orca.manifest.in ${CMAKE_CURRENT_BINARY_DIR}/Snapmaker_Orca.manifest @ONLY)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/dev-utils/platform/osx/Info.plist.in ${CMAKE_CURRENT_BINARY_DIR}/Info.plist @ONLY)
if (WIN32)
add_library(Snapmaker_Orca SHARED Snapmaker_Orca.cpp Snapmaker_Orca.hpp dev-utils/BaseException.cpp dev-utils/BaseException.h dev-utils/StackWalker.cpp dev-utils/StackWalker.h)
add_library(Snapmaker_Orca SHARED Snapmaker_Orca.cpp Snapmaker_Orca.hpp dev-utils/BaseException.cpp dev-utils/BaseException.h dev-utils/StackWalker.cpp dev-utils/StackWalker.h sentry_wrapper/SentryWrapper.hpp sentry_wrapper/SentryWrapper.cpp)
else ()
add_executable(Snapmaker_Orca Snapmaker_Orca.cpp Snapmaker_Orca.hpp)
endif ()
@@ -168,6 +168,12 @@ target_link_libraries(Snapmaker_Orca libslic3r_gui)
#endif ()
endif ()
# Sentry crash reporting integration
if (SLIC3R_SENTRY)
target_compile_definitions(Snapmaker_Orca PUBLIC SLIC3R_SENTRY)
target_link_libraries(Snapmaker_Orca sentry::sentry)
endif()
# On Windows, a shim application is required to produce a console / non console version of the Slic3r application.
# Also the shim may load the Mesa software OpenGL renderer if the default renderer does not support OpenGL 2.0 and higher.
if (WIN32)
@@ -175,7 +181,7 @@ if (WIN32)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -municode")
endif()
add_executable(Snapmaker_Orca_app_gui WIN32 Snapmaker_Orca_app_msvc.cpp ${CMAKE_CURRENT_BINARY_DIR}/Snapmaker_Orca.rc)
add_executable(Snapmaker_Orca_app_gui WIN32 Snapmaker_Orca_app_msvc.cpp sentry_wrapper/SentryWrapper.cpp ${CMAKE_CURRENT_BINARY_DIR}/Snapmaker_Orca.rc)
# Generate debug symbols even in release mode.
if(MSVC)
target_link_options(Snapmaker_Orca_app_gui PUBLIC "$<$<CONFIG:RELEASE>:/DEBUG>")
@@ -183,7 +189,14 @@ if (WIN32)
target_compile_definitions(Snapmaker_Orca_app_gui PRIVATE -DSLIC3R_WRAPPER_NOCONSOLE)
add_dependencies(Snapmaker_Orca_app_gui Snapmaker_Orca)
set_target_properties(Snapmaker_Orca_app_gui PROPERTIES OUTPUT_NAME "snapmaker-orca")
target_link_libraries(Snapmaker_Orca_app_gui PRIVATE boost_headeronly)
if (SLIC3R_SENTRY)
target_link_libraries(Snapmaker_Orca_app_gui PRIVATE boost_headeronly sentry::sentry)
else()
target_link_libraries(Snapmaker_Orca_app_gui PRIVATE boost_headeronly)
endif()
if (SLIC3R_SENTRY)
target_compile_definitions(Snapmaker_Orca_app_gui PRIVATE SLIC3R_SENTRY)
endif()
endif ()
# Link the resources dir to where Slic3r GUI expects it

64
src/Snapmaker_Orca.cpp
View File

@@ -6268,63 +6268,6 @@ std::string CLI::output_filepath(const ModelObject &object, unsigned int index,
}
//BBS: dump stack debug codes, don't delete currently
//#include <dbghelp.h>
//#pragma comment(lib, "version.lib")
//#pragma comment( lib, "dbghelp.lib" )
/*DWORD main_thread_id;
std::string TraceStack()
{
static const int MAX_STACK_FRAMES = 16;
void* pStack[MAX_STACK_FRAMES];
HANDLE process = GetCurrentProcess();
SymInitialize(process, NULL, TRUE);
WORD frames = CaptureStackBackTrace(0, MAX_STACK_FRAMES, pStack, NULL);
std::ostringstream oss;
oss << "stack traceback: frames="<< frames << std::endl;
for (WORD i = 0; i < frames; ++i) {
DWORD64 address = (DWORD64)(pStack[i]);
DWORD64 displacementSym = 0;
char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)];
PSYMBOL_INFO pSymbol = (PSYMBOL_INFO)buffer;
pSymbol->SizeOfStruct = sizeof(SYMBOL_INFO);
pSymbol->MaxNameLen = MAX_SYM_NAME;
DWORD displacementLine = 0;
IMAGEHLP_LINE64 line;
//SymSetOptions(SYMOPT_LOAD_LINES);
line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
if (SymFromAddr(process, address, &displacementSym, pSymbol)
&& SymGetLineFromAddr64(process, address, &displacementLine, &line)) {
oss << "\t" << pSymbol->Name << " at " << line.FileName << ":" << line.LineNumber << "(0x" << std::hex << pSymbol->Address << std::dec << ")" << std::endl;
}
else {
oss << "\terror: " << GetLastError() << std::endl;
}
}
return oss.str();
}
LONG WINAPI VectoredExceptionHandler(PEXCEPTION_POINTERS pExceptionInfo)
{
std::ofstream f;
DWORD cur_thread_id = GetCurrentThreadId();
f.open("VectoredExceptionHandler.txt", std::ios::out | std::ios::app);
f << "main thread id="<<main_thread_id<<", current thread_id="<< cur_thread_id << std::endl;
f << std::hex << pExceptionInfo->ExceptionRecord->ExceptionCode << std::endl;
f << TraceStack();
f.flush();
f.close();
return EXCEPTION_CONTINUE_SEARCH;
}*/
#if defined(_MSC_VER) || defined(__MINGW32__)
extern "C" {
__declspec(dllexport) int __stdcall Snapmaker_Orca_main(int argc, wchar_t **argv)
@@ -6337,13 +6280,6 @@ extern "C" {
for (size_t i = 0; i < argc; ++ i)
argv_ptrs[i] = argv_narrow[i].data();
//BBS: register default exception handler
#if BBL_RELEASE_TO_PUBLIC
SET_DEFULTER_HANDLER();
#else
//AddVectoredExceptionHandler(1, CBaseException::UnhandledExceptionFilter);
SET_DEFULTER_HANDLER();
#endif
std::set_new_handler([]() {
int *a = nullptr;
*a = 0;

172
src/Snapmaker_Orca_app_msvc.cpp
View File

@@ -6,16 +6,15 @@
#include <Windows.h>
#include <shellapi.h>
#include <wchar.h>
#include <shlobj.h>
#include "sentry_wrapper/SentryWrapper.hpp"
#ifdef SLIC3R_GUI
extern "C"
{
// Let the NVIDIA and AMD know we want to use their graphics card
// on a dual graphics card system.
__declspec(dllexport) DWORD NvOptimusEnablement = 0x00000000;
__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 0;
extern "C" {
// Let the NVIDIA and AMD know we want to use their graphics card
// on a dual graphics card system.
__declspec(dllexport) DWORD NvOptimusEnablement = 0x00000000;
__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 0;
}
#endif /* SLIC3R_GUI */
@@ -23,7 +22,7 @@ extern "C"
#include <stdio.h>
#ifdef SLIC3R_GUI
#include <GL/GL.h>
#include <GL/GL.h>
#endif /* SLIC3R_GUI */
#include <string>
@@ -31,9 +30,11 @@ extern "C"
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <boost/asio/ip/host_name.hpp>
#include <stdio.h>
using namespace Slic3r;
#ifdef SLIC3R_GUI
class OpenGLVersionCheck
{
@@ -43,23 +44,24 @@ public:
std::string vendor;
std::string renderer;
HINSTANCE hOpenGL = nullptr;
bool success = false;
HINSTANCE hOpenGL = nullptr;
bool success = false;
bool load_opengl_dll()
{
MSG msg = {0};
WNDCLASS wc = {0};
wc.lpfnWndProc = OpenGLVersionCheck::supports_opengl2_wndproc;
wc.hInstance = (HINSTANCE)GetModuleHandle(nullptr);
wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND);
wc.hInstance = (HINSTANCE) GetModuleHandle(nullptr);
wc.hbrBackground = (HBRUSH) (COLOR_BACKGROUND);
wc.lpszClassName = L"Snapmaker_Orca_opengl_version_check";
wc.style = CS_OWNDC;
wc.style = CS_OWNDC;
if (RegisterClass(&wc)) {
HWND hwnd = CreateWindowW(wc.lpszClassName, L"Snapmaker_Orca_opengl_version_check", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, wc.hInstance, (LPVOID)this);
HWND hwnd = CreateWindowW(wc.lpszClassName, L"Snapmaker_Orca_opengl_version_check", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0,
wc.hInstance, (LPVOID) this);
if (hwnd) {
message_pump_exit = false;
while (GetMessage(&msg, NULL, 0, 0 ) > 0 && ! message_pump_exit)
while (GetMessage(&msg, NULL, 0, 0) > 0 && !message_pump_exit)
DispatchMessage(&msg);
}
}
@@ -115,40 +117,47 @@ protected:
return;
}
typedef HGLRC (WINAPI *Func_wglCreateContext)(HDC);
typedef BOOL (WINAPI *Func_wglMakeCurrent )(HDC, HGLRC);
typedef BOOL (WINAPI *Func_wglDeleteContext)(HGLRC);
typedef GLubyte* (WINAPI *Func_glGetString )(GLenum);
typedef HGLRC(WINAPI * Func_wglCreateContext)(HDC);
typedef BOOL(WINAPI * Func_wglMakeCurrent)(HDC, HGLRC);
typedef BOOL(WINAPI * Func_wglDeleteContext)(HGLRC);
typedef GLubyte*(WINAPI * Func_glGetString)(GLenum);
Func_wglCreateContext wglCreateContext = (Func_wglCreateContext)GetProcAddress(hOpenGL, "wglCreateContext");
Func_wglMakeCurrent wglMakeCurrent = (Func_wglMakeCurrent) GetProcAddress(hOpenGL, "wglMakeCurrent");
Func_wglDeleteContext wglDeleteContext = (Func_wglDeleteContext)GetProcAddress(hOpenGL, "wglDeleteContext");
Func_glGetString glGetString = (Func_glGetString) GetProcAddress(hOpenGL, "glGetString");
Func_wglCreateContext wglCreateContext = (Func_wglCreateContext) GetProcAddress(hOpenGL, "wglCreateContext");
Func_wglMakeCurrent wglMakeCurrent = (Func_wglMakeCurrent) GetProcAddress(hOpenGL, "wglMakeCurrent");
Func_wglDeleteContext wglDeleteContext = (Func_wglDeleteContext) GetProcAddress(hOpenGL, "wglDeleteContext");
Func_glGetString glGetString = (Func_glGetString) GetProcAddress(hOpenGL, "glGetString");
if (wglCreateContext == nullptr || wglMakeCurrent == nullptr || wglDeleteContext == nullptr || glGetString == nullptr) {
printf("Failed loading the system opengl32.dll: The library is invalid.\n");
return;
}
PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA, // The kind of framebuffer. RGBA or palette.
32, // Color depth of the framebuffer.
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
24, // Number of bits for the depthbuffer
8, // Number of bits for the stencilbuffer
0, // Number of Aux buffers in the framebuffer.
PFD_MAIN_PLANE,
0,
0, 0, 0
};
PIXELFORMATDESCRIPTOR pfd = {sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA, // The kind of framebuffer. RGBA or palette.
32, // Color depth of the framebuffer.
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
24, // Number of bits for the depthbuffer
8, // Number of bits for the stencilbuffer
0, // Number of Aux buffers in the framebuffer.
PFD_MAIN_PLANE,
0,
0,
0,
0};
HDC ourWindowHandleToDeviceContext = ::GetDC(hWnd);
// Gdi32.dll
@@ -159,17 +168,17 @@ protected:
HGLRC glcontext = wglCreateContext(ourWindowHandleToDeviceContext);
wglMakeCurrent(ourWindowHandleToDeviceContext, glcontext);
// Opengl32.dll
const char *data = (const char*)glGetString(GL_VERSION);
const char* data = (const char*) glGetString(GL_VERSION);
if (data != nullptr)
this->version = data;
// printf("check -version: %s\n", version.c_str());
data = (const char*)glGetString(0x8B8C); // GL_SHADING_LANGUAGE_VERSION
data = (const char*) glGetString(0x8B8C); // GL_SHADING_LANGUAGE_VERSION
if (data != nullptr)
this->glsl_version = data;
data = (const char*)glGetString(GL_VENDOR);
data = (const char*) glGetString(GL_VENDOR);
if (data != nullptr)
this->vendor = data;
data = (const char*)glGetString(GL_RENDERER);
data = (const char*) glGetString(GL_RENDERER);
if (data != nullptr)
this->renderer = data;
// Opengl32.dll
@@ -180,21 +189,16 @@ protected:
static LRESULT CALLBACK supports_opengl2_wndproc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch(message)
{
case WM_CREATE:
{
CREATESTRUCT *pCreate = reinterpret_cast<CREATESTRUCT*>(lParam);
OpenGLVersionCheck *ogl_data = reinterpret_cast<OpenGLVersionCheck*>(pCreate->lpCreateParams);
switch (message) {
case WM_CREATE: {
CREATESTRUCT* pCreate = reinterpret_cast<CREATESTRUCT*>(lParam);
OpenGLVersionCheck* ogl_data = reinterpret_cast<OpenGLVersionCheck*>(pCreate->lpCreateParams);
ogl_data->check(hWnd);
DestroyWindow(hWnd);
return 0;
}
case WM_NCDESTROY:
message_pump_exit = true;
return 0;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
case WM_NCDESTROY: message_pump_exit = true; return 0;
default: return DefWindowProc(hWnd, message, wParam, lParam);
}
}
};
@@ -203,18 +207,18 @@ bool OpenGLVersionCheck::message_pump_exit = false;
#endif /* SLIC3R_GUI */
extern "C" {
typedef int (__stdcall *Slic3rMainFunc)(int argc, wchar_t **argv);
Slic3rMainFunc Snapmaker_Orca_main = nullptr;
typedef int(__stdcall* Slic3rMainFunc)(int argc, wchar_t** argv);
Slic3rMainFunc Snapmaker_Orca_main = nullptr;
}
extern "C" {
#ifdef SLIC3R_WRAPPER_NOCONSOLE
int APIENTRY wWinMain(HINSTANCE /* hInstance */, HINSTANCE /* hPrevInstance */, PWSTR /* lpCmdLine */, int /* nCmdShow */)
{
int argc;
wchar_t **argv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
int argc;
wchar_t** argv = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
#else
int wmain(int argc, wchar_t **argv)
int wmain(int argc, wchar_t** argv)
{
#endif
// Allow the asserts to open message box, such message box allows to ignore the assert and continue with the application.
@@ -222,9 +226,10 @@ int wmain(int argc, wchar_t **argv)
// the application will be killed even if "Ignore" button is pressed.
_set_error_mode(_OUT_TO_MSGBOX);
initSentry();
std::vector<wchar_t*> argv_extended;
argv_extended.emplace_back(argv[0]);
#ifdef SLIC3R_WRAPPER_GCODEVIEWER
wchar_t gcodeviewer_param[] = L"--gcodeviewer";
argv_extended.emplace_back(gcodeviewer_param);
@@ -234,7 +239,7 @@ int wmain(int argc, wchar_t **argv)
// Here one may push some additional parameters based on the wrapper type.
bool force_mesa = false;
#endif /* SLIC3R_GUI */
for (int i = 1; i < argc; ++ i) {
for (int i = 1; i < argc; ++i) {
#ifdef SLIC3R_GUI
if (wcscmp(argv[i], L"--sw-renderer") == 0)
force_mesa = true;
@@ -247,14 +252,14 @@ int wmain(int argc, wchar_t **argv)
#ifdef SLIC3R_GUI
OpenGLVersionCheck opengl_version_check;
bool load_mesa =
bool load_mesa =
// Forced from the command line.
force_mesa ||
// Try to load the default OpenGL driver and test its context version.
! opengl_version_check.load_opengl_dll() || ! opengl_version_check.is_version_greater_or_equal_to(2, 0);
!opengl_version_check.load_opengl_dll() || !opengl_version_check.is_version_greater_or_equal_to(2, 0);
#endif /* SLIC3R_GUI */
wchar_t path_to_exe[MAX_PATH + 1] = { 0 };
wchar_t path_to_exe[MAX_PATH + 1] = {0};
::GetModuleFileNameW(nullptr, path_to_exe, MAX_PATH);
wchar_t drive[_MAX_DRIVE];
wchar_t dir[_MAX_DIR];
@@ -264,11 +269,11 @@ int wmain(int argc, wchar_t **argv)
_wmakepath(path_to_exe, drive, dir, nullptr, nullptr);
#ifdef SLIC3R_GUI
// https://wiki.qt.io/Cross_compiling_Mesa_for_Windows
// http://download.qt.io/development_releases/prebuilt/llvmpipe/windows/
// https://wiki.qt.io/Cross_compiling_Mesa_for_Windows
// http://download.qt.io/development_releases/prebuilt/llvmpipe/windows/
if (load_mesa) {
opengl_version_check.unload_opengl_dll();
wchar_t path_to_mesa[MAX_PATH + 1] = { 0 };
wchar_t path_to_mesa[MAX_PATH + 1] = {0};
wcscpy(path_to_mesa, path_to_exe);
wcscat(path_to_mesa, L"mesa\\opengl32.dll");
printf("Loading MESA OpenGL library: %S\n", path_to_mesa);
@@ -280,31 +285,36 @@ int wmain(int argc, wchar_t **argv)
}
#endif /* SLIC3R_GUI */
wchar_t path_to_slic3r[MAX_PATH + 1] = { 0 };
wchar_t path_to_slic3r[MAX_PATH + 1] = {0};
wcscpy(path_to_slic3r, path_to_exe);
wcscat(path_to_slic3r, L"Snapmaker_Orca.dll");
// printf("Loading Slic3r library: %S\n", path_to_slic3r);
// printf("Loading Slic3r library: %S\n", path_to_slic3r);
HINSTANCE hInstance_Slic3r = LoadLibraryExW(path_to_slic3r, nullptr, 0);
if (hInstance_Slic3r == nullptr) {
printf("Snapmaker_Orca.dll was not loaded, error=%d\n", GetLastError());
exitSentry();
return -1;
}
// resolve function address here
Snapmaker_Orca_main = (Slic3rMainFunc)GetProcAddress(hInstance_Slic3r,
Snapmaker_Orca_main = (Slic3rMainFunc)
GetProcAddress(hInstance_Slic3r,
#ifdef _WIN64
// there is just a single calling conversion, therefore no mangling of the function name.
"Snapmaker_Orca_main"
#else // stdcall calling convention declaration
"_bambustu_main@8"
// there is just a single calling conversion, therefore no mangling of the function name.
"Snapmaker_Orca_main"
#else // stdcall calling convention declaration
"_bambustu_main@8"
#endif
);
if (Snapmaker_Orca_main == nullptr) {
printf("could not locate the function Snapmaker_Orca_main in Snapmaker_Orca.dll\n");
exitSentry();
return -1;
}
// argc minus the trailing nullptr of the argv
return Snapmaker_Orca_main((int)argv_extended.size() - 1, argv_extended.data());
auto res = Snapmaker_Orca_main((int) argv_extended.size() - 1, argv_extended.data());
exitSentry();
return res;
}
}

2
src/dev-utils/BaseException.h
View File

@@ -26,6 +26,4 @@ protected:
boost::nowide::ofstream *output_file;
};
#define SET_DEFULTER_HANDLER() SetUnhandledExceptionFilter(CBaseException::UnhandledExceptionFilter)
#define SET_DEFAUL_EXCEPTION() _set_se_translator(CBaseException::STF)

9
src/libslic3r/CMakeLists.txt
View File

@@ -511,7 +511,8 @@ endif ()
encoding_check(libslic3r)
target_compile_definitions(libslic3r PUBLIC -DUSE_TBB -DTBB_USE_CAPTURED_EXCEPTION=0)
target_include_directories(libslic3r PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
# Make source directory PUBLIC so other modules (like libslic3r_gui) can include headers like SentryWrapper.hpp
target_include_directories(libslic3r PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
target_include_directories(libslic3r SYSTEM PUBLIC ${EXPAT_INCLUDE_DIRS})
# Find the OCCT and related libraries
@@ -610,3 +611,9 @@ endif()
if (SLIC3R_PCH AND NOT SLIC3R_SYNTAXONLY)
add_precompiled_header(libslic3r pchheader.hpp FORCEINCLUDE)
endif ()
# Sentry crash reporting integration
if (SLIC3R_SENTRY)
target_compile_definitions(libslic3r PUBLIC SLIC3R_SENTRY)
target_link_libraries(libslic3r PUBLIC sentry::sentry)
endif()

2
src/libslic3r/PresetBundle.cpp
View File

@@ -1837,7 +1837,7 @@ void PresetBundle::export_selections(AppConfig &config)
void PresetBundle::update_num_filaments(unsigned int to_del_filament_id)
{
unsigned old_filament_count = this->filament_presets.size();
assert(to_del_flament_id < old_filament_count);
assert(to_del_filament_id < old_filament_count);
filament_presets.erase(filament_presets.begin() + to_del_filament_id);
ConfigOptionStrings* filament_color = project_config.option<ConfigOptionStrings>("filament_colour");

194
src/sentry_wrapper/SentryWrapper.cpp Normal file
View File

@@ -0,0 +1,194 @@
/**
* @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"
#ifdef _WIN32
#include <Windows.h>
#include <shlobj.h>
#endif
#endif
#include <atomic>
namespace Slic3r {
#ifdef SLIC3R_SENTRY
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;
}
void initSentryEx()
{
sentry_options_t* options = sentry_options_new();
{
#ifdef WIN32
std::string dsn = std::string("https://c74b617c2aedc291444d3a238d23e780@o4508125599563776.ingest.us.sentry.io/4510425163956224");
sentry_options_set_dsn(options, dsn.c_str());
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 handlerDir = 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;
};
std::string desDir = wstringTostring(handlerDir);
if (!desDir.empty())
sentry_options_set_handler_path(options, desDir.c_str());
desDir = wstringTostring(wsDmpDir);
desDir = wstringTostring(wsDmpDir);
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\\");
filePath = filePath + appName;
if (!filePath.empty())
sentry_options_set_database_path(options, filePath.c_str());
#endif
std::string softVersion = "snapmaker_orca_2.2.0_beta2";
// Snapmaker_VERSION
sentry_options_set_release(options, softVersion.c_str());
#if defined(_DEBUG) || !defined(NDEBUG)
sentry_options_set_debug(options, 1);
#else
sentry_options_set_debug(options, 0);
#endif
// release version environment(Testing/production/development/Staging)
sentry_options_set_environment(options, "develop");
sentry_options_set_auto_session_tracking(options, false);
sentry_options_set_symbolize_stacktraces(options, true);
sentry_options_set_on_crash(options, on_crash_callback, NULL);
// Enable before_send hook for filtering sensitive data
sentry_options_set_before_send(options, NULL, NULL);
// Ensure all events and crashes are captured (sample rate 100%)
sentry_options_set_sample_rate(options, 1.0); // Capture 100% of events
sentry_options_set_traces_sample_rate(options, 1.0); // Capture 100% of traces
sentry_init(options);
sentry_start_session();
}
}
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()
);
if (!logTraceId.empty())
sentry_set_trace(logTraceId.c_str(), "");
if (!logTagKey.empty())
sentry_set_tag(logTagKey.c_str(), logTagValue.c_str());
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
}
} // namespace Slic3r

30
src/sentry_wrapper/SentryWrapper.hpp Normal file
View File

@@ -0,0 +1,30 @@
#ifndef slic3r_SentryWrapper_hpp_
#define slic3r_SentryWrapper_hpp_
#include <string>
namespace Slic3r {
void initSentry();
void exitSentry();
typedef enum SENTRY_LOG_LEVEL {
SENTRY_LOG_TRACE = -2,
SENTRY_LOG_DEBUG = -1,
SENTRY_LOG_INFO = 0,
SENTRY_LOG_WARNING = 1,
SENTRY_LOG_ERROR = 2,
SENTRY_LOG_FATAL = 3,
};
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 = "");
} // namespace Slic3r
#endif // slic3r_SentryWrapper_hpp_

6
src/slic3r/CMakeLists.txt
View File

@@ -737,3 +737,9 @@ endif ()
# Add a definition so that we can tell we are compiling slic3r.
target_compile_definitions(libslic3r_gui PRIVATE SLIC3R_CURRENTLY_COMPILING_GUI_MODULE)
# Sentry crash reporting integration
if (SLIC3R_SENTRY)
target_compile_definitions(libslic3r_gui PUBLIC SLIC3R_SENTRY)
target_link_libraries(libslic3r_gui sentry::sentry)
endif()

1
src/slic3r/GUI/MainFrame.cpp
View File

@@ -72,6 +72,7 @@
#include <dbt.h>
#include <shlobj.h>
#include <shellapi.h>
#include "sentry_wrapper/SentryWrapper.hpp"
#endif // _WIN32
#include <slic3r/GUI/CreatePresetsDialog.hpp>