@luciq/react-native 19.2.2 → 19.3.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # 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

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/android/native.gradle

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

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

@@ -13,18 +13,20 @@ 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 {
 
@@ -240,73 +242,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 +327,15 @@ public class RNLuciqAPMModule extends EventEmitterModule {
                                    @Nullable final ReadableMap w3cAttributes,
                                    @Nullable final String gqLCQueryName,
                                    @Nullable final String serverErrorMessage
-                                   ) {
+    ) {
         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,7 +344,7 @@ public class RNLuciqAPMModule extends EventEmitterModule {
                 }
 
                 if (!w3cAttributes.isNull("partialId")) {
-                    partialId =(long) w3cAttributes.getDouble("partialId");
+                    partialId = (long) w3cAttributes.getDouble("partialId");
                     networkStartTimeInSeconds = (long) w3cAttributes.getDouble("networkStartTimeInSeconds");
                 }
 
@@ -360,52 +362,135 @@ 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
+                    );
                 } else {
                     Log.e("IB-CP-Bridge", "APMNetworkLogger.log was not found by reflection");
                 }
             } catch (Throwable e) {
                 e.printStackTrace();
             }
-        } catch(Throwable e) {
+        } catch (Throwable 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);
+                }
+            }
+        });
+    }
 }

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

@@ -222,6 +222,26 @@ public class RNLuciqReactnativeModule extends EventEmitterModule {
         });
     }
 
+    /**
+     * Checks if the SDK is built or not.
+     *
+     * @param promise Promise that resolves with boolean indicating if enabled
+     */
+    @ReactMethod
+    public void isBuilt(final Promise promise) {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    promise.resolve(Luciq.isBuilt());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    promise.resolve(false);
+                }
+            }
+        });
+    }
+
     @ReactMethod
     public void setOverAirVersion(@Nullable final ReadableMap overAirVersion) {
         MainThreadHandler.runOnMainThread(new Runnable() {

package/dist/constants/Strings.d.ts

@@ -0,0 +1,9 @@
+export declare class LuciqStrings {
+    static readonly customSpanAPMDisabledMessage: string;
+    static readonly customSpanDisabled: string;
+    static readonly customSpanSDKNotInitializedMessage: string;
+    static readonly customSpanNameEmpty: string;
+    static readonly customSpanEndTimeBeforeStartTime: string;
+    static readonly customSpanNameTruncated: string;
+    static readonly customSpanLimitReached: string;
+}

package/dist/constants/Strings.js

@@ -0,0 +1,12 @@
+export class LuciqStrings {
+    static customSpanAPMDisabledMessage = 'APM is disabled, custom span not created. Please enable APM by following the instructions at this link:\n' +
+        'https://docs.luciq.ai/product-guides-and-integrations/product-guides/application-performance-monitoring';
+    static customSpanDisabled = 'Custom span is disabled, custom span not created. Please enable Custom Span by following the instructions at this link:\n' +
+        'https://docs.luciq.ai/product-guides-and-integrations/product-guides/application-performance-monitoring';
+    static customSpanSDKNotInitializedMessage = 'Luciq API was called before the SDK is built. To build it, first by following the instructions at this link:\n' +
+        'https://docs.luciq.ai/product-guides-and-integrations/product-guides/application-performance-monitoring';
+    static customSpanNameEmpty = 'Custom span name cannot be empty. Please provide a valid name for the custom span.';
+    static customSpanEndTimeBeforeStartTime = 'Custom span end time must be after start time. Please provide a valid start and end time for the custom span.';
+    static customSpanNameTruncated = 'Custom span name truncated to 150 characters';
+    static customSpanLimitReached = 'Maximum number of concurrent custom spans (100) reached. Please end some spans before starting new ones.';
+}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import type { LuciqConfig } from './models/LuciqConfig';
 import Report from './models/Report';
 import type { ThemeConfig } from './models/ThemeConfig';
+import { CustomSpan } from './models/CustomSpan';
 import * as APM from './modules/APM';
 import * as BugReporting from './modules/BugReporting';
 import * as CrashReporting from './modules/CrashReporting';
@@ -15,6 +16,6 @@ import * as Surveys from './modules/Surveys';
 import * as SessionReplay from './modules/SessionReplay';
 import type { SessionMetadata } from './models/SessionMetadata';
 export * from './utils/Enums';
-export { Report, APM, BugReporting, CrashReporting, FeatureRequests, NetworkLogger, SessionReplay, Replies, Surveys, ProactiveReportingConfigOptions, createProactiveReportingConfig, };
+export { Report, CustomSpan, APM, BugReporting, CrashReporting, FeatureRequests, NetworkLogger, SessionReplay, Replies, Surveys, ProactiveReportingConfigOptions, createProactiveReportingConfig, };
 export type { LuciqConfig, Survey, NetworkData, NetworkDataObfuscationHandler, SessionMetadata, ThemeConfig, };
 export default Luciq;

package/dist/index.js

@@ -1,4 +1,5 @@
 import Report from './models/Report';
+import { CustomSpan } from './models/CustomSpan';
 // Modules
 import * as APM from './modules/APM';
 import * as BugReporting from './modules/BugReporting';
@@ -11,5 +12,5 @@ import * as Replies from './modules/Replies';
 import * as Surveys from './modules/Surveys';
 import * as SessionReplay from './modules/SessionReplay';
 export * from './utils/Enums';
-export { Report, APM, BugReporting, CrashReporting, FeatureRequests, NetworkLogger, SessionReplay, Replies, Surveys, createProactiveReportingConfig, };
+export { Report, CustomSpan, APM, BugReporting, CrashReporting, FeatureRequests, NetworkLogger, SessionReplay, Replies, Surveys, createProactiveReportingConfig, };
 export default Luciq;

package/dist/models/CustomSpan.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Callback to unregister a span from tracking
+ */
+type UnregisterCallback = (span: CustomSpan) => void;
+/**
+ * Callback to sync span data to native SDK
+ */
+type SyncCallback = (name: string, startTimestamp: number, endTimestamp: number) => Promise<void>;
+/**
+ * Represents a custom span for performance tracking.
+ * A span measures the duration of an operation and reports it to the native SDK.
+ */
+export declare class CustomSpan {
+    private name;
+    private startTime;
+    private startMonotonic;
+    private endTime?;
+    private duration?;
+    private hasEnded;
+    private endPromise?;
+    private unregisterCallback;
+    private syncCallback;
+    /**
+     * Creates a new custom span. The span starts immediately upon creation.
+     * @internal - Use APM.startCustomSpan() instead
+     */
+    constructor(name: string, unregisterCallback: UnregisterCallback, syncCallback: SyncCallback);
+    /**
+     * Ends this custom span and reports it to the native SDK.
+     * This method is idempotent - calling it multiple times is safe.
+     * Subsequent calls will wait for the first call to complete.
+     */
+    end(): Promise<void>;
+    /**
+     * Get the span name
+     */
+    getName(): string;
+    /**
+     * Check if the span has ended
+     */
+    isEnded(): boolean;
+    /**
+     * Get the span duration in milliseconds (only available after end())
+     */
+    getDuration(): number | undefined;
+}
+export {};