@dynatrace/react-native-plugin 2.307.1 → 2.309.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.309.2.1011
+* iOS Agent: 8.309.1.1009
 
 ## Quick Setup
 
@@ -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,10 @@ If you are struggling with a problem, submit a support ticket to Dynatrace (supp
 <br/><br/>
 ## Changelog
 
+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.309.2.1011'
     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
+        }
+    }
+}