@luciq/react-native 19.2.1 → 19.3.0-40271-SNAPSHOT

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [19.3.0](https://github.com/luciqai/luciq-reactnative-sdk/compare/v19.3.0...19.2.1)
+
+### Added
+
+- **Custom Spans**: New feature to manually instrument code paths for performance tracking
+  - `APM.startCustomSpan(name)` - Start a custom span and return a span object
+  - `CustomSpan.end()` - End the span and report to SDK
+  - `APM.addCompletedCustomSpan(name, startDate, endDate)` - Record a pre-completed span
+  - Support for up to 100 concurrent spans
+  - Comprehensive validation (name length, empty checks, timestamp validation)
+  - Feature flag support to enable/disable custom spans
+
+### Changed
+
+- Bump Luciq iOS SDK to v19.5.0 ([#37](https://github.com/luciqai/luciq-reactnative-sdk/pull/37)). [See release notes](https://github.com/luciqai/Luciq-iOS-sdk/releases/tag/19.5.0).
+
+- Bump Luciq Android SDK to v19.3.0 ([#37](https://github.com/luciqai/luciq-reactnative-sdk/pull/37)). [See release notes](https://github.com/luciqai/Luciq-Android-sdk/releases/tag/v19.4.0).
+
+## [19.2.2](https://github.com/luciqai/luciq-reactnative-sdk/compare/v19.2.2...19.2.1)
+
+### Changed
+
+- Bump Luciq iOS SDK to v19.4.1 ([#34](https://github.com/luciqai/luciq-reactnative-sdk/pull/34)). [See release notes](https://github.com/luciqai/Luciq-iOS-sdk/releases/tag/19.4.1).
+
+- Bump Luciq Android SDK to v19.2.2 ([#34](https://github.com/luciqai/luciq-reactnative-sdk/pull/34)). [See release notes](https://github.com/luciqai/Luciq-Android-sdk/releases/tag/v19.2.2).
+
 ## [19.2.1](https://github.com/luciqai/luciq-reactnative-sdk/compare/v19.2.1...19.1.0)
 
 ### Added
@@ -14,6 +40,10 @@
 
 - Bump Luciq Android SDK to v19.2.1 ([#29](https://github.com/luciqai/luciq-reactnative-sdk/pull/29)). [See release notes](https://github.com/luciqai/Luciq-Android-sdk/releases/tag/v19.2.1).
 
+### Fixed
+
+- Running Expo Plugin on ios [#31](https://github.com/luciqai/luciq-reactnative-sdk/pull/31))
+
 ## [19.1.0](https://github.com/luciqai/luciq-reactnative-sdk/compare/v19.1.0...19.0.0)
 
 ### Added

package/README.md

@@ -141,6 +141,93 @@ You can disable Repro Steps using the following API:
 Luciq.setReproStepsConfig({ all: ReproStepsMode.disabled });
 ```
 
+## Custom Spans
+
+Custom spans allow you to manually instrument arbitrary code paths for performance tracking. This feature enables tracking of operations not covered by automatic instrumentation.
+
+### Starting and Ending a Span
+
+```javascript
+import { APM } from '@luciq/react-native';
+
+// Start a custom span
+const span = await APM.startCustomSpan('Load User Profile');
+
+if (span) {
+  try {
+    // Perform your operation
+    await loadUserProfile();
+  } finally {
+    // Always end the span, even if operation fails
+    await span.end();
+  }
+}
+```
+
+### Recording a Completed Span
+
+```javascript
+const start = new Date();
+// ... operation already completed ...
+const end = new Date();
+
+await APM.addCompletedCustomSpan('Cache Lookup', start, end);
+```
+
+### Important Notes
+
+- **Span Limit**: Maximum of 100 concurrent spans at any time
+- **Name Length**: Span names are truncated to 150 characters
+- **Validation**: Empty names or invalid timestamps will be rejected
+- **Idempotent**: Calling `span.end()` multiple times is safe
+- **Feature Flags**: Spans are only created when SDK is initialized, APM is enabled, and custom spans feature is enabled
+
+### API Reference
+
+#### `APM.startCustomSpan(name: string): Promise<CustomSpan | null>`
+
+Starts a custom span for performance tracking.
+
+**Parameters:**
+
+- `name` (string): The name of the span. Cannot be empty. Max 150 characters.
+
+**Returns:**
+
+- `Promise<CustomSpan | null>`: The span object to end later, or `null` if the span could not be created.
+
+**Example:**
+
+```javascript
+const span = await APM.startCustomSpan('Database Query');
+if (span) {
+  // ... perform operation ...
+  await span.end();
+}
+```
+
+#### `CustomSpan.end(): Promise<void>`
+
+Ends the custom span and reports it to the SDK. This method is idempotent.
+
+#### `APM.addCompletedCustomSpan(name: string, startDate: Date, endDate: Date): Promise<void>`
+
+Records a completed custom span with pre-recorded timestamps.
+
+**Parameters:**
+
+- `name` (string): The name of the span. Cannot be empty. Max 150 characters.
+- `startDate` (Date): The start time of the operation.
+- `endDate` (Date): The end time of the operation (must be after startDate).
+
+**Example:**
+
+```javascript
+const start = new Date(Date.now() - 1500);
+const end = new Date();
+await APM.addCompletedCustomSpan('Background Task', start, end);
+```
+
 ## Documentation
 
 For more details about the supported APIs and how to use them, check our [**Documentation**](https://docs.luciq.ai/docs/react-native-overview).

package/RNLuciq.podspec

@@ -12,7 +12,7 @@ Pod::Spec.new do |s|
   s.homepage     = package["homepage"]
   s.source       = { :git => "https://github.com/Instabug/Instabug-React-Native.git", :tag => 'v' + package["version"] }
 
-  s.platform     = :ios, "13.0"
+  s.platform     = :ios, "15.0"
   s.source_files = "ios/**/*.{h,m,mm}"
 
   s.dependency 'React-Core'

package/android/native.gradle

@@ -1,5 +1,5 @@
 project.ext.luciq = [
-    version: '19.2.1'
+    version: '19.3.0'
 ]
 
 dependencies {

package/android/src/main/java/ai/luciq/reactlibrary/RNLuciqAPMModule.java

@@ -13,21 +13,25 @@ import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableMap;
-import ai.luciq.apm.APM;
-import ai.luciq.apm.networking.APMNetworkLogger;
-import ai.luciq.apm.networkinterception.cp.APMCPNetworkLog;
-import ai.luciq.reactlibrary.utils.EventEmitterModule;
-import ai.luciq.reactlibrary.utils.MainThreadHandler;
 
 import java.lang.reflect.Method;
-import java.util.HashMap;
+import java.util.Date;
 
 import javax.annotation.Nonnull;
 
-import static ai.luciq.reactlibrary.utils.LuciqUtil.getMethod;
+import ai.luciq.apm.APM;
+import ai.luciq.apm.InternalAPM;
+import ai.luciq.apm.configuration.cp.APMFeature;
+import ai.luciq.apm.configuration.cp.FeatureAvailabilityCallback;
+import ai.luciq.apm.networking.APMNetworkLogger;
+import ai.luciq.apm.networkinterception.cp.APMCPNetworkLog;
+import ai.luciq.reactlibrary.utils.EventEmitterModule;
+import ai.luciq.reactlibrary.utils.MainThreadHandler;
 
 public class RNLuciqAPMModule extends EventEmitterModule {
 
+    private static final String NET_TAG = "LCQ-RN-NET";
+
     public RNLuciqAPMModule(ReactApplicationContext reactApplicationContext) {
         super(reactApplicationContext);
     }
@@ -240,73 +244,73 @@ public class RNLuciqAPMModule extends EventEmitterModule {
         });
     }
 
- /**
-  * The `networkLogAndroid` function logs network-related information using APMNetworkLogger in a React
-  * Native module.
-  *
-  * @param requestStartTime The `requestStartTime` parameter in the `networkLogAndroid` method
-  * represents the timestamp when the network request started. It is of type `double` and is passed as
-  * a parameter to log network-related information.
-  * @param requestDuration The `requestDuration` parameter in the `networkLogAndroid` method represents
-  * the duration of the network request in milliseconds. It indicates the time taken for the request to
-  * complete from the moment it was initiated until the response was received. This parameter helps in
-  * measuring the performance of network requests and identifying any potential
-  * @param requestHeaders requestHeaders is a string parameter that contains the headers of the network
-  * request. It typically includes information such as the content type, authorization token, and any
-  * other headers that were sent with the request.
-  * @param requestBody The `requestBody` parameter in the `networkLogAndroid` method represents the
-  * body of the HTTP request being logged. It contains the data that is sent as part of the request to
-  * the server. This could include form data, JSON payload, XML data, or any other content that is
-  * being transmitted
-  * @param requestBodySize The `requestBodySize` parameter in the `networkLogAndroid` method represents
-  * the size of the request body in bytes. It is a double value that indicates the size of the request
-  * body being sent in the network request. This parameter is used to log information related to the
-  * network request, including details
-  * @param requestMethod The `requestMethod` parameter in the `networkLogAndroid` method represents the
-  * HTTP method used in the network request, such as GET, POST, PUT, DELETE, etc. It indicates the type
-  * of operation that the client is requesting from the server.
-  * @param requestUrl The `requestUrl` parameter in the `networkLogAndroid` method represents the URL
-  * of the network request being logged. It typically contains the address of the server to which the
-  * request is being made, along with any additional path or query parameters required for the request.
-  * This URL is essential for identifying the
-  * @param requestContentType The `requestContentType` parameter in the `networkLogAndroid` method
-  * represents the content type of the request being made. This could be values like
-  * "application/json", "application/xml", "text/plain", etc., indicating the format of the data being
-  * sent in the request body. It helps in specifying
-  * @param responseHeaders The `responseHeaders` parameter in the `networkLogAndroid` method represents
-  * the headers of the response received from a network request. These headers typically include
-  * information such as content type, content length, server information, and any other metadata
-  * related to the response. The `responseHeaders` parameter is expected to
-  * @param responseBody The `responseBody` parameter in the `networkLogAndroid` method represents the
-  * body of the response received from a network request. It contains the data or content sent back by
-  * the server in response to the request made by the client. This could be in various formats such as
-  * JSON, XML, HTML
-  * @param responseBodySize The `responseBodySize` parameter in the `networkLogAndroid` method
-  * represents the size of the response body in bytes. It is a double value that indicates the size of
-  * the response body received from the network request. This parameter is used to log information
-  * related to the network request and response, including
-  * @param statusCode The `statusCode` parameter in the `networkLogAndroid` method represents the HTTP
-  * status code of the network request/response. It indicates the status of the HTTP response, such as
-  * success (200), redirection (3xx), client errors (4xx), or server errors (5xx). This parameter is
-  * @param responseContentType The `responseContentType` parameter in the `networkLogAndroid` method
-  * represents the content type of the response received from the network request. It indicates the
-  * format of the data in the response, such as JSON, XML, HTML, etc. This information is useful for
-  * understanding how to parse and handle the
-  * @param errorDomain The `errorDomain` parameter in the `networkLogAndroid` method is used to specify
-  * the domain of an error, if any occurred during the network request. If there was no error, this
-  * parameter will be `null`.
-  * @param w3cAttributes The `w3cAttributes` parameter in the `networkLogAndroid` method is a
-  * ReadableMap object that contains additional attributes related to W3C external trace. It may
-  * include the following key-value pairs:
-  * @param gqLCQueryName The `gqLCQueryName` parameter in the `networkLogAndroid` method represents the
-  * name of the GraphQL query being executed. It is a nullable parameter, meaning it can be null if no
-  * GraphQL query name is provided. This parameter is used to log information related to GraphQL
-  * queries in the network logging
-  * @param serverErrorMessage The `serverErrorMessage` parameter in the `networkLogAndroid` method is
-  * used to pass any error message received from the server during network communication. This message
-  * can provide additional details about any errors that occurred on the server side, helping in
-  * debugging and troubleshooting network-related issues.
-  */
+    /**
+     * The `networkLogAndroid` function logs network-related information using APMNetworkLogger in a React
+     * Native module.
+     *
+     * @param requestStartTime    The `requestStartTime` parameter in the `networkLogAndroid` method
+     *                            represents the timestamp when the network request started. It is of type `double` and is passed as
+     *                            a parameter to log network-related information.
+     * @param requestDuration     The `requestDuration` parameter in the `networkLogAndroid` method represents
+     *                            the duration of the network request in milliseconds. It indicates the time taken for the request to
+     *                            complete from the moment it was initiated until the response was received. This parameter helps in
+     *                            measuring the performance of network requests and identifying any potential
+     * @param requestHeaders      requestHeaders is a string parameter that contains the headers of the network
+     *                            request. It typically includes information such as the content type, authorization token, and any
+     *                            other headers that were sent with the request.
+     * @param requestBody         The `requestBody` parameter in the `networkLogAndroid` method represents the
+     *                            body of the HTTP request being logged. It contains the data that is sent as part of the request to
+     *                            the server. This could include form data, JSON payload, XML data, or any other content that is
+     *                            being transmitted
+     * @param requestBodySize     The `requestBodySize` parameter in the `networkLogAndroid` method represents
+     *                            the size of the request body in bytes. It is a double value that indicates the size of the request
+     *                            body being sent in the network request. This parameter is used to log information related to the
+     *                            network request, including details
+     * @param requestMethod       The `requestMethod` parameter in the `networkLogAndroid` method represents the
+     *                            HTTP method used in the network request, such as GET, POST, PUT, DELETE, etc. It indicates the type
+     *                            of operation that the client is requesting from the server.
+     * @param requestUrl          The `requestUrl` parameter in the `networkLogAndroid` method represents the URL
+     *                            of the network request being logged. It typically contains the address of the server to which the
+     *                            request is being made, along with any additional path or query parameters required for the request.
+     *                            This URL is essential for identifying the
+     * @param requestContentType  The `requestContentType` parameter in the `networkLogAndroid` method
+     *                            represents the content type of the request being made. This could be values like
+     *                            "application/json", "application/xml", "text/plain", etc., indicating the format of the data being
+     *                            sent in the request body. It helps in specifying
+     * @param responseHeaders     The `responseHeaders` parameter in the `networkLogAndroid` method represents
+     *                            the headers of the response received from a network request. These headers typically include
+     *                            information such as content type, content length, server information, and any other metadata
+     *                            related to the response. The `responseHeaders` parameter is expected to
+     * @param responseBody        The `responseBody` parameter in the `networkLogAndroid` method represents the
+     *                            body of the response received from a network request. It contains the data or content sent back by
+     *                            the server in response to the request made by the client. This could be in various formats such as
+     *                            JSON, XML, HTML
+     * @param responseBodySize    The `responseBodySize` parameter in the `networkLogAndroid` method
+     *                            represents the size of the response body in bytes. It is a double value that indicates the size of
+     *                            the response body received from the network request. This parameter is used to log information
+     *                            related to the network request and response, including
+     * @param statusCode          The `statusCode` parameter in the `networkLogAndroid` method represents the HTTP
+     *                            status code of the network request/response. It indicates the status of the HTTP response, such as
+     *                            success (200), redirection (3xx), client errors (4xx), or server errors (5xx). This parameter is
+     * @param responseContentType The `responseContentType` parameter in the `networkLogAndroid` method
+     *                            represents the content type of the response received from the network request. It indicates the
+     *                            format of the data in the response, such as JSON, XML, HTML, etc. This information is useful for
+     *                            understanding how to parse and handle the
+     * @param errorDomain         The `errorDomain` parameter in the `networkLogAndroid` method is used to specify
+     *                            the domain of an error, if any occurred during the network request. If there was no error, this
+     *                            parameter will be `null`.
+     * @param w3cAttributes       The `w3cAttributes` parameter in the `networkLogAndroid` method is a
+     *                            ReadableMap object that contains additional attributes related to W3C external trace. It may
+     *                            include the following key-value pairs:
+     * @param gqLCQueryName       The `gqLCQueryName` parameter in the `networkLogAndroid` method represents the
+     *                            name of the GraphQL query being executed. It is a nullable parameter, meaning it can be null if no
+     *                            GraphQL query name is provided. This parameter is used to log information related to GraphQL
+     *                            queries in the network logging
+     * @param serverErrorMessage  The `serverErrorMessage` parameter in the `networkLogAndroid` method is
+     *                            used to pass any error message received from the server during network communication. This message
+     *                            can provide additional details about any errors that occurred on the server side, helping in
+     *                            debugging and troubleshooting network-related issues.
+     */
     @ReactMethod
     private void networkLogAndroid(final double requestStartTime,
                                    final double requestDuration,
@@ -325,15 +329,16 @@ public class RNLuciqAPMModule extends EventEmitterModule {
                                    @Nullable final ReadableMap w3cAttributes,
                                    @Nullable final String gqLCQueryName,
                                    @Nullable final String serverErrorMessage
-                                   ) {
+    ) {
+        Log.d(NET_TAG, "[networkLogAndroid-APM] Received from JS: " + requestMethod + " " + requestUrl + ", status=" + (int) statusCode + ", duration=" + (long) requestDuration + "ms, startTime=" + (long) requestStartTime + ", error=" + errorDomain + ", gqlQuery=" + gqLCQueryName);
         try {
             APMNetworkLogger networkLogger = new APMNetworkLogger();
 
             final boolean hasError = errorDomain != null && !errorDomain.isEmpty();
             final String errorMessage = hasError ? errorDomain : null;
-            Boolean isW3cHeaderFound=false;
-            Long partialId=null;
-            Long networkStartTimeInSeconds=null;
+            Boolean isW3cHeaderFound = false;
+            Long partialId = null;
+            Long networkStartTimeInSeconds = null;
 
 
             try {
@@ -342,13 +347,15 @@ public class RNLuciqAPMModule extends EventEmitterModule {
                 }
 
                 if (!w3cAttributes.isNull("partialId")) {
-                    partialId =(long) w3cAttributes.getDouble("partialId");
+                    partialId = (long) w3cAttributes.getDouble("partialId");
                     networkStartTimeInSeconds = (long) w3cAttributes.getDouble("networkStartTimeInSeconds");
                 }
 
             } catch (Exception e) {
+                Log.e(NET_TAG, "[networkLogAndroid-APM] Error parsing W3C attributes for " + requestMethod + " " + requestUrl, e);
                 e.printStackTrace();
             }
+            Log.d(NET_TAG, "[networkLogAndroid-APM] W3C attrs — isW3cHeaderFound=" + isW3cHeaderFound + ", partialId=" + partialId + ", networkStartTimeInSeconds=" + networkStartTimeInSeconds + ", generatedHeader=" + (w3cAttributes != null && !w3cAttributes.isNull("w3cGeneratedHeader") ? w3cAttributes.getString("w3cGeneratedHeader") : "null") + ", caughtHeader=" + (w3cAttributes != null && !w3cAttributes.isNull("w3cCaughtHeader") ? w3cAttributes.getString("w3cCaughtHeader") : "null"));
             APMCPNetworkLog.W3CExternalTraceAttributes w3cExternalTraceAttributes =
                     new APMCPNetworkLog.W3CExternalTraceAttributes(
                             isW3cHeaderFound,
@@ -360,52 +367,139 @@ public class RNLuciqAPMModule extends EventEmitterModule {
             try {
                 Method method = getMethod(Class.forName("ai.luciq.apm.networking.APMNetworkLogger"), "log", long.class, long.class, String.class, String.class, long.class, String.class, String.class, String.class, String.class, String.class, long.class, int.class, String.class, String.class, String.class, String.class, APMCPNetworkLog.W3CExternalTraceAttributes.class);
                 if (method != null) {
-                        method.invoke(
-                                networkLogger,
-                                (long) requestStartTime * 1000,
-                                (long) requestDuration,
-                                requestHeaders,
-                                requestBody,
-                                (long)  requestBodySize,
-                                requestMethod,
-                                requestUrl,
-                                requestContentType,
-                                responseHeaders,
-                                responseBody,
-                                (long)responseBodySize,
-                                (int) statusCode,
-                                responseContentType,
-                                errorMessage,
-                                gqLCQueryName,
-                                serverErrorMessage,
-                                w3cExternalTraceAttributes
-                        );
+                    method.invoke(
+                            networkLogger,
+                            (long) requestStartTime * 1000,
+                            (long) requestDuration,
+                            requestHeaders,
+                            requestBody,
+                            (long) requestBodySize,
+                            requestMethod,
+                            requestUrl,
+                            requestContentType,
+                            responseHeaders,
+                            responseBody,
+                            (long) responseBodySize,
+                            (int) statusCode,
+                            responseContentType,
+                            errorMessage,
+                            gqLCQueryName,
+                            serverErrorMessage,
+                            w3cExternalTraceAttributes
+                    );
+                    Log.d(NET_TAG, "[networkLogAndroid-APM] Successfully invoked APMNetworkLogger.log via reflection: " + requestMethod + " " + requestUrl);
                 } else {
+                    Log.e(NET_TAG, "[networkLogAndroid-APM] APMNetworkLogger.log method NOT found by reflection — network log will be lost: " + requestMethod + " " + requestUrl);
                     Log.e("IB-CP-Bridge", "APMNetworkLogger.log was not found by reflection");
                 }
             } catch (Throwable e) {
+                Log.e(NET_TAG, "[networkLogAndroid-APM] Exception invoking APMNetworkLogger.log: " + e.getMessage() + " for " + requestMethod + " " + requestUrl, e);
                 e.printStackTrace();
             }
-        } catch(Throwable e) {
+        } catch (Throwable e) {
+            Log.e(NET_TAG, "[networkLogAndroid-APM] Top-level exception: " + e.getMessage() + " for " + requestMethod + " " + requestUrl, e);
             e.printStackTrace();
         }
     }
-        /**
-         * Enables or disables screen rendering
-         *
-         * @param isEnabled boolean indicating enabled or disabled.
-         */
-        @ReactMethod
-        public void setScreenRenderingEnabled(boolean isEnabled) {
-            MainThreadHandler.runOnMainThread(new Runnable() {
-                @Override
-                public void run() {
-                    try {
-                        APM.setScreenRenderingEnabled(isEnabled);
-                    } catch (Exception e) {
-                        e.printStackTrace();
-                    }
+
+    /**
+     * Enables or disables screen rendering
+     *
+     * @param isEnabled boolean indicating enabled or disabled.
+     */
+    @ReactMethod
+    public void setScreenRenderingEnabled(boolean isEnabled) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    APM.setScreenRenderingEnabled(isEnabled);
+                } catch (Exception e) {
+                    e.printStackTrace();
                 }
-            });
-        }
+            }
+        });
+    }
+
+    /**
+     * Syncs a custom span to the native SDK (currently logs only).
+     *
+     * @param name           Name of the custom span
+     * @param startTimestamp Start time in microseconds since epoch
+     * @param endTimestamp   End time in microseconds since epoch
+     * @param promise        Promise to resolve when complete
+     */
+    @ReactMethod
+    public void syncCustomSpan(final String name,
+                               final double startTimestamp,
+                               final double endTimestamp,
+                               final Promise promise) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    // Convert microseconds to milliseconds for Date objects
+                    Date startDate = new Date((long) (startTimestamp / 1000));
+                    Date endDate = new Date((long) (endTimestamp / 1000));
+
+                    APM.addCompletedCustomSpan(name, startDate, endDate);
+
+                    promise.resolve(true);
+                } catch (Exception e) {
+                    Log.e("IB-CP-Bridge", "Error syncing span", e);
+                    promise.resolve(false);
+                }
+            }
+        });
+    }
+
+    /**
+     * Checks if custom spans feature is enabled.
+     *
+     * @param promise Promise that resolves with boolean indicating if enabled
+     */
+    @ReactMethod
+    public void isCustomSpanEnabled(final Promise promise) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    InternalAPM._isFeatureEnabledCP(APMFeature.CUSTOM_SPANS, "LuciqCustomSpan", new FeatureAvailabilityCallback() {
+                        @Override
+                        public void invoke(boolean isEnabled) {
+                            promise.resolve(isEnabled);
+                        }
+                    });
+                } catch (Exception e) {
+                    Log.e("IB-CP-Bridge", "Error checking feature flag", e);
+                    promise.resolve(false);
+                }
+            }
+        });
+    }
+
+    /**
+     * Checks if APM is enabled.
+     *
+     * @param promise Promise that resolves with boolean indicating if enabled
+     */
+    @ReactMethod
+    public void isAPMEnabled(final Promise promise) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    InternalAPM._isFeatureEnabledCP(APMFeature.APM, "APM", new FeatureAvailabilityCallback() {
+                        @Override
+                        public void invoke(boolean isEnabled) {
+                            promise.resolve(isEnabled);
+                        }
+                    });
+                } catch (Exception e) {
+                    Log.e("IB-CP-Bridge", "Error checking APM enabled", e);
+                    promise.resolve(false);
+                }
+            }
+        });
+    }
 }