@@ -3,6 +3,7 @@ package com.parseable.android.ui.screens.logviewer
3import androidx.lifecycle.ViewModel
3import androidx.lifecycle.ViewModel
4import androidx.lifecycle.viewModelScope
4import androidx.lifecycle.viewModelScope
5import com.parseable.android.data.escapeIdentifier
5import com.parseable.android.data.escapeIdentifier
6+import com.parseable.android.data.escapeLikePattern
6import com.parseable.android.data.escapeSql
7import com.parseable.android.data.escapeSql
7import com.parseable.android.data.model.*
8import com.parseable.android.data.model.*
8import com.parseable.android.data.repository.ParseableRepository
9import com.parseable.android.data.repository.ParseableRepository
@@ -15,8 +16,13 @@ import kotlinx.coroutines.flow.asStateFlow
15import kotlinx.coroutines.flow.update
16import kotlinx.coroutines.flow.update
16import kotlinx.coroutines.isActive
17import kotlinx.coroutines.isActive
17import kotlinx.coroutines.launch
18import kotlinx.coroutines.launch
19+import kotlinx.coroutines.sync.Mutex
20+import kotlinx.coroutines.sync.withLock
18import kotlinx.serialization.json.JsonObject
21import kotlinx.serialization.json.JsonObject
19import kotlinx.serialization.json.jsonPrimitive
22import kotlinx.serialization.json.jsonPrimitive
23+import java.time.Instant
24+import java.time.LocalDateTime
25+import java.time.OffsetDateTime
20import java.time.ZoneOffset
26import java.time.ZoneOffset
21import java.time.ZonedDateTime
27import java.time.ZonedDateTime
22import java.time.format.DateTimeFormatter
28import java.time.format.DateTimeFormatter
@@ -34,10 +40,21 @@ enum class TimeRange(val label: String, val minutes: Long) {
34 CUSTOM("Custom", 0),
40 CUSTOM("Custom", 0),
43+/** The original (column, operator, value) a filter chip was built from. */
44+data class FilterCondition(
46+ val operator: String,
37data class FilterState(
50data class FilterState(
38 val searchQuery: String = "",
51 val searchQuery: String = "",
39 val activeFilters: List<String> = emptyList(),
52 val activeFilters: List<String> = emptyList(),
40 val filterClauses: List<String> = emptyList(),
53 val filterClauses: List<String> = emptyList(),
54+ // Structured form of each chip, index-aligned with activeFilters/filterClauses.
55+ // Kept so saved filters reconstruct from real values instead of re-parsing the
56+ // human-readable display string (which is ambiguous when a value contains an operator).
57+ val filterConditions: List<FilterCondition> = emptyList(),
41 val customSql: String = "",
58 val customSql: String = "",
42 val isSearching: Boolean = false,
59 val isSearching: Boolean = false,
@@ -72,6 +89,10 @@ data class LogViewerState(
72 val hasMore: Boolean = false,
89 val hasMore: Boolean = false,
73 val customStartTime: Long? = null,
90 val customStartTime: Long? = null,
74 val customEndTime: Long? = null,
91 val customEndTime: Long? = null,
92+ // Upper time bound (epoch millis) fixed at the first page of a paging session, so loadMore()
93+ // doesn't slide a relative ("last N minutes") window forward as it re-queries. Null until the
94+ // first refresh of a session; re-anchored whenever currentLimit resets to the initial page.
95+ val pageAnchorTime: Long? = null,
76 // Convenience accessors for backward compatibility with Screen
97 // Convenience accessors for backward compatibility with Screen
77 val searchQuery: String get() = filters.searchQuery
98 val searchQuery: String get() = filters.searchQuery
@@ -99,13 +120,29 @@ class LogViewerViewModel @Inject constructor(
99 @Volatile private var streamingGeneration: Int = 0
120 @Volatile private var streamingGeneration: Int = 0
100 @Volatile private var lastSeenTimestamp: String? = null
121 @Volatile private var lastSeenTimestamp: String? = null
101 @Volatile private var consecutiveStreamingErrors: Int = 0
122 @Volatile private var consecutiveStreamingErrors: Int = 0
123+ // True while the log list is scrolled to the top. New rows prepend at the top, so when the
124+ // user is already there they see them live and the "+N new" badge must stay at 0. The badge
125+ // only accumulates while the user is scrolled away, and resets when they return to the top.
126+ @Volatile private var viewingTop: Boolean = true
128+ // Identities of rows already surfaced during the current streaming session. Used to dedupe
129+ // re-fetched boundary rows. Kept INDEPENDENT of the displayed `logs` list — which is capped
130+ // at STREAMING_MAX_LOGS — so that under sustained high-volume streaming, boundary rows
131+ // evicted from the view are still recognized as duplicates and not prepended twice.
132+ // Insertion-ordered so the oldest keys are trimmed first. Touched only from the single
133+ // streaming coroutine and from startStreaming (which first cancels that coroutine).
134+ private val seenStreamingKeys = LinkedHashSet<String>()
102 private var searchJob: Job? = null
135 private var searchJob: Job? = null
103 private var schemaJob: Job? = null
136 private var schemaJob: Job? = null
137+ private var refreshJob: Job? = null
105 companion object {
139 companion object {
106 private const val STREAMING_BASE_INTERVAL_MS = 3000L
140 private const val STREAMING_BASE_INTERVAL_MS = 3000L
107 private const val STREAMING_MAX_INTERVAL_MS = 30000L
141 private const val STREAMING_MAX_INTERVAL_MS = 30000L
108 private const val STREAMING_MAX_LOGS = 1000
142 private const val STREAMING_MAX_LOGS = 1000
143+ // Remember more identities than the display cap so a row evicted from the view is still
144+ // deduped on a later re-fetch. 2x the display cap covers the worst realistic overlap.
145+ private const val SEEN_STREAMING_KEYS_MAX = STREAMING_MAX_LOGS * 2
109 private const val MAX_LOAD_LIMIT = 5000
146 private const val MAX_LOAD_LIMIT = 5000
110 private const val LOAD_MORE_INCREMENT = 500
147 private const val LOAD_MORE_INCREMENT = 500
111 private const val MAX_STREAMING_ERRORS = 5
148 private const val MAX_STREAMING_ERRORS = 5
@@ -118,10 +155,13 @@ class LogViewerViewModel @Inject constructor(
118 internal fun computeLogKeys(logs: List<JsonObject>): List<String> {
155 internal fun computeLogKeys(logs: List<JsonObject>): List<String> {
119 val seen = mutableMapOf<String, Int>()
156 val seen = mutableMapOf<String, Int>()
120 return logs.map { log ->
157 return logs.map { log ->
121− val ts = log["p_timestamp"]?.toString()
158+ // Key on the full row content (same identity used for streaming dedup, see
122− val meta = log["p_metadata"]?.toString()
159+ // logIdentity). Keying on only p_timestamp/p_metadata/p_tags collided for rows
123− val tag = log["p_tags"]?.toString()
160+ // sharing those fields but differing in body, so the positional tiebreaker made
161+ // keys shift when streaming prepended rows — corrupting expanded state and
162+ // letting remember(stableKey) blocks render a stale body. The trailing counter
163+ // only disambiguates genuinely identical rows, whose rendering is identical too.
124− val base = if (ts != null) "$ts|${meta.orEmpty()}|${tag.orEmpty()}" else log.hashCode().toString()
164+ val base = log.toString()
125 val count = seen.getOrDefault(base, 0)
165 val count = seen.getOrDefault(base, 0)
126 seen[base] = count + 1
166 seen[base] = count + 1
127 if (count == 0) base else "$base|$count"
167 if (count == 0) base else "$base|$count"
@@ -178,7 +218,11 @@ class LogViewerViewModel @Inject constructor(
180 fun onSearchQueryChange(query: String) {
220 fun onSearchQueryChange(query: String) {
221+ // A new query invalidates the live-tail baseline and the paged-up limit, matching
222+ // the time-range / custom-SQL handlers.
224+ // Searching returns to the filter-builder query path, so drop any active custom SQL.
181− _state.update { it.copy(filters = it.filters.copy(searchQuery = query, isSearching = query.isNotBlank())) }
225+ _state.update { it.copy(currentLimit = 500, filters = it.filters.copy(searchQuery = query, customSql = "", isSearching = query.isNotBlank())) }
182 searchJob?.cancel()
226 searchJob?.cancel()
183 searchJob = viewModelScope.launch {
227 searchJob = viewModelScope.launch {
184 delay(300)
228 delay(300)
@@ -187,28 +231,55 @@ class LogViewerViewModel @Inject constructor(
235+ * Run the current search immediately (e.g. the IME "Search" action). Cancels the pending
236+ * debounce so it can't fire a second, redundant refresh ~300ms later.
238+ fun submitSearch() {
240+ _state.update { it.copy(filters = it.filters.copy(isSearching = false)) }
190 fun addFilter(column: String, operator: String, value: String) {
245 fun addFilter(column: String, operator: String, value: String) {
246+ addFilterInternal(column, operator, value)
250+ private fun addFilterInternal(column: String, operator: String, value: String) {
191 if (operator !in ALLOWED_OPERATORS) return
251 if (operator !in ALLOWED_OPERATORS) return
192 val safeColumn = escapeIdentifier(column)
252 val safeColumn = escapeIdentifier(column)
193− val safeValue = escapeSql(value)
194 val clause = when (operator) {
253 val clause = when (operator) {
195 "IS NULL", "IS NOT NULL" -> "\"$safeColumn\" $operator"
254 "IS NULL", "IS NOT NULL" -> "\"$safeColumn\" $operator"
255+ // %/_ in the user's value must match literally, so escape the LIKE wildcards
256+ // and declare the escape character. Exact comparisons keep %/_ verbatim.
196− "LIKE", "ILIKE" -> "\"$safeColumn\" $operator '%$safeValue%'"
257+ "LIKE", "ILIKE" -> "\"$safeColumn\" $operator '%${escapeLikePattern(value)}%' ESCAPE '\\'"
197− else -> "\"$safeColumn\" $operator '$safeValue'"
258+ else -> "\"$safeColumn\" $operator '${escapeSql(value)}'"
260+ // IS NULL / IS NOT NULL ignore the value in both the clause and the display, so store
261+ // an empty value in the structured condition too (keeps saved filters clean).
262+ val conditionValue = when (operator) {
263+ "IS NULL", "IS NOT NULL" -> ""
199 val display = when (operator) {
266 val display = when (operator) {
200 "IS NULL", "IS NOT NULL" -> "$column $operator"
267 "IS NULL", "IS NOT NULL" -> "$column $operator"
201 else -> "$column $operator $value"
268 else -> "$column $operator $value"
270+ // A new filter invalidates the live-tail baseline and the paged-up limit.
203 _state.update {
272 _state.update {
205 filters = it.filters.copy(
275 filters = it.filters.copy(
206 filterClauses = it.filters.filterClauses + clause,
276 filterClauses = it.filters.filterClauses + clause,
207 activeFilters = it.filters.activeFilters + display,
277 activeFilters = it.filters.activeFilters + display,
278+ filterConditions = it.filters.filterConditions + FilterCondition(column, operator, conditionValue),
214 fun removeFilter(display: String) {
285 fun removeFilter(display: String) {
@@ -218,81 +289,93 @@ class LogViewerViewModel @Inject constructor(
218 if (index >= 0 && index < it.filters.filterClauses.size) {
289 if (index >= 0 && index < it.filters.filterClauses.size) {
219 removed = true
290 removed = true
221 filters = it.filters.copy(
293 filters = it.filters.copy(
222 activeFilters = it.filters.activeFilters.filterIndexed { i, _ -> i != index },
294 activeFilters = it.filters.activeFilters.filterIndexed { i, _ -> i != index },
223 filterClauses = it.filters.filterClauses.filterIndexed { i, _ -> i != index },
295 filterClauses = it.filters.filterClauses.filterIndexed { i, _ -> i != index },
296+ filterConditions = it.filters.filterConditions.filterIndexed { i, _ -> i != index },
230− if (removed) refresh()
304+ if (removed) {
305+ // A changed filter set invalidates the live-tail baseline.
233 fun clearFilters() {
311 fun clearFilters() {
234 _state.update {
313 _state.update {
235− it.copy(filters = it.filters.copy(activeFilters = emptyList(), filterClauses = emptyList()))
314+ it.copy(currentLimit = 500, filters = it.filters.copy(activeFilters = emptyList(), filterClauses = emptyList(), filterConditions = emptyList(), customSql = "", searchQuery = "", isSearching = false))
237 refresh()
316 refresh()
240 fun executeCustomSql(sql: String) {
319 fun executeCustomSql(sql: String) {
320+ // Custom SQL changes the query basis, so cancel any pending search debounce that would
321+ // otherwise fire a redundant refresh() ~300ms later. (Unlike the filter/time-range
322+ // handlers, this path doesn't route through stopStreaming().)
324+ // Drop a trailing statement terminator before we append anything — otherwise
325+ // "SELECT * FROM x;" would become "SELECT * FROM x; LIMIT 5000", a syntax error.
241− val trimmed = sql.trim()
326+ val trimmed = sql.trim().trimEnd(';').trim()
242 if (!trimmed.uppercase().startsWith("SELECT")) {
327 if (!trimmed.uppercase().startsWith("SELECT")) {
243 _state.update { it.copy(error = "Only SELECT queries are allowed") }
328 _state.update { it.copy(error = "Only SELECT queries are allowed") }
246− // Enforce a LIMIT to prevent OOM from unbounded queries
331+ // Enforce a LIMIT to prevent OOM from unbounded queries. Only honor a *top-level*
247− val safeSql = if (!trimmed.uppercase().contains("LIMIT")) {
332+ // `LIMIT <n>` (optionally with OFFSET) anchored at the end of the statement — a
333+ // LIMIT inside a subquery doesn't bound the outer result set, so matching it
334+ // anywhere would let an unbounded outer query slip past the safety limit. Anchoring
335+ // at the end also means a string literal like 'LIMIT EXCEEDED' can't disable it.
336+ val hasTopLevelLimit =
337+ Regex("(?i)\\bLIMIT\\s+\\d+(\\s+OFFSET\\s+\\d+)?\\s*$").containsMatchIn(trimmed)
338+ val safeSql = if (!hasTopLevelLimit) {
248 "$trimmed LIMIT $MAX_LOAD_LIMIT"
339 "$trimmed LIMIT $MAX_LOAD_LIMIT"
343+ // Store the custom SQL and let refresh() run it. Keeping it in state means
344+ // pull-to-refresh / time-range changes re-run the custom query instead of
345+ // silently replacing it with the default filter query.
252 _state.update { it.copy(filters = it.filters.copy(customSql = safeSql), currentLimit = 500) }
346 _state.update { it.copy(filters = it.filters.copy(customSql = safeSql), currentLimit = 500) }
253− viewModelScope.launch {
347+ refresh()
254− _state.update { it.copy(isLoading = true, error = null) }
256− val (startTime, endTime) = getTimeRange()
257− when (val result = repository.queryLogsRaw(safeSql, startTime, endTime)) {
258− is ApiResult.Success -> {
259− val keys = computeLogKeys(result.data)
265− hasMore = result.data.size >= it.currentLimit,
269− is ApiResult.Error -> {
271− it.copy(isLoading = false, error = result.userMessage)
278 private fun buildSearchClause(searchableColumns: List<String>, searchQuery: String): String? {
350 private fun buildSearchClause(searchableColumns: List<String>, searchQuery: String): String? {
279 if (searchQuery.isBlank()) return null
351 if (searchQuery.isBlank()) return null
280 if (searchableColumns.isEmpty()) return null
352 if (searchableColumns.isEmpty()) return null
281− val safeSearch = escapeSql(searchQuery)
353+ val safeSearch = escapeLikePattern(searchQuery)
282 return searchableColumns.joinToString(" OR ") {
354 return searchableColumns.joinToString(" OR ") {
283− "\"${escapeIdentifier(it)}\" ILIKE '%$safeSearch%'"
355+ "CAST(\"${escapeIdentifier(it)}\" AS VARCHAR) ILIKE '%$safeSearch%' ESCAPE '\\'"
287 fun refresh() {
359 fun refresh() {
288 if (_state.value.streamName.isEmpty()) return
360 if (_state.value.streamName.isEmpty()) return
362+ // Cancel any in-flight query so out-of-order completions can't overwrite
363+ // fresh results with stale ones (filter/search/time-range/loadMore all call refresh()).
364+ refreshJob?.cancel()
290− viewModelScope.launch {
365+ refreshJob = viewModelScope.launch {
366+ // Anchor the upper time bound on the first page of a paging session (currentLimit at
367+ // its initial value) and reuse it for subsequent loadMore() pages. Otherwise a relative
368+ // range would recompute "now" on every page in getTimeRange(), sliding the window and
369+ // duplicating/dropping rows on an actively-ingesting stream.
370+ val anchor = _state.value.let { s ->
371+ if (s.currentLimit <= 500) System.currentTimeMillis() else s.pageAnchorTime
291 _state.update {
373 _state.update {
293 isLoading = true,
375 isLoading = true,
294 error = null,
376 error = null,
295 streaming = it.streaming.copy(streamingError = null),
377 streaming = it.streaming.copy(streamingError = null),
378+ pageAnchorTime = anchor,
@@ -300,6 +383,20 @@ class LogViewerViewModel @Inject constructor(
300 val current = _state.value
383 val current = _state.value
301 val (startTime, endTime) = getTimeRange()
384 val (startTime, endTime) = getTimeRange()
386+ // A custom SQL query owns the whole statement (its own LIMIT, columns, ordering),
387+ // so re-run it verbatim. It is not paginated via loadMore(), hence hasMore = false.
388+ if (current.filters.customSql.isNotBlank()) {
389+ when (val result = repository.queryLogsRaw(current.filters.customSql, startTime, endTime)) {
390+ is ApiResult.Success -> {
391+ _state.update { it.copy(logs = result.data, logKeys = computeLogKeys(result.data), isLoading = false, hasMore = false) }
393+ is ApiResult.Error -> {
394+ _state.update { it.copy(isLoading = false, error = result.userMessage) }
303 // Build WHERE clause from filters + search
400 // Build WHERE clause from filters + search
304 val clauses = current.filters.filterClauses.toMutableList()
401 val clauses = current.filters.filterClauses.toMutableList()
305 if (current.filters.searchQuery.isNotBlank()) {
402 if (current.filters.searchQuery.isNotBlank()) {
@@ -316,22 +413,26 @@ class LogViewerViewModel @Inject constructor(
317 val filterSql = clauses.joinToString(" AND ")
414 val filterSql = clauses.joinToString(" AND ")
416+ // Over-fetch by one row so we can distinguish "exactly currentLimit rows exist"
417+ // (no more pages) from "the page is full and more may exist" without firing a
418+ // wasted extra query the next time the user scrolls to the bottom.
419+ val requestLimit = current.currentLimit + 1
319 when (val result = repository.queryLogs(
420 when (val result = repository.queryLogs(
320 stream = current.streamName,
421 stream = current.streamName,
321 startTime = startTime,
422 startTime = startTime,
322 endTime = endTime,
423 endTime = endTime,
323 filterSql = filterSql,
424 filterSql = filterSql,
324− limit = current.currentLimit,
425+ limit = requestLimit,
326 is ApiResult.Success -> {
427 is ApiResult.Success -> {
327− val keys = computeLogKeys(result.data)
428+ val hasMore = result.data.size > current.currentLimit && current.currentLimit < MAX_LOAD_LIMIT
429+ val logs = if (result.data.size > current.currentLimit) {
430+ result.data.take(current.currentLimit)
328 _state.update {
434 _state.update {
329− it.copy(
435+ it.copy(logs = logs, logKeys = computeLogKeys(logs), isLoading = false, hasMore = hasMore)
333− hasMore = result.data.size >= it.currentLimit,
337 is ApiResult.Error -> {
438 is ApiResult.Error -> {
@@ -343,8 +444,29 @@ class LogViewerViewModel @Inject constructor(
448+ * Pull-to-refresh: restart the paging session from the first page. Resetting currentLimit
449+ * makes refresh() re-anchor pageAnchorTime to "now", so a relative time range advances and
450+ * newly-ingested rows appear. Calling refresh() alone keeps the frozen anchor once the user
451+ * has paged past the first page, making pull-to-refresh look like it does nothing.
454+ if (_state.value.streamName.isEmpty()) return
455+ // While live-tailing, the poller continuously prepends fresh rows; a concurrent refresh()
456+ // would replace the list with a full page at the same time, racing the poller on logs/
457+ // logKeys/streamingError and producing duplicated or dropped rows plus a stale "+N" badge.
458+ // The displayed logs are already current under streaming, so the pull is a no-op here —
459+ // mirror loadMore()'s guard rather than the stopStreaming() path the other mutators take.
460+ if (_state.value.streaming.isStreaming) return
461+ _state.update { it.copy(currentLimit = 500) }
346 fun loadMore() {
465 fun loadMore() {
347 val current = _state.value
466 val current = _state.value
467+ // While live-tailing, logs are prepended in memory; a refresh() here would replace
468+ // them with a fresh page and drop the streamed rows. Pagination resumes once stopped.
469+ if (current.streaming.isStreaming) return
348 if (current.currentLimit >= MAX_LOAD_LIMIT) {
470 if (current.currentLimit >= MAX_LOAD_LIMIT) {
349 _state.update { it.copy(hasMore = false) }
471 _state.update { it.copy(hasMore = false) }
@@ -367,7 +489,9 @@ class LogViewerViewModel @Inject constructor(
368 return Pair(start.format(dateFormatter), end.format(dateFormatter))
490 return Pair(start.format(dateFormatter), end.format(dateFormatter))
492+ val now = current.pageAnchorTime
493+ ?.let { ZonedDateTime.ofInstant(java.time.Instant.ofEpochMilli(it), ZoneOffset.UTC) }
370− val now = ZonedDateTime.now(ZoneOffset.UTC)
494+ ?: ZonedDateTime.now(ZoneOffset.UTC)
371 val start = now.minusMinutes(current.selectedTimeRange.minutes)
495 val start = now.minusMinutes(current.selectedTimeRange.minutes)
372 return Pair(
496 return Pair(
373 start.format(dateFormatter),
497 start.format(dateFormatter),
@@ -375,6 +499,17 @@ class LogViewerViewModel @Inject constructor(
503+ * Report whether the log list is scrolled to the top. Clears the "+N new" streaming badge
504+ * when the user returns to the top, since prepended rows there are seen immediately.
506+ fun setViewingTop(atTop: Boolean) {
508+ if (atTop && _state.value.streaming.streamingNewCount != 0) {
509+ _state.update { it.copy(streaming = it.streaming.copy(streamingNewCount = 0)) }
378 fun toggleStreaming() {
513 fun toggleStreaming() {
379 if (_state.value.streaming.isStreaming) {
514 if (_state.value.streaming.isStreaming) {
380 stopStreaming()
515 stopStreaming()
@@ -384,6 +519,10 @@ class LogViewerViewModel @Inject constructor(
386 private fun startStreaming() {
521 private fun startStreaming() {
522+ // The poller builds its own default SELECT * query and cannot honor a custom SQL
523+ // projection/filter, so streaming custom-query results would prepend mismatched rows.
524+ // The UI disables the toggle in this state; guard here too in case it's reached anyway.
525+ if (_state.value.filters.customSql.isNotBlank()) return
387 stopStreaming()
526 stopStreaming()
388 consecutiveStreamingErrors = 0
527 consecutiveStreamingErrors = 0
389 val generation = ++streamingGeneration
528 val generation = ++streamingGeneration
@@ -391,6 +530,12 @@ class LogViewerViewModel @Inject constructor(
391 it.copy(streaming = StreamingState(isStreaming = true, streamingNewCount = 0))
530 it.copy(streaming = StreamingState(isStreaming = true, streamingNewCount = 0))
533+ // Seed the dedup set with the rows already on screen so an initial row sitting exactly
534+ // on the streaming baseline timestamp can't be re-fetched and duplicated.
535+ seenStreamingKeys.clear()
536+ _state.value.logs.forEach { seenStreamingKeys.add(logIdentity(it)) }
537+ trimSeenStreamingKeys()
394 // Set the baseline timestamp to "now" so we only poll for new logs
539 // Set the baseline timestamp to "now" so we only poll for new logs
395 lastSeenTimestamp = ZonedDateTime.now(ZoneOffset.UTC).format(dateFormatter)
540 lastSeenTimestamp = ZonedDateTime.now(ZoneOffset.UTC).format(dateFormatter)
@@ -413,6 +558,13 @@ class LogViewerViewModel @Inject constructor(
415 fun stopStreaming() {
560 fun stopStreaming() {
561+ // Cancel any pending search debounce too. Every query-basis change (time range, filters,
562+ // saved filter, clear, new search) routes through stopStreaming(); without this, a
563+ // searchJob scheduled moments before such a change would still fire refresh() ~300ms
564+ // later and redundantly re-query over the just-applied state. onSearchQueryChange()
565+ // re-assigns searchJob immediately after calling stopStreaming(), so its own debounce
416 streamingGeneration++
568 streamingGeneration++
417 streamingJob?.cancel()
569 streamingJob?.cancel()
418 streamingJob = null
570 streamingJob = null
@@ -427,6 +579,49 @@ class LogViewerViewModel @Inject constructor(
583+ * Content-based identity for a log row, used to dedupe re-fetched boundary logs.
584+ * Uses the full row: two rows are duplicates only when every field matches, so
585+ * distinct logs that happen to share a timestamp/metadata/tags are not dropped.
587+ private fun logIdentity(log: JsonObject): String = log.toString()
590+ * Parse a server-rendered p_timestamp (which may be ISO with 'Z', offset-carrying,
591+ * space-separated, or offset-less UTC) and reformat it to the canonical query format
592+ * (`dateFormatter`) so it's a valid inclusive startTime for the next poll. Returns null
593+ * if the value can't be parsed, so the caller can keep the previous boundary.
595+ private fun normalizeBoundaryTimestamp(raw: String): String? {
596+ val isoLike = if (' ' in raw && 'T' !in raw) raw.replaceFirst(' ', 'T') else raw
598+ Instant.parse(isoLike)
599+ } catch (_: Exception) {
601+ OffsetDateTime.parse(isoLike).toInstant()
602+ } catch (_: Exception) {
604+ LocalDateTime.parse(isoLike).toInstant(ZoneOffset.UTC)
605+ } catch (_: Exception) {
610+ return instant.atOffset(ZoneOffset.UTC).format(dateFormatter)
613+ /** Bound the dedup set, evicting the oldest identities first (insertion order). */
614+ private fun trimSeenStreamingKeys() {
615+ if (seenStreamingKeys.size <= SEEN_STREAMING_KEYS_MAX) return
616+ val iterator = seenStreamingKeys.iterator()
617+ var toRemove = seenStreamingKeys.size - SEEN_STREAMING_KEYS_MAX
618+ while (toRemove > 0 && iterator.hasNext()) {
430 private suspend fun pollNewLogs() {
625 private suspend fun pollNewLogs() {
431 val current = _state.value
626 val current = _state.value
432 if (current.streamName.isEmpty()) return
627 if (current.streamName.isEmpty()) return
@@ -439,45 +634,116 @@ class LogViewerViewModel @Inject constructor(
439 if (current.filters.searchQuery.isNotBlank()) {
634 if (current.filters.searchQuery.isNotBlank()) {
440 val searchClause = buildSearchClause(current.searchableColumns, current.filters.searchQuery)
635 val searchClause = buildSearchClause(current.searchableColumns, current.filters.searchQuery)
441 if (searchClause != null) {
636 if (searchClause != null) {
637+ // Parenthesize: the search clause is OR-joined and must not break the
638+ // precedence of the AND-joined filter clauses around it.
442− clauses.add(searchClause)
639+ clauses.add("($searchClause)")
641+ // Schema not loaded yet, so we can't build the search filter. Skip this
642+ // poll rather than querying without it — otherwise we'd prepend rows that
643+ // don't match the active search into a filtered view. Mirrors refresh(),
644+ // which errors out instead of running an unfiltered query.
647+ streaming = it.streaming.copy(
648+ streamingError = "Search unavailable: stream schema not loaded",
446 val whereClause = if (clauses.isNotEmpty()) " WHERE ${clauses.joinToString(" AND ")}" else ""
656 val whereClause = if (clauses.isNotEmpty()) " WHERE ${clauses.joinToString(" AND ")}" else ""
447 val safeName = escapeIdentifier(current.streamName)
657 val safeName = escapeIdentifier(current.streamName)
658+ // Fetch up to the in-memory display cap. With a small limit (e.g. 200), a burst of
659+ // more than that many logs in one interval would advance lastSeenTimestamp past the
660+ // un-fetched rows and drop them permanently. Capping at STREAMING_MAX_LOGS means we
661+ // never skip rows we'd actually keep (anything older is evicted by the cap anyway).
448− val sql = "SELECT * FROM \"$safeName\"$whereClause ORDER BY p_timestamp DESC LIMIT 200"
662+ val sql = "SELECT * FROM \"$safeName\"$whereClause ORDER BY p_timestamp DESC LIMIT $STREAMING_MAX_LOGS"
450 when (val result = repository.queryLogsRaw(sql, startTime, endTime)) {
664 when (val result = repository.queryLogsRaw(sql, startTime, endTime)) {
451 is ApiResult.Success -> {
665 is ApiResult.Success -> {
452 val newLogs = result.data
666 val newLogs = result.data
453 if (newLogs.isNotEmpty()) {
667 if (newLogs.isNotEmpty()) {
454− // Update the last seen timestamp to the most recent log
668+ // Advance the last-seen boundary. Rows are ordered newest-first, so
455− val newestTimestamp = try {
669+ // normally we jump to the newest. But a full page means the LIMIT may
456− newLogs.firstOrNull()
670+ // have capped off matching rows OLDER than the newest in this batch
671+ // (possible once filters/search narrow a high-volume stream) — advancing
672+ // to the newest would skip them forever. In that case advance only to the
673+ // oldest row we did fetch, so the next poll re-queries forward and closes
674+ // the gap (re-fetched rows are deduped below).
675+ val fullPage = newLogs.size >= STREAMING_MAX_LOGS
676+ val boundaryLog = if (fullPage) newLogs.lastOrNull() else newLogs.firstOrNull()
677+ val boundaryTimestamp = try {
457− ?.get("p_timestamp")?.jsonPrimitive?.content
678+ boundaryLog?.get("p_timestamp")?.jsonPrimitive?.content
458 } catch (_: Exception) {
679 } catch (_: Exception) {
682+ // Re-canonicalize the server's p_timestamp before reusing it as the next
683+ // query's startTime. The raw value can be space-separated or offset-less,
684+ // which the query API may reject or misparse — that would stall live-tail
685+ // after the first batch. If it can't be parsed, leave lastSeenTimestamp as-is
686+ // (the inclusive startTime simply re-fetches the window; rows are deduped).
687+ var normalized = boundaryTimestamp?.let { normalizeBoundaryTimestamp(it) }
688+ // On a saturated (full) page the boundary is the OLDEST fetched row so the
689+ // next poll re-queries forward and closes the LIMIT gap. But if that oldest
690+ // row carries the SAME timestamp we're already at — e.g. a burst of more than
691+ // STREAMING_MAX_LOGS rows sharing one millisecond, or the parse failing — the
692+ // boundary wouldn't move and we'd re-query the identical window forever. Fall
693+ // back to the NEWEST row's timestamp to guarantee forward progress; the
694+ // skipped backlog would be evicted by the display cap anyway.
695+ if (fullPage && (normalized == null || normalized == lastSeenTimestamp)) {
461− if (newestTimestamp != null) {
696+ val newestTimestamp = try {
697+ newLogs.firstOrNull()?.get("p_timestamp")?.jsonPrimitive?.content
698+ } catch (_: Exception) {
701+ val newestNormalized = newestTimestamp?.let { normalizeBoundaryTimestamp(it) }
702+ if (newestNormalized != null && newestNormalized != lastSeenTimestamp) {
703+ normalized = newestNormalized
706+ if (normalized != null) {
462− lastSeenTimestamp = newestTimestamp
707+ lastSeenTimestamp = normalized
710+ // The query's startTime is inclusive, so rows sitting on the previous
711+ // boundary timestamp get re-fetched. Dedup against everything seen this
712+ // session (independent of the display cap) to avoid duplicate rows and an
713+ // inflated count. Computed BEFORE the state update — and the seen-set
714+ // mutated here, not inside the update lambda, which may re-run.
715+ val freshLogs = newLogs.filterNot { logIdentity(it) in seenStreamingKeys }
716+ newLogs.forEach { seenStreamingKeys.add(logIdentity(it)) }
717+ trimSeenStreamingKeys()
719+ if (freshLogs.isEmpty()) {
720+ _state.update { it.copy(streaming = it.streaming.copy(streamingError = null)) }
465− _state.update { state ->
722+ _state.update { state ->
466− // Prepend new logs, cap total — avoid full intermediate list allocation
723+ // Prepend new logs, cap total — avoid full intermediate list allocation
467− val remaining = (STREAMING_MAX_LOGS - newLogs.size).coerceAtLeast(0)
724+ val remaining = (STREAMING_MAX_LOGS - freshLogs.size).coerceAtLeast(0)
468− val capped = ArrayList<JsonObject>(newLogs.size + remaining).apply {
725+ val capped = ArrayList<JsonObject>(freshLogs.size + remaining).apply {
469− addAll(newLogs)
726+ addAll(freshLogs)
470− val oldLogs = state.logs
727+ val oldLogs = state.logs
471− addAll(oldLogs.subList(0, remaining.coerceAtMost(oldLogs.size)))
728+ addAll(oldLogs.subList(0, remaining.coerceAtMost(oldLogs.size)))
732+ logKeys = computeLogKeys(capped),
733+ streaming = state.streaming.copy(
734+ // Accumulate new rows while the user is scrolled away; reset
735+ // to 0 when they're at the top (where prepended rows are seen
736+ // live). The previous cap was against total list size, so the
737+ // badge saturated at the display cap and never cleared.
738+ streamingNewCount = if (viewingTop) {
741+ state.streaming.streamingNewCount + freshLogs.size
743+ streamingError = null,
475− logKeys = computeLogKeys(capped),
476− streaming = state.streaming.copy(
477− streamingNewCount = state.streaming.streamingNewCount + newLogs.size,
478− streamingError = null,
483 consecutiveStreamingErrors = 0
749 consecutiveStreamingErrors = 0
@@ -504,21 +770,37 @@ class LogViewerViewModel @Inject constructor(
505 // --- Saved Filters (synced with Parseable server) ---
771 // --- Saved Filters (synced with Parseable server) ---
773+ // Serializes loadSavedFilters / saveCurrentFilter / deleteSavedFilter so they never
774+ // interleave. Without this, a wholesale-overwrite load completing after a concurrent
775+ // save (append) or delete (remove) would silently drop the local add/remove — a
776+ // read-modify-write race across coroutines.
777+ private val savedFiltersMutex = Mutex()
507 fun loadSavedFilters() {
779 fun loadSavedFilters() {
780+ // Capture the stream this load is for; if the user navigates to a different stream
781+ // before it completes, bind the result to the right stream instead of clobbering the
782+ // new stream's filter list with another stream's results.
783+ val stream = _state.value.streamName
508 viewModelScope.launch {
784 viewModelScope.launch {
785+ savedFiltersMutex.withLock {
509− _state.update { it.copy(savedFilters = it.savedFilters.copy(isLoading = true, error = null)) }
786+ _state.update { it.copy(savedFilters = it.savedFilters.copy(isLoading = true, error = null)) }
510− when (val result = repository.listFilters()) {
787+ when (val result = repository.listFilters()) {
511− is ApiResult.Success -> {
788+ is ApiResult.Success -> {
789+ if (_state.value.streamName != stream) {
790+ _state.update { it.copy(savedFilters = it.savedFilters.copy(isLoading = false)) }
512− val streamFilters = result.data
793+ val streamFilters = result.data
513− .filter { it.streamName == _state.value.streamName }
794+ .filter { it.streamName == stream }
514− .sortedBy { it.filterName.lowercase() }
795+ .sortedBy { it.filterName.lowercase() }
515− _state.update {
796+ _state.update {
516− it.copy(savedFilters = it.savedFilters.copy(filters = streamFilters, isLoading = false))
797+ it.copy(savedFilters = it.savedFilters.copy(filters = streamFilters, isLoading = false))
519− is ApiResult.Error -> {
800+ is ApiResult.Error -> {
520− _state.update {
801+ _state.update {
521− it.copy(savedFilters = it.savedFilters.copy(isLoading = false, error = result.userMessage))
802+ it.copy(savedFilters = it.savedFilters.copy(isLoading = false, error = result.userMessage))
@@ -530,6 +812,7 @@ class LogViewerViewModel @Inject constructor(
530 if (current.streamName.isEmpty()) return
812 if (current.streamName.isEmpty()) return
532 viewModelScope.launch {
814 viewModelScope.launch {
815+ savedFiltersMutex.withLock {
533 _state.update { it.copy(savedFilters = it.savedFilters.copy(isSaving = true, error = null)) }
816 _state.update { it.copy(savedFilters = it.savedFilters.copy(isSaving = true, error = null)) }
535 val query = if (current.filters.customSql.isNotBlank()) {
818 val query = if (current.filters.customSql.isNotBlank()) {
@@ -538,15 +821,13 @@ class LogViewerViewModel @Inject constructor(
538 filterQuery = current.filters.customSql,
821 filterQuery = current.filters.customSql,
541− val ruleGroups = current.filters.activeFilters.zip(current.filters.filterClauses)
824+ val ruleGroups = current.filters.filterConditions
542− .mapIndexed { index, (display, _) ->
825+ .mapIndexed { index, condition ->
543− // Parse display back to field/operator/value
544− val parts = parseFilterDisplay(display)
545 FilterRule(
826 FilterRule(
546 id = "rule_$index",
827 id = "rule_$index",
547− field = parts.first,
828+ field = condition.column,
548− value = parts.third,
829+ value = condition.value,
549− operator = parts.second,
830+ operator = condition.operator,
552 val builder = if (ruleGroups.isNotEmpty()) {
833 val builder = if (ruleGroups.isNotEmpty()) {
@@ -593,6 +874,7 @@ class LogViewerViewModel @Inject constructor(
@@ -602,9 +884,15 @@ class LogViewerViewModel @Inject constructor(
602 when (filter.query.filterType) {
884 when (filter.query.filterType) {
603 "sql" -> {
885 "sql" -> {
604 val sql = filter.query.filterQuery ?: return
886 val sql = filter.query.filterQuery ?: return
887+ // Reset to a clean filter state first, then let executeCustomSql validate
888+ // the SQL and own the customSql state. Pre-seeding filters.customSql with
889+ // the raw, unvalidated query meant that if executeCustomSql rejected it
890+ // (e.g. a legacy non-SELECT saved filter, which returns early without
891+ // touching state) we were left wedged in custom-SQL mode with broken SQL
892+ // that every later refresh() would keep re-running.
605 _state.update {
893 _state.update {
607− filters = FilterState(customSql = sql),
895+ filters = FilterState(),
608 currentLimit = 500,
896 currentLimit = 500,
@@ -640,7 +928,7 @@ class LogViewerViewModel @Inject constructor(
640 for (group in builder.rules) {
928 for (group in builder.rules) {
641 for (rule in group.rules) {
929 for (rule in group.rules) {
642 if (rule.field.isNotBlank()) {
930 if (rule.field.isNotBlank()) {
643− addFilter(rule.field, rule.operator, rule.value)
931+ addFilterInternal(rule.field, rule.operator, rule.value)
@@ -648,32 +936,21 @@ class LogViewerViewModel @Inject constructor(
649 fun deleteSavedFilter(filterId: String) {
937 fun deleteSavedFilter(filterId: String) {
650 viewModelScope.launch {
938 viewModelScope.launch {
939+ savedFiltersMutex.withLock {
651− when (repository.deleteFilter(filterId)) {
940+ when (repository.deleteFilter(filterId)) {
652− is ApiResult.Success -> {
941+ is ApiResult.Success -> {
653− _state.update {
942+ _state.update {
654− it.copy(
943+ it.copy(
655− savedFilters = it.savedFilters.copy(
944+ savedFilters = it.savedFilters.copy(
656− filters = it.savedFilters.filters.filter { f -> f.filterId != filterId },
945+ filters = it.savedFilters.filters.filter { f -> f.filterId != filterId },
950+ is ApiResult.Error -> { /* Silently ignore — will show on next reload */ }
661− is ApiResult.Error -> { /* Silently ignore — will show on next reload */ }
666− /** Parse a display string like "column = value" back into (field, operator, value) */
667− private fun parseFilterDisplay(display: String): Triple<String, String, String> {
668− for (op in listOf("IS NOT NULL", "IS NULL", "ILIKE", "LIKE", "!=", ">=", "<=", "=", ">", "<")) {
669− val idx = display.indexOf(" $op")
671− val field = display.substring(0, idx)
672− val value = display.substring(idx + op.length + 1).trim()
673− return Triple(field, op, value)
676− return Triple(display, "=", "")
679 override fun onCleared() {
956 override fun onCleared() {