RUM Configuration¶

import {
  DetectFrequency,
  DeviceMetricsMonitorType,
  ErrorMonitorType,
  FTSDK,
  FTRUMConfig
} from '@guancecloud/ft_sdk/Index';

const rumConfig = new FTRUMConfig()
  .setRumAppId('your-app-id')
  .setSamplingRate(1.0)
  .setSessionErrorSampleRate(1.0)
  .setEnableTraceUserAction(true)
  .setEnableTraceUserView(true)
  .setEnableTraceUserResource(true)
  .setEnableTrackAppUIBlock(true)
  .setEnableTrackAppANR(true)
  .setEnableTrackAppCrash(true)
  .setEnableTraceWebView(true)
  .setDeviceMetricsMonitorType(DeviceMetricsMonitorType.ALL, DetectFrequency.DEFAULT)
  .setExtraMonitorTypeWithError(ErrorMonitorType.ALL)
  .addGlobalContext('rum_channel', new String('official'));

FTSDK.installRUMConfig(rumConfig);

/**
 * Starts the View lifecycle.
 *
 * @param viewName View name.
 * @param property Optional extended attributes.
 */
startView(viewName: string, property?: Record<string, object>): Promise<void>

/**
 * Ends the current View lifecycle.
 *
 * @param property Optional extended attributes.
 */
stopView(property?: Record<string, object>): Promise<void>

/**
 * Updates the load time of the current View.
 *
 * @param loadTime Load time in nanoseconds.
 */
updateLoadTime(loadTime: number): void

import { FTRUMGlobalManager } from '@guancecloud/ft_sdk/Index';

@Entry
@Component
struct ProductPage {
  async aboutToAppear() {
    // Scenario 1:
    await FTRUMGlobalManager.getInstance().startView('ProductPage');

    // Scenario 2: With extended attributes
    const viewProperty: Record<string, object> = { page_category: new String('product'), page_id: new String('12345') };
    await FTRUMGlobalManager.getInstance().startView('ProductPage', viewProperty);

  }

  async aboutToDisappear() {
    // Scenario 1:
    await FTRUMGlobalManager.getInstance().stopView();

    // Scenario 2:
    const stopViewProperty: Record<string, object> = { view_duration: new Number(1000) };
    await FTRUMGlobalManager.getInstance().stopView(stopViewProperty);
  }

  build() {
    Column() {
      Text('Product Page');
    }
  }
}

/**
 * Adds a completed Action; this data is not associated with Error, Resource, or LongTask.
 *
 * @param actionName Action name.
 * @param actionType Action type, for example `click`.
 * @param durationOrProperty Optional. When a number is passed, it represents the duration in nanoseconds; when a Record is passed, it represents extended attributes.
 * @param property Optional. Pass extended attributes only when the third parameter is a duration.
 */
addAction(
  actionName: string,
  actionType: string,
  durationOrProperty?: number | Record<string, object>,
  property?: Record<string, object>
): void

/**
 * Starts an Action; the SDK manages when it ends and associates nearby Resource, LongTask, and Error data.
 *
 * @param actionName Action name.
 * @param actionType Action type, for example `click`.
 * @param property Optional extended attributes.
 */
startAction(
  actionName: string,
  actionType: string,
  property?: Record<string, object>
): void

import { FTRUMGlobalManager } from '@guancecloud/ft_sdk/Index';

// Scenario 1:
FTRUMGlobalManager.getInstance().addAction('buy_button_click', 'click');

// Scenario 2: With extended attributes
const actionProperty: Record<string, object> = {
  product_id: new String('product_id'),
  product_name: new String('product_name')
};
FTRUMGlobalManager.getInstance().addAction('buy_button_click', 'click', actionProperty);

// Scenario 1:
FTRUMGlobalManager.getInstance().startAction('buy_button_click', 'click');

// Scenario 2: With extended attributes
const startActionProperty: Record<string, object> = {
  product_id: new String('product_id'),
  product_name: new String('product_name')
};
FTRUMGlobalManager.getInstance().startAction('buy_button_click', 'click', startActionProperty);

/**
 * Reports an Error.
 *
 * @param log Error log or stack information.
 * @param message Message.
 * @param errorType Error type; can be an `ErrorType` enum or a string.
 * @param state App running state when the error occurred.
 * @param property Optional extended attributes.
 */
addError(
  log: string,
  message: string,
  errorType: string | ErrorType,
  state: AppState,
  property?: Record<string, object> | null
): void

