Filter the log by the process that wrote it

Which process wrote a line is not in the line's words, so no search can ask it, but it is the question
a reader most often has of a log several applications share. It becomes a filter like the others: the
scan counts uids as it already counts tags and levels, the sheet offers them as chips between the
levels and the tags, and a chosen one shows as a chip that undoes itself -- with its own avatar, since
it sits beside the tag's and says something else.

The three read as one question. Within a category the choices are alternatives -- two applications,
two levels, and now two tags, which was a single choice before and had no reason to be -- while across
categories they are conditions on the same line. The counts follow: each category is counted under the
others and never under itself, so choosing an application leaves the sheet listing the tags that
application writes, with the counts it wrote them, while the applications beside it stay listed and
switchable. Anything the rest of the filter has left with nothing goes, since a chip that selects no
line is a choice not worth offering; a chosen one stays regardless, or a filter could not be undone.

A uid is not a name, so the host puts one to it through writerLabel, asked once per scan and off the
main thread. Both hosts read logs written by installed packages and would answer alike, so the rule is
written once, in WriterLabeler: one package holding the uid is named by its label, a uid several share
by the platform's name for it. The platform names only what it has a package setting for, and the
writers that dominate a privileged daemon's log have none -- root has no setting at all -- so the few
fixed assignments a reader actually meets are spelled out. What remains unnamed keeps its number,
which still separates one process from another, and a writer outside the first user carries the user
it belongs to, since the same application in a second profile is a different writer with the same
label.

hasVerboseStream, from the same seam: a host reduced to its own process's log has no second stream to
unfold into, where both would be the same lines under two names, and says so instead of offering a
control that changes nothing.

Author: JingMatrix

manager-ui/src/main/kotlin/org/matrix/vector/ui/logs/LogFacetCounter.kt

@@ -0,0 +1,54 @@
+package org.matrix.vector.ui.logs
+
+/**
+ * Counts what a log holds while deciding what the current query keeps, in the host's one scanning pass.
+ *
+ * A category is counted under the *other* categories, never under itself. Choosing an application and then opening the
+ * filter should show the tags that application writes, with the counts it wrote them — not the tags of a log the reader
+ * has already narrowed away, which would offer choices that select nothing, nor the counts of the whole file, which
+ * would promise lines the filter will not show. Its own category is left out so that the alternatives beside a chosen
+ * chip stay visible: picking one tag must not make every other tag disappear, or a second one could never be added.
+ *
+ * The rule falls out of that: for each facet, every condition applies except the facet's own.
+ *
+ * Both hosts scan their own format but ask the same question of it, so this is written once. [add] reports whether the
+ * row survives the whole query, which is what the caller records as a match.
+ */
+class LogFacetCounter(private val query: LogQuery) {
+
+    private val tags = HashMap<String, Int>()
+    private val levels = HashMap<LogLevel, Int>()
+    private val writers = HashMap<Int, Int>()
+
+    fun add(row: LogRow): Boolean {
+        if (row !is LogRow.Entry) return query.matches(row)
+
+        val level = query.matchesLevel(row)
+        val writer = query.matchesWriter(row)
+        val tag = query.matchesTag(row)
+        val text = query.matchesText(row)
+
+        if (writer && tag && text) levels[row.level] = (levels[row.level] ?: 0) + 1
+        if (level && tag && text && row.uid >= 0) writers[row.uid] = (writers[row.uid] ?: 0) + 1
+        if (level && writer && text) tags[row.tag] = (tags[row.tag] ?: 0) + 1
+
+        return level && writer && tag && text
+    }
+
+    /**
+     * Ordered by weight: what a log is mostly made of is what a reader is mostly looking to include or exclude.
+     *
+     * Whatever the query already selects is listed even where nothing survives the rest of the filter -- at a count of
+     * zero, which is the honest number. A chip counted out of existence would be a filter still narrowing the log with
+     * no way left to switch it off.
+     */
+    fun facets(): LogFacets {
+        query.tags.forEach { tags.putIfAbsent(it, 0) }
+        query.uids.forEach { writers.putIfAbsent(it, 0) }
+        return LogFacets(
+            tags = tags.entries.sortedByDescending { it.value }.map { it.key to it.value },
+            levels = levels,
+            writers = writers.entries.sortedByDescending { it.value }.map { LogWriter(it.key, it.value) },
+        )
+    }
+}

manager-ui/src/main/kotlin/org/matrix/vector/ui/logs/LogModel.kt

