sentry-native
breakpad
sentry-native | breakpad | |
---|---|---|
2 | 4 | |
367 | 2,536 | |
1.9% | 0.9% | |
7.8 | 7.8 | |
2 days ago | 11 days ago | |
C | C++ | |
MIT License | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
sentry-native
-
Luau Goes Open-Source
I understand what C bindings means - hence my comment about the lowest common denominator. I'm not deeply familiar with the Lua api so I don't feel comfortable commenting on it, but the sentry C api is a prime example. Yes you can use this API from many different languages, including C++, but you end up writing code like this. You almost always lose type safety, RAII, and introduce error prone, verbose code, such as: sentry_value_t debug_crumb = sentry_value_new_breadcrumb("http", "debug crumb"); sentry_value_set_by_key( debug_crumb, "category", sentry_value_new_string("example!")); sentry_value_set_by_key( debug_crumb, "depth", sentry_value_new_int32(11)); sentry_value_set_by_key( debug_crumb, "level", sentry_value_new_string("debug")); sentry_add_breadcrumb(debug_crumb);
-
Goodbye C++, Hello C
> Put another way, I'd rather fix relatively simple C (which also tends to be simpler code in general) than the monsters created by "modern C++" because they thought the "added safety" would mean they could go crazy with the complexity without adding bugs.
It's completely possible to write C++ code without it being a mess of a template mostrosity and massively overloaded function names. People who write C++ like that would write C filled with macros, void pointers and all the other footguns that C encourages you to use instead.
I've been working with the sentry-native SDK recently [0] which is a C api. It's full of macros, unclear ownership of pointers (in their callback, _you_ must manually free the random pointer, using the right free method for their type, which isn't type checked), custom functions for working with their types (sentry_free, sentry_free_envelope), opaque data types (everythign is a sentry_value_t created by a custom function - to access the data you have to call the right function not just access the member, and this is a runtime check).
Compare [1] (their C api example)
[0] https://github.com/getsentry/sentry-native
breakpad
-
Monitoring C++ Applications
Another onr is Raygun. Although it doesn't have an SDK itself, it shows how you can integrate your software with Google's breakpad and send the crash report via an http request.
-
We Halved Go Monorepo CI Build Time
Google also has projects like this: https://github.com/google/breakpad
It supports 5 platforms, but uses 4 completely different build systems, including 2 custom ones (3 if you count depot_tools). There is very little overlap between the platform versions, meaning it's effectively 5 different projects smashed together into a single folder, and pretty much no way to use them in a cross platform project without some serious work. There isn't even a basic abstraction over the similar callback APIs between the platforms, although that's not a huge deal because the effort to write a basic abstraction layer is nothing compared to the effort of getting to a point where you can actually use it in a cross-platform project.
It's also funny that one of the build systems is GYP, which is basically a reinvention of CMake, except it's only used for the Windows build even though it can generate projects for the other platforms. Also, the VS project generator for GYP has been broken for a while (simple typo, trying to import OrderedDict from the wrong module. There's a PR to fix it, hasn't been merged for some reason), so it doesn't even work. Beyond that, it's also broken because GYP forces treating all warnings as errors, with a whitelist of warnings, yet the latest version (since yesterday at least) fails to build (tested on VS2019) because there's a warning that isn't in the whitelist.
You could try to fork it and fix these issues, but depot_tools doesn't provide a way to change the clone URL for repos, meaning you need to dig through the source code and wrap it in your own script that interacts with the internal APIs to do a simple clone (hint: fetch.py has a 'run' method that you can call with a custom constructed 'spec' object, which is a dictionary where you can inject your own url; just look at the hard-coded spec object for breakpad as a starting point). If you don't use depot_tools, then you need to manually clone all of the dependencies in the project since they're not even set up as git submodules.
There's also no versioning scheme whatsoever. Depot_tools seems to automatically checkout the latest version of everything (including itself).
I spent the past week wrestling with this monstrosity. Ended up successfully writing a Conan package for it that builds for Windows and Linux (there's one on Conan center, but it only supports Linux). I have 3 more platforms to go, but I think it'll be a better idea to just scrap everything and refactor into something more reasonable using CMake.
Instead of Breakpad, they also have a newer one called Crashpad, which is meant to improve reliability on Mac OS. Unfortunately, it depends on Chromium, so it won't work for my purposes.
...so all I'm saying is, maybe don't use Google as a role model for your project infrastructure.
/end rant
-
How can I collect native crashes info without Crashlytics and without writing my own signals handler with <signal.h>?
I don't think you're accomplishing this without writing a least a little bit of C at some level. but I'd use this if for some reason you cannot connect a third party.
- Improving Firefox Stability on Linux
What are some alternatives?
GSL - Guidelines Support Library
opentelemetry-cpp - The OpenTelemetry C++ Client
cJSON - Ultralightweight JSON parser in ANSI C
rust-minidump - Type definitions, parsing, and analysis for the minidump file format.
score-simple-api-2
yalc - Work with yarn/npm packages locally like a boss.
tl - The compiler for Teal, a typed dialect of Lua
svntogit-packages - Automatic import of svn 'packages' repo (read-only mirror)
CppCoreGuidelines - The C++ Core Guidelines are a set of tried-and-true guidelines, rules, and best practices about coding in C++
Bugsnag - BugSnag crash monitoring and reporting tool for Android apps
sentry-dart - Sentry SDK for Dart and Flutter
dump_syms - Rewrite of breakpad dump_syms tools in Rust