/**
 * Reports an Error with a specified occurrence time.
 *
 * @param log Error log or stack information.
 * @param message Message.
 * @param dateline Error occurrence time in nanoseconds.
 * @param errorType Error type; can be an `ErrorType` enum or a string.
 * @param state App running state when the error occurred.
 * @param property Optional extended attributes.
 */
addError(
  log: string,
  message: string,
  dateline: number,
  errorType: string | ErrorType,
  state: AppState,
  property?: Record<string, object> | null
): void

import { FTRUMGlobalManager, ErrorType, AppState } from '@guancecloud/ft_sdk/Index';
import { systemDateTime } from '@kit.BasicServicesKit';

// Scenario 1:
FTRUMGlobalManager.getInstance().addError('error log', 'error message', ErrorType.CUSTOM, AppState.RUN);

// Scenario 2: For delayed reporting, pass the actual error occurrence time (in nanoseconds).
const errorTimeNs = systemDateTime.getTime(true);
FTRUMGlobalManager.getInstance().addError('error log', 'error message', errorTimeNs, ErrorType.CUSTOM, AppState.RUN);

// Scenario 3: With extended attributes.
const errorProperty: Record<string, object> = {
  module: new String('checkout'),
  action: new String('submit_order')
};
FTRUMGlobalManager.getInstance().addError('error log', 'error message', ErrorType.CUSTOM, AppState.RUN, errorProperty);

/**
 * Reports a LongTask.
 *
 * @param log Log or stack information during the freeze.
 * @param duration Freeze duration in nanoseconds.
 * @param property Optional extended attributes.
 */
addLongTask(log: string, duration: number, property?: Record<string, string | number | boolean>): void

import { FTRUMGlobalManager } from '@guancecloud/ft_sdk/Index';

const durationMs = 350;
const durationNs = durationMs * 1000000;
const stack = new Error('checkout render long task').stack ?? 'Stack trace not available';

// Scenario 1:
FTRUMGlobalManager.getInstance().addLongTask(stack, durationNs);

// Scenario 2: With extended attributes.
const longTaskProperty: Record<string, string | number | boolean> = {
  module: 'checkout',
  operation: 'render_order_list',
  threshold_ms: 200
};
FTRUMGlobalManager.getInstance().addLongTask(stack, durationNs, longTaskProperty);

/**
 * Starts the Resource lifecycle.
 *
 * @param resourceId Unique resource identifier; must use the same value as `stopResource` and `addResource`.
 * @param property Optional extended attributes.
 */
startResource(resourceId: string, property?: Record<string, object>): void

/**
 * Ends the Resource lifecycle.
 *
 * @param resourceId Unique resource identifier; should use the same value as `startResource`.
 * @param property Optional extended attributes.
 */
stopResource(resourceId: string, property?: Record<string, object>): void

/**
 * Adds the request, response, and network performance data for a Resource.
 *
 * @param resourceId Unique resource identifier; should use the same value as `startResource` and `stopResource`.
 * @param resourceParams Resource details such as URL, request method, response status, response length, and extended attributes.
 * @param netStatusBean Network performance data such as DNS, TCP, TTFB, and response time.
 */
addResource(resourceId: string, resourceParams: ResourceParams, netStatusBean: NetStatusBean): void

import {
  FTRUMGlobalManager,
  ResourceParams,
  NetStatusBean
} from '@guancecloud/ft_sdk/Index';

const resourceId = 'https://api.example.com/data';

// Scenario 1:
// Request start
FTRUMGlobalManager.getInstance().startResource(resourceId);

// After the request completes, add request, response, and network performance data.
const resourceParams = new ResourceParams();
resourceParams.setUrl(resourceId);
resourceParams.setResourceStatus(200);
resourceParams.setResponseContentLength(1024);
resourceParams.resourceType = 'xhr';

const netStatusBean = new NetStatusBean();
netStatusBean.setResourceHostIP('192.168.1.1');
netStatusBean.setDNSTime(10000000);
netStatusBean.setTcpTime(20000000);
netStatusBean.setTTFB(50000000);
netStatusBean.setResponseTime(100000000);

FTRUMGlobalManager.getInstance().stopResource(resourceId);
FTRUMGlobalManager.getInstance().addResource(resourceId, resourceParams, netStatusBean);

// Scenario 2: With extended attributes. This is an independent request; when using it, replace the startResource and stopResource calls in Scenario 1.
const startResourceProperty: Record<string, object> = {
  request_source: new String('checkout')
};
FTRUMGlobalManager.getInstance().startResource(resourceId, startResourceProperty);

