Merge changes from topic "cherrypicker-L19100000960963656:N27300001373608395" into udc-qpr-dev (f3c15c80) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/SystemUIService.java

+17 −2

Original line number	Diff line number	Diff line
		@@ -30,8 +30,10 @@ import com.android.internal.os.BinderInternal;
		import com.android.systemui.broadcast.BroadcastDispatcher;
		import com.android.systemui.dagger.qualifiers.Main;
		import com.android.systemui.dump.DumpHandler;
		import com.android.systemui.dump.LogBufferEulogizer;
		import com.android.systemui.dump.LogBufferFreezer;
		import com.android.systemui.dump.SystemUIAuxiliaryDumpService;
		import com.android.systemui.shared.system.UncaughtExceptionPreHandlerManager;
		import com.android.systemui.statusbar.policy.BatteryStateNotifier;

		import java.io.FileDescriptor;
		@@ -44,22 +46,29 @@ public class SystemUIService extends Service {
		private final Handler mMainHandler;
		private final DumpHandler mDumpHandler;
		private final BroadcastDispatcher mBroadcastDispatcher;
		private final LogBufferEulogizer mLogBufferEulogizer;
		private final LogBufferFreezer mLogBufferFreezer;
		private final BatteryStateNotifier mBatteryStateNotifier;

		private final UncaughtExceptionPreHandlerManager mUncaughtExceptionPreHandlerManager;

		@Inject
		public SystemUIService(
		@Main Handler mainHandler,
		DumpHandler dumpHandler,
		BroadcastDispatcher broadcastDispatcher,
		LogBufferEulogizer logBufferEulogizer,
		LogBufferFreezer logBufferFreezer,
		BatteryStateNotifier batteryStateNotifier) {
		BatteryStateNotifier batteryStateNotifier,
		UncaughtExceptionPreHandlerManager uncaughtExceptionPreHandlerManager) {
		super();
		mMainHandler = mainHandler;
		mDumpHandler = dumpHandler;
		mBroadcastDispatcher = broadcastDispatcher;
		mLogBufferEulogizer = logBufferEulogizer;
		mLogBufferFreezer = logBufferFreezer;
		mBatteryStateNotifier = batteryStateNotifier;
		mUncaughtExceptionPreHandlerManager = uncaughtExceptionPreHandlerManager;
		}

		@Override
		@@ -71,7 +80,13 @@ public class SystemUIService extends Service {

		// Finish initializing dump logic
		mLogBufferFreezer.attach(mBroadcastDispatcher);
		mDumpHandler.init();

		// Attempt to dump all LogBuffers for any uncaught exception
		mUncaughtExceptionPreHandlerManager.registerHandler((thread, throwable) -> {
		if (throwable instanceof Exception) {
		mLogBufferEulogizer.record(((Exception) throwable));
		}
		});

		// If configured, set up a battery notification
		if (getResources().getBoolean(R.bool.config_showNotificationForUnknownBatteryState)) {

packages/SystemUI/src/com/android/systemui/dump/DumpHandler.kt

+234 −78

Original line number	Diff line number	Diff line
		@@ -20,12 +20,16 @@ import android.content.Context
		import android.os.SystemClock
		import android.os.Trace
		import com.android.systemui.CoreStartable
		import com.android.systemui.ProtoDumpable
		import com.android.systemui.R
		import com.android.systemui.dump.DumpHandler.Companion.PRIORITY_ARG_CRITICAL
		import com.android.systemui.dump.DumpHandler.Companion.PRIORITY_ARG_NORMAL
		import com.android.systemui.dump.DumpsysEntry.DumpableEntry
		import com.android.systemui.dump.DumpsysEntry.LogBufferEntry
		import com.android.systemui.dump.DumpsysEntry.TableLogBufferEntry
		import com.android.systemui.dump.nano.SystemUIProtoDump
		import com.android.systemui.log.LogBuffer
		import com.android.systemui.shared.system.UncaughtExceptionPreHandlerManager
		import com.android.systemui.log.table.TableLogBuffer
		import com.google.protobuf.nano.MessageNano
		import java.io.BufferedOutputStream
		import java.io.FileDescriptor
		@@ -39,11 +43,11 @@ import javax.inject.Provider
		*
		* Dump output is split into two sections, CRITICAL and NORMAL. In general, the CRITICAL section
		* contains all dumpables that were registered to the [DumpManager], while the NORMAL sections
		* contains all [LogBuffer]s (due to their length).
		* contains all [LogBuffer]s and [TableLogBuffer]s (due to their length).
		*
		* The CRITICAL and NORMAL sections can be found within a bug report by searching for
		* "SERVICE com.android.systemui/.SystemUIService" and
		* "SERVICE com.android.systemui/.dump.SystemUIAuxiliaryDumpService", respectively.
		* The CRITICAL and NORMAL sections can be found within a bug report by searching for "SERVICE
		* com.android.systemui/.SystemUIService" and "SERVICE
		* com.android.systemui/.dump.SystemUIAuxiliaryDumpService", respectively.
		*
		* Finally, some or all of the dump can be triggered on-demand via adb (see below).
		*
		@@ -72,6 +76,7 @@ import javax.inject.Provider
		* # To dump all dumpables or all buffers:
		* $ <invocation> dumpables
		* $ <invocation> buffers
		* $ <invocation> tables
		*
		* # Finally, the following will simulate what we dump during the CRITICAL and NORMAL sections of a
		* # bug report:
		@@ -83,32 +88,21 @@ import javax.inject.Provider
		* $ <invocation> --help
		* ```
		*/
		class DumpHandler @Inject constructor(
		class DumpHandler
		@Inject
		constructor(
		private val context: Context,
		private val dumpManager: DumpManager,
		private val logBufferEulogizer: LogBufferEulogizer,
		private val startables: MutableMap<Class<*>, Provider<CoreStartable>>,
		private val uncaughtExceptionPreHandlerManager: UncaughtExceptionPreHandlerManager
		) {
		/**
		* Registers an uncaught exception handler
		*/
		fun init() {
		uncaughtExceptionPreHandlerManager.registerHandler { _, e ->
		if (e is Exception) {
		logBufferEulogizer.record(e)
		}
		}
		}

		/**
		* Dump the diagnostics! Behavior can be controlled via [args].
		*/
		/** Dump the diagnostics! Behavior can be controlled via [args]. */
		fun dump(fd: FileDescriptor, pw: PrintWriter, args: Array<String>) {
		Trace.beginSection("DumpManager#dump()")
		val start = SystemClock.uptimeMillis()

		val parsedArgs = try {
		val parsedArgs =
		try {
		parseArgs(args)
		} catch (e: ArgParseException) {
		pw.println(e.message)
		@@ -134,6 +128,7 @@ class DumpHandler @Inject constructor(
		"bugreport-normal" -> dumpNormal(pw, args)
		"dumpables" -> dumpDumpables(pw, args)
		"buffers" -> dumpBuffers(pw, args)
		"tables" -> dumpTables(pw, args)
		"config" -> dumpConfig(pw)
		"help" -> dumpHelp(pw)
		else -> {
		@@ -147,44 +142,65 @@ class DumpHandler @Inject constructor(
		}

		private fun dumpCritical(pw: PrintWriter, args: ParsedArgs) {
		dumpManager.dumpCritical(pw, args.rawArgs)
		val targets = dumpManager.getDumpables()
		for (target in targets) {
		if (target.priority == DumpPriority.CRITICAL) {
		dumpDumpable(target, pw, args.rawArgs)
		}
		}
		dumpConfig(pw)
		}

		private fun dumpNormal(pw: PrintWriter, args: ParsedArgs) {
		dumpManager.dumpNormal(pw, args.rawArgs, args.tailLength)
		logBufferEulogizer.readEulogyIfPresent(pw)
		val targets = dumpManager.getDumpables()
		for (target in targets) {
		if (target.priority == DumpPriority.NORMAL) {
		dumpDumpable(target, pw, args.rawArgs)
		}
		}

		private fun dumpDumpables(pw: PrintWriter, args: ParsedArgs) {
		if (args.listOnly) {
		dumpManager.listDumpables(pw)
		} else {
		dumpManager.dumpDumpables(pw, args.rawArgs)
		val buffers = dumpManager.getLogBuffers()
		for (buffer in buffers) {
		dumpBuffer(buffer, pw, args.tailLength)
		}

		val tableBuffers = dumpManager.getTableLogBuffers()
		for (table in tableBuffers) {
		dumpTableBuffer(table, pw, args.rawArgs)
		}

		private fun dumpBuffers(pw: PrintWriter, args: ParsedArgs) {
		if (args.listOnly) {
		dumpManager.listBuffers(pw)
		} else {
		dumpManager.dumpBuffers(pw, args.tailLength)
		logBufferEulogizer.readEulogyIfPresent(pw)
		}

		private fun dumpDumpables(pw: PrintWriter, args: ParsedArgs) =
		dumpManager.getDumpables().listOrDumpEntries(pw, args)

		private fun dumpBuffers(pw: PrintWriter, args: ParsedArgs) =
		dumpManager.getLogBuffers().listOrDumpEntries(pw, args)

		private fun dumpTables(pw: PrintWriter, args: ParsedArgs) =
		dumpManager.getTableLogBuffers().listOrDumpEntries(pw, args)

		private fun listTargetNames(targets: Collection<DumpsysEntry>, pw: PrintWriter) {
		for (target in targets) {
		pw.println(target.name)
		}
		}

		private fun dumpProtoTargets(
		targets: List<String>,
		fd: FileDescriptor,
		args: ParsedArgs
		) {
		private fun dumpProtoTargets(targets: List<String>, fd: FileDescriptor, args: ParsedArgs) {
		val systemUIProto = SystemUIProtoDump()
		val dumpables = dumpManager.getDumpables()
		if (targets.isNotEmpty()) {
		for (target in targets) {
		dumpManager.dumpProtoTarget(target, systemUIProto, args.rawArgs)
		findBestProtoTargetMatch(dumpables, target)?.dumpProto(systemUIProto, args.rawArgs)
		}
		} else {
		dumpManager.dumpProtoDumpables(systemUIProto, args.rawArgs)
		// Dump all protos
		for (dumpable in dumpables) {
		(dumpable.dumpable as? ProtoDumpable)?.dumpProto(systemUIProto, args.rawArgs)
		}
		}

		val buffer = BufferedOutputStream(FileOutputStream(fd))
		buffer.use {
		it.write(MessageNano.toByteArray(systemUIProto))
		@@ -192,36 +208,70 @@ class DumpHandler @Inject constructor(
		}
		}

		private fun dumpTargets(
		targets: List<String>,
		pw: PrintWriter,
		args: ParsedArgs
		) {
		// Attempts to dump the target list to the given PrintWriter. Since the arguments come in as
		// a list of strings, we use the [findBestTargetMatch] method to determine the most-correct
		// target with the given search string.
		private fun dumpTargets(targets: List<String>, pw: PrintWriter, args: ParsedArgs) {
		if (targets.isNotEmpty()) {
		for (target in targets) {
		dumpManager.dumpTarget(target, pw, args.rawArgs, args.tailLength)
		val dumpables = dumpManager.getDumpables()
		val buffers = dumpManager.getLogBuffers()
		val tableBuffers = dumpManager.getTableLogBuffers()

		targets.forEach { target ->
		findTargetInCollection(target, dumpables, buffers, tableBuffers)?.dump(pw, args)
		}
		} else {
		if (args.listOnly) {
		val dumpables = dumpManager.getDumpables()
		val buffers = dumpManager.getLogBuffers()

		pw.println("Dumpables:")
		dumpManager.listDumpables(pw)
		listTargetNames(dumpables, pw)
		pw.println()

		pw.println("Buffers:")
		dumpManager.listBuffers(pw)
		listTargetNames(buffers, pw)
		} else {
		pw.println("Nothing to dump :(")
		}
		}
		}

		private fun findTargetInCollection(
		target: String,
		dumpables: Collection<DumpableEntry>,
		logBuffers: Collection<LogBufferEntry>,
		tableBuffers: Collection<TableLogBufferEntry>,
		) =
		sequence {
		findBestTargetMatch(dumpables, target)?.let { yield(it) }
		findBestTargetMatch(logBuffers, target)?.let { yield(it) }
		findBestTargetMatch(tableBuffers, target)?.let { yield(it) }
		}
		.sortedBy { it.name }
		.minByOrNull { it.name.length }

		private fun dumpDumpable(entry: DumpableEntry, pw: PrintWriter, args: Array<String>) {
		pw.preamble(entry)
		entry.dumpable.dump(pw, args)
		}

		private fun dumpBuffer(entry: LogBufferEntry, pw: PrintWriter, tailLength: Int) {
		pw.preamble(entry)
		entry.buffer.dump(pw, tailLength)
		}

		private fun dumpTableBuffer(buffer: TableLogBufferEntry, pw: PrintWriter, args: Array<String>) {
		pw.preamble(buffer)
		buffer.table.dump(pw, args)
		}

		private fun dumpConfig(pw: PrintWriter) {
		pw.println("SystemUiServiceComponents configuration:")
		pw.print("vendor component: ")
		pw.println(context.resources.getString(R.string.config_systemUIVendorServiceComponent))
		val services: MutableList<String> = startables.keys
		.map({ cls: Class<*> -> cls.simpleName })
		.toMutableList()
		val services: MutableList<String> =
		startables.keys.map({ cls: Class<*> -> cls.simpleName }).toMutableList()

		services.add(context.resources.getString(R.string.config_systemUIVendorServiceComponent))
		dumpServiceList(pw, "global", services.toTypedArray())
		@@ -265,6 +315,7 @@ class DumpHandler @Inject constructor(
		pw.println("Special commands:")
		pw.println("$ <invocation> dumpables")
		pw.println("$ <invocation> buffers")
		pw.println("$ <invocation> tables")
		pw.println("$ <invocation> bugreport-critical")
		pw.println("$ <invocation> bugreport-normal")
		pw.println("$ <invocation> config")
		@@ -274,6 +325,7 @@ class DumpHandler @Inject constructor(
		pw.println("$ <invocation> --list")
		pw.println("$ <invocation> dumpables --list")
		pw.println("$ <invocation> buffers --list")
		pw.println("$ <invocation> tables --list")
		pw.println()

		pw.println("Show only the most recent N lines of buffers")
		@@ -291,7 +343,8 @@ class DumpHandler @Inject constructor(
		iterator.remove()
		when (arg) {
		PRIORITY_ARG -> {
		pArgs.dumpPriority = readArgument(iterator, PRIORITY_ARG) {
		pArgs.dumpPriority =
		readArgument(iterator, PRIORITY_ARG) {
		if (PRIORITY_OPTIONS.contains(it)) {
		it
		} else {
		@@ -300,15 +353,16 @@ class DumpHandler @Inject constructor(
		}
		}
		PROTO -> pArgs.proto = true
		"-t", "--tail" -> {
		pArgs.tailLength = readArgument(iterator, arg) {
		it.toInt()
		"-t",
		"--tail" -> {
		pArgs.tailLength = readArgument(iterator, arg) { it.toInt() }
		}
		}
		"-l", "--list" -> {
		"-l",
		"--list" -> {
		pArgs.listOnly = true
		}
		"-h", "--help" -> {
		"-h",
		"--help" -> {
		pArgs.command = "help"
		}
		// This flag is passed as part of the proto dump in Bug reports, we can ignore
		@@ -345,29 +399,131 @@ class DumpHandler @Inject constructor(
		}
		}

		private fun DumpsysEntry.dump(pw: PrintWriter, args: ParsedArgs) =
		when (this) {
		is DumpableEntry -> dumpDumpable(this, pw, args.rawArgs)
		is LogBufferEntry -> dumpBuffer(this, pw, args.tailLength)
		is TableLogBufferEntry -> dumpTableBuffer(this, pw, args.rawArgs)
		}

		private fun Collection<DumpsysEntry>.listOrDumpEntries(pw: PrintWriter, args: ParsedArgs) =
		if (args.listOnly) {
		listTargetNames(this, pw)
		} else {
		forEach { it.dump(pw, args) }
		}

		companion object {
		const val PRIORITY_ARG = "--dump-priority"
		const val PRIORITY_ARG_CRITICAL = "CRITICAL"
		const val PRIORITY_ARG_NORMAL = "NORMAL"
		const val PROTO = "--proto"

		/**
		* Important: do not change this divider without updating any bug report processing tools
		* (e.g. ABT), since this divider is used to determine boundaries for bug report views
		*/
		const val DUMPSYS_DUMPABLE_DIVIDER =
		"----------------------------------------------------------------------------"

		/**
		* Important: do not change this divider without updating any bug report processing tools
		* (e.g. ABT), since this divider is used to determine boundaries for bug report views
		*/
		const val DUMPSYS_BUFFER_DIVIDER =
		"============================================================================"

		private fun findBestTargetMatch(c: Collection<DumpsysEntry>, target: String) =
		c.asSequence().filter { it.name.endsWith(target) }.minByOrNull { it.name.length }

		private fun findBestProtoTargetMatch(
		c: Collection<DumpableEntry>,
		target: String
		): ProtoDumpable? =
		c.asSequence()
		.filter { it.name.endsWith(target) }
		.filter { it.dumpable is ProtoDumpable }
		.minByOrNull { it.name.length }
		?.dumpable as? ProtoDumpable

		private fun PrintWriter.preamble(entry: DumpsysEntry) =
		when (entry) {
		// Historically TableLogBuffer was not separate from dumpables, so they have the
		// same header
		is DumpableEntry,
		is TableLogBufferEntry -> {
		println()
		println(entry.name)
		println(DUMPSYS_DUMPABLE_DIVIDER)
		}
		is LogBufferEntry -> {
		println()
		println()
		println("BUFFER ${entry.name}:")
		println(DUMPSYS_BUFFER_DIVIDER)
		}
		}

		/**
		* Zero-arg utility to write a [DumpableEntry] to the given [PrintWriter] in a
		* dumpsys-appropriate format.
		*/
		private fun dumpDumpable(entry: DumpableEntry, pw: PrintWriter) {
		pw.preamble(entry)
		entry.dumpable.dump(pw, arrayOf())
		}

		/**
		* Zero-arg utility to write a [LogBufferEntry] to the given [PrintWriter] in a
		* dumpsys-appropriate format.
		*/
		private fun dumpBuffer(entry: LogBufferEntry, pw: PrintWriter) {
		pw.preamble(entry)
		entry.buffer.dump(pw, 0)
		}

		/**
		* Zero-arg utility to write a [TableLogBufferEntry] to the given [PrintWriter] in a
		* dumpsys-appropriate format.
		*/
		private fun dumpTableBuffer(entry: TableLogBufferEntry, pw: PrintWriter) {
		pw.preamble(entry)
		entry.table.dump(pw, arrayOf())
		}

		/**
		* Zero-arg utility to write a [DumpsysEntry] to the given [PrintWriter] in a
		* dumpsys-appropriate format.
		*/
		fun DumpsysEntry.dump(pw: PrintWriter) {
		when (this) {
		is DumpableEntry -> dumpDumpable(this, pw)
		is LogBufferEntry -> dumpBuffer(this, pw)
		is TableLogBufferEntry -> dumpTableBuffer(this, pw)
		}
		}

		/** Format [entries] in a dumpsys-appropriate way, using [pw] */
		fun dumpEntries(entries: Collection<DumpsysEntry>, pw: PrintWriter) {
		entries.forEach { it.dump(pw) }
		}
		}
		}

		private val PRIORITY_OPTIONS = arrayOf(PRIORITY_ARG_CRITICAL, PRIORITY_ARG_NORMAL)

		private val COMMANDS = arrayOf(
		private val COMMANDS =
		arrayOf(
		"bugreport-critical",
		"bugreport-normal",
		"buffers",
		"dumpables",
		"tables",
		"config",
		"help"
		)

		private class ParsedArgs(
		val rawArgs: Array<String>,
		val nonFlagArgs: List<String>
		) {
		private class ParsedArgs(val rawArgs: Array<String>, val nonFlagArgs: List<String>) {
		var dumpPriority: String? = null
		var tailLength: Int = 0
		var command: String? = null

packages/SystemUI/src/com/android/systemui/dump/DumpManager.kt

+30 −182

File changed.

Preview size limit exceeded, changes collapsed.

packages/SystemUI/src/com/android/systemui/dump/DumpsysEntry.kt

0 → 100644

+62 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2023 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.systemui.dump

		import com.android.systemui.Dumpable
		import com.android.systemui.log.LogBuffer
		import com.android.systemui.log.table.TableLogBuffer

		/**
		* A DumpsysEntry is a named, registered entry tracked by [DumpManager] which can be addressed and
		* used both in a bugreport / dumpsys invocation or in an individual CLI implementation.
		*
		* The idea here is that we define every type that [DumpManager] knows about and defines the minimum
		* shared interface between each type. So far, just [name] and [priority]. This way, [DumpManager]
		* can just store them in separate maps and do the minimal amount of work to discriminate between
		* them.
		*
		* Individual consumers can request these participants in a list via the relevant get* methods on
		* [DumpManager]
		*/
		sealed interface DumpsysEntry {
		val name: String
		val priority: DumpPriority

		data class DumpableEntry(
		val dumpable: Dumpable,
		override val name: String,
		override val priority: DumpPriority,
		) : DumpsysEntry

		data class LogBufferEntry(
		val buffer: LogBuffer,
		override val name: String,
		) : DumpsysEntry {
		// All buffers must be priority NORMAL, not CRITICAL, because they often contain a lot of
		// data.
		override val priority: DumpPriority = DumpPriority.NORMAL
		}

		data class TableLogBufferEntry(
		val table: TableLogBuffer,
		override val name: String,
		) : DumpsysEntry {
		// All buffers must be priority NORMAL, not CRITICAL, because they often contain a lot of
		// data.
		override val priority: DumpPriority = DumpPriority.NORMAL
		}
		}

packages/SystemUI/src/com/android/systemui/dump/LogBufferEulogizer.kt

+23 −20

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@ import android.content.Context
		import android.icu.text.SimpleDateFormat
		import android.util.Log
		import com.android.systemui.dagger.SysUISingleton
		import com.android.systemui.dump.DumpHandler.Companion.dumpEntries
		import com.android.systemui.log.LogBuffer
		import com.android.systemui.util.io.Files
		import com.android.systemui.util.time.SystemClock
		@@ -48,20 +49,21 @@ class LogBufferEulogizer(
		private val files: Files,
		private val logPath: Path,
		private val minWriteGap: Long,
		private val maxLogAgeToDump: Long
		private val maxLogAgeToDump: Long,
		) {
		@Inject constructor(
		@Inject
		constructor(
		context: Context,
		dumpManager: DumpManager,
		systemClock: SystemClock,
		files: Files
		files: Files,
		) : this(
		dumpManager,
		systemClock,
		files,
		Paths.get(context.filesDir.toPath().toString(), "log_buffers.txt"),
		MIN_WRITE_GAP,
		MAX_AGE_TO_DUMP
		MAX_AGE_TO_DUMP,
		)

		/**
		@@ -91,7 +93,8 @@ class LogBufferEulogizer(
		pw.println()
		pw.println("Dump triggered by exception:")
		reason.printStackTrace(pw)
		dumpManager.dumpBuffers(pw, 0)
		val buffers = dumpManager.getLogBuffers()
		dumpEntries(buffers, pw)
		duration = systemClock.uptimeMillis() - start
		pw.println()
		pw.println("Buffer eulogy took ${duration}ms")
		@@ -105,16 +108,17 @@ class LogBufferEulogizer(
		return reason
		}

		/**
		* If a eulogy file is present, writes its contents to [pw].
		*/
		/** If a eulogy file is present, writes its contents to [pw]. */
		fun readEulogyIfPresent(pw: PrintWriter) {
		try {
		val millisSinceLastWrite = getMillisSinceLastWrite(logPath)
		if (millisSinceLastWrite > maxLogAgeToDump) {
		Log.i(TAG, "Not eulogizing buffers; they are " +
		Log.i(
		TAG,
		"Not eulogizing buffers; they are " +
		TimeUnit.HOURS.convert(millisSinceLastWrite, TimeUnit.MILLISECONDS) +
		" hours old")
		" hours old"
		)
		return
		}

		@@ -122,9 +126,7 @@ class LogBufferEulogizer(
		pw.println()
		pw.println()
		pw.println("=============== BUFFERS FROM MOST RECENT CRASH ===============")
		s.forEach { line ->
		pw.println(line)
		}
		s.forEach { line -> pw.println(line) }
		}
		} catch (e: IOException) {
		// File doesn't exist, okay
		@@ -134,7 +136,8 @@ class LogBufferEulogizer(
		}

		private fun getMillisSinceLastWrite(path: Path): Long {
		val stats = try {
		val stats =
		try {
		files.readAttributes(path, BasicFileAttributes::class.java)
		} catch (e: IOException) {
		// File doesn't exist