@grafana/faro-react-native 1.2.1 → 1.3.0

package/android/build.gradle

@@ -7,11 +7,13 @@ buildscript {
     dependencies {
         classpath 'com.android.tools.build:gradle:7.4.2'
         classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.0'
+        classpath 'com.google.protobuf:protobuf-gradle-plugin:0.9.4'
     }
 }
 
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
+apply plugin: 'com.google.protobuf'
 
 android {
     namespace 'com.grafana.faro.reactnative'
@@ -20,17 +22,40 @@ android {
     defaultConfig {
         minSdkVersion 21
         targetSdkVersion 33
+        consumerProguardFiles 'consumer-proguard-rules.pro'
     }
 
     sourceSets {
         main {
             java.srcDirs = ['src/main/java']
+            proto {
+                srcDir 'src/main/proto'
+            }
         }
     }
 
     lintOptions {
         abortOnError false
     }
+
+    testOptions {
+        unitTests.returnDefaultValues = true
+    }
+}
+
+protobuf {
+    protoc {
+        artifact = 'com.google.protobuf:protoc:3.25.1'
+    }
+    generateProtoTasks {
+        all().each { task ->
+            task.builtins {
+                java {
+                    option 'lite'
+                }
+            }
+        }
+    }
 }
 
 repositories {
@@ -42,6 +67,11 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation 'com.facebook.react:react-native:+'
     implementation 'org.jetbrains.kotlin:kotlin-stdlib:1.8.0'
+    implementation 'com.google.protobuf:protobuf-javalite:3.25.1'
+
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation 'org.robolectric:robolectric:4.11.1'
+    testImplementation 'androidx.test:core:1.5.0'
 }
 
 /* ---------------------------------------------------------------------------
@@ -53,8 +83,9 @@ dependencies {
  *
  *   1. npm install @grafana/faro-react-native @grafana/faro-metro-plugin
  *   2. Wrap metro.config.js with `withFaroConfig(...)`
- *   3. Export FARO_BUNDLE_ID + FARO_SOURCEMAP_* before running
- *      `yarn android --mode=release`.
+ *   3. Export FARO_SOURCEMAP_* before running `yarn android --mode=release`.
+ *      Bundle id is read from `app/build/faro/bundle-id-release.txt` when the
+ *      `com.grafana.faro` Gradle plugin is applied (same id Metro uses).
  *
  * On any release-style command (assembleRelease, bundleRelease, installRelease,
  * `yarn android --mode=release`), release entry tasks depend on
@@ -62,21 +93,20 @@ dependencies {
  * the JS bundle task (`bundleReleaseJsAndAssets` or `createBundleReleaseJsAndAssets`)
  * so upload runs only after a successful bundle — never via a finalizer (which
  * can run even when bundling fails and could upload a stale map). The upload
- * task runs `faro-cli metro upload` via a small Node shim. Gradle reads every
- * required setting from env vars and passes them as **explicit CLI arguments** so the CLI never has to fall
- * back to its own env-var resolution from this entry point — making the
- * contract between Gradle and the CLI fully visible in the command line that
- * you'll see in `--info` build output.
+ * task runs `faro-cli metro upload` via a small Node shim. Bundle id comes from
+ * the Gradle plugin file; upload credentials from env or sourcemaps.config.json.
+ * Credentials are forwarded as **process environment variables** (not CLI flags)
+ * so secrets do not appear in `ps` or Gradle `--info` command lines.
+ *
+ * Required at build time:
+ *   Bundle id — `app/build/faro/bundle-id-release.txt` from `com.grafana.faro`
+ *               (`faroWriteBundleIdRelease`). Same id Metro uses. Forwarded as --bundle-id.
  *
- * Required env at build time (Gradle forwards each as a CLI flag):
- *   FARO_BUNDLE_ID                — must match the id baked into the JS bundle
- *                                   preamble by @grafana/faro-metro-plugin so
- *                                   meta.app.bundleId on the device matches
- *                                   the uploaded map. Forwarded as --bundle-id.
- *   FARO_SOURCEMAP_ENDPOINT       — Forwarded as --endpoint.
- *   FARO_SOURCEMAP_APP_ID         — Forwarded as --app-id.
- *   FARO_SOURCEMAP_STACK_ID       — Forwarded as --stack-id.
- *   FARO_SOURCEMAP_API_KEY        — Forwarded as --api-key.
+ * Required env (Gradle forwards to the Node child process):
+ *   FARO_SOURCEMAP_ENDPOINT
+ *   FARO_SOURCEMAP_APP_ID
+ *   FARO_SOURCEMAP_STACK_ID
+ *   FARO_SOURCEMAP_API_KEY
  *
  * Optional env at build time:
  *   FARO_SKIP_SOURCEMAP_UPLOAD=1  — skip the upload (e.g. offline iteration).
@@ -109,6 +139,45 @@ gradle.projectsEvaluated {
     def jsRoot = rootProject.projectDir.parentFile
     def cliPath = new File(jsRoot, "node_modules/@grafana/faro-metro-plugin/bin/faro-upload-source-map.js")
     def composedMap = new File(appProject.buildDir, "generated/sourcemaps/react/release/index.android.bundle.map")
+    def bundleIdFile = new File(appProject.buildDir, "faro/bundle-id-release.txt")
+
+    // Security: sourcemaps.config.json is a fallback for local dev only.
+    // In CI/production, prefer FARO_SOURCEMAP_* env vars to avoid committing credentials.
+    // Add sourcemaps.config.json to .gitignore if it contains apiKey.
+    def readSourcemapsConfigValue = { String key ->
+        def configFile = new File(jsRoot, "sourcemaps.config.json")
+        if (!configFile.exists()) {
+            return ""
+        }
+        try {
+            def parsed = new groovy.json.JsonSlurper().parse(configFile)
+            def val = parsed[key]
+            return val == null ? "" : val.toString().trim()
+        } catch (Exception e) {
+            logger.error("[Faro] Failed to parse ${configFile}: ${e.message}")
+            return ""
+        }
+    }
+
+    def envOrSourcemapsConfig = { String envName, String configKey ->
+        def fromEnv = (System.getenv(envName) ?: "").trim()
+        if (!fromEnv.isEmpty()) {
+            return fromEnv
+        }
+        return readSourcemapsConfigValue(configKey)
+    }
+
+    def resolveFaroBundleId = {
+        if (!bundleIdFile.exists()) {
+            return ""
+        }
+        def fromFile = bundleIdFile.getText("UTF-8").trim()
+        return fromFile.isEmpty() ? "" : fromFile
+    }
+
+    def isValidAndroidBundleId = { String id ->
+        id ==~ /^[^@]+@\d+@[^@]+$/
+    }
 
     def uploadTask = appProject.tasks.register("faroUploadComposedSourceMapAndroidRelease", Exec) {
         group = "react"
@@ -117,17 +186,16 @@ gradle.projectsEvaluated {
         workingDir = jsRoot
 
         def faroSkip = (System.getenv("FARO_SKIP_SOURCEMAP_UPLOAD") ?: "").trim().toLowerCase()
-        def faroBundleId = (System.getenv("FARO_BUNDLE_ID") ?: "").trim()
-        def faroEndpoint = (System.getenv("FARO_SOURCEMAP_ENDPOINT") ?: "").trim()
-        def faroAppId = (System.getenv("FARO_SOURCEMAP_APP_ID") ?: "").trim()
-        def faroStackId = (System.getenv("FARO_SOURCEMAP_STACK_ID") ?: "").trim()
-        def faroApiKey = (System.getenv("FARO_SOURCEMAP_API_KEY") ?: "").trim()
+        def faroEndpoint = envOrSourcemapsConfig("FARO_SOURCEMAP_ENDPOINT", "endpoint")
+        def faroAppId = envOrSourcemapsConfig("FARO_SOURCEMAP_APP_ID", "appId")
+        def faroStackId = envOrSourcemapsConfig("FARO_SOURCEMAP_STACK_ID", "stackId")
+        def faroApiKey = envOrSourcemapsConfig("FARO_SOURCEMAP_API_KEY", "apiKey")
 
         // Capture the inputs we use for caching / up-to-date checks. We
         // deliberately *don't* track FARO_SOURCEMAP_API_KEY in inputs to
         // avoid Gradle leaking it into a cache-key string.
         inputs.file(composedMap).withPropertyName("composedMap").optional()
-        inputs.property("faroBundleId", faroBundleId)
+        inputs.file(bundleIdFile).withPropertyName("bundleIdFile").optional()
         inputs.property("faroEndpoint", faroEndpoint)
         inputs.property("faroAppId", faroAppId)
         inputs.property("faroStackId", faroStackId)
@@ -139,40 +207,54 @@ gradle.projectsEvaluated {
                 return false
             }
             if (!cliPath.exists()) {
-                logger.warn("[Faro] Skipping composed source map upload — CLI shim not found at ${cliPath}. Install @grafana/faro-metro-plugin alongside @grafana/faro-react-native.")
+                logger.error("[Faro] Skipping composed source map upload — CLI shim not found at ${cliPath}. Install @grafana/faro-metro-plugin alongside @grafana/faro-react-native.")
                 return false
             }
             if (!composedMap.exists()) {
-                logger.warn("[Faro] Skipping composed source map upload — ${composedMap} does not exist. Did Hermes precompile run?")
+                logger.error("[Faro] Skipping composed source map upload — ${composedMap} does not exist. Did Hermes precompile run?")
                 return false
             }
+            def resolvedBundleId = resolveFaroBundleId()
             def missing = []
-            if (faroBundleId.isEmpty()) missing << "FARO_BUNDLE_ID"
+            if (resolvedBundleId.isEmpty()) {
+                missing << "bundle id file ${bundleIdFile} (apply com.grafana.faro and run faroWriteBundleIdRelease)"
+            } else if (!isValidAndroidBundleId(resolvedBundleId)) {
+                logger.error("[Faro] Skipping composed source map upload — invalid bundle id \"${resolvedBundleId}\" in ${bundleIdFile} (expected applicationId@versionCode@versionName).")
+                return false
+            }
             if (faroEndpoint.isEmpty()) missing << "FARO_SOURCEMAP_ENDPOINT"
             if (faroAppId.isEmpty()) missing << "FARO_SOURCEMAP_APP_ID"
             if (faroStackId.isEmpty()) missing << "FARO_SOURCEMAP_STACK_ID"
             if (faroApiKey.isEmpty()) missing << "FARO_SOURCEMAP_API_KEY"
             if (!missing.isEmpty()) {
-                logger.warn("[Faro] Skipping composed source map upload — missing required env vars: ${missing.join(", ")}. Export them before running `yarn android --mode=release`. FARO_BUNDLE_ID must match the id baked into the bundle preamble by @grafana/faro-metro-plugin.")
+                logger.error("[Faro] Skipping composed source map upload — missing: ${missing.join(", ")}. Set FARO_SOURCEMAP_* or fill sourcemaps.config.json (endpoint, appId, stackId, apiKey). Bundle id is read from ${bundleIdFile}.")
                 return false
             }
+            ext.resolvedBundleId = resolvedBundleId
             return true
         }
 
-        commandLine(
-            "node", cliPath.absolutePath,
-            "--verbose",
-            "--map", composedMap.absolutePath,
-            "--endpoint", faroEndpoint,
-            "--app-id", faroAppId,
-            "--stack-id", faroStackId,
-            "--api-key", faroApiKey,
-            "--bundle-id", faroBundleId,
-        )
+        doFirst {
+            def bundleId = ext.resolvedBundleId ?: resolveFaroBundleId()
+            environment 'FARO_SOURCEMAP_ENDPOINT', faroEndpoint
+            environment 'FARO_SOURCEMAP_APP_ID', faroAppId
+            environment 'FARO_SOURCEMAP_STACK_ID', faroStackId
+            environment 'FARO_SOURCEMAP_API_KEY', faroApiKey
+            commandLine(
+                "node", cliPath.absolutePath,
+                "--verbose",
+                "--map", composedMap.absolutePath,
+                "--bundle-id", bundleId,
+            )
+        }
     }
 
     def bundleTaskNames = ["bundleReleaseJsAndAssets", "createBundleReleaseJsAndAssets"]
     uploadTask.configure { task ->
+        def writeBundleIdTask = appProject.tasks.findByName("faroWriteBundleIdRelease")
+        if (writeBundleIdTask != null) {
+            task.dependsOn(writeBundleIdTask)
+        }
         bundleTaskNames.each { name ->
             def bundleTask = appProject.tasks.findByName(name)
             if (bundleTask != null) {

package/android/consumer-proguard-rules.pro

@@ -0,0 +1,2 @@
+# Keep generated tombstone protobuf classes when the host app minifies release builds.
+-keep class com.grafana.faro.reactnative.tombstone.** { *; }

package/android/src/main/java/com/grafana/faro/reactnative/ANRTracker.kt

@@ -1,5 +1,6 @@
 package com.grafana.faro.reactnative
 
+import android.content.Context
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
@@ -20,7 +21,9 @@ class ANRTracker : Thread("ANRTracker") {
         private const val TAG = "ANRTracker"
         
         /**
-         * Time interval for checking ANR, in milliseconds (default 5 seconds)
+         * Watchdog check interval in milliseconds (default 5 seconds).
+         * Updated from JS via [FaroReactNativeModule.startANRTracking].
+         * Exported in ANR payloads as `duration` — the detection threshold, not measured block time.
          */
         var timeout: Long = 5000L
         
@@ -49,13 +52,36 @@ class ANRTracker : Thread("ANRTracker") {
         }
         
         /**
-         * Clear the ANR events list
+         * Application context used to persist ANRs before JS delivery.
          */
-        fun resetANR() {
+        @Volatile
+        var applicationContext: Context? = null
+
+        /**
+         * Remove in-memory ANRs that were acknowledged on disk.
+         */
+        fun acknowledgeInMemory(timestamps: Collection<Long>) {
+            if (timestamps.isEmpty()) {
+                return
+            }
+            val timestampSet = timestamps.toSet()
             synchronized(anrListLock) {
-                anrList.clear()
+                anrList.removeAll { json ->
+                    try {
+                        JSONObject(json).optLong("timestamp", 0L) in timestampSet
+                    } catch (_: Exception) {
+                        false
+                    }
+                }
             }
         }
+
+        /**
+         * Optional callback invoked on the ANR tracker thread when an ANR is recorded.
+         * Used to push telemetry immediately instead of waiting for the JS poll interval.
+         */
+        @Volatile
+        var onAnrDetected: ((String) -> Unit)? = null
     }
     
     private val mainHandler = Handler(Looper.getMainLooper())
@@ -63,6 +89,9 @@ class ANRTracker : Thread("ANRTracker") {
     private val isRunning = AtomicBoolean(true)
     private val taskExecuted = AtomicBoolean(false)
     
+    /** True while the main thread is blocked and we already recorded one ANR for this period. */
+    private val anrInProgress = AtomicBoolean(false)
+    
     private val checkTask = Runnable {
         // This task runs on the main thread
         taskExecuted.set(true)
@@ -91,6 +120,11 @@ class ANRTracker : Thread("ANRTracker") {
                     break
                 }
                 
+                if (taskExecuted.get()) {
+                    // Main thread recovered — allow a future blocked period to be reported again.
+                    anrInProgress.set(false)
+                }
+
                 // If the task hasn't executed after the check interval, start monitoring for ANR
                 if (!taskExecuted.get()) {
                     Log.d(TAG, "Task not executed after initial check")
@@ -114,8 +148,14 @@ class ANRTracker : Thread("ANRTracker") {
                     // Check again if the task has executed
                     if (!taskExecuted.get()) {
                         Log.d(TAG, "Task is still not executed after ${timeout}ms")
-                        // The main thread is blocked - this is an ANR
-                        handleAnrDetected()
+                        // The main thread is blocked - record once per blocked period.
+                        if (!anrInProgress.get()) {
+                            anrInProgress.set(true)
+                            handleAnrDetected()
+                        }
+                    } else if (anrInProgress.get()) {
+                        // Main thread recovered during the extended wait — same cycle as line 123.
+                        anrInProgress.set(false)
                     }
                 }
                 
@@ -175,9 +215,12 @@ class ANRTracker : Thread("ANRTracker") {
             val stackTrace = mainThread.stackTrace
             
             // Build a readable stack trace
+            // Match Android Log.getStackTraceString / ApplicationExitInfo format so
+            // ingest R8 retrace and parseAndroidCrashTrace can consume the text.
             val stackTraceStr = StringBuilder()
             for (element in stackTrace) {
-                stackTraceStr.append(element.className)
+                stackTraceStr.append("    at ")
+                    .append(element.className)
                     .append(".")
                     .append(element.methodName)
                     .append("(")
@@ -193,12 +236,21 @@ class ANRTracker : Thread("ANRTracker") {
                 put("timestamp", System.currentTimeMillis())
                 put("stacktrace", stackTraceStr.toString())
                 put("duration", timeout)
+                put("source", "ANRTracker")
             }
             
-            // Store the ANR information
+            val payload = anrInfo.toString()
+
+            // Persist first: survives process kill before JS/network can run.
+            applicationContext?.let { context ->
+                FaroAnrCache.savePendingAnr(context, payload)
+            }
+
             synchronized(anrListLock) {
-                anrList.add(anrInfo.toString())
+                anrList.add(payload)
             }
+
+            onAnrDetected?.invoke(payload)
             
             Log.w(TAG, "ANR detected: $stackTraceStr")
         } catch (e: Exception) {

package/android/src/main/java/com/grafana/faro/reactnative/AnrThreadDumpParser.kt

@@ -0,0 +1,70 @@
+package com.grafana.faro.reactnative
+
+/**
+ * Extracts the blocked main-thread stack from an ApplicationExitInfo ANR trace dump.
+ *
+ * Android emits a multi-thread text blob (see `ApplicationExitInfo.traceInputStream`).
+ * Sentry-style ANR reporting uses the `"main"` thread section, not a live
+ * [Thread.getStackTrace] snapshot from a watchdog thread.
+ */
+internal object AnrThreadDumpParser {
+
+    private val threadHeader = Regex("^\"[^\"]+\".*prio=")
+    private val frameWithAt = Regex("^at\\s+.+")
+    private val frameWithoutAt = Regex("^[\\w$.]+\\.[\\w$<>]+\\(.+\\)\\s*$")
+
+    fun extractMainThreadStack(fullDump: String): String {
+        if (fullDump.isBlank()) {
+            return ""
+        }
+
+        val lines = fullDump.lines()
+        var inMain = false
+        val stack = StringBuilder()
+
+        for (line in lines) {
+            val trimmed = line.trim()
+            if (trimmed.isEmpty()) {
+                continue
+            }
+
+            if (!inMain) {
+                if (trimmed.startsWith("\"main\"") || trimmed == "main") {
+                    inMain = true
+                }
+                continue
+            }
+
+            if (threadHeader.matches(trimmed) && !trimmed.startsWith("\"main\"")) {
+                break
+            }
+
+            if (frameWithAt.matches(trimmed)) {
+                stack.appendLine(if (line.startsWith("    ")) line else "    $trimmed")
+                continue
+            }
+
+            if (frameWithoutAt.matches(trimmed)) {
+                stack.appendLine("    at $trimmed")
+            }
+        }
+
+        if (stack.isNotEmpty()) {
+            return stack.toString().trim()
+        }
+
+        // Some devices return only flat "at …" lines without a DALVIK THREADS header.
+        return extractFlatAtLines(fullDump)
+    }
+
+    private fun extractFlatAtLines(fullDump: String): String {
+        val stack = StringBuilder()
+        for (line in fullDump.lines()) {
+            val trimmed = line.trim()
+            if (frameWithAt.matches(trimmed)) {
+                stack.appendLine(if (line.startsWith("    ")) line else "    $trimmed")
+            }
+        }
+        return stack.toString().trim()
+    }
+}

package/android/src/main/java/com/grafana/faro/reactnative/ApplicationExitTraceReader.kt

@@ -0,0 +1,142 @@
+package com.grafana.faro.reactnative
+
+import android.app.ApplicationExitInfo
+import android.os.Build
+import android.util.Log
+import java.io.ByteArrayOutputStream
+
+/**
+ * Reads and normalizes ApplicationExitInfo trace streams into text tombstones.
+ */
+internal object ApplicationExitTraceReader {
+
+    private const val TAG = "FaroCrashReporter"
+    private const val MAX_TRACE_BYTES = 512 * 1024
+    private const val MAX_TRACE_LINES = 200
+
+    data class ParsedExitTrace(
+        val text: String,
+        val signal: String = "",
+        val source: TraceSource = TraceSource.NONE,
+    )
+
+    enum class TraceSource {
+        NONE,
+        TEXT_STREAM,
+        PROTOBUF_TOMBSTONE,
+        CACHED_NATIVE,
+    }
+
+    fun read(exitInfo: ApplicationExitInfo): ParsedExitTrace {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+            return ParsedExitTrace("")
+        }
+
+        return try {
+            val traceInputStream = exitInfo.traceInputStream ?: return ParsedExitTrace("")
+            val bytes = readAllBytes(traceInputStream)
+            if (bytes.isEmpty()) {
+                return ParsedExitTrace("")
+            }
+
+            parseTraceBytes(exitInfo, bytes)
+        } catch (error: Exception) {
+            Log.w(TAG, "Failed to read ApplicationExitInfo trace: ${error.message}")
+            ParsedExitTrace("")
+        }
+    }
+
+    fun parseTraceBytes(exitInfo: ApplicationExitInfo, bytes: ByteArray): ParsedExitTrace {
+        val asText = decodeUtf8(bytes)
+        if (TombstoneBacktraceFormatter.looksLikeTextTombstone(asText)) {
+            Log.i(TAG, "[Faro crash native] Using text tombstone from ApplicationExitInfo (${asText.lineCount()} lines)")
+            return ParsedExitTrace(
+                text = trimTraceLines(asText),
+                source = TraceSource.TEXT_STREAM,
+            )
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S &&
+            exitInfo.reason == ApplicationExitInfo.REASON_CRASH_NATIVE
+        ) {
+            return parseProtobufTombstone(bytes)
+        }
+
+        if (asText.isNotBlank()) {
+            return ParsedExitTrace(
+                text = trimTraceLines(asText),
+                source = TraceSource.TEXT_STREAM,
+            )
+        }
+
+        return ParsedExitTrace("")
+    }
+
+    private fun parseProtobufTombstone(bytes: ByteArray): ParsedExitTrace {
+        val parsed = TombstoneWireParser.parse(bytes)
+        if (parsed == null) {
+            Log.w(TAG, "[Faro crash native] Failed to parse tombstone protobuf (${bytes.size} bytes)")
+            return ParsedExitTrace("")
+        }
+
+        val formatted = TombstoneBacktraceFormatter.format(parsed)
+        if (formatted.text.isBlank()) {
+            Log.w(TAG, "[Faro crash native] Tombstone protobuf parsed but backtrace was empty")
+            return ParsedExitTrace("")
+        }
+
+        Log.i(
+            TAG,
+            "[Faro crash native] Decoded tombstone protobuf (${formatted.text.lineCount()} lines, signal=${formatted.signal})",
+        )
+        return ParsedExitTrace(
+            text = trimTraceLines(formatted.text),
+            signal = formatted.signal,
+            source = TraceSource.PROTOBUF_TOMBSTONE,
+        )
+    }
+
+    private fun readAllBytes(input: java.io.InputStream): ByteArray {
+        val buffer = ByteArrayOutputStream()
+        val chunk = ByteArray(8192)
+        var total = 0
+        while (true) {
+            val read = input.read(chunk)
+            if (read <= 0) {
+                break
+            }
+            total += read
+            if (total > MAX_TRACE_BYTES) {
+                Log.w(TAG, "ApplicationExitInfo trace exceeded ${MAX_TRACE_BYTES} bytes; truncating")
+                buffer.write(chunk, 0, read.coerceAtMost(MAX_TRACE_BYTES - (total - read)))
+                break
+            }
+            buffer.write(chunk, 0, read)
+        }
+        return buffer.toByteArray()
+    }
+
+    private fun decodeUtf8(bytes: ByteArray): String {
+        if (bytes.isEmpty()) {
+            return ""
+        }
+        if (bytes.any { it == 0.toByte() }) {
+            return ""
+        }
+        return bytes.toString(Charsets.UTF_8).trim()
+    }
+
+    private fun trimTraceLines(text: String): String {
+        return text.lineSequence()
+            .take(MAX_TRACE_LINES)
+            .joinToString("\n")
+            .trim()
+    }
+
+    private fun String.lineCount(): Int {
+        if (isEmpty()) {
+            return 0
+        }
+        return lines().size
+    }
+}