feat(logs): add sentry log API + send first logs (#1272)

* add sentry log API + send first logs

* fix log_level_as_string

* attach attributes to logs

* attach formatted message + args

* add to example

* add more attributes

* cleanup

* windows warning-as-error

* windows warning-as-error v2

* windows warning-as-error v2 (final)

* add unit tests for initial logs

* memleak attempted fix

* memleak attempted fix 2

* cleanup

* use `sentry_level_t` instead of new log level enum

* add SENTRY_LEVEL_TRACE to sentry_logger

* quick anti-brownout fix
- see #1274

* fix missing SENTRY_LEVEL_INFO string return

* fix logger level check + add test

* cleanup logs parameter extraction

* warn-as-error fix

* const char* fix

* static function

* feat(logs): add (u)int64 sentry_value_t type (#1301)

* add (u)int64 sentry_value_t type

* add value_to_msgpack missing switch cases

* remove undefined behavior test (C99 6.3.1.4)

* avoid Windows sized integer name collision

* cleanup & apply code review feedback

* more cleanup & remove type coercion

* update logs param conversion

* own uint64 string

* apply suggestions from code review

Author: JoshuaMoelans

.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

@@ -359,6 +359,26 @@ main(int argc, char **argv)
 
     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);
@@ -566,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,
@@ -1750,6 +1773,13 @@ SENTRY_EXPERIMENTAL_API void sentry_options_set_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, ...);
+
 #ifdef SENTRY_PLATFORM_LINUX
 
 /**

src/CMakeLists.txt

@@ -15,6 +15,8 @@ sentry_target_sources_cwd(sentry
 	sentry_json.h
 	sentry_logger.c
 	sentry_logger.h
+	sentry_logs.c
+	sentry_logs.h
 	sentry_options.c
 	sentry_options.h
 	sentry_os.c

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;