Présentation

Dans Datadog Real User Monitoring (RUM), un parcours représente une zone majeure de votre application destinée aux utilisateurs, comme le paiement, la connexion ou la recherche. Chaque parcours inclut des opérations, qui sont les étapes techniques critiques permettant à l’expérience de fonctionner.

• Les équipes métier utilisent les parcours pour suivre et améliorer la conversion des utilisateurs.
• Les équipes d’ingénierie utilisent les opérations pour surveiller et minimiser les échecs techniques qui ont un impact sur les moments clés des utilisateurs.

Vous pouvez créer des opérations avec les API du SDK RUM, directement dans Datadog, ou par programmation avec la Datadog API.

Par exemple, l’expérience de paiement d’une plateforme de commerce électronique est un parcours. Au sein de celui-ci, les opérations peuvent inclure la saisie des détails de paiement, l’enregistrement d’un moyen de paiement et la finalisation d’un achat. Après avoir créé des opérations, Datadog RUM mesure la performance de chaque opération, notamment le volume d’exécution, le taux de réussite et le taux d’échec. La mesure de la santé des opérations vous permet d’identifier précisément quand et pourquoi les utilisateurs peuvent ne pas convertir dans votre parcours.

Le tableau suivant présente d’autres exemples de parcours et leurs opérations de parcours associées par secteur.

Prérequis

• RUM without Limits doit être activé dans votre organisation.
• Pour créer des opérations avec les API du SDK, téléchargez une version prise en charge du SDK Datadog RUM avec des API côté client pour définir les opérations :
  • Navigateur (6.20.0)
  • Android (3.1.0)
  • iOS (3.1.0)
  • Flutter (3.0.0)
    • Remarque : Sur Flutter Web, les opérations passent par le SDK Navigateur, ce qui nécessite l’activation de la fonctionnalité expérimentale feature_operation_vital.
  • Kotlin Multiplatform (1.4.0)
  • React Native (3.0.0)
  • Roku (1.4.0)

Créer des opérations avec les API du SDK

Utilisez les API du SDK pour définir vos opérations.

Démarrer une opération

Chaque opération doit être démarrée en appelant startOperation (certains SDK peuvent utiliser l’ancien nom de cette 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
)

Arrêter une opération avec succès

Chaque opération démarrée doit avoir un arrêt. Utilisez succeedOperation pour arrêter une opération avec un résultat positif (certains SDK peuvent utiliser l’ancien nom de cette API - succeedFeatureOperation).

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
)

Arrêter une opération avec échec

Chaque opération démarrée doit avoir un arrêt. Utilisez failOperation pour arrêter une opération avec un résultat d’échec (certains SDK peuvent utiliser l’ancien nom de cette 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 {},
  }
)

Parallélisation

Il peut arriver que des utilisateurs démarrent plusieurs opérations de parcours en parallèle. Pour les suivre individuellement, utilisez le operationKey défini lors de l’appel de startOperation. Vous devez réutiliser le même operationKey ultérieurement dans d’autres API, par exemple lors de l’appel de succeedOperation.

Créer des opérations depuis Datadog

Vous pouvez créer une opération depuis le catalogue des opérations ou le rapport de détails d’un parcours :

• Catalogue des opérations : Accédez à RUM > Operations, puis cliquez sur New Operation
• Journey Monitoring : Accédez à Digital Experience > Journey Monitoring, sélectionnez un parcours, accédez à ses Details Report, puis cliquez sur New Operation

Étape 1 : Saisissez les détails de l’opération et sélectionnez la catégorie d’opération

Sélectionnez l’application RUM de l’opération et saisissez un nom d’affichage. Vous pouvez éventuellement ajouter une description à l’opération.

Sélectionnez la catégorie de l’opération pour déterminer les types d’événements RUM compatibles avec les conditions de début, de succès et d’échec.

Étape 2 : Définissez l’événement de début

Chaque opération doit avoir un événement RUM de début. Les opérations peuvent commencer par un événement d’action ou de vue, selon la catégorie d’opération sélectionnée.

Étape 3 : Définissez les conditions de succès

Chaque opération doit avoir une condition pour se terminer par un succès. Les opérations peuvent se terminer par un succès avec un événement de ressource, de vue ou d’action personnalisée, selon la catégorie d’opération sélectionnée.

Étape 4 : Définissez les conditions d’échec

Chaque opération doit avoir une condition de fin en cas d’échec : Les échecs - Erreur peuvent se terminer en tant que ressource, erreur ou action personnalisée. Les échecs - Abandon peuvent être activés dans le cas où l’utilisateur quitte la vue initiale avant que l’opération ne se termine.

Créer des opérations avec la Datadog API

Les opérations peuvent également être créées via la Datadog API.

Modifier des opérations

Dans le catalogue des opérations, cliquez sur l’icône en forme de crayon pour modifier une opération. Vous pouvez modifier la description de n’importe quelle opération, quelle que soit la manière dont elle a été créée. Les opérations créées via l’interface utilisateur ou l’API peuvent être entièrement modifiées (pas seulement la description).

Surveillez votre disponibilité sur Datadog

Après avoir créé des opérations avec les API du SDK RUM, directement dans Datadog ou avec la Datadog API, surveillez-les en accédant à RUM > Performance Monitoring > Operations.

Datadog regroupe toutes les opérations portant le même nom dans un catalogue.

Chaque opération dispose de deux métriques prêtes à l’emploi calculées sur l’ensemble de votre trafic ingéré et non échantillonné:

• rum.measure.operation, qui compte le volume d’opérations signalées à Datadog
• rum.measure.operation.duration, qui mesure le temps écoulé entre le début et la fin de toutes les opérations signalées à Datadog

Les deux métriques sont conservées pendant 15 mois et incluent plusieurs dimensions:

• operation.name, qui est définie côté client
• operation.status, qui est soit un succès, soit un échec
• operation.failure_reason, qui peut être une erreur, un abandon ou autre

Ces métriques sont incluses dans le prix de RUM Measure et sont disponibles pour tous les clients RUM without Limits qui définissent une ou plusieurs opérations.

Recherchez les causes profondes avec l’IA

Vous pouvez lancer une investigation par l’agent sur une seule opération directement depuis la page Opérations. L’agent analyse à la fois le taux de réussite et la latence de l’opération et met en évidence des investigations ciblées pour chaque mode de défaillance (erreurs, délais d’attente, abandons) et pour les régressions de latence. Pour plus d’informations, consultez Operation AI Investigation.

Configurez les filtres de rétention

Les opérations sont un nouveau type d’événement dans RUM. Les opérations sont liées à une session RUM, mais peuvent représenter plusieurs vues RUM. Les opérations peuvent être ciblées dans les filtres de rétention. Cela vous permet d’aligner votre stratégie de rétention sur les parcours qui sont des piliers de vos expériences utilisateur. Par exemple, vous pouvez conserver par programmation les sessions RUM pour lesquelles des opérations spécifiques ont échoué ou prennent plus de temps que souhaité.

De même que pour les métriques, ces événements sont accompagnés d’attributs spécifiques que vous pouvez utiliser dans les filtres de rétention:

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

Pour aller plus loin

Documentation, liens et articles supplémentaires utiles:

En savoir plus sur RUMDOCUMENTATION Bonnes pratiques pour la configuration de la surveillance des opérationsGUIDE Bonnes pratiques pour la création de SLO pour les opérations RUMGUIDE