RUM Configuration¶

RUM Initialization Configuration¶

var rum = uni.requireNativePlugin("GCUniPlugin-RUM");
rum.setConfig({
    androidAppId: 'YOUR_ANDROID_APP_ID',
    iOSAppId: 'YOUR_IOS_APP_ID',
    errorMonitorType: 'all',
    deviceMonitorType: ['cpu', 'memory']
});

RUM User Data Tracking¶

var rum = uni.requireNativePlugin("GCUniPlugin-RUM");

Action¶

API - startAction¶

Start a RUM Action.

RUM binds Resource, Error, and LongTask events that may be triggered during this Action. Avoid calling multiple times within 0.1s; only one Action is associated with a 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¶

Add an Action event. This type of data cannot be associated with Error, Resource, or LongTask, 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 foreground/background events, and automatically calls the native RUM View API.

Call this 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:

• When the page is first displayed, loading_time is calculated from onLoad to onReady, in nanoseconds.
• If the collector starts too late or does not receive the complete page lifecycle, the load time cannot be reliably calculated and defaults to -1; when the page is shown again or the app returns to the foreground, it defaults to 0.
• When the page is hidden, unloaded, or the app enters the background, the current View is stopped. Repeated onShow/resume events within the same lifecycle are automatically deduplicated.
• Route failures do not generate a View. Multiple page instances with the same route maintain their own states.

Compatibility Collection Method¶

The old mixin method is retained for compatibility. New projects should use gcViewTracking as the priority. Do not enable both automatic collection methods simultaneously, as this may cause duplicate Views.

The combined configuration of App.vue and the first page can be referenced in the SDK example project Hbuilder_Example/App.vue and Hbuilder_Example/pages/index/index.vue:

// step 1. Add GC-JSPlugin to the project uni_modules
// 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 example project 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¶

Create a record of page load duration.

API - startView¶

Enter the page.

API - stopView¶

Leave the 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¶

It is recommended to use gcResourceTracking (SDK 0.2.7+). It installs a global interceptor for standard uni.request, automatically generates Resource identifiers, injects request headers matching the Trace configuration, and collects RUM Resource data on request success or failure.

Call startTracking once before making requests, 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:

• Only supported on App Android and App iOS. It should be executed 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 configured, requests matching the Trace allowlist will have Trace headers injected. Explicit request headers set in business code take precedence.
• Original success, fail, and complete callbacks remain unchanged.
• gcRequest.request is retained only as a deprecated compatibility API since 0.2.7. Do not replace uni.request after enabling the global collector, and do not use both collection methods in parallel.

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

Manual Collection¶

You can implement it manually by calling startResource, stopResource, and addResource. See GCRequest.js.

API - startResource¶

API - stopResource¶

API - addResource¶

content object¶