sentry.h

Go to the documentation of this file.

 
#ifndef SENTRY_H_INCLUDED
#define SENTRY_H_INCLUDED
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* SDK Version */
#define SENTRY_SDK_NAME "sentry.native"
#define SENTRY_SDK_VERSION "0.3.1"
#define SENTRY_SDK_USER_AGENT (SENTRY_SDK_NAME "/" SENTRY_SDK_VERSION)
 
/* common platform detection */
#ifdef _WIN32
#    define SENTRY_PLATFORM_WINDOWS
#elif defined(__APPLE__)
#    define SENTRY_PLATFORM_MACOS
#    define SENTRY_PLATFORM_DARWIN
#    define SENTRY_PLATFORM_UNIX
#elif defined(__ANDROID__)
#    define SENTRY_PLATFORM_ANDROID
#    define SENTRY_PLATFORM_LINUX
#    define SENTRY_PLATFORM_UNIX
#elif defined(__linux) || defined(__linux__)
#    define SENTRY_PLATFORM_LINUX
#    define SENTRY_PLATFORM_UNIX
#else
#    error unsupported platform
#endif
 
/* marks a function as part of the sentry API */
#ifndef SENTRY_API
#    ifdef _WIN32
#        if defined(SENTRY_BUILD_SHARED) /* build dll */
#            define SENTRY_API __declspec(dllexport)
#        elif !defined(SENTRY_BUILD_STATIC) /* use dll */
#            define SENTRY_API __declspec(dllimport)
#        else /* static library */
#            define SENTRY_API
#        endif
#    else
#        if __GNUC__ >= 4
#            define SENTRY_API __attribute__((visibility("default")))
#        else
#            define SENTRY_API
#        endif
#    endif
#endif
 
/* marks a function as experimental api */
#ifndef SENTRY_EXPERIMENTAL_API
#    define SENTRY_EXPERIMENTAL_API SENTRY_API
#endif
 
#include <inttypes.h>
#include <stdbool.h>
#include <stddef.h>
 
/* context type dependencies */
#ifdef _WIN32
#    include <wtypes.h>
#else
#    include <signal.h>
#endif
 
SENTRY_API void *sentry_malloc(size_t size);
 
SENTRY_API void sentry_free(void *ptr);
 
#define sentry_string_free sentry_free
 
/* -- Protocol Value API -- */
 
typedef enum {
    SENTRY_VALUE_TYPE_NULL,
    SENTRY_VALUE_TYPE_BOOL,
    SENTRY_VALUE_TYPE_INT32,
    SENTRY_VALUE_TYPE_DOUBLE,
    SENTRY_VALUE_TYPE_STRING,
    SENTRY_VALUE_TYPE_LIST,
    SENTRY_VALUE_TYPE_OBJECT,
} sentry_value_type_t;
 
union sentry_value_u {
    uint64_t _bits;
    double _double;
};
typedef union sentry_value_u sentry_value_t;
 
SENTRY_API void sentry_value_incref(sentry_value_t value);
 
SENTRY_API void sentry_value_decref(sentry_value_t value);
 
SENTRY_API size_t sentry_value_refcount(sentry_value_t value);
 
SENTRY_API void sentry_value_freeze(sentry_value_t value);
 
SENTRY_API int sentry_value_is_frozen(sentry_value_t value);
 
SENTRY_API sentry_value_t sentry_value_new_null(void);
 
SENTRY_API sentry_value_t sentry_value_new_int32(int32_t value);
 
SENTRY_API sentry_value_t sentry_value_new_double(double value);
 
SENTRY_API sentry_value_t sentry_value_new_bool(int value);
 
SENTRY_API sentry_value_t sentry_value_new_string(const char *value);
 
SENTRY_API sentry_value_t sentry_value_new_list(void);
 
SENTRY_API sentry_value_t sentry_value_new_object(void);
 
SENTRY_API sentry_value_type_t sentry_value_get_type(sentry_value_t value);
 
SENTRY_API int sentry_value_set_by_key(
    sentry_value_t value, const char *k, sentry_value_t v);
 
SENTRY_API int sentry_value_remove_by_key(sentry_value_t value, const char *k);
 
SENTRY_API int sentry_value_append(sentry_value_t value, sentry_value_t v);
 
SENTRY_API int sentry_value_set_by_index(
    sentry_value_t value, size_t index, sentry_value_t v);
 
SENTRY_API int sentry_value_remove_by_index(sentry_value_t value, size_t index);
 
SENTRY_API sentry_value_t sentry_value_get_by_key(
    sentry_value_t value, const char *k);
 
SENTRY_API sentry_value_t sentry_value_get_by_key_owned(
    sentry_value_t value, const char *k);
 
SENTRY_API sentry_value_t sentry_value_get_by_index(
    sentry_value_t value, size_t index);
 
SENTRY_API sentry_value_t sentry_value_get_by_index_owned(
    sentry_value_t value, size_t index);
 
SENTRY_API size_t sentry_value_get_length(sentry_value_t value);
 
SENTRY_API int32_t sentry_value_as_int32(sentry_value_t value);
 