@@ -63,6 +63,12 @@ sealed interface LogRow {
         val date: String,
         /** `HH:mm:ss.SSS`. The date is redundant on every row and moves to the separator. */
         val time: String,
+        /**
+         * Who wrote the line, or -1 where the format carries no uid for it.
+         *
+         * Negative rather than zero, because zero is root, and a log written by a privileged daemon is full of its
+         * lines: a sentinel sharing that value would hide them from a filter that lists writers.
+         */
         val uid: Int,
         val pid: Int,
         val tid: Int,
@@ -115,34 +121,62 @@ class LogIndex(val bounds: LongArray, val droppedLeading: Int) {
 /** What [LogContent.scan] found: the filtered line numbers, and what the file contains. */
 class LogScanResult(val matches: IntArray?, val facets: LogFacets)
 
-/** The tags and levels actually present, with counts, so the filter sheet cannot go stale. */
+/**
+ * A process the log has lines from, and how many it wrote.
+ *
+ * Counted in the host's own scanning pass, where the lines already are. Naming it is a separate question, asked of the
+ * host through [LogSource.writerLabel] only for the few uids a filter actually offers, rather than carried here for
+ * every one of them.
+ */
+data class LogWriter(val uid: Int, val count: Int)
+
+/** The tags, levels and writers actually present, with counts, so the filter sheet cannot go stale. */
 data class LogFacets(
     val tags: List<Pair<String, Int>> = emptyList(),
     val levels: Map<LogLevel, Int> = emptyMap(),
+    val writers: List<LogWriter> = emptyList(),
 )
 
-/** Everything that narrows the view. All of it is applied in one pass over the file. */
+/**
+ * Everything that narrows the view. All of it is applied in one pass over the file.
+ *
+ * Within a category the choices are alternatives and within a category alone: two levels, two writers or two tags are
+ * read together, because "these two apps" and "these two tags" are ordinary questions. Across categories they are
+ * conditions on the same line, so a level, a writer and a tag chosen together mean all three at once.
+ */
 data class LogQuery(
+    /** Levels to keep; empty for all of them. */
     val levels: Set<LogLevel> = emptySet(),
-    val tag: String? = null,
+    /** Writers to keep, by uid; empty for all of them. */
+    val uids: Set<Int> = emptySet(),
+    /** Tags to keep; empty for all of them. */
+    val tags: Set<String> = emptySet(),
     val text: String = "",
 ) {
     val isActive: Boolean
-        get() = levels.isNotEmpty() || tag != null || text.isNotBlank()
+        get() = levels.isNotEmpty() || uids.isNotEmpty() || tags.isNotEmpty() || text.isNotBlank()
+
+    fun matchesLevel(row: LogRow.Entry): Boolean = levels.isEmpty() || row.level in levels
+
+    fun matchesWriter(row: LogRow.Entry): Boolean = uids.isEmpty() || row.uid in uids
+
+    fun matchesTag(row: LogRow.Entry): Boolean = tags.isEmpty() || row.tag in tags
+
+    fun matchesText(row: LogRow.Entry): Boolean =
+        text.isBlank() ||
+            row.message.contains(text, ignoreCase = true) ||
+            row.tag.contains(text, ignoreCase = true)
 
     fun matches(row: LogRow): Boolean =
         when (row) {
             is LogRow.Entry ->
-                (levels.isEmpty() || row.level in levels) &&
-                    (tag == null || row.tag == tag) &&
-                    (text.isBlank() ||
-                        row.message.contains(text, ignoreCase = true) ||
-                        row.tag.contains(text, ignoreCase = true))
-            // A rotation banner has neither level nor tag, so it survives only a plain text
+                matchesLevel(row) && matchesWriter(row) && matchesTag(row) && matchesText(row)
+            // A rotation banner has no level, no writer and no tag, so it survives only a plain text
             // search. It marks where a writer restarted, which is worth keeping when it can be.
             is LogRow.Marker ->
                 levels.isEmpty() &&
-                    tag == null &&
+                    uids.isEmpty() &&
+                    tags.isEmpty() &&
                     (text.isBlank() || row.text.contains(text, ignoreCase = true))
             is LogRow.DayBreak -> false
         }

manager-ui/src/main/kotlin/org/matrix/vector/ui/logs/LogSource.kt

@@ -32,6 +32,15 @@ interface LogSource {
     /** The rotated parts of a stream, oldest first; the last is the live one. Empty when a host keeps no parts. */
     suspend fun parts(verbose: Boolean): List<String>
 
+    /**
+     * A name for the process behind a uid, or null to leave it as the number.
+     *
+     * The log records who wrote a line as a uid, which is not something a reader recognises. Asked only of the uids the
+     * filter offers, so a host may resolve it however it likes -- LSPatch reads its package list -- without that cost
+     * falling on the scan.
+     */
+    fun writerLabel(uid: Int): String? = null
+
     /**
      * Opens a stream for reading. [part] names a rotated part, or null for the live tail.
      *
@@ -42,6 +51,21 @@ interface LogSource {
      */
     suspend fun open(verbose: Boolean, part: String?): Result<LogContent?>
 
+    /**
+     * Whether the host actually has a second, verbose stream to unfold into.
+     *
+     * A host can be reduced to a single log — one that reads only its own process because the
+     * privileged backend it normally reads the device through is unavailable — and then the two
+     * streams would be the same lines under two names. Saying so drops the unfold control instead of
+     * offering a choice that changes nothing.
+     *
+     * Read from composition on every frame that matters, because a backend can come and go while the screen is open and
+     * the control has to follow it. A host whose answer can change must therefore back it with snapshot state; one
+     * computing it from a plain field would keep the control on screen after the stream behind it was gone.
+     */
+    val hasVerboseStream: Boolean
+        get() = true
+
     // --- Verbose-logging preference (distinct from which stream is on screen) ------------------
 
     /** Whether the host has a persistent "write verbose lines at all" preference to toggle. */