UI refinements for the Live Feed

Author: 0xadam-brown

sentry-android-buddy/src/main/java/io/sentry/android/buddy/BuddyLiveFeed.kt

@@ -16,6 +16,7 @@ internal data class BuddyLiveFeedItem(
   val severity: Severity = Severity.LOW,
   val adverse: Boolean = false,
   val viewed: Boolean = false,
+  val visibleScreens: List<String> = emptyList(),
 ) {
   enum class Category(val label: String) {
     SCREEN("Screen"),
@@ -39,6 +40,7 @@ internal class BuddyLiveFeedBuffer(private val capacity: Int) {
     category: BuddyLiveFeedItem.Category,
     severity: Severity,
     adverse: Boolean,
+    visibleScreens: List<String>,
   ): BuddyLiveFeed {
     nextId++
     items +=
@@ -48,6 +50,7 @@ internal class BuddyLiveFeedBuffer(private val capacity: Int) {
         category = category,
         severity = severity,
         adverse = adverse,
+        visibleScreens = visibleScreens,
       )
     while (items.size > capacity) {
       items.removeFirst()

sentry-android-buddy/src/main/java/io/sentry/android/buddy/SentryBuddyUi.kt

@@ -595,34 +595,36 @@ private fun LiveFeedSheet(
     BuddyButtonText("Start Recording")
   }
   Text(
-    "Recent useful signals",
+    "Live feed",
     style = MaterialTheme.typography.titleMedium,
     fontWeight = FontWeight.Bold,
     color = BuddyInk,
   )
   if (liveFeed.items.isEmpty()) {
     EmptyLiveFeedCard()
   } else {
-    LiveFeedRows(liveFeed.items, sentryUiLinks, nowMs)
+    LiveFeedRows(liveFeed.items.take(LIVE_FEED_VISIBLE_ITEM_LIMIT), sentryUiLinks, nowMs)
   }
 }
 
 @Composable
 private fun AttentionCard(liveFeed: BuddyLiveFeed, sentryUiLinks: BuddySentryUiLinks, nowMs: Long) {
+  Text(
+    "Needs attention",
+    style = MaterialTheme.typography.titleMedium,
+    fontWeight = FontWeight.Bold,
+    color = BuddyInk,
+  )
+
   val item = liveFeed.latestAdverseItem
   if (item == null) {
-    Card(border = CardDefaults.outlinedCardBorder()) {
-      Row(
-        modifier = Modifier.fillMaxWidth().padding(16.dp),
-        horizontalArrangement = Arrangement.SpaceBetween,
-        verticalAlignment = Alignment.CenterVertically,
-      ) {
-        Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
-          Text("Needs attention", color = BuddyInk, fontWeight = FontWeight.Bold)
-          Text("No recent errors or slow spans.", color = BuddyMuted)
-        }
-        Text("OK", color = BuddyPurple, fontWeight = FontWeight.Bold)
-      }
+    Row(
+      modifier = Modifier.fillMaxWidth().padding(vertical = 6.dp),
+      horizontalArrangement = Arrangement.SpaceBetween,
+      verticalAlignment = Alignment.CenterVertically,
+    ) {
+      Text("No recent errors or slow spans.", color = BuddyMuted)
+      Text("OK", color = BuddyPurple, fontWeight = FontWeight.Bold)
     }
     return
   }
@@ -634,34 +636,36 @@ private fun AttentionCard(liveFeed: BuddyLiveFeed, sentryUiLinks: BuddySentryUiL
     modifier =
       Modifier.clickable(enabled = link != null) { link?.let { openSentryLink(context, it) } },
     colors = CardDefaults.cardColors(containerColor = color.copy(alpha = 0.10f)),
-    border = CardDefaults.outlinedCardBorder(),
   ) {
     Column(
       modifier = Modifier.fillMaxWidth().padding(16.dp),
       verticalArrangement = Arrangement.spacedBy(10.dp),
     ) {
       Row(
+        modifier = Modifier.fillMaxWidth(),
         horizontalArrangement = Arrangement.spacedBy(10.dp),
         verticalAlignment = Alignment.CenterVertically,
       ) {
-        Box(modifier = Modifier.size(10.dp).background(color, CircleShape))
-        Text("Needs attention", color = BuddyInk, fontWeight = FontWeight.Bold)
-        Text(relativeTime(item.timestamp.time, nowMs), color = BuddyMuted)
-      }
-      Text(
-        item.title(),
-        color = BuddyInk,
-        style = MaterialTheme.typography.titleMedium,
-        fontWeight = FontWeight.Bold,
-      )
-      item.subtitle()?.let { Text(it, color = BuddyMuted) }
-      if (link != null) {
+        LiveFeedCategoryPill(item.category.label, color)
         Text(
-          "Open in Sentry",
-          color = BuddyPurple,
-          style = MaterialTheme.typography.labelMedium,
+          item.title(),
+          modifier = Modifier.weight(1f),
+          color = BuddyInk,
+          style = MaterialTheme.typography.titleMedium,
           fontWeight = FontWeight.Bold,
         )
+        Text(
+          relativeTime(item.timestamp.time, nowMs),
+          color = BuddyMuted,
+          style = MaterialTheme.typography.labelMedium,
+        )
+      }
+      item.screenContextText()?.let { screenContext ->
+        Text(
+          screenContext,
+          color = BuddyMuted,
+          style = MaterialTheme.typography.bodySmall,
+        )
       }
       Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
         adverseCountChips(liveFeed).forEach { chip ->
@@ -707,29 +711,26 @@ private fun LiveFeedRows(
       val color =
         if (item.adverse) severityColor(item.severity) else timelineColor(item.timelineItem)
       val link = sentryUiLinks.linkFor(item)
-      Card(
+      Row(
         modifier =
-          Modifier.clickable(enabled = link != null) { link?.let { openSentryLink(context, it) } },
-        border = CardDefaults.outlinedCardBorder(),
+          Modifier.fillMaxWidth()
+            .clickable(enabled = link != null) { link?.let { openSentryLink(context, it) } }
+            .padding(vertical = 7.dp),
+        horizontalArrangement = Arrangement.spacedBy(10.dp),
+        verticalAlignment = Alignment.CenterVertically,
       ) {
-        Row(
-          modifier = Modifier.fillMaxWidth().padding(14.dp),
-          horizontalArrangement = Arrangement.spacedBy(10.dp),
-          verticalAlignment = Alignment.CenterVertically,
-        ) {
-          LiveFeedCategoryPill(item.category.label, color)
-          Text(
-            item.title(),
-            modifier = Modifier.weight(1f),
-            color = BuddyInk,
-            fontWeight = FontWeight.Bold,
-          )
-          Text(
-            relativeTime(item.timestamp.time, nowMs),
-            color = BuddyMuted,
-            style = MaterialTheme.typography.labelMedium,
-          )
-        }
+        LiveFeedCategoryPill(item.category.label, color)
+        Text(
+          item.title(),
+          modifier = Modifier.weight(1f),
+          color = BuddyInk,
+          fontWeight = if (item.adverse) FontWeight.Bold else FontWeight.Normal,
+        )
+        Text(
+          relativeTime(item.timestamp.time, nowMs),
+          color = BuddyMuted,
+          style = MaterialTheme.typography.labelMedium,
+        )
       }
     }
   }
@@ -1035,45 +1036,21 @@ private fun BuddyLiveFeedItem.title(): String =
     BuddyLiveFeedItem.Category.FAILED_SPAN -> timelineItem.name ?: "Failed span"
   }
 
-private fun BuddyLiveFeedItem.subtitle(): String? =
-  when (category) {
-    BuddyLiveFeedItem.Category.SCREEN -> null
-    BuddyLiveFeedItem.Category.STEP -> null
-    BuddyLiveFeedItem.Category.ERROR ->
-      listOfNotNull(
-          timelineItem.data.stringValue("message"),
-          timelineItem.data.stringValue("transaction")?.let { "in $it" },
-        )
-        .joinToString(" • ")
-        .ifBlank { null }
-    BuddyLiveFeedItem.Category.FAILED_HTTP -> httpSubtitle()
-    BuddyLiveFeedItem.Category.SLOW_SPAN,
-    BuddyLiveFeedItem.Category.FAILED_SPAN -> spanSubtitle()
-  }
-
 private fun BuddyLiveFeedItem.httpTitle(): String {
   val data = timelineItem.data.mapValue("data")
   val method = data.stringValue("method") ?: data.stringValue("http.method")
   val url = data.stringValue("url") ?: data.stringValue("http.url")
   return listOfNotNull(method, url).joinToString(" ").ifBlank { timelineItem.name ?: "Failed HTTP" }
 }
 
-private fun BuddyLiveFeedItem.httpSubtitle(): String? {
-  val data = timelineItem.data.mapValue("data")
-  val statusCode = data.longValue("status_code") ?: timelineItem.data.longValue("status_code")
-  return statusCode?.let { "HTTP $it" }
+private fun BuddyLiveFeedItem.screenContextText(): String? {
+  if (visibleScreens.isEmpty()) {
+    return null
+  }
+  val label = if (visibleScreens.size == 1) "Screen" else "Screens"
+  return "$label: ${visibleScreens.joinToString(" -> ")}"
 }
 
-private fun BuddyLiveFeedItem.spanSubtitle(): String? =
-  listOfNotNull(
-      timelineItem.data.stringValue("op"),
-      timelineItem.data.stringValue("status")?.let { "status $it" },
-      timelineItem.data.longValue("duration_ms")?.let { "${it}ms" },
-      timelineItem.data.stringValue("transaction")?.let { "in $it" },
-    )
-    .joinToString(" • ")
-    .ifBlank { null }
-
 private fun relativeTime(timestampMs: Long, nowMs: Long): String {
   val ageMs = (nowMs - timestampMs).coerceAtLeast(0)
   if (ageMs < 1000) {
@@ -1400,6 +1377,7 @@ private val BuddyBubbleInitialTop = 96.dp
 private val BuddyBubbleTouchPadding = 20.dp
 private val BuddyTransientTextWidth = 190.dp
 private val BuddyTransientTextHeight = 28.dp
+private const val LIVE_FEED_VISIBLE_ITEM_LIMIT = 7
 private const val ANALYSIS_POLL_INTERVAL_MS = 1000L
 private const val ANALYSIS_TIMEOUT_MS = 30_000L
 

sentry-android-buddy/src/main/java/io/sentry/android/buddy/internal.kt

@@ -394,10 +394,42 @@ internal class BuddyRecorder(
     severity: Severity,
     adverse: Boolean,
   ) {
-    val snapshot = liveFeed.add(item, category, severity, adverse)
+    val snapshot =
+      liveFeed.add(
+        item = item,
+        category = category,
+        severity = severity,
+        adverse = adverse,
+        visibleScreens = activeRecording.visibleScreensFor(item),
+      )
     liveFeedListeners.toList().forEach { it(snapshot) }
   }
 
+  private fun ActiveRecording?.visibleScreensFor(item: BuddyTimelineItem): List<String> {
+    val recording = this ?: return emptyList()
+    val startMs = item.timestamp.time
+    val endMs = item.data.longValue(DATA_DURATION_MS)?.let { startMs + it } ?: startMs
+    val screenItems =
+      recording.timeline
+        .filter { it.type == BuddyTimelineItem.Type.SCREEN && !it.name.isNullOrBlank() }
+        .sortedBy { it.timestamp.time }
+    val screenAtStart = screenItems.lastOrNull { it.timestamp.time <= startMs }
+    val screensDuringItem = screenItems.filter { it.timestamp.time in (startMs + 1)..endMs }
+    return (listOfNotNull(screenAtStart) + screensDuringItem)
+      .mapNotNull { it.name }
+      .dedupeConsecutive()
+  }
+
+  private fun List<String>.dedupeConsecutive(): List<String> {
+    val deduped = mutableListOf<String>()
+    forEach { screen ->
+      if (deduped.lastOrNull() != screen) {
+        deduped += screen
+      }
+    }
+    return deduped
+  }
+
   private fun ActiveRecording?.elapsedAt(timestamp: Date): Long =
     this?.let { timestamp.time - it.startedAt.time } ?: 0
 

sentry-android-buddy/src/test/java/io/sentry/android/buddy/BuddyRecorderTest.kt

@@ -420,6 +420,51 @@ class BuddyRecorderTest {
     assertThat(item.severity).isEqualTo(Severity.HIGH)
   }
 
+  @Test
+  fun `live feed records visible screen for adverse event`() {
+    val fixture = Fixture()
+    fixture.recorder.start(BuddyFlowIntent("Checkout"))
+    fixture.recorder.recordScreen("/home")
+
+    fixture.recorder.recordEvent(BuddyObservedEvent(Date(500), "Boom", emptyMap()))
+
+    val item = fixture.recorder.liveFeedSnapshot().latestAdverseItem
+
+    assertThat(item?.visibleScreens).containsExactly("/home")
+  }
+
+  @Test
+  fun `live feed records screen path for adverse span crossing screens`() {
+    val fixture = Fixture()
+    fixture.recorder.start(BuddyFlowIntent("Checkout"))
+    fixture.recorder.recordScreen("/home")
+    fixture.clock.advance(500)
+    fixture.recorder.recordScreen("/profile")
+
+    fixture.recorder.recordTransaction(
+      BuddyObservedTransaction(
+        recordingId = "recording-1",
+        operation = "ui.load",
+        transactionName = "ProfileActivity",
+        timestamp = Date(1000),
+        spans =
+          listOf(
+            BuddyObservedSpan(
+              id = "slow-span",
+              timestamp = Date(100),
+              operation = "ui.load",
+              description = "full display",
+              data = linkedMapOf("duration_ms" to 1000),
+            )
+          ),
+      )
+    )
+
+    val item = fixture.recorder.liveFeedSnapshot().latestAdverseItem
+
+    assertThat(item?.visibleScreens).containsExactly("/home", "/profile").inOrder()
+  }
+
   @Test
   fun `mark live feed seen clears unviewed adverse count`() {
     val fixture = Fixture()