Memfault BORT SDK 5.3.0 (Build 2885152)

Author: Memfault Inc.

CHANGELOG.md

@@ -1,4 +1,58 @@
-# Memfault Bort Changelog
+# Memfault Android SDK Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+This project currently does not attempt to adhere to Semantic Versioning, but
+breaking changes are avoided unless absolutely necessary.
+
+## v5.3.0 - February 14, 2025
+
+### :rocket: New Features
+
+- Added new per-component total storage metrics. The total storage used
+  (apps+cache+data+external) by an application can be recorded as a
+  `storage_<package>_bytes` metric. Please feel free to contact us if you would
+  like this enabled for applications in your project.
+- Added new mechanism to group operational crashes by package. The existing
+  `operational_crashes` core metric can be divided into
+  `operational_crashes_<group>` metrics, based off of the package names of the
+  crashes. Please feel free to contact us if you would like this enabled for
+  your project.
+- Added new DropBox count core metrics. The number of DropBox entries processed
+  each heartbeat, grouped by Issue type, is now recorded as a
+  `drop_box_<type>_count` metric. This makes identifying crashy devices even
+  easier.
+- Added new `.mean_time_in_state` metric alongside `.total_secs` when the
+  `TIME_TOTALS` aggregation is used with `StateTracker`s. The existing
+  `.total_secs` metric is truncated between heartbeats, so it is only useful as
+  a rough percentage comparison versus other states. The new
+  `.mean_time_in_state` metric can be used to track the absolute time spent in a
+  state, even across heartbeats, so its value can be used as an absolute number.
+
+### :chart_with_upwards_trend: Improvements
+
+- Returned a `Session` object when `startSession` is called to improve the API
+  usability.
+- Removed `SYSTEM_BOOT` from the default list of 'other' collected DropBox
+  Entries. After some field testing, this DropBox Entry was not consistently
+  collected and did not contain useful information.
+- Silenced tags in continuous logs that did not match the filter spec.
+
+### :construction: Fixes
+
+- Fixed a logs-to-metrics bug where it could not parse logcat tags with spaces.
+- Fixed a harmless SELinux violation where memfault_structured_app could not
+  access its own data directory.
+- Fixed a bug in bort_cli.py's validation-sdk-integration command where it
+  wouldn't check the right location for system_ext sepolicy.
+- Fixed a continuous log bug where spaces in the tag would break parsing.
+
+### :house: Internal
+
+- Migrated off junit5/jupiter back to junit4, at least until it has first party
+  support from the Android team/
+- Added minio to the debug network security config for local development.
 
 ## v5.2.0 - November 15, 2024
 

MemfaultDumpster/ContinuousLogcat.cpp

