Operations Monitoring

Overview

In Datadog RUM, a feature represents a major user-facing area of your application like checkout, login, or search. Each feature includes operations, which are the critical technical steps that make the experience work.

• Business teams use features to track and improve user conversion.
• Engineering teams use operations to monitor and minimize technical failures that impact key user moments.

For example, the checkout experience of an e-commerce platform is a feature. Within it, operations might include entering payment details, saving a payment method, and completing a purchase. After the SDK has been instrumented, Datadog RUM measures each operation’s performance, including execution volume, completion rate, and failure rate. Measuring operations’ health enables you to identify exactly when and why users may not convert in your feature.

The following table shows additional example features and their associated feature operations by industry.

Prerequisites

• RUM without Limits must be enabled in your organization.
• Make sure you’ve downloaded a supported Datadog RUM SDK version with client-side APIs to define operations:
  • Browser (6.20.0)
  • Android (3.1.0)
  • iOS (3.1.0)
  • Flutter (3.0.0)
    • Note: On Flutter Web, operations route through the Browser SDK, which requires the feature_operation_vital experimental feature to be enabled.
  • Kotlin Multiplatform (1.4.0)
  • React Native (3.0.0)
  • Roku (1.4.0)

Setup

Use the SDK APIs to define your operations.

Start an operation

Every operation must be started by calling startOperation (some SDKs may use the legacy name of this API - startFeatureOperation).

DD_RUM.init({
...,
enableExperimentalFeatures: ["feature_operation_vital"], // you need to have this flag turned on for the API to work
})
startFeatureOperation: (
name: string,
options?: {
 operationKey?: string,
 context?: Context,
 description?: string,
}) => void

GlobalRumMonitor.get().startOperation(
	name: String,
	operationKey: String?,
	options: OperationOptions,
	attributes: Map<String, Any?>
)

RUMMonitor.shared().startOperation(
	name: String,
	operationKey: String?,
	attributes: [AttributeKey: AttributeValue]?,
	options: OperationOptions?
)

DdRum.startFeatureOperation(
	name: string,
	operationKey?: string,
	attributes?: Record<string, any>
)

DatadogSdk.instance.rum?.startFeatureOperation(
 String name, {
 String? operationKey,
 Map<String, Object?> attributes = const {},
 }
)

m.global.datadogRumAgent@.startOperation(
 name as string,
 operationKey = invalid as dynamic, ' optional: string or invalid for unkeyed operations
 context = {} as object ' optional: AssocArray of custom attributes
)

Stop an operation with success

Every started operation must have a stop. Use succeedOperation to stop an operation with a successful outcome (some SDKs may use the legacy name of this API - succeedFeatureOperation).

DD_RUM.init({
...,
enableExperimentalFeatures: ["feature_operation_vital"], // this flag needs to be enabled for the API to work
})
succeedFeatureOperation: (
name: string,
options?: {
 operationKey?: string,
 context?: Context,
 description?: string,
}) => void

GlobalRumMonitor.get().succeedOperation(
	name: String,
	operationKey: String?,
	attributes: Map<String, Any?>
)

RUMMonitor.shared().succeedOperation(
	name: String,
	operationKey: String?,
	attributes: [AttributeKey: AttributeValue]?
)

DdRum.succeedFeatureOperation(
	name: string,
	operationKey?: string,
	attributes?: Record<string, any>
)

DatadogSdk.instance.rum?.succeedFeatureOperation(
 String name, {
 String? operationKey,
 Map<String, Object?> attributes = const {},
 }
)

m.global.datadogRumAgent@.succeedOperation(
 name as string,
 operationKey = invalid as dynamic, ' optional: string or invalid for unkeyed operations
 context = {} as object ' optional: AssocArray of custom attributes
)

Stop an operation with failure

Every started operation must have a stop. Use failOperation to stop an operation with a failure outcome (some SDKs may use the legacy name of this API - failFeatureOperation).

DD_RUM.init({
...,
enableExperimentalFeatures: ["feature_operation_vital"], // this flag needs to be enabled for the API to work
})
failFeatureOperation: (
name: string, 
failureReason: FailureReason, //'error' | 'abandoned' | 'other'
options?: {
 operationKey?: string,
 context?: Context,
 description?: string,
}) => void

GlobalRumMonitor.get().failOperation(
	name: String,
	operationKey: String?,
	failureReason: FailureReason,	// ERROR, ABANDONED, OTHER
	attributes: Map<String, Any?>
)

RUMMonitor.shared().failOperation(
	name: String,
	operationKey: String?,
 reason: RUMFeatureOperationFailureReason, // .error, .abandoned, .other
	attributes: [AttributeKey: AttributeValue]
)

m.global.datadogRumAgent@.failOperation(
 name as string,
 failureReason as string, ' "error", "abandoned", or "other"
 operationKey = invalid as dynamic, ' optional: string or invalid for unkeyed operations
 context = {} as object ' optional: AssocArray of custom attributes
)

DdRum.failFeatureOperation(
	name: string,
	operationKey?: string,
	reason: FeatureOperationFailure, // 'ERROR' | 'ABANDONED' | 'OTHER'
	attributes: Record<string, any>
)

DatadogSdk.instance.rum?.failFeatureOperation(
 String name,
 RumFeatureOperationFailureReason failureReason, // .error, .abandoned, .other
 {
 String? operationKey,
 Map<String, Object?> attributes = const {},
 }
)

Parallelization

You may have cases where users are starting several feature operations in parallel. To individually track them, use the operationKey defined when calling startOperation. You must reuse the same operationKey later in other APIs, for example when calling succeedOperation.

Monitor your availability on Datadog

After you’ve configured the SDK APIs, you can monitor your operations by navigating to RUM > Performance Monitoring > Operations.

Datadog groups together all operations with the same name into a catalog.

Each operation has two out-of-the-box metrics computed over your full, ingested, unsampled traffic:

• rum.measure.operation, which counts the volume of operations reported to Datadog
• rum.measure.operation.duration, which measures the elapsed time between the start and end of all the operations reported to Datadog

Both metrics are retained for 15 months, and include several dimensions:

• operation.name, which is defined on the client side
• operation.status, which is either a success or failure
• operation.failure_reason, which can be an error, or abandoned, or other

Those metrics are included in the price of RUM Measure and available to all RUM without Limits customers that define one or more operations.

Investigate root causes with AI

You can run an agentic investigation on a single operation directly from the Operations page. The agent analyzes both the success rate and the latency of the operation and surfaces focused investigations for each failure mode (errors, timeouts, abandonment) and for latency regressions. For more information, see Operation AI Investigation.

Configure retention filters

Operations are a new type of event in RUM. Operations are bound to a RUM Session, but can span across multiple RUM Views. Operations can be targeted in retention filters. This allows you to align your retention strategy on features that are cornerstones for your user experiences. For example, you can programmatically keep RUM Sessions that had specific operations fail or are taking longer than desired.

Similarly to metrics, those events come with specific attributes you can use in retention filters:

• @operation.name
• @operation.status
• @operation.failure_reason
• @operation.duration
• @operation.start_view.name
• @operation.end_view.name

Further Reading

Request a personalized demo