@dynatrace/react-native-plugin 2.307.1 → 2.311.1

package/README.md

@@ -32,8 +32,8 @@ If you want to start using this plugin and are not a Dynatrace customer yet, hea
 ## Agent Versions
 This agent versions are configured in this plugin:
 
-* Android Agent: 8.307.1.1005
-* iOS Agent: 8.307.1.1014
+* Android Agent: 8.311.1.1007
+* iOS Agent: 8.311.1.1013
 
 ## Quick Setup
 
@@ -327,7 +327,7 @@ Combining manual and auto instrumentation should not be a problem. As they're ru
 
 There are two options to create an action. Either using `enterAutoAction` (the previous `enterAction`) or `enterManualAction`:
 
-* `enterAutoAction` - Creates an Action which will be automatically handled by the plugin (This is the type of action which is internally used by the plugin when monitoring components and touchables). This means that the plugin decides about the hierachy of this action. If there is no open action, the following action will be a root action. All other actions created by this method, while a root action is open, will be automatically inserted as a child action. Furthermore the plugin will automatically link webrequest (if they are not tagged manually) to the open root action. Be aware that the timeout/wait time for sub actions or web requests cannot be modified on the Android side for React Native Auto actions. The timeout is fixed to a 1000ms.
+* `enterAutoAction` - Creates an Action which will be automatically handled by the plugin (This is the type of action which is internally used by the plugin when monitoring components and touchables). This means that the plugin decides about the hierarchy of this action. If there is no open action, the following action will be a root action. All other actions created by this method, while a root action is open, will be automatically inserted as a child action. Furthermore the plugin will automatically link webrequest (if they are not tagged manually) to the open root action. Be aware that the timeout/wait time for sub actions or web requests cannot be modified on the Android side for React Native Auto actions. The timeout is fixed to a 1000ms.
 
 ```ts
 import { Dynatrace } from '@dynatrace/react-native-plugin';
@@ -402,7 +402,7 @@ let url = 'https://www.dynatrace.com';
 // You can also use enterAutoAction if desired
 let action = Dynatrace.enterManualAction("Manual Web Request");
 let tag = await action.getRequestTag(url);
-let timing = new DynatraceWebRequestTiming(url, tag);
+let timing = new DynatraceWebRequestTiming(tag, url);
 
 try {      
   timing.startWebRequestTiming();
@@ -1463,6 +1463,15 @@ If you are struggling with a problem, submit a support ticket to Dynatrace (supp
 <br/><br/>
 ## Changelog
 
+2.311.1
+* Updated Android (8.311.1.1007) & iOS Agent (8.311.1.1013)
+* Configuration copied to android folder which supports cloud builds
+* Removed dynamic import for jsx runtime as it was causing issue
+
+2.309.1
+* Updated Android (8.309.2.1011) & iOS Agent (8.309.1.1009)
+* Fixed issue with metro when internal require was not resolved correctly 
+
 2.307.1
 * Updated Android (8.307.1.1005) & iOS Agent (8.307.1.1014)
 * Now require the use of NodeJS 18+

package/android/build.gradle

@@ -16,10 +16,12 @@ buildscript {
 
     dependencies {
         classpath 'com.android.tools.build:gradle:7.3.1'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.10"
 	}
 }
 
 apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
 
 if (isNewArchitectureEnabled()) {
     apply plugin: 'com.facebook.react'
@@ -70,7 +72,7 @@ repositories {
 }
 
 dependencies {
-	implementation 'com.dynatrace.agent:agent-android:8.307.1.1005'
+	implementation 'com.dynatrace.agent:agent-android:8.311.1.1007'
     implementation "com.facebook.react:react-native:${safeExtGet('reactNative', '+')}"
 }
   

package/android/src/main/java/com/dynatrace/android/agent/DynatraceAppStartModule.kt

@@ -0,0 +1,128 @@
+package com.dynatrace.android.agent
+
+import android.os.SystemClock
+import com.dynatrace.android.agent.model.AppStartMeasurement
+import com.dynatrace.android.agent.model.AppStartMeasurementType
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMarker
+import com.facebook.react.bridge.ReactMarkerConstants
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.util.Queue
+import java.util.concurrent.ConcurrentLinkedQueue
+
+/**
+ * Name of the module
+ */
+private const val APP_START_MODULE = "DynatraceAppStartModule"
+
+/**
+ * Emitting app start event with this identifier
+ */
+private const val EMIT_APP_START = "dynatraceAppStartMeasurements"
+
+/**
+ * Queue which contains all our measured app start timestamps
+ */
+private val buffer: Queue<AppStartMeasurement> = ConcurrentLinkedQueue()
+
+/**
+ * Setup to register all time points which we want to use to report correct app startup time.
+ */
+fun setupAppStartListener() {
+    ReactMarker.addListener { name: ReactMarkerConstants?, _: String?, _: Int ->
+        when (name) {
+            ReactMarkerConstants.RELOAD -> {
+                buffer.clear()
+                buffer.add(
+                    AppStartMeasurement(
+                        AppStartMeasurementType.RELOAD.value,
+                        SystemClock.uptimeMillis()
+                    )
+                )
+            }
+
+            ReactMarkerConstants.CONTENT_APPEARED -> buffer.add(
+                AppStartMeasurement(
+                    AppStartMeasurementType.CONTENT_APPEARED.value,
+                    SystemClock.uptimeMillis()
+                )
+            )
+
+            ReactMarkerConstants.DOWNLOAD_END -> buffer.add(
+                AppStartMeasurement(
+                    AppStartMeasurementType.DOWNLOAD_END.value,
+                    SystemClock.uptimeMillis()
+                )
+            )
+
+            ReactMarkerConstants.DOWNLOAD_START -> buffer.add(
+                AppStartMeasurement(
+                    AppStartMeasurementType.DOWNLOAD_START.value,
+                    SystemClock.uptimeMillis()
+                )
+            )
+
+            ReactMarkerConstants.RUN_JS_BUNDLE_END -> buffer.add(
+                AppStartMeasurement(
+                    AppStartMeasurementType.RUN_JS_BUNDLE_END.value,
+                    SystemClock.uptimeMillis()
+                )
+            )
+
+            ReactMarkerConstants.RUN_JS_BUNDLE_START -> buffer.add(
+                AppStartMeasurement(
+                    AppStartMeasurementType.RUN_JS_BUNDLE_START.value,
+                    SystemClock.uptimeMillis()
+                )
+            )
+
+            else -> {
+                // Not important
+            }
+        }
+    }
+}
+
+/**
+ * Module which is handling the app start measurements
+ */
+internal class DynatraceAppStartModule(reactContext: ReactApplicationContext?) :
+    ReactContextBaseJavaModule(reactContext) {
+    init {
+        setupInternalListener()
+    }
+
+    /**
+     * We setup the listener internally as we
+     */
+    private fun setupInternalListener() {
+        ReactMarker.addListener { name: ReactMarkerConstants, _: String?, _: Int ->
+            if (name == ReactMarkerConstants.CONTENT_APPEARED) {
+                // When content appeared we will emit the event with all the information
+                flushMeasurements()
+            }
+        }
+    }
+
+    /**
+     * We flush all events when content appeared is triggered, as it marks the last event
+     */
+    private fun flushMeasurements() {
+        val params = Arguments.createMap()
+        val iterator: Iterator<AppStartMeasurement> = buffer.iterator()
+        while (iterator.hasNext()) {
+            val entry = iterator.next()
+            params.putDouble(entry.name, entry.timestamp.toDouble())
+        }
+
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(EMIT_APP_START, params)
+    }
+
+    override fun getName(): String {
+        return APP_START_MODULE
+    }
+}

package/android/src/main/java/com/dynatrace/android/agent/DynatraceInternalModule.kt

@@ -0,0 +1,22 @@
+package com.dynatrace.android.agent
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+
+class DynatraceInternalModule(reactContext: ReactApplicationContext?) :
+    ReactContextBaseJavaModule(reactContext) {
+    override fun getName(): String {
+        return "DynatraceInternalModule"
+    }
+
+    /**
+     * Helper method which should not be called.
+     * @param name Action name
+     * @return Action
+     */
+    @ReactMethod
+    fun enterAction(name: String?): DTXAction {
+        return Dynatrace.integrateNewAction(name)
+    }
+}

package/android/src/main/java/com/dynatrace/android/agent/DynatraceRNBridgeImpl.kt

@@ -0,0 +1,411 @@
+package com.dynatrace.android.agent
+
+import android.location.Location
+import com.dynatrace.android.agent.conf.DataCollectionLevel
+import com.dynatrace.android.agent.conf.DynatraceConfigurationBuilder
+import com.dynatrace.android.agent.conf.UserPrivacyOptions
+import com.dynatrace.android.agent.crash.PlatformType
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import org.json.JSONObject
+import java.net.URI
+import java.net.URISyntaxException
+
+private const val PLATFORM_ANDROID = "android"
+private const val PLATFORM_IOS = "ios"
+private const val DATA_COLLECTION_OFF = "OFF"
+private const val DATA_COLLECTION_PERFORMANCE = "PERFORMANCE"
+private const val DATA_COLLECTION_USERBEHAVIOR = "USER_BEHAVIOR"
+const val BRIDGE_NAME = "DynatraceBridge"
+
+class DynatraceRNBridgeImpl(
+    private val reactApplicationContext: ReactApplicationContext,
+    private val _internal: DynatraceInternalModule
+) {
+    private val webTimings: HashMap<String, WebRequestTiming> = HashMap()
+    private val actions: HashMap<String, DTXAction?> = HashMap()
+
+    private val constants = mapOf(
+        "PLATFORM_ANDROID" to PLATFORM_ANDROID,
+        "PLATFORM_IOS" to PLATFORM_IOS,
+        "DATA_COLLECTION_OFF" to DATA_COLLECTION_OFF,
+        "DATA_COLLECTION_PERFORMANCE" to DATA_COLLECTION_PERFORMANCE,
+        "DATA_COLLECTION_USERBEHAVIOR" to DATA_COLLECTION_USERBEHAVIOR
+    )
+
+    fun getConstants(): Map<String, Any> {
+        return constants;
+    }
+
+    fun start(configuration: ReadableMap?, promise: Promise) {
+        if (configuration == null) {
+            promise.resolve(false)
+            return
+        } else {
+            if (configuration.getString("applicationId") == null || configuration.getString("beaconUrl") == null) {
+                promise.resolve(false)
+                return
+            }
+
+            val builder = DynatraceConfigurationBuilder(
+                configuration.getString("applicationId"),
+                configuration.getString("beaconUrl")
+            )
+
+            builder.apply {
+                withUserOptIn(configuration.getBoolean("userOptIn"))
+                withCrashReporting(configuration.getBoolean("reportCrash"))
+                // 0 == Debug / 1 == Info
+                withDebugLogging(configuration.getInt("logLevel") == 0)
+            }
+
+            Dynatrace.startup(reactApplicationContext, builder.buildConfiguration())
+            promise.resolve(true)
+        }
+    }
+
+    //
+    // Expects a key which is generated in JS. This is to circumvent the async callback system.
+    //
+    fun enterAction(name: String, key: String, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            newAction(name, key)
+        }
+    }
+
+    fun enterManualAction(name: String, key: String, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            actions[key] = Dynatrace.enterAction(name)
+        }
+    }
+
+    fun enterManualActionWithParent(
+        name: String,
+        key: String,
+        parentKey: String,
+        platform: String?
+    ) {
+        if (shouldWorkOnAndroid(platform)) {
+            val parent = actions[parentKey]
+            if (parent != null) {
+                actions[key] = Dynatrace.enterAction(name, parent)
+            } else {
+                enterManualAction(name, key, platform)
+            }
+        }
+    }
+
+    fun leaveAction(key: String, @Suppress("UNUSED_PARAMETER") leave: Boolean, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            val action = getAction(key) ?: return
+            if (action is DTXAutoAction) {
+                action.startTimer()
+            } else {
+                action.leaveAction()
+            }
+            actions.remove(key)
+        }
+    }
+
+    fun cancelAction(key: String, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            val action = getAction(key) ?: return
+            action.cancel()
+            actions.remove(key)
+        }
+    }
+
+    fun endVisit(platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            Dynatrace.endVisit()
+        }
+    }
+
+    fun reportErrorWithoutStacktrace(errorName: String, errorCode: Int, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            Dynatrace.internalReportError(errorName, errorCode)
+        }
+    }
+
+    /**
+     * Reports a stacktrace
+     * @param errorName Name of the Error - SyntaxError
+     * @param errorValue Value of the Error
+     * @param reason Reason for the Error
+     * @param stacktrace Whole Stacktrace
+     * @param platform Platform wise or both
+     */
+    fun reportError(
+        errorName: String,
+        errorValue: String,
+        reason: String,
+        stacktrace: String,
+        platform: String?
+    ) {
+        if (shouldWorkOnAndroid(platform)) {
+            Dynatrace.reportError(PlatformType.CUSTOM, errorName, errorValue, reason, stacktrace)
+        }
+    }
+
+    fun reportCrash(
+        errorName: String,
+        reason: String,
+        stacktrace: String,
+        isRealError: Boolean,
+        platform: String?
+    ) {
+        if (shouldWorkOnAndroid(platform)) {
+            Dynatrace.reportCrash(
+                if (isRealError) PlatformType.JAVA_SCRIPT else PlatformType.CUSTOM,
+                errorName,
+                reason,
+                stacktrace
+            )
+            // Generate new session like iOS to make sure the behavior is the same
+            Dynatrace.createNewSession()
+        }
+    }
+
+    fun reportErrorInAction(key: String, errorName: String, errorCode: Int, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            val action = getAction(key) ?: return
+            action.reportError(errorName, errorCode)
+        }
+    }
+
+    fun reportValue(key: String, valueName: String, value: String, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            val action = getAction(key) ?: return
+            action.reportValue(valueName, value)
+        }
+    }
+
+    fun getRequestTag(key: String, @Suppress("UNUSED_PARAMETER") url: String, promise: Promise) {
+        val action = getAction(key)
+        if (action == null) {
+            promise.resolve(Dynatrace.getRequestTag())
+            return
+        }
+        promise.resolve(action.requestTag)
+    }
+
+    fun startWebRequestTiming(requestTag: String?, @Suppress("UNUSED_PARAMETER") url: String) {
+        if (requestTag != null) {
+            val timing = Dynatrace.getWebRequestTiming(requestTag)
+            if (timing != null) {
+                webTimings[requestTag] = timing
+                timing.startWebRequestTiming()
+            }
+        }
+    }
+
+    fun stopWebRequestTiming(
+        requestTag: String?,
+        url: String,
+        responseCode: Int,
+        responseMessage: String
+    ) {
+        stopWebRequestTimingWithSize(requestTag, url, responseCode, responseMessage, -1, -1)
+    }
+
+    fun stopWebRequestTimingWithSize(
+        requestTag: String?,
+        url: String,
+        responseCode: Int,
+        responseMessage: String,
+        requestSize: Long,
+        responseSize: Long
+    ) {
+        if (requestTag != null) {
+            val timing = webTimings[requestTag]
+            if (timing != null) {
+                try {
+                    timing.stopWebRequestTiming(
+                        URI(url),
+                        responseCode,
+                        responseMessage,
+                        requestSize,
+                        responseSize
+                    )
+                    webTimings.remove(requestTag)
+                } catch (ex: URISyntaxException) {
+                    // do nothing
+                }
+            }
+        }
+    }
+
+    fun identifyUser(user: String, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            Dynatrace.identifyUser(user)
+        }
+    }
+
+    fun reportEventInAction(actionKey: String, name: String, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            val action = getAction(actionKey) ?: return
+            action.reportEvent(name)
+        }
+    }
+
+    fun reportStringValueInAction(
+        actionKey: String,
+        name: String,
+        value: String,
+        platform: String?
+    ) {
+        if (shouldWorkOnAndroid(platform)) {
+            val action = getAction(actionKey) ?: return
+            action.reportValue(name, value)
+        }
+    }
+
+    fun reportIntValueInAction(actionKey: String, name: String, value: Int, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            val action = getAction(actionKey) ?: return
+            action.reportValue(name, value)
+        }
+    }
+
+    fun reportDoubleValueInAction(
+        actionKey: String,
+        name: String,
+        value: Double,
+        platform: String?
+    ) {
+        if (shouldWorkOnAndroid(platform)) {
+            val action = getAction(actionKey) ?: return
+            action.reportValue(name, value)
+        }
+    }
+
+    fun sendBizEvent(type: String, attributes: ReadableMap, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            Dynatrace.sendBizEvent(type, JSONObject(DynatraceUtils.toHashMap(attributes)))
+        }
+    }
+
+    fun forwardEvent(attributes: ReadableMap) {
+        HybridBridge.forwardEvent(JSONObject(DynatraceUtils.toHashMap(attributes)))
+    }
+
+    fun startView(name: String) {
+        Dynatrace.startView(name)
+    }
+
+    fun stopView() {
+        Dynatrace.stopView()
+    }
+
+    fun setGPSLocation(lat: Double, lng: Double, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            val location = Location("")
+
+            location.apply {
+                latitude = lat
+                longitude = lng
+            }
+
+            Dynatrace.setGpsLocation(location)
+        }
+    }
+
+    fun flushEvents(platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            Dynatrace.flushEvents()
+        }
+    }
+
+    fun isCrashReportingOptedIn(platform: String?, promise: Promise) {
+        if (shouldWorkOnAndroid(platform)) {
+            promise.resolve(Dynatrace.isCrashReportingOptedIn())
+        }
+    }
+
+    fun setCrashReportingOptedIn(crashReporting: Boolean, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            Dynatrace.setCrashReportingOptedIn(crashReporting)
+        }
+    }
+
+    fun setDataCollectionLevel(collectionLevel: String, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            Dynatrace.setDataCollectionLevel(DataCollectionLevel.valueOf(collectionLevel))
+        }
+    }
+
+    fun getDataCollectionLevel(platform: String?, promise: Promise) {
+        if (shouldWorkOnAndroid(platform)) {
+            val level = Dynatrace.getDataCollectionLevel()
+            promise.resolve(level.name)
+        }
+    }
+
+    fun setBeaconHeaders(headers: ReadableMap?, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            if (headers == null) {
+                Dynatrace.setBeaconHeaders(null)
+            } else {
+                val beaconHeaders = mutableMapOf<String, String?>()
+                val iterator = headers.keySetIterator()
+                while (iterator.hasNextKey()) {
+                    val currentKey = iterator.nextKey()
+                    beaconHeaders[currentKey] = headers.getString(currentKey)
+                }
+                Dynatrace.setBeaconHeaders(beaconHeaders)
+            }
+        }
+    }
+
+    fun applyUserPrivacyOptions(userPrivacyOptions: ReadableMap, platform: String?) {
+        if (shouldWorkOnAndroid(platform)) {
+            val optionsBuilder = UserPrivacyOptions.builder()
+            optionsBuilder.withCrashReportingOptedIn(userPrivacyOptions.getBoolean("_crashReportingOptedIn"))
+            optionsBuilder.withDataCollectionLevel(
+                DataCollectionLevel.valueOf(
+                    userPrivacyOptions.getString(
+                        "_dataCollectionLevel"
+                    )!!
+                )
+            )
+            Dynatrace.applyUserPrivacyOptions(
+                optionsBuilder
+                    .build()
+            )
+        }
+    }
+
+    fun getUserPrivacyOptions(platform: String?, promise: Promise) {
+        if (shouldWorkOnAndroid(platform)) {
+            val options = Dynatrace.getUserPrivacyOptions()
+            val privacyMap = Arguments.createMap()
+            privacyMap.putString("dataCollectionLevel", options.dataCollectionLevel.name)
+            privacyMap.putBoolean("crashReportingOptedIn", options.isCrashReportingOptedIn)
+            promise.resolve(privacyMap)
+        }
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    fun addListener(eventName: String) {
+        // Here because of event emitter
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    fun removeListeners(count: Double) {
+        // Here because of event emitter
+    }
+
+    private fun newAction(name: String, key: String) {
+        actions[key] = _internal.enterAction(name)
+    }
+
+    private fun getAction(key: String): DTXAction? {
+        return actions[key]
+    }
+
+    private fun shouldWorkOnAndroid(platform: String?): Boolean {
+        return platform == null || platform == PLATFORM_ANDROID || platform == ""
+    }
+}

package/android/src/main/java/com/dynatrace/android/agent/DynatraceReactPackage.kt

@@ -0,0 +1,54 @@
+package com.dynatrace.android.agent
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+import java.util.Arrays
+
+class DynatraceReactPackage : TurboReactPackage() {
+    init {
+        setupAppStartListener()
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        val bridge = DynatraceInternalModule(reactContext)
+        val appStart = DynatraceAppStartModule(reactContext)
+        return Arrays.asList<NativeModule>(
+            DynatraceRNBridge(reactContext, bridge),
+            bridge,
+            appStart
+        )
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+        val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+        moduleInfos[BRIDGE_NAME] = ReactModuleInfo(
+            BRIDGE_NAME,
+            BRIDGE_NAME,
+            false,  // canOverrideExistingModule
+            false,  // needsEagerInit
+            true,  // hasConstants
+            false,  // isCxxModule
+            isTurboModule // isTurboModule
+        )
+        return ReactModuleInfoProvider { moduleInfos }
+    }
+
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == BRIDGE_NAME) {
+            DynatraceAppStartModule(reactContext)
+            DynatraceRNBridge(reactContext, DynatraceInternalModule(reactContext))
+        } else {
+            null
+        }
+    }
+}