txlemetry-react-native 4.55.1

package/tooling/txlemetry.gradle

@@ -0,0 +1,407 @@
+// Portions of this file are derived from getsentry/sentry-react-native
+// Copyright (c) 2017 Sentry
+// Licensed under the MIT License: https://github.com/getsentry/sentry-react-native/blob/main/LICENSE.md
+
+import org.apache.tools.ant.taskdefs.condition.Os
+
+import java.util.regex.Matcher
+import java.util.regex.Pattern
+
+import org.gradle.api.logging.Logging
+
+interface InjectedExecOps {
+    @Inject //@javax.inject.Inject
+    ExecOperations getExecOps()
+}
+
+plugins.withId('com.android.application') {
+    def androidComponents = extensions.getByName("androidComponents")
+
+    androidComponents.onVariants(androidComponents.selector().all()) { v ->
+        if (!v.name.toLowerCase().contains("debug")) {
+            // separately we then hook into the bundle task of react native to inject
+            // sourcemap generation parameters.  In case for whatever reason no release
+            // was found for the asset folder we just bail.
+            def bundleTasks = tasks.findAll { task -> (task.name.startsWith("createBundle") || task.name.startsWith("bundle")) && task.name.endsWith("JsAndAssets") && !task.name.contains("Debug") && task.enabled }
+            // this is the task that calls react-native bundle {params}
+            bundleTasks.each { bundleTask ->
+                def shouldCleanUp
+                def sourcemapOutput
+                def bundleOutput
+                def packagerSourcemapOutput
+                def bundleCommand
+                def props = bundleTask.getProperties()
+                def reactRoot = props.get("workingDir")
+                if (reactRoot == null) {
+                    reactRoot = props.get("root").get() // RN 0.71 and above
+                }
+
+                (shouldCleanUp, bundleOutput, sourcemapOutput, packagerSourcemapOutput, bundleCommand) = forceSourceMapOutputFromBundleTask(bundleTask)
+
+                // Lets leave this here if we need to debug
+                // println bundleTask.properties
+                //     .sort{it.key}
+                //     .collect{it}
+                //     .findAll{!['class', 'active'].contains(it.key)}
+                //     .join('\n')
+
+                def currentVariants = extractCurrentVariants(bundleTask, v)
+                if (currentVariants == null) return
+
+                def previousCliTask = null
+                def applicationVariant = null
+
+                def nameCleanup = "${bundleTask.name}_TxlemetryUploadCleanUp"
+                // Upload the source map several times if necessary: once for each release and versionCode.
+                currentVariants.each { key, currentVariant ->
+                    def variant = currentVariant[0]
+                    def releaseName = currentVariant[1]
+                    def versionCode = currentVariant[2]
+                    applicationVariant = currentVariant[3]
+                    def appId = currentVariant[4]
+                    def versionName = currentVariant[5]
+
+                    try {
+                        if (versionCode instanceof String) {
+                            versionCode = Integer.parseInt(versionCode)
+                            versionCode = Math.abs(versionCode)
+                        }
+                    } catch (NumberFormatException e) {
+                        project.logger.info("versionCode: '$versionCode' isn't an Integer, using the plain value.")
+                    }
+
+                    def nameCliTask = "${bundleTask.name}_TxlemetryUpload_${releaseName}_${versionCode}"
+
+                    // If several outputs have the same releaseName and versionCode, we'd do the exact same
+                    // upload for each of them.  No need to repeat.
+                    try { tasks.named(nameCliTask); return } catch (Exception e) {}
+
+                    /** Upload source map file to the Txlemetry server via CLI call. */
+                    def cliTask = tasks.register(nameCliTask) {
+                        description = "upload sourcemaps to Txlemetry"
+                        group = 'txlemetry.com'
+
+                        def extraArgs = []
+                        if (appId != null && !appId.isEmpty()) {
+                            extraArgs.addAll(["--release-name", appId.toString()])
+                        }
+                        if (versionName != null && !versionName.toString().isEmpty()) {
+                            extraArgs.addAll(["--release-version", versionName.toString()])
+                        }
+                        if (versionCode != null) {
+                            extraArgs.addAll(["--build", versionCode.toString()])
+                        }
+
+                        def txlemetryUploadArgs = []
+                        if ((project.ext.has("txlemetryReactNativeSkipOnConflict") && project.ext.get("txlemetryReactNativeSkipOnConflict") == true) ||
+                            (project.ext.has("posthogReactNativeSkipOnConflict") && project.ext.get("posthogReactNativeSkipOnConflict") == true)) {
+                            txlemetryUploadArgs.add("--skip-on-conflict")
+                        }
+
+                        def injected = project.objects.newInstance(InjectedExecOps)
+
+                        // Resolve the txlemetry-cli path at execution time, not during
+                        // configuration. The resolver starts node/npm via Groovy's `.execute()`,
+                        // and Gradle's configuration cache forbids starting external processes at
+                        // configuration time. Resolution lives in the static
+                        // TxlemetryCli.resolveCliPackagePath() so these serialized task actions can
+                        // call it without relying on the apply-from script's owner chain — a
+                        // script-level method fails under the configuration cache with "Could not
+                        // find method ... on object of type DefaultExecAction_Decorated". rootDir
+                        // is captured as plain serializable state; `Task.project` must not be read
+                        // at execution time, so logging uses the task's own `logger`.
+                        def rootDirFile = rootDir
+                        def osCompatibility = Os.isFamily(Os.FAMILY_WINDOWS) ? ['cmd', '/c', 'node'] : []
+
+                        doFirst {
+                            def cliPackage = TxlemetryCli.resolveCliPackagePath(rootDirFile, reactRoot)
+                            def args = [cliPackage]
+                            args.addAll(["hermes", "clone",
+                                "--minified-map-path", packagerSourcemapOutput, // The path to a sourcemap
+                                "--composed-map-path", sourcemapOutput          // The path of the composed source map
+                            ])
+                            args.addAll(extraArgs)
+                            logger.info("txlemetry-cli clone arguments: ${args}")
+
+                            injected.execOps.exec {
+                                workingDir reactRoot
+                                commandLine(*osCompatibility, *args)
+                            }
+                        }
+
+                        doLast {
+                            def cliPackage = TxlemetryCli.resolveCliPackagePath(rootDirFile, reactRoot)
+                            def args = [cliPackage]
+                            args.addAll(["hermes", "upload",
+                                "--directory", sourcemapOutput.getParent()      // The path to a sourcemap that should be uploaded.
+                            ])
+                            args.addAll(extraArgs)
+                            args.addAll(txlemetryUploadArgs)
+                            logger.info("txlemetry-cli upload arguments: ${args}")
+
+                            injected.execOps.exec {
+                                workingDir reactRoot
+                                commandLine(*osCompatibility, *args)
+                            }
+                        }
+
+                        enabled true
+                    }
+
+                    // chain the upload tasks so they run sequentially in order to run
+                    // the cliCleanUpTask after the final upload task is run
+                    if (previousCliTask != null) {
+                        previousCliTask.configure { finalizedBy cliTask }
+                    } else {
+                        bundleTask.configure { finalizedBy cliTask }
+                    }
+                    previousCliTask = cliTask
+                }
+
+                /** Delete sourcemap files */
+                def cliCleanUpTask = tasks.register(nameCleanup, Delete) {
+                    description = "clean up extra sourcemap"
+                    group = 'txlemetry.com'
+
+                    delete sourcemapOutput
+                    delete "$buildDir/intermediates/assets/release/index.android.bundle.map"
+                    // react native default bundle dir
+                }
+
+                // register clean task extension
+                cliCleanUpTask.configure { onlyIf { shouldCleanUp } }
+                // due to chaining the last value of previousCliTask will be the final
+                // upload task, after which the cleanup can be done
+                previousCliTask.configure { finalizedBy cliCleanUpTask }
+
+                def packageTasks = tasks.matching {
+                    task -> ("package${applicationVariant}".equalsIgnoreCase(task.name) || "package${applicationVariant}Bundle".equalsIgnoreCase(task.name)) && task.enabled
+                }
+            }
+        }
+    }
+}
+
+// Static so the serialized sourcemap-upload task actions can call it under the
+// Gradle configuration cache. It starts node/npm, so it must run at execution
+// time — starting external processes at configuration time is rejected by the
+// configuration cache. Uses its own logger (not `project.logger`) and takes
+// rootDir as a parameter so it never touches `Task.project` at execution time.
+abstract class TxlemetryCli {
+    static String resolveCliPackagePath(File rootDir, reactRoot) {
+        def logger = Logging.getLogger(TxlemetryCli)
+
+        // First, try to find @txlemetry/cli folder from require.resolve
+        try {
+            def resolvedPath = new File(["node", "--print", "require.resolve('@txlemetry/cli/package.json')"].execute(null, rootDir).text.trim()).getParentFile()
+            if (resolvedPath != null && resolvedPath.exists()) {
+                def runTxlemetryCliFile = new File(resolvedPath, "run-txlemetry-cli.js")
+                if (runTxlemetryCliFile.exists()) {
+                    logger.info("resolved txlemetry-cli dynamically: `${runTxlemetryCliFile.getAbsolutePath()}`")
+                    return runTxlemetryCliFile.getAbsolutePath()
+                }
+            }
+        } catch (Throwable ignored) {}
+
+        // Second, check if @txlemetry/cli exists in $reactRoot/node_modules
+        def nodeModulesPath = new File("$reactRoot/node_modules/@txlemetry/cli")
+        if (nodeModulesPath.exists()) {
+            def runTxlemetryCliFile = new File(nodeModulesPath, "run-txlemetry-cli.js")
+            if (runTxlemetryCliFile.exists()) {
+                logger.info("resolved txlemetry-cli hard-coded path (yarn or npm): `${runTxlemetryCliFile.getAbsolutePath()}`")
+                return runTxlemetryCliFile.getAbsolutePath()
+            }
+        }
+
+        // Third, check for pnpm installation with node_modules/.bin/txlemetry-cli
+        def pnpmBinPath = new File("$reactRoot/node_modules/.bin/txlemetry-cli")
+        if (pnpmBinPath.exists()) {
+            logger.info("resolved txlemetry-cli hard-coded path (pnpm): `${pnpmBinPath.getAbsolutePath()}`")
+            return pnpmBinPath.getAbsolutePath()
+        }
+
+        // Fourth, check using npm root for local installation
+        try {
+            def npmRoot = ["npm", "root"].execute(null, rootDir).text.trim()
+            def npmTxlemetryCliPath = new File(npmRoot, "@txlemetry/cli")
+            if (npmTxlemetryCliPath.exists()) {
+                def runTxlemetryCliFile = new File(npmTxlemetryCliPath, "run-txlemetry-cli.js")
+                if (runTxlemetryCliFile.exists()) {
+                    logger.info("resolved txlemetry-cli via npm root: `${runTxlemetryCliFile.getAbsolutePath()}`")
+                    return runTxlemetryCliFile.getAbsolutePath()
+                }
+            }
+        } catch (Throwable ignored) {}
+
+        // Fifth, check for global npm installation of @txlemetry/cli
+        try {
+            def globalPrefix = ["npm", "prefix", "-g"].execute().text.trim()
+            def globalTxlemetryCliPath = new File(globalPrefix, "lib/node_modules/@txlemetry/cli")
+            if (globalTxlemetryCliPath.exists()) {
+                def runTxlemetryCliFile = new File(globalTxlemetryCliPath, "run-txlemetry-cli.js")
+                if (runTxlemetryCliFile.exists()) {
+                    logger.info("resolved txlemetry-cli from global npm installation: `${runTxlemetryCliFile.getAbsolutePath()}`")
+                    return runTxlemetryCliFile.getAbsolutePath()
+                }
+            }
+        } catch (Throwable ignored) {}
+
+        // Finally, fallback to global install
+        logger.info("falling back to global txlemetry-cli")
+        return "txlemetry-cli"
+    }
+}
+
+def resolveTxlemetryReactNativeSDKPath(reactRoot) {
+    def resolvedPath = null
+    try {
+        resolvedPath = new File(["node", "--print", "require.resolve('txlemetry-react-native/package.json')"].execute(null, rootDir).text.trim()).getParentFile();
+    } catch (Throwable ignored) {} // if the resolve fails we fallback to the default path
+    def packagePath = resolvedPath != null && resolvedPath.exists() ? resolvedPath.getAbsolutePath() : "$reactRoot/node_modules/txlemetry-react-native"
+    return packagePath
+}
+
+/** Extract from arguments collection bundle and sourcemap files output names. */
+static extractBundleTaskArgumentsLegacy(cmdArgs, Project project) {
+    def bundleOutput = null
+    def sourcemapOutput = null
+    def packagerSourcemapOutput = null
+    // packagerBundleOutput doesn't exist, because packager output is overwritten by Hermes
+
+    cmdArgs.eachWithIndex { String arg, int i ->
+        if (arg == "--bundle-output") {
+            bundleOutput = cmdArgs[i + 1]
+            project.logger.info("--bundle-output: `${bundleOutput}`")
+        } else if (arg == "--sourcemap-output") {
+            sourcemapOutput = cmdArgs[i + 1]
+            packagerSourcemapOutput = sourcemapOutput
+            project.logger.info("--sourcemap-output param: `${sourcemapOutput}`")
+        }
+    }
+
+    // Best thing would be if we just had access to the local gradle variables here:
+    // https://github.com/facebook/react-native/blob/ff3b839e9a5a6c9e398a1327cde6dd49a3593092/react.gradle#L89-L97
+    // Now, the issue is that hermes builds have a different pipeline:
+    // `metro -> hermes -> compose-source-maps`, which then combines both intermediate sourcemaps into the final one.
+    // In this function here, we only grep through the first `metro` step, which only generates an intermediate sourcemap,
+    // which is wrong. We need the final one. Luckily, we can just generate the path from the `bundleOutput`, since
+    // the paths seem to be well defined.
+
+    // if sourcemapOutput is null, it means there's no source maps at all
+    // if hermes is enabled and has intermediates folder, we need to fix paths
+    // if hermes is disabled, sourcemapOutput is already ok
+    def enableHermes = project.ext.react.get("enableHermes", false);
+    project.logger.info("enableHermes: `${enableHermes}`")
+
+    if (bundleOutput != null && sourcemapOutput != null && enableHermes) {
+        // react-native < 0.60.1
+        def pattern = Pattern.compile("(/|\\\\)intermediates\\1sourcemaps\\1react\\1")
+        Matcher matcher = pattern.matcher(sourcemapOutput)
+        // if its intermediates/sourcemaps/react then it should be generated/sourcemaps/react
+        if (matcher.find()) {
+            project.logger.info("sourcemapOutput has the wrong path, let's fix it.")
+            // replacing from bundleOutput which is more reliable
+            sourcemapOutput = bundleOutput.replaceAll("(/|\\\\)generated\\1assets\\1react\\1", "\$1generated\$1sourcemaps\$1react\$1") + ".map"
+            project.logger.info("sourcemapOutput new path: `${sourcemapOutput}`")
+        }
+    }
+
+    // get the current bundle command, if not peresent use default plain "bundle"
+    // we use this later to decide how to upload source maps
+    def bundleCommand = project.ext.react.get("bundleCommand", "bundle")
+
+    return [bundleOutput, sourcemapOutput, packagerSourcemapOutput, bundleCommand]
+}
+
+/** Extract bundle and sourcemap paths from bundle task props.
+  * Based on https://github.com/facebook/react-native/blob/93c17cd0c43ba7fe3bc09f547b64771984992fbb/packages/gradle-plugin/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/tasks/BundleHermesCTask.kt
+  * Output source map path is the same for both Hermes and JSC.
+  */
+static extractBundleTaskArgumentsRN71AndAbove(bundleTask, logger) {
+    def props = bundleTask.getProperties()
+    def bundleAssetName = props.bundleAssetName?.get()
+
+    if (bundleAssetName == null) {
+        return [null, null]
+    }
+
+    def bundleCommand = props.bundleCommand.get()
+    def bundleFile = new File(props.jsBundleDir.get().asFile.absolutePath, bundleAssetName)
+    def outputSourceMap = new File(props.jsSourceMapsDir.get().asFile.absolutePath, "${bundleAssetName}.map")
+    def packagerOutputSourceMap = new File(props.jsIntermediateSourceMapsDir.get().asFile.absolutePath, "${bundleAssetName}.packager.map")
+
+    logger.info("bundleFile: `${bundleFile}`")
+    logger.info("outputSourceMap: `${outputSourceMap}`")
+    logger.info("packagerOutputSourceMap: `${packagerOutputSourceMap}`")
+    return [bundleFile, outputSourceMap, packagerOutputSourceMap, bundleCommand]
+}
+
+/** Force Bundle task to produce sourcemap files if they are not pre-configured by user yet. */
+def forceSourceMapOutputFromBundleTask(bundleTask) {
+    def props = bundleTask.getProperties()
+    def cmd = props.get("commandLine") as List<String>
+    def cmdArgs = props.get("args") as List<String>
+    def shouldCleanUp = false
+    def bundleOutput = null
+    def sourcemapOutput = null
+    def packagerSourcemapOutput = null
+    def bundleCommand = null
+
+    (bundleOutput, sourcemapOutput, packagerSourcemapOutput, bundleCommand) = extractBundleTaskArgumentsRN71AndAbove(bundleTask, logger)
+    if (bundleOutput == null) {
+        (bundleOutput, sourcemapOutput, packagerSourcemapOutput, bundleCommand) = extractBundleTaskArgumentsLegacy(cmdArgs, project)
+    }
+
+    if (sourcemapOutput == null) {
+        sourcemapOutput = bundleOutput + ".map"
+
+        cmd.addAll(["--sourcemap-output", sourcemapOutput])
+        cmdArgs.addAll(["--sourcemap-output", sourcemapOutput])
+
+        shouldCleanUp = true
+
+        bundleTask.setProperty("commandLine", cmd)
+        bundleTask.setProperty("args", cmdArgs)
+
+        project.logger.info("forced sourcemap file output for `${bundleTask.name}` task")
+    } else {
+        project.logger.info("Info: used pre-configured source map files: ${sourcemapOutput}")
+    }
+
+    return [shouldCleanUp, bundleOutput, sourcemapOutput, packagerSourcemapOutput, bundleCommand]
+}
+
+/** compose array with one item - current build flavor name */
+static extractCurrentVariants(bundleTask, variant) {
+    // examples: bundleLocalReleaseJsAndAssets, createBundleYellowDebugJsAndAssets
+    def pattern = Pattern.compile("(?:create)?(?:B|b)undle([A-Z][A-Za-z0-9_]+)JsAndAssets")
+
+    def currentRelease = ""
+
+    Matcher matcher = pattern.matcher(bundleTask.name)
+    if (matcher.find()) {
+        def match = matcher.group(1)
+        currentRelease = match.substring(0, 1).toLowerCase() + match.substring(1)
+    }
+
+    def currentVariants = null
+    if (variant.name.equalsIgnoreCase(currentRelease)) {
+        currentVariants = [:]
+        def variantName = variant.name
+        variant.outputs.each { output ->
+            def defaultVersionCode = output.versionCode.getOrElse(0)
+            def versionCode        = defaultVersionCode
+            def appId              = variant.applicationId.get()
+            def versionName        = output.versionName.getOrElse('')  // may be empty if not set
+            def defaultReleaseName = "${appId}@${versionName}+${versionCode}"
+            def releaseName        = defaultReleaseName
+
+            def outputName = output.baseName
+
+            if (currentVariants[outputName] == null) currentVariants[outputName] = []
+            currentVariants[outputName] = [outputName, releaseName, versionCode, variantName, appId, versionName]
+        }
+    }
+
+    return currentVariants
+}