diff --git a/malheur/src/main/java/de/kuschku/malheur/CrashContext.kt b/malheur/src/main/java/de/kuschku/malheur/CrashContext.kt new file mode 100644 index 0000000000000000000000000000000000000000..ec7719c1f9437b7ddc31d766f50aaa9156c84684 --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/CrashContext.kt @@ -0,0 +1,15 @@ +package de.kuschku.malheur + +import android.app.Application +import de.kuschku.malheur.config.ReportConfig +import java.util.* + +data class CrashContext( + val application: Application, + val config: ReportConfig, + val crashingThread: Thread, + val throwable: Throwable, + val startTime: Date, + val crashTime: Date, + val buildConfig: Class<*>? +) diff --git a/malheur/src/main/java/de/kuschku/malheur/CrashHandler.kt b/malheur/src/main/java/de/kuschku/malheur/CrashHandler.kt index 415e19ddc3b9f194125edd4c171dad448aea1f60..4fe85518c1508d6ae14c57e5e3eede0e6cc494c1 100644 --- a/malheur/src/main/java/de/kuschku/malheur/CrashHandler.kt +++ b/malheur/src/main/java/de/kuschku/malheur/CrashHandler.kt @@ -1,166 +1,44 @@ package de.kuschku.malheur -import android.annotation.SuppressLint import android.app.Application -import android.content.pm.PackageManager -import android.os.Build -import android.os.Debug -import android.os.Environment -import android.os.Process -import android.provider.Settings import com.google.gson.GsonBuilder -import de.kuschku.malheur.data.* -import de.kuschku.malheur.util.* -import java.io.File -import java.text.SimpleDateFormat +import de.kuschku.malheur.collectors.ReportCollector +import de.kuschku.malheur.config.ReportConfig import java.util.* object CrashHandler { - private lateinit var packageManager: PackageManager - private lateinit var config: ReportConfiguration - - private lateinit var originalHandler: Thread.UncaughtExceptionHandler - - private val logcatTimeFormatter = SimpleDateFormat("MM-dd HH:mm:ss.SSS", Locale.US) private val gson = GsonBuilder().disableHtmlEscaping().setPrettyPrinting().create() - data class ReportConfiguration( - val crash: Boolean = true, - val crashCause: Boolean = true, - val crashException: Boolean = true, - val crashActiveThread: Boolean = true, - val crashStartTime: Boolean = true, - val crashCrashTime: Boolean = true, - val threads: Boolean = true, - val logcat: List<String> = listOf("main", "events", "crash"), - val application: Boolean = true, - val applicationVersionName: Boolean = true, - val applicationVersionCode: Boolean = true, - val applicationBuildConfig: Boolean = true, - val device: Boolean = true, - val deviceBuild: Boolean = true, - val deviceVersion: Boolean = true, - val deviceInstallationId: Boolean = true, - val deviceProcessor: Boolean = true, - val deviceRuntime: Boolean = true, - val environment: Boolean = true, - val environmentPaths: Boolean = true, - val environmentMemory: Boolean = true - ) + private val startTime = Date() + private var originalHandler: Thread.UncaughtExceptionHandler? = null - @SuppressLint("HardwareIds") - fun init(application: Application, configuration: ReportConfiguration = ReportConfiguration(), + fun init(application: Application, config: ReportConfig = ReportConfig(), buildConfig: Class<*>?) { - val startTime = Date() - packageManager = application.packageManager - originalHandler = Thread.getDefaultUncaughtExceptionHandler() - - config = configuration + if (myHandler == null) { + originalHandler = Thread.getDefaultUncaughtExceptionHandler() + } - Thread.setDefaultUncaughtExceptionHandler { activeThread, throwable -> + val reportCollector = ReportCollector(application) + myHandler = Thread.UncaughtExceptionHandler { activeThread, throwable -> Thread { - val pid = Process.myPid().toString() - val crashTime = Date() try { - val since = logcatTimeFormatter.format(startTime) - val data = Report( - crash = CrashInfo( - cause = orNull(config.crashCause) { - ExceptionInfo(throwable) - }, - exception = orNull(config.crashException) { - throwable.printStackTraceToString() - }, - activeThread = orNull(config.crashActiveThread) { - ThreadInfo(activeThread) - }, - startTime = orNull(config.crashStartTime) { - startTime.time - }, - crashTime = orNull(config.crashCrashTime) { - crashTime.time - } - ), - threads = orNull(config.threads) { - Thread.getAllStackTraces() - .filterKeys { it != Thread.currentThread() } - .map { (thread, stackTrace) -> - ThreadInfo(thread, stackTrace) - } - }, - logcat = config.logcat.map { buffer -> - buffer to readLogCat(since, buffer, pid) - }.toMap(), - application = orNull(config.application) { - AppInfo( - versionName = orNull(config.applicationVersionName) { - packageManager.getPackageInfo(application.packageName, 0).versionName - }, - versionCode = orNull(config.applicationVersionCode) { - packageManager.getPackageInfo(application.packageName, 0).versionCode - }, - buildConfig = orNull(config.applicationBuildConfig) { - reflectionCollectConstants( - buildConfig ?: getBuildConfigClass(application.packageName)) - } - ) - }, - device = orNull(config.device) { - DeviceInfo( - build = orNull(config.deviceBuild) { - reflectionCollectConstants(Build::class.java) - }, - version = orNull(config.deviceVersion) { - reflectionCollectConstants(Build.VERSION::class.java) - }, - installationId = orNull(config.deviceInstallationId) { - Settings.Secure.getString( - application.contentResolver, Settings.Secure.ANDROID_ID - ) - }, - processor = orNull(config.deviceProcessor) { - readProcInfo() - } - ) - }, - environment = orNull(config.environment) { - mapOf( - "paths" to orNull(config.environmentPaths) { - reflectionCollectGetters(Environment::class.java)?.map { (key, value) -> - key to if (value is File) { - value.canonicalPath - } else { - value - } - }?.toMap() - }, - "memory" to orNull(config.environmentMemory) { - val memoryInfo = Debug.MemoryInfo() - Debug.getMemoryInfo(memoryInfo) - MemoryInfo(memoryInfo) - } - ) - } - ) - - val json = gson.toJson(data) + val json = gson.toJson(reportCollector.collect(CrashContext( + application = application, + config = config, + crashingThread = activeThread, + throwable = throwable, + startTime = startTime, + crashTime = Date(), + buildConfig = buildConfig + ), config)) println(json) } catch (e: Throwable) { - originalHandler.uncaughtException(activeThread, throwable) + originalHandler?.uncaughtException(activeThread, throwable) } }.start() } + Thread.setDefaultUncaughtExceptionHandler(myHandler) } - private fun getBuildConfigClass(packageName: String) = try { - Class.forName("$packageName.BuildConfig") - } catch (e: ClassNotFoundException) { - null - } - - private fun <T> orNull(condition: Boolean, closure: (() -> T)) = if (condition) { - closure() - } else { - null - } + var myHandler: Thread.UncaughtExceptionHandler? = null } diff --git a/malheur/src/main/java/de/kuschku/malheur/collectors/AppCollector.kt b/malheur/src/main/java/de/kuschku/malheur/collectors/AppCollector.kt new file mode 100644 index 0000000000000000000000000000000000000000..859edd19be3f950a31eaf418307733f135bba752 --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/collectors/AppCollector.kt @@ -0,0 +1,29 @@ +package de.kuschku.malheur.collectors + +import android.app.Application +import de.kuschku.malheur.CrashContext +import de.kuschku.malheur.config.AppConfig +import de.kuschku.malheur.data.AppInfo +import de.kuschku.malheur.util.reflectionCollectConstants + +class AppCollector(private val application: Application) : Collector<AppInfo, AppConfig> { + override fun collect(context: CrashContext, config: AppConfig) = AppInfo( + versionName = collectIf(config.versionName) { + application.packageManager.getPackageInfo(application.packageName, 0).versionName + }, + versionCode = collectIf(config.versionCode) { + application.packageManager.getPackageInfo(application.packageName, 0).versionCode + }, + buildConfig = collectIf(config.buildConfig) { + reflectionCollectConstants( + context.buildConfig ?: getBuildConfigClass(application.packageName) + ) + } + ) + + private fun getBuildConfigClass(packageName: String) = try { + Class.forName("$packageName.BuildConfig") + } catch (e: ClassNotFoundException) { + null + } +} diff --git a/malheur/src/main/java/de/kuschku/malheur/collectors/Collector.kt b/malheur/src/main/java/de/kuschku/malheur/collectors/Collector.kt new file mode 100644 index 0000000000000000000000000000000000000000..a6720d1bb251e0c72b81cb24e9282a4b03f47611 --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/collectors/Collector.kt @@ -0,0 +1,20 @@ +package de.kuschku.malheur.collectors + +import de.kuschku.malheur.CrashContext + +interface Collector<out DataType, ConfigType> { + fun collect(context: CrashContext, config: ConfigType): DataType? +} + +inline fun <DataType, ConfigType> Collector<DataType, ConfigType>.collectIf( + context: CrashContext, + config: ConfigType? +) = if (config != null) + collect(context, config) +else + null + +inline fun <DataType> collectIf(enabled: Boolean, closure: () -> DataType?) = if (enabled) + closure() +else + null diff --git a/malheur/src/main/java/de/kuschku/malheur/collectors/ConfigurationCollector.kt b/malheur/src/main/java/de/kuschku/malheur/collectors/ConfigurationCollector.kt new file mode 100644 index 0000000000000000000000000000000000000000..bb0bcfe4b2071a1982eb83c27006346807a838ef --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/collectors/ConfigurationCollector.kt @@ -0,0 +1,110 @@ +package de.kuschku.malheur.collectors + +import android.app.Application +import android.content.res.Configuration +import android.util.SparseArray +import de.kuschku.malheur.CrashContext +import java.lang.reflect.Modifier + +class ConfigurationCollector(private val application: Application) : + Collector<Map<String, Any?>, Boolean> { + private val configValueInfo = mutableMapOf<String, SparseArray<String>>() + + private val configurationFields = listOf( + FieldDefinition( + fieldName = "mcc" + ), + FieldDefinition( + fieldName = "mnc" + ), + FieldDefinition( + fieldName = "screenHeightDp" + ), + FieldDefinition( + fieldName = "screenWidthDp" + ), + FieldDefinition( + fieldName = "smallestScreenWidthDp" + ), + FieldDefinition( + fieldName = "navigation", + enumPrefix = "NAVIGATION" + ), + FieldDefinition( + fieldName = "navigationHidden", + enumPrefix = "NAVIGATIONHIDDEN" + ), + FieldDefinition( + fieldName = "orientation", + enumPrefix = "ORIENTATION" + ), + FieldDefinition( + fieldName = "screenLayout", + enumPrefix = "SCREENLAYOUT", + isFlag = true + ), + FieldDefinition( + fieldName = "touchscreen", + enumPrefix = "TOUCHSCREEN" + ), + FieldDefinition( + fieldName = "uiMode", + enumPrefix = "UI_MODE", + isFlag = true + ) + ) + + init { + val configurationFieldPrefixes = configurationFields.map(FieldDefinition::enumPrefix) + + Configuration::class.java.declaredFields.filter { + Modifier.isStatic(it.modifiers) + }.filter { + it.type == Int::class.java + }.filterNot { + it.name.endsWith("_MASK") + }.forEach { field -> + val group = configurationFieldPrefixes.find { field.name.startsWith(it + "_") } + if (group != null) { + val value = field.name.substring(group.length + 1) + configValueInfo.getOrPut(group, ::SparseArray).put(field.getInt(null), value) + } + } + } + + override fun collect(context: CrashContext, config: Boolean) = configurationFields.map { + it to Configuration::class.java.getDeclaredField(it.fieldName) + }.filter { (_, field) -> + field != null && !Modifier.isStatic(field.modifiers) + }.map { (info, field) -> + val groupInfo = configValueInfo[info.enumPrefix] + if (groupInfo != null) { + val value = field.getInt(application.resources.configuration) + if (info.isFlag) { + info.fieldName to (0 until groupInfo.size()).map { idx -> + groupInfo.keyAt(idx) to groupInfo.valueAt(idx) + }.filter { (key, _) -> + value and key != 0 + }.map { (_, value) -> + value + }.toList() + } else { + val valueConstant = groupInfo[value] + if (valueConstant == null) { + info.fieldName to value + } else { + info.fieldName to valueConstant + } + } + } else { + val value = field.getInt(application.resources.configuration) + info.fieldName to value + } + }.toMap() + + class FieldDefinition( + val fieldName: String, + val enumPrefix: String? = null, + val isFlag: Boolean = false + ) +} diff --git a/malheur/src/main/java/de/kuschku/malheur/collectors/CrashCollector.kt b/malheur/src/main/java/de/kuschku/malheur/collectors/CrashCollector.kt new file mode 100644 index 0000000000000000000000000000000000000000..99fc29c1c0afb142852c128d7587e17207b6103c --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/collectors/CrashCollector.kt @@ -0,0 +1,35 @@ +package de.kuschku.malheur.collectors + +import android.app.Application +import de.kuschku.malheur.CrashContext +import de.kuschku.malheur.config.CrashConfig +import de.kuschku.malheur.data.CrashInfo +import de.kuschku.malheur.data.ExceptionInfo +import de.kuschku.malheur.data.ThreadInfo +import de.kuschku.malheur.util.printStackTraceToString +import java.text.SimpleDateFormat +import java.util.* + +class CrashCollector(application: Application) : Collector<CrashInfo, CrashConfig> { + private val configurationCollector = ConfigurationCollector(application) + private val isoFormatter = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSX", Locale.US) + + override fun collect(context: CrashContext, config: CrashConfig) = CrashInfo( + cause = collectIf(config.cause) { + ExceptionInfo(context.throwable) + }, + exception = collectIf(config.exception) { + context.throwable.printStackTraceToString() + }, + activeThread = collectIf(config.activeThread) { + ThreadInfo(context.crashingThread) + }, + startTime = collectIf(config.startTime) { + isoFormatter.format(context.startTime) + }, + crashTime = collectIf(config.crashTime) { + isoFormatter.format(context.crashTime) + }, + configuration = configurationCollector.collectIf(context, config.configuration) + ) +} diff --git a/malheur/src/main/java/de/kuschku/malheur/collectors/DeviceCollector.kt b/malheur/src/main/java/de/kuschku/malheur/collectors/DeviceCollector.kt new file mode 100644 index 0000000000000000000000000000000000000000..2768e1a065d9c7090574eb61a57162cc73d59551 --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/collectors/DeviceCollector.kt @@ -0,0 +1,29 @@ +package de.kuschku.malheur.collectors + +import android.annotation.SuppressLint +import android.app.Application +import android.os.Build +import android.provider.Settings +import de.kuschku.malheur.CrashContext +import de.kuschku.malheur.config.DeviceConfig +import de.kuschku.malheur.data.DeviceInfo +import de.kuschku.malheur.util.readProcInfo +import de.kuschku.malheur.util.reflectionCollectConstants + +class DeviceCollector(private val application: Application) : Collector<DeviceInfo, DeviceConfig> { + @SuppressLint("HardwareIds") + override fun collect(context: CrashContext, config: DeviceConfig) = DeviceInfo( + build = collectIf(config.build) { + reflectionCollectConstants(Build::class.java) + }, + version = collectIf(config.version) { + reflectionCollectConstants(Build.VERSION::class.java) + }, + installationId = collectIf(config.installationId) { + Settings.Secure.getString(application.contentResolver, Settings.Secure.ANDROID_ID) + }, + processor = collectIf(config.processor) { + readProcInfo() + } + ) +} diff --git a/malheur/src/main/java/de/kuschku/malheur/collectors/EnvCollector.kt b/malheur/src/main/java/de/kuschku/malheur/collectors/EnvCollector.kt new file mode 100644 index 0000000000000000000000000000000000000000..fb5ca1e8aa16bc1ab111fee0cc3b1244aa5175f9 --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/collectors/EnvCollector.kt @@ -0,0 +1,30 @@ +package de.kuschku.malheur.collectors + +import android.app.Application +import android.os.Debug +import android.os.Environment +import de.kuschku.malheur.CrashContext +import de.kuschku.malheur.config.EnvConfig +import de.kuschku.malheur.data.MemoryInfo +import de.kuschku.malheur.util.reflectionCollectGetters +import java.io.File + +class EnvCollector(application: Application) : Collector<Map<String, Any?>, EnvConfig> { + override fun collect(context: CrashContext, config: EnvConfig) = mapOf( + "paths" to collectIf(config.paths) { + reflectionCollectGetters( + Environment::class.java)?.map { (key, value) -> + key to if (value is File) { + value.canonicalPath + } else { + value + } + }?.toMap() + }, + "memory" to collectIf(config.memory) { + val memoryInfo = Debug.MemoryInfo() + Debug.getMemoryInfo(memoryInfo) + MemoryInfo(memoryInfo) + } + ) +} diff --git a/malheur/src/main/java/de/kuschku/malheur/collectors/LogCollector.kt b/malheur/src/main/java/de/kuschku/malheur/collectors/LogCollector.kt new file mode 100644 index 0000000000000000000000000000000000000000..a8d1733135115bef8165acb9b402570401546b5d --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/collectors/LogCollector.kt @@ -0,0 +1,21 @@ +package de.kuschku.malheur.collectors + +import android.app.Application +import android.os.Process +import de.kuschku.malheur.CrashContext +import de.kuschku.malheur.config.LogConfig +import de.kuschku.malheur.util.readLogCat +import java.text.SimpleDateFormat +import java.util.* + +class LogCollector(application: Application) : Collector<Map<String, List<String>>, LogConfig> { + private val logcatTimeFormatter = SimpleDateFormat("MM-dd HH:mm:ss.SSS", Locale.US) + private val pid = Process.myPid().toString() + + override fun collect(context: CrashContext, config: LogConfig): Map<String, List<String>> { + val since = logcatTimeFormatter.format(context.startTime) + return config.buffers.map { buffer -> + buffer to readLogCat(since, buffer, pid) + }.toMap() + } +} diff --git a/malheur/src/main/java/de/kuschku/malheur/collectors/ReportCollector.kt b/malheur/src/main/java/de/kuschku/malheur/collectors/ReportCollector.kt new file mode 100644 index 0000000000000000000000000000000000000000..ebe95f841240d2fbc125c7a97ba3e8a7a570ccfe --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/collectors/ReportCollector.kt @@ -0,0 +1,30 @@ +package de.kuschku.malheur.collectors + +import android.app.Application +import de.kuschku.malheur.CrashContext +import de.kuschku.malheur.config.ReportConfig +import de.kuschku.malheur.data.Report +import de.kuschku.malheur.data.ThreadInfo + +class ReportCollector(application: Application) : Collector<Report, ReportConfig> { + private val logcatCollector = LogCollector(application) + private val crashCollector = CrashCollector(application) + private val applicationCollector = AppCollector(application) + private val deviceCollector = DeviceCollector(application) + private val environmentCollector = EnvCollector(application) + + override fun collect(context: CrashContext, config: ReportConfig) = Report( + crash = crashCollector.collectIf(context, config.crash), + threads = collectIf(config.threads) { + Thread.getAllStackTraces() + .filterKeys { it != Thread.currentThread() } + .map { (thread, stackTrace) -> + ThreadInfo(thread, stackTrace) + } + }, + logcat = logcatCollector.collectIf(context, config.logcat), + application = applicationCollector.collectIf(context, config.application), + device = deviceCollector.collectIf(context, config.device), + environment = environmentCollector.collectIf(context, config.environment) + ) +} diff --git a/malheur/src/main/java/de/kuschku/malheur/config/AppConfig.kt b/malheur/src/main/java/de/kuschku/malheur/config/AppConfig.kt new file mode 100644 index 0000000000000000000000000000000000000000..38922707c723322cab49ee5838adef4c06705929 --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/config/AppConfig.kt @@ -0,0 +1,7 @@ +package de.kuschku.malheur.config + +data class AppConfig( + val versionName: Boolean = true, + val versionCode: Boolean = true, + val buildConfig: Boolean = true +) diff --git a/malheur/src/main/java/de/kuschku/malheur/config/CrashConfig.kt b/malheur/src/main/java/de/kuschku/malheur/config/CrashConfig.kt new file mode 100644 index 0000000000000000000000000000000000000000..05728d5becab5f951c12cd2403b54fb660714cb9 --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/config/CrashConfig.kt @@ -0,0 +1,10 @@ +package de.kuschku.malheur.config + +data class CrashConfig( + val cause: Boolean = true, + val exception: Boolean = true, + val activeThread: Boolean = true, + val startTime: Boolean = true, + val crashTime: Boolean = true, + val configuration: Boolean = true +) diff --git a/malheur/src/main/java/de/kuschku/malheur/config/DeviceConfig.kt b/malheur/src/main/java/de/kuschku/malheur/config/DeviceConfig.kt new file mode 100644 index 0000000000000000000000000000000000000000..ca332a7733ac53d9c7c6a88869eb065dbfde1dc2 --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/config/DeviceConfig.kt @@ -0,0 +1,9 @@ +package de.kuschku.malheur.config + +data class DeviceConfig( + val build: Boolean = true, + val version: Boolean = true, + val installationId: Boolean = true, + val processor: Boolean = true, + val runtime: Boolean = true +) diff --git a/malheur/src/main/java/de/kuschku/malheur/config/EnvConfig.kt b/malheur/src/main/java/de/kuschku/malheur/config/EnvConfig.kt new file mode 100644 index 0000000000000000000000000000000000000000..29c5fbbfae95173d62ad34d864d780a43b0559e3 --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/config/EnvConfig.kt @@ -0,0 +1,6 @@ +package de.kuschku.malheur.config + +data class EnvConfig( + val paths: Boolean = true, + val memory: Boolean = true +) diff --git a/malheur/src/main/java/de/kuschku/malheur/config/LogConfig.kt b/malheur/src/main/java/de/kuschku/malheur/config/LogConfig.kt new file mode 100644 index 0000000000000000000000000000000000000000..7995c58b91633be2ea63611969d714264a991667 --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/config/LogConfig.kt @@ -0,0 +1,5 @@ +package de.kuschku.malheur.config + +data class LogConfig( + val buffers: List<String> = listOf("main", "events", "crash") +) diff --git a/malheur/src/main/java/de/kuschku/malheur/config/ReportConfig.kt b/malheur/src/main/java/de/kuschku/malheur/config/ReportConfig.kt new file mode 100644 index 0000000000000000000000000000000000000000..4ee6eedec3556a4b4a975aa0f47b7a56f9776093 --- /dev/null +++ b/malheur/src/main/java/de/kuschku/malheur/config/ReportConfig.kt @@ -0,0 +1,10 @@ +package de.kuschku.malheur.config + +data class ReportConfig( + val crash: CrashConfig? = CrashConfig(), + val threads: Boolean = true, + val logcat: LogConfig? = LogConfig(), + val application: AppConfig? = AppConfig(), + val device: DeviceConfig? = DeviceConfig(), + val environment: EnvConfig? = EnvConfig() +) diff --git a/malheur/src/main/java/de/kuschku/malheur/data/CrashInfo.kt b/malheur/src/main/java/de/kuschku/malheur/data/CrashInfo.kt index cae838453144125c071c25491959958f0acad96f..609624d65cc393b259a061c40fe73e36e2056f06 100644 --- a/malheur/src/main/java/de/kuschku/malheur/data/CrashInfo.kt +++ b/malheur/src/main/java/de/kuschku/malheur/data/CrashInfo.kt @@ -4,6 +4,7 @@ data class CrashInfo( val cause: ExceptionInfo?, val exception: String?, val activeThread: ThreadInfo?, - val startTime: Long?, - val crashTime: Long? + val startTime: String?, + val crashTime: String?, + val configuration: Map<String, Any?>? ) diff --git a/malheur/src/main/java/de/kuschku/malheur/data/ExceptionInfo.kt b/malheur/src/main/java/de/kuschku/malheur/data/ExceptionInfo.kt index 73befa66709657709500cf3103f0785f5a9a83bb..4ebba03194f0e91e3e461c66bf643cfba814ea66 100644 --- a/malheur/src/main/java/de/kuschku/malheur/data/ExceptionInfo.kt +++ b/malheur/src/main/java/de/kuschku/malheur/data/ExceptionInfo.kt @@ -5,7 +5,6 @@ data class ExceptionInfo( val message: String?, val localizedMessage: String?, val stackTrace: List<TraceElement>?, - val suppressed: List<ExceptionInfo>?, val cause: ExceptionInfo? ) { constructor(throwable: Throwable) : this( @@ -13,7 +12,6 @@ data class ExceptionInfo( message = throwable.message, localizedMessage = throwable.localizedMessage, stackTrace = throwable.stackTrace?.map(::TraceElement), - suppressed = throwable.suppressed?.map(::ExceptionInfo), cause = throwable.cause?.let(::ExceptionInfo) ) } diff --git a/malheur/src/main/java/de/kuschku/malheur/data/RuntimeInfo.kt b/malheur/src/main/java/de/kuschku/malheur/data/MemoryInfo.kt similarity index 100% rename from malheur/src/main/java/de/kuschku/malheur/data/RuntimeInfo.kt rename to malheur/src/main/java/de/kuschku/malheur/data/MemoryInfo.kt