SENTRY_API double sentry_value_as_double(sentry_value_t value);
 
SENTRY_API const char *sentry_value_as_string(sentry_value_t value);
 
SENTRY_API int sentry_value_is_true(sentry_value_t value);
 
SENTRY_API int sentry_value_is_null(sentry_value_t value);
 
SENTRY_API char *sentry_value_to_json(sentry_value_t value);
 
typedef enum sentry_level_e {
    SENTRY_LEVEL_DEBUG = -1,
    SENTRY_LEVEL_INFO = 0,
    SENTRY_LEVEL_WARNING = 1,
    SENTRY_LEVEL_ERROR = 2,
    SENTRY_LEVEL_FATAL = 3,
} sentry_level_t;
 
SENTRY_API sentry_value_t sentry_value_new_event(void);
 
SENTRY_API sentry_value_t sentry_value_new_message_event(
    sentry_level_t level, const char *logger, const char *text);
 
SENTRY_API sentry_value_t sentry_value_new_breadcrumb(
    const char *type, const char *message);
 
/* -- Experimental APIs -- */
 
SENTRY_EXPERIMENTAL_API char *sentry_value_to_msgpack(
    sentry_value_t value, size_t *size_out);
 
SENTRY_EXPERIMENTAL_API void sentry_event_value_add_stacktrace(
    sentry_value_t event, void **ips, size_t len);
 
typedef struct sentry_ucontext_s {
#ifdef _WIN32
    EXCEPTION_POINTERS exception_ptrs;
#else
    int signum;
    siginfo_t *siginfo;
    ucontext_t *user_context;
#endif
} sentry_ucontext_t;
 
SENTRY_EXPERIMENTAL_API size_t sentry_unwind_stack(
    void *addr, void **stacktrace_out, size_t max_len);
 
SENTRY_EXPERIMENTAL_API size_t sentry_unwind_stack_from_ucontext(
    const sentry_ucontext_t *uctx, void **stacktrace_out, size_t max_len);
 
typedef struct sentry_uuid_s {
    char bytes[16];
} sentry_uuid_t;
 
SENTRY_API sentry_uuid_t sentry_uuid_nil(void);
 
SENTRY_API sentry_uuid_t sentry_uuid_new_v4(void);
 
SENTRY_API sentry_uuid_t sentry_uuid_from_string(const char *str);
 
SENTRY_API sentry_uuid_t sentry_uuid_from_bytes(const char bytes[16]);
 
SENTRY_API int sentry_uuid_is_nil(const sentry_uuid_t *uuid);
 
SENTRY_API void sentry_uuid_as_bytes(const sentry_uuid_t *uuid, char bytes[16]);
 
SENTRY_API void sentry_uuid_as_string(const sentry_uuid_t *uuid, char str[37]);
 
struct sentry_envelope_s;
typedef struct sentry_envelope_s sentry_envelope_t;
 
SENTRY_API void sentry_envelope_free(sentry_envelope_t *envelope);
 
SENTRY_API sentry_value_t sentry_envelope_get_event(
    const sentry_envelope_t *envelope);
 
SENTRY_API char *sentry_envelope_serialize(
    const sentry_envelope_t *envelope, size_t *size_out);
 
SENTRY_API int sentry_envelope_write_to_file(
    const sentry_envelope_t *envelope, const char *path);
 
struct sentry_options_s;
typedef struct sentry_options_s sentry_options_t;
 
struct sentry_transport_s;
typedef struct sentry_transport_s sentry_transport_t;
 
SENTRY_API sentry_transport_t *sentry_transport_new(
    void (*send_func)(sentry_envelope_t *envelope, void *state));
 
SENTRY_API void sentry_transport_set_state(
    sentry_transport_t *transport, void *state);
 
SENTRY_API void sentry_transport_set_free_func(
    sentry_transport_t *transport, void (*free_func)(void *state));
 
SENTRY_API void sentry_transport_set_startup_func(sentry_transport_t *transport,
    void (*startup_func)(const sentry_options_t *options, void *state));
 
SENTRY_API void sentry_transport_set_shutdown_func(
    sentry_transport_t *transport,
    bool (*shutdown_func)(uint64_t timeout, void *state));
 
SENTRY_API void sentry_transport_free(sentry_transport_t *transport);
 
SENTRY_API sentry_transport_t *sentry_new_function_transport(
    void (*func)(const sentry_envelope_t *envelope, void *data), void *data);
 
typedef sentry_value_t (*sentry_event_function_t)(
    sentry_value_t event, void *hint, void *closure);
 
/* -- Options APIs -- */
 
typedef enum {
    SENTRY_USER_CONSENT_UNKNOWN = -1,
    SENTRY_USER_CONSENT_GIVEN = 1,
    SENTRY_USER_CONSENT_REVOKED = 0,
} sentry_user_consent_t;
 
SENTRY_API sentry_options_t *sentry_options_new(void);
 
SENTRY_API void sentry_options_free(sentry_options_t *opts);
 
SENTRY_API void sentry_options_set_transport(
    sentry_options_t *opts, sentry_transport_t *transport);
 