const stopResourceProperty: Record<string, object> = {
  response_cache: new Boolean(false)
};
FTRUMGlobalManager.getInstance().stopResource(resourceId, stopResourceProperty);

import { rcp } from '@kit.RemoteCommunicationKit';
import { createFTRCPTrackConfig } from '@guancecloud/ft_sdk/Index';

const session = rcp.createSession(
  createFTRCPTrackConfig({
    baseAddress: 'https://api.example.com'
  })
);

// GET request
const request = new rcp.Request('/data', 'GET');
const response = await session.fetch(request);

// POST request
const headers: rcp.RequestHeaders = { 'Content-Type': 'application/json' };
const postRequest = new rcp.Request('/data', 'POST', headers, { name: 'test' });
const postResponse = await session.fetch(postRequest);

import { createFTRCPTrackConfig } from '@guancecloud/ft_sdk/Index';

import { rcp } from '@kit.RemoteCommunicationKit';
import { RCPTraceInterceptor, RCPResourceInterceptor } from '@guancecloud/ft_sdk/Index';

const session = rcp.createSession({
  baseAddress: 'https://api.example.com',
  interceptors: [
    new RCPTraceInterceptor(),
    new RCPResourceInterceptor()
  ],
  requestConfiguration: {
    tracing: {
      collectTimeInfo: true
    }
  }
});

import { http } from '@kit.NetworkKit';
import { createFTHttpInterceptorChain } from '@guancecloud/ft_sdk_ext/Index';

const request = http.createHttp();
const interceptorChain = createFTHttpInterceptorChain();
interceptorChain.apply(request);

try {
  const response = await request.request('https://httpbin.org/get', {
    method: http.RequestMethod.GET,
    header: {
      'Accept': 'application/json'
    }
  });
} finally {
  request.destroy();
}

import { http } from '@kit.NetworkKit';
import { createFTHttpInterceptorChain } from '@guancecloud/ft_sdk_ext/Index';

const request = http.createHttp();
const interceptorChain = createFTHttpInterceptorChain({
  interceptors: [
    new CustomAfterInterceptor()// Append custom interceptor
  ]
});
interceptorChain.apply(request);

[
  new HttpInitialRequestInterceptor(),
  new HttpFinalResponseInterceptor(),
  new CustomAfterInterceptor()
]

import { http } from '@kit.NetworkKit';
import {
  HttpInitialRequestInterceptor,
  HttpFinalResponseInterceptor
} from '@guancecloud/ft_sdk_ext/Index';

const request = http.createHttp();
const interceptorChain = new http.HttpInterceptorChain();
interceptorChain.addChain([
  new CustomBeforeInterceptor(),
  new HttpInitialRequestInterceptor(),
  new HttpFinalResponseInterceptor()
]);
interceptorChain.apply(request);

import axios from '@ohos/axios';
import { applyFTAxiosTrack } from '@guancecloud/ft_sdk/Index';

const client = axios.create({
  timeout: 10000
});

applyFTAxiosTrack(client);

import axios from '@ohos/axios';
import { applyFTAxiosTrack } from '@guancecloud/ft_sdk/Index';

const client = axios.create({
  timeout: 10000
});

applyFTAxiosTrack(client);

client.interceptors.request.use((config) => {
  config.headers = {
    ...(config.headers || {}),
    Authorization: 'Bearer <token>',
    'X-Signature': 'signed-value'
  };
  return config;
});

client.interceptors.response.use((response) => {
  return response;
});

import axios from '@ohos/axios';
import {
  createFTHttpInterceptorChain,
  applyFTAxiosChainMethodBridge
} from '@guancecloud/ft_sdk_ext/Index';

const client = axios.create({
  timeout: 10000,
  interceptorChain: createFTHttpInterceptorChain()
});

applyFTAxiosChainMethodBridge(client);

const response = await client.post('https://api.example.com/data', {
  source: 'axios',
  message: 'ft auto track'
});

import axios from '@ohos/axios';
import { createFTHttpInterceptorChain } from '@guancecloud/ft_sdk_ext/Index';

const response = await axios.request({
  url: 'https://httpbin.org/post',
  method: 'post',
  data: {
    source: 'axios',
    message: 'ft auto track'
  },
  responseType: 'string',
  interceptorChain: createFTHttpInterceptorChain()
});