@@ -156,8 +156,11 @@ void ContinuousLogcat::rebuild_log_format(const std::vector<std::string>& filter
   // add filters
   for (auto &filter : filter_specs) {
     ALOGT("clog: filter: %s", filter.c_str());
-    android_log_addFilterString(log_format.get(), filter.c_str());
+    android_log_addFilterRule(log_format.get(), filter.c_str());
   }
+
+  // silence all other tags and levels
+  android_log_addFilterRule(log_format.get(), "*:S");
 }
 
 void ContinuousLogcat::join() {
@@ -281,7 +284,9 @@ void ContinuousLogcat::run() {
       // Force-checked if line should be printed, in some android
       // versions, the filters are not passed to the logd backend
       // so we need to recheck them
-      if (!android_log_shouldPrintLine(log_format.get(), entry.tag, entry.priority)) {
+      if (!android_log_shouldPrintLine(log_format.get(),
+                                       std::string(entry.tag, entry.tagLen).c_str(),
+                                       entry.priority)) {
         continue;
       }
 

MemfaultPackages/bort-ota-lib/src/test/java/com/memfault/bort/ota/lib/ABUpdateActionHandlerTest.kt

@@ -2,6 +2,10 @@ package com.memfault.bort.ota.lib
 
 import android.app.Application
 import android.content.SharedPreferences
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
 import com.memfault.bort.shared.SoftwareUpdateSettings
 import io.mockk.coEvery
 import io.mockk.every
@@ -11,9 +15,8 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.UnconfinedTestDispatcher
 import kotlinx.coroutines.test.runTest
-import org.junit.jupiter.api.Assertions.assertEquals
-import org.junit.jupiter.api.BeforeEach
-import org.junit.jupiter.api.Test
+import org.junit.Before
+import org.junit.Test
 
 private const val OLD_SOFTWARE_VERSION = "old"
 
@@ -51,7 +54,7 @@ class ABUpdateActionHandlerTest {
         isForced = null,
     )
 
-    @BeforeEach
+    @Before
     fun setup() {
         softwareUpdateCheckerMock = mockk {
             coEvery { getLatestRelease() } coAnswers { ota }
@@ -108,61 +111,58 @@ class ABUpdateActionHandlerTest {
 
     @Test
     fun testCallbacks() = runBlocking {
-        assertEquals(1, updateEngineCallbacks.size)
+        assertThat(updateEngineCallbacks.size).isEqualTo(1)
     }
 
     @Test
     fun testCheckForUpdate_foreground() = runBlocking {
         handler.handle(State.Idle, Action.CheckForUpdate(background = false))
-        assertEquals(
+        assertThat(collectedStates).isEqualTo(
             listOf(State.CheckingForUpdates, State.UpdateAvailable(ota!!, showNotification = false)),
-            collectedStates,
+
         )
-        assertEquals(listOf<Event>(), collectedEvents)
+        assertThat(collectedEvents).isEmpty()
     }
 
     @Test
     fun testCheckForUpdate_forcedNotSet() = runTest {
         ota = ota?.copy(isForced = null)
         handler.handle(State.Idle, Action.CheckForUpdate(background = true))
-        assertEquals(
+        assertThat(collectedStates).isEqualTo(
             listOf(State.CheckingForUpdates, State.UpdateAvailable(ota!!, showNotification = true)),
-            collectedStates,
         )
-        assertEquals(listOf<Event>(), collectedEvents)
+        assertThat(collectedEvents).isEmpty()
         verify(exactly = 0) { scheduleDownload.scheduleDownload(any()) }
     }
 
     @Test
     fun testCheckForUpdate_notForced() = runTest {
         ota = ota?.copy(isForced = false)
         handler.handle(State.Idle, Action.CheckForUpdate(background = true))
-        assertEquals(
+        assertThat(collectedStates).isEqualTo(
             listOf(State.CheckingForUpdates, State.UpdateAvailable(ota!!, showNotification = true)),
-            collectedStates,
         )
-        assertEquals(listOf<Event>(), collectedEvents)
+        assertThat(collectedEvents).isEmpty()
         verify(exactly = 0) { scheduleDownload.scheduleDownload(any()) }
     }
 
     @Test
     fun testCheckForUpdate_forced_scheduleAutoDownload() = runTest {
         ota = ota?.copy(isForced = true)
         handler.handle(State.Idle, Action.CheckForUpdate(background = true))
-        assertEquals(
+        assertThat(collectedStates).isEqualTo(
             listOf(State.CheckingForUpdates, State.UpdateAvailable(ota!!, showNotification = false)),
-            collectedStates,
         )
-        assertEquals(listOf<Event>(), collectedEvents)
+        assertThat(collectedEvents).isEmpty()
         verify(exactly = 1) { scheduleDownload.scheduleDownload(ota!!) }
     }
 
     @Test
     fun testCheckForUpdateAlreadyAtLatest() = runBlocking {
         ota = null
         handler.handle(State.Idle, Action.CheckForUpdate())
-        assertEquals(listOf(State.CheckingForUpdates, State.Idle), collectedStates)
-        assertEquals(listOf<Event>(Event.NoUpdatesAvailable), collectedEvents)
+        assertThat(collectedStates).containsExactly(State.CheckingForUpdates, State.Idle)
+        assertThat(collectedEvents).containsExactly(Event.NoUpdatesAvailable)
     }
 
     @Test
@@ -173,8 +173,8 @@ class ABUpdateActionHandlerTest {
             onStatusUpdate(UPDATE_ENGINE_STATUS_DOWNLOADING, 0f)
         }
 
-        assertEquals(listOf(State.UpdateDownloading(ota!!)), collectedStates)
-        assertEquals(listOf<Event>(), collectedEvents)
+        assertThat(collectedStates).containsExactly(State.UpdateDownloading(ota!!))
+        assertThat(collectedEvents).isEmpty()
         verify(exactly = 1) {
             testingUpdateEngine.applyPayload(
                 ota!!.url,
@@ -195,14 +195,13 @@ class ABUpdateActionHandlerTest {
             onStatusUpdate(UPDATE_ENGINE_STATUS_DOWNLOADING, 1f)
         }
 
-        assertEquals(
+        assertThat(collectedStates).isEqualTo(
             listOf(
                 State.UpdateDownloading(ota!!, progress = 50),
                 State.UpdateDownloading(ota!!, progress = 100),
             ),
-            collectedStates,
         )
-        assertEquals(listOf<Event>(), collectedEvents)
+        assertThat(collectedEvents).isEmpty()
         verify(exactly = 1) {
             testingUpdateEngine.applyPayload(
                 ota!!.url,
@@ -216,13 +215,12 @@ class ABUpdateActionHandlerTest {
     @Test
     fun testRebootAfterCompletion() = runBlocking {
         handler.handle(State.RebootNeeded(ota!!), Action.Reboot)
-        assertEquals(
+        assertThat(collectedStates).isEqualTo(
             listOf<State>(
                 State.RebootedForInstallation(ota!!, OLD_SOFTWARE_VERSION),
             ),
-            collectedStates,
         )
-        assertEquals(listOf<Event>(), collectedEvents)
+        assertThat(collectedEvents).isEmpty()
 
         verify(exactly = 1) { rebootDevice() }
     }
@@ -236,55 +234,51 @@ class ABUpdateActionHandlerTest {
             onStatusUpdate(UPDATE_ENGINE_FINALIZING, 1f)
         }
 
-        assertEquals(
+        assertThat(collectedStates).isEqualTo(
             listOf(
                 State.Finalizing(ota!!, progress = 50),
                 State.Finalizing(ota!!, progress = 100),
             ),
-            collectedStates,
         )
-        assertEquals(listOf<Event>(), collectedEvents)
+        assertThat(collectedEvents).isEmpty()
     }
 
     @Test
     fun testBecomeIdle() = runBlocking {
         forEachCallback {
             onStatusUpdate(UPDATE_ENGINE_STATUS_IDLE, 0f)
         }
-        assertEquals(
+        assertThat(collectedStates).isEqualTo(
             listOf(
                 State.Idle,
             ),
-            collectedStates,
         )
-        assertEquals(listOf<Event>(), collectedEvents)
+        assertThat(collectedEvents).isEmpty()
     }
 
     @Test
     fun testUpdateFinishedNeedReboot() = runBlocking {
         forEachCallback {
             onStatusUpdate(UPDATE_ENGINE_UPDATED_NEED_REBOOT, 0f)
         }
-        assertEquals(
+        assertThat(collectedStates).isEqualTo(
             listOf(
                 State.RebootNeeded(ota!!),
             ),
-            collectedStates,
         )
-        assertEquals(listOf<Event>(), collectedEvents)
+        assertThat(collectedEvents).isEmpty()
     }
 
     @Test
     fun testDownloadFailedTrigger() = runBlocking {
         forEachCallback {
             onPayloadApplicationComplete(UPDATE_ENGINE_ERROR_DOWNLOAD_TRANSFER_ERROR)
         }
-        assertEquals(listOf<State>(), collectedStates)
-        assertEquals(
+        assertThat(collectedStates).isEmpty()
+        assertThat(collectedEvents).isEqualTo(
             listOf<Event>(
                 Event.DownloadFailed,
             ),
-            collectedEvents,
         )
     }
 
@@ -293,12 +287,11 @@ class ABUpdateActionHandlerTest {
         forEachCallback {
             onPayloadApplicationComplete(-1)
         }
-        assertEquals(listOf<State>(), collectedStates)
-        assertEquals(
+        assertThat(collectedStates).isEmpty()
+        assertThat(collectedEvents).isEqualTo(
             listOf<Event>(
                 Event.VerificationFailed,
             ),
-            collectedEvents,
         )
     }
 

MemfaultPackages/bort-ota-lib/src/test/java/com/memfault/bort/ota/lib/BortSoftwareUpdateSettingsProviderTest.kt

@@ -5,6 +5,9 @@ import android.database.MatrixCursor
 import android.net.Uri
 import androidx.work.NetworkType.CONNECTED
 import androidx.work.NetworkType.UNMETERED
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
 import com.memfault.bort.shared.LegacySoftwareUpdateSettings
 import com.memfault.bort.shared.SoftwareUpdateSettings
 import com.memfault.bort.shared.SoftwareUpdateSettings.Companion.createCursor
@@ -13,8 +16,6 @@ import io.mockk.every
 import io.mockk.mockk
 import kotlinx.serialization.SerializationException
 import kotlinx.serialization.json.Json
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
@@ -46,30 +47,30 @@ class BortSoftwareUpdateSettingsProviderTest {
     fun oldOtaNewBort() {
         cursor = createCursor(settings)
         val provider = LegacyProviderClient(resolver)
-        assertEquals(settings.asLegacyOtaSettings(), provider.settings())
+        assertThat(provider.settings()).isEqualTo(settings.asLegacyOtaSettings())
     }
 
     @Test
     fun oldOtaNewBort_newFormat_crashes() {
         // This is what would have happened if we did not go to all this trouble to include "legacy" formatted settings.
         cursor = legacyCreateCursorWithNewFormat(settings)
         val provider = LegacyProviderClient(resolver)
-        assertNull(provider.settings())
+        assertThat(provider.settings()).isNull()
     }
 
     @Test
     fun newOtaNewBort() {
         cursor = createCursor(settings)
         val provider = BortSoftwareUpdateSettingsFetcher(resolver)
-        assertEquals(settings, provider.settings())
+        assertThat(provider.settings()).isEqualTo(settings)
     }
 
     @Test
     fun newOtaOldBort() {
         cursor = legacyCreateCursor(settings.asLegacyOtaSettings())
         val provider = BortSoftwareUpdateSettingsFetcher(resolver)
         // Default value should be used for new field.
-        assertEquals(settings.copy(downloadNetworkTypeConstraint = UNMETERED), provider.settings())
+        assertThat(provider.settings()).isEqualTo(settings.copy(downloadNetworkTypeConstraint = UNMETERED))
     }
 
     /**