Memfault Firmware SDK 0.42.1 (Build 1866)

Author: Memfault Inc

CHANGES.md

@@ -1,3 +1,20 @@
+### Changes between Memfault SDK 0.42.1 and 0.42.0 - April 4, 2023
+
+#### :chart_with_upwards_trend: Improvements
+
+- Zephyr:
+
+  - Remove `LEGACY_CONFIG_PATH` Kconfig selection, now that the `zephyr.h`
+    header is no longer used as of Memfault SDK `0.42.0`. This option no longer
+    exists after Zephyr v3.3.0. Fixes
+    [#48](https://github.com/memfault/memfault-firmware-sdk/issues/48)
+
+- Minor changes to the [ESP8266 port](ports/esp8266_sdk) to improve
+  out-of-the-box compilation
+- Add new functionality to output buffered log data via
+  `memfault_log_export_logs()`. See the
+  [`log.h` header](components/include/memfault/core/log.h) for detailed usage.
+
 ### Changes between Memfault SDK 0.42.0 and 0.41.2 - Mar 22, 2023
 
 #### :chart_with_upwards_trend: Improvements
@@ -7,7 +24,8 @@
   - Add option to capture full thread stacks for classifying stack overflows and
     determining stack high watermarks. This feature is enabled by setting
     `CONFIG_MEMFAULT_COREDUMP_FULL_THREAD_STACKS=y`
-  - Remove usage of the `zephyr.h` header in preparation for Zephyr v3.4.0
+  - Remove usage of the `zephyr.h` header in preparation for Zephyr v3.4.0.
+    Thanks to @jfischer-no for the patch!
 
 - `memfault_gdb.py`:
   - Add support for exporting data from GCC 12 compiled symbol files
@@ -32,8 +50,9 @@
 - Zephyr / nRF-Connect SDK:
   - Improve compatibility with Zephyr pre-3.0 deferred logging, when using the
     Memfault backend
-  - Add an option to the [examples/nrf-connect/nrf5](examples/nrf-connect/nrf5)
-    to enable capturing all of RAM in a coredump.
+  - Add an option to the
+    [examples/nrf-connect-sdk/nrf5](examples/nrf-connect-sdk/nrf5) to enable
+    capturing all of RAM in a coredump.
 
 ### Changes between Memfault SDK 0.41.1 and SDK 0.41.0 - Mar 1, 2023
 

VERSION

@@ -1,2 +1,2 @@
-BUILD ID: 1778
-GIT COMMIT: 539b8ab42
+BUILD ID: 1866
+GIT COMMIT: 96e2f7fa4

components/core/src/memfault_batched_events.c

@@ -11,12 +11,6 @@
 #include "memfault/core/sdk_assert.h"
 #include "memfault/util/cbor.h"
 
-
-static void prv_fill_header_cb(void *ctx, uint32_t offset, const void *buf, size_t buf_len) {
-  uint8_t *header_buf = (uint8_t *)ctx;
-  memcpy(&header_buf[offset], buf, buf_len);
-}
-
 void memfault_batched_events_build_header(
     size_t num_events, sMemfaultBatchedEventsHeader *header_out) {
   MEMFAULT_SDK_ASSERT(header_out != NULL);
@@ -28,7 +22,7 @@ void memfault_batched_events_build_header(
 
   // there's multiple events to read. We will add a header to indicate the total count
   sMemfaultCborEncoder encoder;
-  memfault_cbor_encoder_init(&encoder, prv_fill_header_cb, header_out->data,
+  memfault_cbor_encoder_init(&encoder, memfault_cbor_encoder_memcpy_write, header_out->data,
                              sizeof(header_out->data));
   memfault_cbor_encode_array_begin(&encoder, num_events);
   header_out->length = memfault_cbor_encoder_deinit(&encoder);

components/core/src/memfault_custom_data_recording.c

@@ -114,11 +114,6 @@ static void prv_try_get_cdr_source_with_data(sMfltCdrSourceCtx *ctx) {
   }
 }
 
-static void prv_fill_header_cb(void *ctx, uint32_t offset, const void *buf, size_t buf_len) {
-  uint8_t *header_buf = (uint8_t *)ctx;
-  memcpy(&header_buf[offset], buf, buf_len);
-}
-
 static bool prv_has_cdr(size_t *total_size) {
   sMfltCdrSourceCtx *cdr_ctx = &s_memfault_cdr_source_ctx;
 
@@ -128,7 +123,8 @@ static bool prv_has_cdr(size_t *total_size) {
   }
 
   sMemfaultCborEncoder encoder;
-  memfault_cbor_encoder_init(&encoder, prv_fill_header_cb, cdr_ctx->encoded_metadata.data,
+  memfault_cbor_encoder_init(&encoder, memfault_cbor_encoder_memcpy_write,
+                             cdr_ctx->encoded_metadata.data,
                              sizeof(cdr_ctx->encoded_metadata.data));
 
   if (!prv_encode_cdr_metadata(&encoder, cdr_ctx)) {

components/core/src/memfault_log.c

@@ -7,26 +7,25 @@
 //! is collected using the panics component, the logs will be decoded and displayed in the Memfault
 //! cloud UI.
 
-#include "memfault/core/log.h"
-#include "memfault/core/log_impl.h"
-#include "memfault_log_private.h"
-
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "memfault/config.h"
+#include "memfault/core/compact_log_serializer.h"
 #include "memfault/core/compiler.h"
 #include "memfault/core/debug_log.h"
+#include "memfault/core/log.h"
+#include "memfault/core/log_impl.h"
 #include "memfault/core/math.h"
 #include "memfault/core/platform/debug_log.h"
 #include "memfault/core/platform/overrides.h"
+#include "memfault/core/sdk_assert.h"
+#include "memfault/util/base64.h"
 #include "memfault/util/circular_buffer.h"
 #include "memfault/util/crc16_ccitt.h"
-#include "memfault/core/compact_log_serializer.h"
-
-#include "memfault/config.h"
+#include "memfault_log_private.h"
 
 #if MEMFAULT_LOG_DATA_SOURCE_ENABLED
 #include "memfault_log_data_source_private.h"
@@ -262,6 +261,61 @@ bool memfault_log_read(sMemfaultLog *log) {
   return found_unread_log;
 }
 
+MEMFAULT_WEAK void memfault_log_export_msg(MEMFAULT_UNUSED eMemfaultPlatformLogLevel level,
+                                           const char *msg, MEMFAULT_UNUSED size_t msg_len) {
+  memfault_platform_log_raw("%s", msg);
+}
+
+void memfault_log_export_log(sMemfaultLog *log) {
+  MEMFAULT_SDK_ASSERT(log != NULL);
+
+  char base64[MEMFAULT_LOG_EXPORT_BASE64_CHUNK_MAX_LEN];
+  size_t log_read_offset = 0;
+
+  switch (log->type) {
+    case kMemfaultLogRecordType_Compact:
+      while (log_read_offset < log->msg_len) {
+        memcpy(base64, MEMFAULT_LOG_EXPORT_BASE64_CHUNK_PREFIX,
+               MEMFAULT_LOG_EXPORT_BASE64_CHUNK_PREFIX_LEN);
+
+        size_t log_read_len =
+          MEMFAULT_MIN(log->msg_len - log_read_offset, MEMFAULT_LOG_EXPORT_CHUNK_MAX_LEN);
+        size_t write_offset = MEMFAULT_LOG_EXPORT_BASE64_CHUNK_PREFIX_LEN;
+
+        memfault_base64_encode(&log->msg[log_read_offset], log_read_len, &base64[write_offset]);
+        log_read_offset += log_read_len;
+        write_offset += MEMFAULT_BASE64_ENCODE_LEN(log_read_len);
+
+        memcpy(&base64[write_offset], MEMFAULT_LOG_EXPORT_BASE64_CHUNK_SUFFIX,
+               MEMFAULT_LOG_EXPORT_BASE64_CHUNK_SUFFIX_LEN);
+        write_offset += MEMFAULT_LOG_EXPORT_BASE64_CHUNK_SUFFIX_LEN;
+
+        base64[write_offset] = '\0';
+
+        memfault_log_export_msg(log->level, base64, write_offset);
+      }
+      break;
+    case kMemfaultLogRecordType_Preformatted:
+      memfault_log_export_msg(log->level, log->msg, log->msg_len);
+      break;
+    case kMemfaultLogRecordType_NumTypes:  // silences -Wswitch-enum
+    default:
+      break;
+  }
+}
+
+void memfault_log_export_logs(void) {
+  while (1) {
+    sMemfaultLog log = {0};
+    const bool log_found = memfault_log_read(&log);
+    if (!log_found) {
+      break;
+    }
+
+    memfault_log_export_log(&log);
+  }
+}
+
 static bool prv_should_log(eMemfaultPlatformLogLevel level) {
   if (!s_memfault_ram_logger.enabled) {
     return false;
@@ -342,17 +396,13 @@ static void prv_log_save(eMemfaultPlatformLogLevel level,
 
 #if MEMFAULT_COMPACT_LOG_ENABLE
 
-static void prv_fill_compact_log_cb(void *ctx, uint32_t offset, const void *buf, size_t buf_len) {
-  uint8_t *log = (uint8_t *)ctx;
-  memcpy(&log[offset], buf, buf_len);
-}
-
 void memfault_compact_log_save(eMemfaultPlatformLogLevel level, uint32_t log_id,
                                uint32_t compressed_fmt, ...) {
   char log_buf[MEMFAULT_LOG_MAX_LINE_SAVE_LEN + 1];
 
   sMemfaultCborEncoder encoder;
-  memfault_cbor_encoder_init(&encoder, prv_fill_compact_log_cb, log_buf, sizeof(log_buf));
+  memfault_cbor_encoder_init(&encoder, memfault_cbor_encoder_memcpy_write, log_buf,
+                             sizeof(log_buf));
 
   va_list args;
   va_start(args, compressed_fmt);

components/core/src/memfault_trace_event.c

@@ -245,11 +245,6 @@ int memfault_trace_event_with_log_capture(
 
 #else
 
-static void prv_fill_compact_log_cb(void *ctx, uint32_t offset, const void *buf, size_t buf_len) {
-  uint8_t *log = (uint8_t *)ctx;
-  memcpy(&log[offset], buf, buf_len);
-}
-
 int memfault_trace_event_with_compact_log_capture(
     eMfltTraceReasonUser reason, void *lr_addr,
     uint32_t log_id, uint32_t compressed_fmt, ...) {
@@ -266,7 +261,7 @@ int memfault_trace_event_with_compact_log_capture(
   uint8_t log[MEMFAULT_TRACE_EVENT_MAX_LOG_LEN] = { 0 };
 
   sMemfaultCborEncoder encoder;
-  memfault_cbor_encoder_init(&encoder, prv_fill_compact_log_cb, log, sizeof(log));
+  memfault_cbor_encoder_init(&encoder, memfault_cbor_encoder_memcpy_write, log, sizeof(log));
   memfault_vlog_compact_serialize(&encoder, log_id, compressed_fmt, args);
   size_t log_len = memfault_cbor_encoder_deinit(&encoder);
 

components/include/memfault/core/log.h

@@ -34,6 +34,19 @@
 extern "C" {
 #endif
 
+#define MEMFAULT_LOG_EXPORT_BASE64_CHUNK_PREFIX "ML:"  // *M*emfault *L*og
+#define MEMFAULT_LOG_EXPORT_BASE64_CHUNK_PREFIX_LEN \
+  MEMFAULT_STATIC_STRLEN(MEMFAULT_LOG_EXPORT_BASE64_CHUNK_PREFIX)
+
+#define MEMFAULT_LOG_EXPORT_BASE64_CHUNK_SUFFIX ":"
+#define MEMFAULT_LOG_EXPORT_BASE64_CHUNK_SUFFIX_LEN \
+  MEMFAULT_STATIC_STRLEN(MEMFAULT_LOG_EXPORT_BASE64_CHUNK_SUFFIX)
+
+#define MEMFAULT_LOG_EXPORT_BASE64_CHUNK_MAX_LEN                   \
+  (MEMFAULT_LOG_EXPORT_BASE64_CHUNK_PREFIX_LEN +                   \
+   MEMFAULT_BASE64_ENCODE_LEN(MEMFAULT_LOG_EXPORT_CHUNK_MAX_LEN) + \
+   MEMFAULT_LOG_EXPORT_BASE64_CHUNK_SUFFIX_LEN + 1 /* '\0' */)
+
 //! Must be called on boot to initialize the Memfault logging module
 //!
 //! @param buffer The ram buffer to save logs into
@@ -155,6 +168,25 @@ typedef struct {
 //!   }
 bool memfault_log_read(sMemfaultLog *log);
 
+//! Utility that formats and outputs a log via the output medium defined in
+//! `memfault_log_export_msg`.
+//!
+//! @note In case the log message is stored in the binary "compact log" format, the message is first
+//! formatted as 'ML:COMPACT_LOG_DATA_BASE64_ENCODED:'
+//! A python library for decoding compact logs can be found here:
+//! https://pypi.org/project/mflt-compact-log/
+void memfault_log_export_log(sMemfaultLog *log);
+
+//! Helper function that repeatedly calls memfault_log_read() until there are no more logs
+//! available. For each log `memfault_log_export_log` is called.
+void memfault_log_export_logs(void);
+
+//! Called as part of memfault_log_export() for every time a log message needs to be exported.
+//!
+//! @note This is a weak function that by default calls `memfault_platform_log_raw`. It can be
+//! overriden to change the formatting of the output, as well as where it is stored.
+extern void memfault_log_export_msg(eMemfaultPlatformLogLevel level, const char *msg, size_t msg_len);
+
 //! Invoked every time a new log has been saved
 //!
 //! @note By default this is a weak function which behaves as a no-op. Platforms which dispatch

components/include/memfault/default_config.h

@@ -103,6 +103,13 @@ extern "C" {
 #define MEMFAULT_LOG_DATA_SOURCE_ENABLED 1
 #endif
 
+//! Maximum length of a compact log export chunk.
+//!
+//! Controls the maximum chunk length when exporting compact logs with memfault_log_export.
+#ifndef MEMFAULT_LOG_EXPORT_CHUNK_MAX_LEN
+  #define MEMFAULT_LOG_EXPORT_CHUNK_MAX_LEN 80
+#endif
+
 //! Maximum length a log record can occupy
 //!
 //! Structs holding this log may be allocated on the stack so care should be taken

components/include/memfault/util/cbor.h

@@ -161,6 +161,15 @@ bool memfault_cbor_encode_long_signed_integer(sMemfaultCborEncoder *encoder, int
 //! @return true on success, false otherwise
 bool memfault_cbor_encode_null(sMemfaultCborEncoder *encoder);
 
+//! Helper utility to copy a given buffer to the output buffer at the given offset using memcpy.
+//!
+//! @param ctx Output buffer
+//! @param offset Offset data is copied to in output buffer
+//! @param buf Input buffer to be copied
+//! @param buf_len Length of input buffer
+void memfault_cbor_encoder_memcpy_write(void *ctx, uint32_t offset, const void *buf,
+                                        size_t buf_len);
+
 //! NOTE: For internal use only, included in the header so it's easy for a caller to statically
 //! allocate the structure
 struct MemfaultCborEncoder {

components/include/memfault/version.h

@@ -19,7 +19,7 @@ typedef struct {
   uint8_t patch;
 } sMfltSdkVersion;
 
-#define MEMFAULT_SDK_VERSION   { .major = 0, .minor = 42, .patch = 0 }
+#define MEMFAULT_SDK_VERSION   { .major = 0, .minor = 42, .patch = 1 }
 
 #ifdef __cplusplus
 }