feat(logs): alternative logs API

.github/workflows/ci.yml

@@ -121,7 +121,7 @@ jobs:
             SYSTEM_VERSION_COMPAT: 0
             RUN_ANALYZER: asan,llvm-cov
           - name: Windows (old VS, 32-bit)
-            os: windows-2019
+            os: windows-2022
             TEST_X86: 1
           - name: Windows (latest)
             os: windows-latest

examples/example.c

@@ -353,8 +353,32 @@ main(int argc, char **argv)
         sentry_options_add_view_hierarchy(options, "./view-hierarchy.json");
     }
 
+    if (has_arg(argc, argv, "enable-logs")) {
+        sentry_options_set_enable_logs(options, true);
+    }
+
     sentry_init(options);
 
+    // TODO incorporate into test
+    if (sentry_options_get_enable_logs(options)) {
+        sentry_log_trace("We log it up  %i%%, %s style", 100, "trace");
+        sentry_log_debug("We log it up  %i%%, %s style", 100, "debug");
+        sentry_log_info("We log it up  %i%%, %s style", 100, "info");
+        sentry_log_warn("We log it up  %i%%, %s style", 100, "warn");
+        sentry_log_error("We log it up  %i%%, %s style", 100, "error");
+        sentry_log_fatal("We log it up  %i%%, %s style", 100, "fatal");
+
+        // Test the logger with various parameter types
+        sentry_log_info(
+            "API call to %s completed in %d ms with %f success rate",
+            "/api/products", 2500, 0.95);
+
+        sentry_log_warn("Processing %d items, found %u errors, pointer: %p",
+            100, 5u, (void *)0x12345678);
+
+        sentry_log_error("Character '%c' is invalid", 'X');
+    }
+
     if (!has_arg(argc, argv, "no-setup")) {
         sentry_set_transaction("test-transaction");
         sentry_set_level(SENTRY_LEVEL_WARNING);
@@ -562,6 +586,9 @@ main(int argc, char **argv)
                 SENTRY_LEVEL_INFO, "my-logger", "Hello World!");
             sentry_capture_event(event);
         }
+        if (sentry_options_get_enable_logs(options)) {
+            sentry_log_debug("logging after scoped transaction event");
+        }
 
         sentry_transaction_finish(tx);
     }

include/sentry.h

