RUM Configuration¶

Obtaining RUM¶

Standard uni-app:

import { rum } from '@/uni_modules/GC-UniPlugin';

uni Mini Program:

import { rum } from '@/uni_modules/GC-JSPlugin';

In uni Mini Programs, RUM initialization is completed by the host App; do not call rum.setConfig(). The automatic collectors and manual collection APIs on this page can be used after the host initialization is complete.

RUM Initialization Configuration¶

rum.setConfig({
    androidAppId: 'YOUR_ANDROID_APP_ID',
    iOSAppId: 'YOUR_IOS_APP_ID',
    harmonyAppId: 'YOUR_HARMONY_APP_ID',
    errorMonitorType: 'all',
    deviceMonitorType: ['cpu', 'memory']
});

RUM User Data Tracking¶

Action¶

For HarmonyOS, to automatically collect click, tap, long press, and Tab switch actions, you need to explicitly start the JS Action collector:

import { gcActionTracking } from '@/uni_modules/GC-JSPlugin';

gcActionTracking.startTracking();

Native Action automatic collection on Android and iOS is controlled by enableNativeUserAction.

API - startAction¶

Starts a RUM Action.

RUM will bind Resource, Error, and LongTask events that may occur during this Action. Avoid calling it multiple times within 0.1s; only one Action is associated with the same View at a time. If the previous Action has not ended, the new Action will be discarded. It does not affect addAction.

rum.startAction({
    actionName: 'action name',
    actionType: 'action type'
});

API - addAction¶

Adds an Action event. This type of data cannot be associated with Error, Resource, or LongTask events, and has no discard logic.

rum.addAction({
    actionName: 'action name',
    actionType: 'action type'
});

View¶

Automatic Collection¶

It is recommended to use gcViewTracking. It uniformly listens for page lifecycle events (onLoad, onReady, onShow, onHide, onUnload) and App front/background events, and automatically calls the native RUM View API.

Call it once as early as possible in the project's main.js. For Vue 2, call it before creating the root Vue instance; for Vue 3, pass the app returned by createSSRApp:

Vue 2¶

import App from './App';
import { gcViewTracking } from '@/uni_modules/GC-JSPlugin';
import Vue from 'vue';

gcViewTracking.startTracking();

const app = new Vue({
    ...App
});
app.$mount();

Vue 3¶

import App from './App';
import { gcViewTracking } from '@/uni_modules/GC-JSPlugin';
import { createSSRApp } from 'vue';

export function createApp() {
    const app = createSSRApp(App);
    gcViewTracking.startTracking(app);
    return { app };
}

Collection rules:

• On the first page display, loading_time is calculated from onLoad to onReady, in nanoseconds.
• If the collector starts too late or does not receive the full page lifecycle, the loading time that cannot be reliably calculated uses -1; when the page is shown again or the App returns to foreground, it uses 0.
• The current View is stopped when the page is hidden, unloaded, or the App enters background; repeated onShow/resume within the same lifecycle are automatically deduplicated.
• Route failures do not generate a View; multiple page instances of the same route maintain their own states.

Compatible Collection Method¶

The older mixin approach is retained for compatibility. New projects should prefer gcViewTracking and not enable both automatic collection methods simultaneously, as this may produce duplicate Views.

For the combined configuration of App.vue + the first page, refer to the SDK package examples Hbuilder_Example/App.vue and Hbuilder_Example/pages/index/index.vue:

// step 1. Add GC-JSPlugin to the uni_modules of the project
// step 2. Add Router monitoring in App.vue
<script>
import { gcWatchRouter } from '@/uni_modules/GC-JSPlugin';
export default {
    mixins: [gcWatchRouter],
}
</script>

// step 3. Add pageMixin to the first page
<script>
import { gcPageMixin } from '@/uni_modules/GC-JSPlugin';
export default {
    mixins: [gcPageMixin],
}
</script>

To collect only specific pages, refer to the SDK package example Hbuilder_Example/pages/rum/index.vue:

<script>
import { gcPageViewMixinOnly } from '@/uni_modules/GC-JSPlugin';
export default {
    mixins: [gcPageViewMixinOnly],
}
</script>

Manual Collection¶

rum.onCreateView({
    viewName: 'Current Page Name',
    loadTime: 100000000
});

rum.startView({
    viewName: 'Current Page Name'
});
rum.stopView();

API - onCreateView¶

Creates a page load duration record.

API - startView¶

Enters a page.

API - stopView¶

Leaves a page.

Error¶

Automatic Collection¶

import { gcErrorTracking } from '@/uni_modules/GC-JSPlugin';

gcErrorTracking.startTracking();

Manual Collection¶

rum.addError({
    message: 'Error message',
    stack: 'Error stack'
});

API - addError¶

Resource¶

Automatic Collection¶

Starting from 0.3.0, it is recommended to use gcResourceTracking. It intercepts the standard uni.request on Android, iOS, and HarmonyOS, automatically collecting RUM Resources for successful or failed requests. If Trace is already initialized, it will generate a Trace Header based on the configured trace type and add it to the request headers; when enableLinkRUMData is enabled, it can associate the RUM Resource with the Trace. Identical request headers already set by business code are not overwritten.

Call startTracking once before making requests, and then continue using uni.request directly:

import { gcResourceTracking } from '@/uni_modules/GC-JSPlugin';

gcResourceTracking.startTracking();

uni.request({
    url: requestUrl,
    method: method,
    header: header,
    timeout: 30000,
    success(res) {
        console.log('success:' + JSON.stringify(res));
    },
    fail(err) {
        console.log('fail:' + JSON.stringify(err));
    },
    complete() {
        console.log('complete');
    }
});

startTracking configuration:

// When native collection is already enabled on iOS via rum.setConfig({ enableNativeUserResource: true }):
gcResourceTracking.startTracking({
    enableIOS: false
});

Usage notes:

• Supported on App Android, App iOS, and App HarmonyOS; should be called during the application startup phase, before the first uni.request call.
• startTracking should only be called once; repeated calls will not reinstall the interceptor.
• If Trace is initialized, the request will automatically have a Trace Header added; business code headers with the same name take precedence.
• The original success, fail, and complete callbacks remain unchanged.
• gcRequest.request is retained only as a deprecated compatibility API since 0.2.7. After enabling the global collector, there is no need to replace uni.request, and do not use both collection methods simultaneously.

The old configuration of gcRequest.request is provided for reference only for projects that have not yet migrated:

Manual Collection¶

Implement manually by calling startResource, stopResource, and addResource. See GCResourceTracking.js.

API - startResource¶

API - stopResource¶

API - addResource¶

content object¶