@dynatrace/react-native-plugin 2.305.1 → 2.309.1

package/README.md

@@ -27,17 +27,18 @@ If you want to start using this plugin and are not a Dynatrace customer yet, hea
   * Android Gradle plugin version 7.0+
   * Java 11
 * For iOS users: Minimum iOS 12
+* NodeJS 18+
 
 ## Agent Versions
 This agent versions are configured in this plugin:
 
-* Android Agent: 8.305.1.1005
-* iOS Agent: 8.305.3.1016
+* Android Agent: 8.309.2.1011
+* iOS Agent: 8.309.1.1009
 
 ## Quick Setup
 
 1. [Install plugin](#1-install-the-plugin)
-2. [Register Dynatrace transformer](#2-register-the-dynatrace-transformer)
+2. [Register Dynatrace transformer and reporter](#2-register-the-dynatrace-transformer-and-reporter)
 3. [Setup configuration](#3-setup-dynatraceconfigjs)
 4. [Update Babel Configuration](#4-update-babel-configuration)
 5. [Build and run your app](#4-build-and-run-your-app)
@@ -106,7 +107,9 @@ This agent versions are configured in this plugin:
 - Standalone Project: If you are using React Native standalone and embed it in your native project have a look [here](#configuration-of-standalone-react-native-project).
 - If for some reason (e.g. seperate native projects) `react-native link` doesn't work as expected, [manually add the iOS agent to your project](#manually-adding-ios-oneagent-to-a-project).
 
-## 2. Register the Dynatrace transformer
+## 2. Register the Dynatrace transformer and reporter
+
+The transformer will add modifications to your code during build. The reporter will notify us if you clear the cache of the metro bundler.
 
 Depending on your React Native version, you will need to use a different way to register the transformer. If you don't know the version, enter `react-native --version` in your terminal.
 
@@ -193,7 +196,7 @@ The required changes for the versions above can be found [here](#react-automatic
 
 1. Only for Expo: If using expo make sure that your project is containing a "android" and/or "ios" folder. This can be done by using `npx expo prebuild`.
 
-2. Execute [`npx instrumentDynatrace`](#npx-instrumentdynatrace) or `react-native instrument-dynatrace` in the root of your React Native project. This will configure both Android and iOS projects with the settings from `dynatrace.config.js`. You can use the same [custom arguments](#customizing-paths-for-configuration) as mentioned above.
+2. Execute [`npx instrumentDynatrace`](#npx-instrumentdynatrace) or `react-native instrument-dynatrace` in the root of your React Native project. This will configure both Android and iOS projects with the settings from `dynatrace.config.js`. You can use the same [custom arguments](#customizing-paths-for-configuration) as mentioned above. Be aware this configuration step will modify your application's *.plist and build.gradle file. This modification enables auto instrumentation on Android and is writing the configuration for both platforms needed for the OneAgent.
 
 1. Use `react-native run-android` or `react-native run-ios` to rebuild and run your app. Specify custom paths via [custom arguments.](#customizing-paths-for-configuration).
 
@@ -318,13 +321,13 @@ Dynatrace.withMonitoring(MyFunctionalComponent, "MyFunctionalComponent");
 
 The String "MyFunctionalComponent" is optional as the name of the component can be retrieved through [different properties](#how-does-dynatrace-determine-the-user-action-name).
 
-Combining manual and auto instrumentation is not creating a problem as both are executing the same thing. Manual instrumentation would only override the content of auto instrumentation happening through the transformer.
+Combining manual and auto instrumentation should not be a problem. As they're running the same execution, the manual instrumentation will only override the content of auto instrumentation happening through the transformer.
 
 ### Create custom actions
 
 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.
+* `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.
 
 ```ts
 import { Dynatrace } from '@dynatrace/react-native-plugin';
@@ -399,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();
@@ -1236,7 +1239,7 @@ module.exports = {
 
 If you want to register the Dynatrace transformer in your configuration and you already have a transformer in place, change the upstreaming transformer for the Dynatrace transformer.
 
-This can be done via a configuration value in the `dynatrace.config.js`. The following example shows how the configuration might look like for the popular `react-native-svg-transformer`. Be aware that the following example is targeting *React Native v0.72.1* or newer.
+This can be done via a configuration value in the `dynatrace.config.js`. The following example shows how the configuration might look like for the popular `react-native-svg-transformer`. Be aware that the following example is targeting *React Native v0.72.1* or newer. Be aware if you are using a different second transformer, you need to change `react-native-svg-transformer/react-native` accordingly.
 
 #### dynatrace.config.js
 
@@ -1244,7 +1247,7 @@ This can be done via a configuration value in the `dynatrace.config.js`. The fol
 // The `...` only indicates that there are other values as well, but we've omitted them in this example.
 module.exports = {
     react : {
-        upstreamTransformer: require.resolve('customTransformerLib/myTransformer'),
+        upstreamTransformer: require.resolve('react-native-svg-transformer/react-native'),
         ...
     },
     ...       
@@ -1460,6 +1463,14 @@ 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+
+
 2.305.1
 * Updated Android (8.305.1.1005) & iOS Agent (8.305.3.1016)
 

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.305.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 == ""
+    }
+}