SENTRY_API void sentry_options_set_before_send(
    sentry_options_t *opts, sentry_event_function_t func, void *data);
 
SENTRY_API void sentry_options_set_dsn(sentry_options_t *opts, const char *dsn);
 
SENTRY_API const char *sentry_options_get_dsn(const sentry_options_t *opts);
 
SENTRY_API void sentry_options_set_sample_rate(
    sentry_options_t *opts, double sample_rate);
 
SENTRY_API double sentry_options_get_sample_rate(const sentry_options_t *opts);
 
SENTRY_API void sentry_options_set_release(
    sentry_options_t *opts, const char *release);
 
SENTRY_API const char *sentry_options_get_release(const sentry_options_t *opts);
 
SENTRY_API void sentry_options_set_environment(
    sentry_options_t *opts, const char *environment);
 
SENTRY_API const char *sentry_options_get_environment(
    const sentry_options_t *opts);
 
SENTRY_API void sentry_options_set_dist(
    sentry_options_t *opts, const char *dist);
 
SENTRY_API const char *sentry_options_get_dist(const sentry_options_t *opts);
 
SENTRY_API void sentry_options_set_http_proxy(
    sentry_options_t *opts, const char *proxy);
 
SENTRY_API const char *sentry_options_get_http_proxy(
    const sentry_options_t *opts);
 
SENTRY_API void sentry_options_set_ca_certs(
    sentry_options_t *opts, const char *path);
 
SENTRY_API const char *sentry_options_get_ca_certs(
    const sentry_options_t *opts);
 
SENTRY_API void sentry_options_set_debug(sentry_options_t *opts, int debug);
 
SENTRY_API int sentry_options_get_debug(const sentry_options_t *opts);
 
SENTRY_API void sentry_options_set_require_user_consent(
    sentry_options_t *opts, int val);
 
SENTRY_API int sentry_options_get_require_user_consent(
    const sentry_options_t *opts);
 
SENTRY_API void sentry_options_set_symbolize_stacktraces(
    sentry_options_t *opts, int val);
 
SENTRY_API int sentry_options_get_symbolize_stacktraces(
    const sentry_options_t *opts);
 
SENTRY_API void sentry_options_add_attachment(
    sentry_options_t *opts, const char *name, const char *path);
 
SENTRY_API void sentry_options_set_handler_path(
    sentry_options_t *opts, const char *path);
 
SENTRY_API void sentry_options_set_database_path(
    sentry_options_t *opts, const char *path);
 
#ifdef SENTRY_PLATFORM_WINDOWS
 
SENTRY_API void sentry_options_add_attachmentw(
    sentry_options_t *opts, const char *name, const wchar_t *path);
 
SENTRY_API void sentry_options_set_handler_pathw(
    sentry_options_t *opts, const wchar_t *path);
 
SENTRY_API void sentry_options_set_database_pathw(
    sentry_options_t *opts, const wchar_t *path);
#endif
 
SENTRY_API void sentry_options_set_system_crash_reporter_enabled(
    sentry_options_t *opts, int enabled);
 
/* -- Global APIs -- */
 
SENTRY_API int sentry_init(sentry_options_t *options);
 
SENTRY_API void sentry_shutdown(void);
 
SENTRY_EXPERIMENTAL_API void sentry_clear_modulecache(void);
 
SENTRY_API const sentry_options_t *sentry_get_options(void);
 
SENTRY_API void sentry_user_consent_give(void);
 
SENTRY_API void sentry_user_consent_revoke(void);
 
SENTRY_API void sentry_user_consent_reset(void);
 
SENTRY_API sentry_user_consent_t sentry_user_consent_get(void);
 
SENTRY_API sentry_uuid_t sentry_capture_event(sentry_value_t event);
 
SENTRY_EXPERIMENTAL_API void sentry_handle_exception(
    const sentry_ucontext_t *uctx);
 
SENTRY_API void sentry_add_breadcrumb(sentry_value_t breadcrumb);
 
SENTRY_API void sentry_set_user(sentry_value_t user);
 
SENTRY_API void sentry_remove_user(void);
 
SENTRY_API void sentry_set_tag(const char *key, const char *value);
 
SENTRY_API void sentry_remove_tag(const char *key);
 
SENTRY_API void sentry_set_extra(const char *key, sentry_value_t value);
 
SENTRY_API void sentry_remove_extra(const char *key);
 
SENTRY_API void sentry_set_context(const char *key, sentry_value_t value);
 
SENTRY_API void sentry_remove_context(const char *key);
 
SENTRY_API void sentry_set_fingerprint(const char *fingerprint, ...);
 
SENTRY_API void sentry_remove_fingerprint(void);
 
SENTRY_API void sentry_set_transaction(const char *transaction);
 
SENTRY_API void sentry_remove_transaction(void);
 
SENTRY_API void sentry_set_level(sentry_level_t level);
 
SENTRY_EXPERIMENTAL_API void sentry_start_session(void);
 
SENTRY_EXPERIMENTAL_API void sentry_end_session(void);
 
#ifdef __cplusplus
}
#endif
#endif