@@ -137,6 +137,8 @@ typedef enum {
     SENTRY_VALUE_TYPE_NULL,
     SENTRY_VALUE_TYPE_BOOL,
     SENTRY_VALUE_TYPE_INT32,
+    SENTRY_VALUE_TYPE_INT64,
+    SENTRY_VALUE_TYPE_UINT64,
     SENTRY_VALUE_TYPE_DOUBLE,
     SENTRY_VALUE_TYPE_STRING,
     SENTRY_VALUE_TYPE_LIST,
@@ -200,6 +202,16 @@ SENTRY_API sentry_value_t sentry_value_new_null(void);
  */
 SENTRY_API sentry_value_t sentry_value_new_int32(int32_t value);
 
+/**
+ * Creates a new 64-bit signed integer value.
+ */
+SENTRY_API sentry_value_t sentry_value_new_int64(int64_t value);
+
+/**
+ * Creates a new 64-bit unsigned integer value.
+ */
+SENTRY_API sentry_value_t sentry_value_new_uint64(uint64_t value);
+
 /**
  * Creates a new double value.
  */
@@ -338,6 +350,16 @@ SENTRY_API size_t sentry_value_get_length(sentry_value_t value);
  */
 SENTRY_API int32_t sentry_value_as_int32(sentry_value_t value);
 
+/**
+ * Converts a value into a 64 bit signed integer.
+ */
+SENTRY_API int64_t sentry_value_as_int64(sentry_value_t value);
+
+/**
+ * Converts a value into a 64 bit unsigned integer.
+ */
+SENTRY_API uint64_t sentry_value_as_uint64(sentry_value_t value);
+
 /**
  * Converts a value into a double value.
  */
@@ -370,6 +392,7 @@ SENTRY_API char *sentry_value_to_json(sentry_value_t value);
  * Sentry levels for events and breadcrumbs.
  */
 typedef enum sentry_level_e {
+    SENTRY_LEVEL_TRACE = -2,
     SENTRY_LEVEL_DEBUG = -1,
     SENTRY_LEVEL_INFO = 0,
     SENTRY_LEVEL_WARNING = 1,
@@ -1741,6 +1764,35 @@ typedef double (*sentry_traces_sampler_function)(
 SENTRY_EXPERIMENTAL_API void sentry_options_set_traces_sampler(
     sentry_options_t *opts, sentry_traces_sampler_function callback);
 
+/**
+ * Enables or disables the structured logging feature.
+ * When disabled, all calls to sentry_logger_X() are no-ops.
+ */
+SENTRY_EXPERIMENTAL_API void sentry_options_set_enable_logs(
+    sentry_options_t *opts, int enable_logs);
+SENTRY_EXPERIMENTAL_API int sentry_options_get_enable_logs(
+    const sentry_options_t *opts);
+
+SENTRY_EXPERIMENTAL_API void sentry_log_trace(const char *message, ...);
+SENTRY_EXPERIMENTAL_API void sentry_log_debug(const char *message, ...);
+SENTRY_EXPERIMENTAL_API void sentry_log_info(const char *message, ...);
+SENTRY_EXPERIMENTAL_API void sentry_log_warn(const char *message, ...);
+SENTRY_EXPERIMENTAL_API void sentry_log_error(const char *message, ...);
+SENTRY_EXPERIMENTAL_API void sentry_log_fatal(const char *message, ...);
+
+SENTRY_EXPERIMENTAL_API void sentry_log_trace_value(
+    const char *message, sentry_value_t args);
+SENTRY_EXPERIMENTAL_API void sentry_log_debug_value(
+    const char *message, sentry_value_t args);
+SENTRY_EXPERIMENTAL_API void sentry_log_info_value(
+    const char *message, sentry_value_t args);
+SENTRY_EXPERIMENTAL_API void sentry_log_warn_value(
+    const char *message, sentry_value_t args);
+SENTRY_EXPERIMENTAL_API void sentry_log_error_value(
+    const char *message, sentry_value_t args);
+SENTRY_EXPERIMENTAL_API void sentry_log_fatal_value(
+    const char *message, sentry_value_t args);
+
 #ifdef SENTRY_PLATFORM_LINUX
 
 /**

src/CMakeLists.txt

@@ -51,6 +51,8 @@ sentry_target_sources_cwd(sentry
 	transports/sentry_disk_transport.h
 	transports/sentry_function_transport.c
 	unwinder/sentry_unwinder.c
+	sentry_logs.c
+	sentry_logs.h
 )
 
 # generic platform / path / symbolizer

src/sentry_core.c

@@ -125,6 +125,7 @@ sentry_init(sentry_options_t *options)
     sentry_close();
 
     sentry_logger_t logger = { NULL, NULL, SENTRY_LEVEL_DEBUG };
+
     if (options->debug) {
         logger = options->logger;
     }

src/sentry_envelope.c

@@ -295,6 +295,32 @@ sentry__envelope_add_transaction(
     return item;
 }
 
+sentry_envelope_item_t *
+sentry__envelope_add_logs(sentry_envelope_t *envelope, sentry_value_t logs)
+{
+    sentry_envelope_item_t *item = envelope_add_item(envelope);
+    if (!item) {
+        return NULL;
+    }
+
+    sentry_jsonwriter_t *jw = sentry__jsonwriter_new_sb(NULL);
+    if (!jw) {
+        return NULL;
+    }
+
+    sentry__jsonwriter_write_value(jw, logs);
+    item->payload = sentry__jsonwriter_into_string(jw, &item->payload_len);
+
+    sentry__envelope_item_set_header(
+        item, "type", sentry_value_new_string("log"));
+    sentry__envelope_item_set_header(item, "item_count",
+        sentry_value_new_int32((int32_t)sentry_value_get_length(logs)));
+    sentry__envelope_item_set_header(item, "content_type",
+        sentry_value_new_string("application/vnd.sentry.items.log+json"));
+
+    return item;
+}
+
 sentry_envelope_item_t *
 sentry__envelope_add_user_feedback(
     sentry_envelope_t *envelope, sentry_value_t user_feedback)

src/sentry_envelope.h

@@ -42,6 +42,12 @@ sentry_envelope_item_t *sentry__envelope_add_event(
 sentry_envelope_item_t *sentry__envelope_add_transaction(
     sentry_envelope_t *envelope, sentry_value_t transaction);
 
+/**
+ * Add a list of logs to this envelope.
+ */
+sentry_envelope_item_t *sentry__envelope_add_logs(
+    sentry_envelope_t *envelope, sentry_value_t logs);
+
 /**
  * Add a user feedback to this envelope.
  */

src/sentry_json.c

@@ -364,6 +364,26 @@ sentry__jsonwriter_write_int32(sentry_jsonwriter_t *jw, int32_t val)
     }
 }
 
+void
+sentry__jsonwriter_write_int64(sentry_jsonwriter_t *jw, int64_t val)
+{
+    if (can_write_item(jw)) {
+        char buf[24];
+        snprintf(buf, sizeof(buf), "%" PRId64, val);
+        write_str(jw, buf);
+    }
+}
+
+void
+sentry__jsonwriter_write_uint64(sentry_jsonwriter_t *jw, uint64_t val)
+{
+    if (can_write_item(jw)) {
+        char buf[24];
+        snprintf(buf, sizeof(buf), "%" PRIu64, val);
+        write_str(jw, buf);
+    }
+}
+
 void
 sentry__jsonwriter_write_double(sentry_jsonwriter_t *jw, double val)
 {

src/sentry_json.h

@@ -53,6 +53,16 @@ void sentry__jsonwriter_write_bool(sentry_jsonwriter_t *jw, bool val);
  */
 void sentry__jsonwriter_write_int32(sentry_jsonwriter_t *jw, int32_t val);
 
+/**
+ * Write a 64-bit signed integer, encoded as JSON number.
+ */
+void sentry__jsonwriter_write_int64(sentry_jsonwriter_t *jw, int64_t val);
+
+/**
+ * Write a 64-bit unsigned integer, encoded as JSON number.
+ */
+void sentry__jsonwriter_write_uint64(sentry_jsonwriter_t *jw, uint64_t val);
+
 /**
  * Write a 64-bit float, encoded as JSON number.
  */

src/sentry_logger.c

@@ -69,6 +69,8 @@ const char *
 sentry__logger_describe(sentry_level_t level)
 {
     switch (level) {
+    case SENTRY_LEVEL_TRACE:
+        return "TRACE ";
     case SENTRY_LEVEL_DEBUG:
         return "DEBUG ";
     case SENTRY_LEVEL_INFO:
@@ -87,8 +89,7 @@ sentry__logger_describe(sentry_level_t level)
 void
 sentry__logger_log(sentry_level_t level, const char *message, ...)
 {
-    if (g_logger.logger_level != SENTRY_LEVEL_DEBUG
-        && level < g_logger.logger_level) {
+    if (level < g_logger.logger_level) {
         return;
     }
     sentry_logger_t logger = g_logger;

src/sentry_logger.h

@@ -18,6 +18,11 @@ const char *sentry__logger_describe(sentry_level_t level);
 
 void sentry__logger_log(sentry_level_t level, const char *message, ...);
 
+#define SENTRY_TRACEF(message, ...)                                            \
+    sentry__logger_log(SENTRY_LEVEL_TRACE, message, __VA_ARGS__)
+
+#define SENTRY_TRACE(message) sentry__logger_log(SENTRY_LEVEL_TRACE, message)
+
 #define SENTRY_DEBUGF(message, ...)                                            \
     sentry__logger_log(SENTRY_LEVEL_DEBUG, message, __VA_ARGS__)