Functions

RUMvision exposes direct JavaScript functions through the same rumv() API.

Requirement: Make sure the RUMvision JavaScript API is enabled. See JavaScript API requirements.

Introduction

Unlike get, set and config, functions perform an action or return a utility value directly.

Examples include creating a pagehit, forcing data to be sent, generating a UUID or reading the current viewport.

Available functions

Additional functions can be exposed by enabled plugins.

Tracking

RUMvision already handles most regular hard navigations and supported soft navigations automatically. For soft navigations, this is largely covered through our integration with the Soft Navigation API in the web-vitals library. See our SPA & soft navigation monitoring introduction for more information.

The tracking functions below are therefore mainly useful when you deliberately want to create or control a navigation outside the normal hard-navigation or soft-navigation flow, or within browsers that do not support the Soft Navigations API. For example, you may want to start a new RUMvision navigation after a specific user interaction that represents a meaningful new view or state in your application.

pagehit

Use pagehit to manually create a new RUMvision navigation.

A navigation type is required:

rumv('pagehit', 'soft-navigation');

You can optionally provide more navigation context:

rumv('pagehit', navType, url, navId, startTime);

RUMvision already handles normal page loads and supported browser navigation scenarios automatically.

Manual pagehits are mainly useful when your application knows about a navigation that RUMvision cannot identify automatically.

For SPA implementations, prefer RUMvision's built-in soft-navigation support where it covers your framework.

send

Use send to immediately send the currently available data:

rumv('send');

RUMvision normally manages beacon timing automatically.

A manual send is useful when your application has a specific lifecycle moment at which currently collected information should be submitted immediately.

The call returns RUMvision's transport result or promise.

A specific navigation can also be supplied when available:

rumv('send', navId);

Most integrations only need:

rumv('send');

dnt

Use dnt to stop tracking the current navigation:

rumv('dnt');

RUMvision cancels pending send work for that navigation where possible, marks the current RUM session state as opted out and prevents that navigation from being tracked further.

This is different from:

rumv('config', 'consent_storage', 0);

consent_storage controls whether RUMvision may use browser storage, while dnt stops RUM tracking for the navigation itself.

To make dnt persist across pagehits, RUMvision still needs access to sessionStorage. This allows the opt-out state to be remembered for the remainder of the browser session instead of only affecting the current pagehit.

For that reason, disabling storage completely is not the same as using dnt. If consent_storage is disabled, RUMvision cannot persist this state itself. In that case, your own implementation should call rumv('dnt') again on every new pagehit for as long as the visitor should remain opted out.

Utilities

These utility functions are mainly intended to help you align custom data and dimensions with the same values and timing references RUMvision uses internally. This can be useful when you need to enrich custom data in a way that stays consistent with RUMvision's own measurements.

viewport

Get RUMvision's current viewport dimensions:

const viewport = rumv('viewport');

A typical result:

{w: 1440, h: 900}

RUMvision prefers visualViewport where available and otherwise falls back to document or window dimensions.

now

Get the current page-relative timing value:

const time = rumv('now');

This returns a rounded value based on:

performance.now()

It is useful for timings relative to the current document lifecycle.

date

Get the current Unix timestamp in milliseconds:

const timestamp = rumv('date');

This is equivalent to:

Date.now()

uuid

Generate a UUID:

const id = rumv('uuid');

RUMvision uses the browser's native:

crypto.randomUUID()

This can be useful when an integration needs an identifier without loading another utility.

Plugins

Enabled RUMvision modules can register additional functions.

Their availability depends on the generated script for the domain.

error

When error tracking is enabled, handled errors can be reported manually:

try {
  initializePayment();
  } catch (error) {
  rumv('error', error);
  }

Additional error context can also be supplied:

rumv('error', {
  error,
  message,
  filename,
  lineno,
  colno
  });

Manual reporting does not swallow or rethrow the error.

Your application remains responsible for its own error handling.

event

When the conversions plugin is enabled, it can expose:

rumv('event', ...);

The accepted arguments depend on the conversion configuration generated for the domain.

define

The conversions plugin can also expose:

rumv('define', ...);

Its accepted configuration depends on the conversion definitions for the domain.

Plugin-specific functions should be documented together with the relevant feature because they are not universally available.

Examples

Create a manual soft navigation:

rumv('pagehit', 'soft-navigation');

Immediately send the current data:

rumv('send');

Stop tracking the current navigation:

rumv('dnt');

Read the viewport:

const viewport = rumv('viewport');

Generate a UUID:

const id = rumv('uuid');

• PreviousConfig
• back to parent