createTracer (API SPA)

Syntaxe

newrelic.interaction().createTracer(string $name[, function $callback])

Chronomètre les sous-composants d'une interaction SPA séparément, y compris le temps d'attente et le temps d'exécution JS.

Exigences

• Agent navigateur Pro ou Pro+SPA (v963 ou supérieur)

• Si vous utilisez npm pour installer l'agent du navigateur, vous devez activer la fonctionnalité spa lors de l'instanciation de la classe BrowserAgent . Dans l'éventail features , ajoutez ce qui suit :

  import { Spa } from '@newrelic/browser-agent/features/spa';
  
  const options = {
    info: { ... },
    loader_config: { ... },
    init: { ... },
    features: [
      Spa
    ]
  }

  Copier

  Pour plus d'informations, consultez la documentation d'installation du navigateur npm.

Description

Cette méthode fournit un moyen de chronométrer les sous-composants d'une interaction SPA séparément dans le navigateur. Chaque sous-composant mesurera :

• Temps d'attente jusqu'à ce que le rappel soit exécuté
• Temps d'exécution JS du rappel une fois qu'il est invoqué

Cette méthode peut également être utilisée pour combler le fossé asynchrone créé par les méthodes asynchrones non instrumentées.

Si l'interaction actuelle est enregistrée, New Relic créera un événementBrowserTiming .

La méthode createTracer() renvoie une méthode de rappel encapsulée, que vous devez appeler à partir de votre code. Le rappel encapsulé renvoyé fera trois choses lorsqu'il sera invoqué :

1. Enregistre la fin de la partie asynchrone du traceur personnalisé.
2. Exécute le rappel d'origine passé à createTracer() avec les mêmes arguments et le même contexte.
3. Chronomètre l'exécution du rappel d'origine.

Un BrowserInteraction qui exécute createTracer() créera un événementBrowserTiming . Tout nouveau XHR ou trace personnalisée créé pendant le rappel sera inclus dans le cadre de l'interaction.

Une interaction ne sera pas considérée comme terminée tant que tous ses traceurs ne seront pas terminés. C'est ce qui permet à traceur d'encapsuler des fonctions asynchrones que l'agent du navigateur ne gère pas par défaut.

Paramètres

Valeurs de retour

Renvoie une méthode qui encapsule le rappel d'origine. Lorsque cette méthode est invoquée, elle appelle le rappel d'origine et met fin à la temporisation asynchrone.

Exemples

Créer un traceur

Si vous souhaitez simplement mesurer la durée d'un appel de fonction JavaScript particulier, vous pouvez transmettre la fonction à createTracer() en tant que rappel. Cela invoque immédiatement le rappel du wrapper renvoyé :

newrelic
  .interaction()
  .createTracer('customSegment', function myCallback () {
    // ... do your work ...
  })();

Dans ce scénario, le traceur personnalisé résultant aura une durée d'attente asynchrone négligeable, ainsi qu'une durée synchrone égale au temps d'exécution de myCallback().

tracer une API asynchrone non instrumentée

Par défaut, l'agent du navigateur encapsule la plupart des fonctions asynchrones les plus courantes (telles que setTimeout()). Cependant, certaines fonctions ne sont pas gérées automatiquement (par exemple, requestAnimationFrame()). De plus, certains cas se produisent où la causalité ne peut pas être facilement déterminée (par exemple, une implémentation RPC personnalisée sur des websockets). Pour ces cas, vous pouvez utiliser createTracer() pour vous assurer que le rappel vers ces fonctions non instrumentées est considéré comme faisant partie de l'interaction.

L'utilisation de createTracer() n'est pas nécessaire pour tout système de planification asynchrone basé sur des API asynchrones encapsulées de manière native par l'agent du navigateur, telles que setTimeout(), setImmediate(), Promise(), fetch() et XMLHttpRequest(). Les limites asynchrones créées par ces API seront automatiquement comblées par l'agent du navigateur.

Dans l'exemple de code ci-dessous, vous avez une fonction, doAsyncWork(), qui accepte un rappel et l'exécute de manière asynchrone à un moment donné dans le futur. Vous souhaitez mesurer à la fois le temps entre le moment où vous invoquez doAsyncWork() et le moment où le rappel commence à s'exécuter (le temps d'attente asynchrone), ainsi que le temps nécessaire à l'exécution du rappel (le temps de rappel synchrone).

var wrappedCallback = newrelic
  .interaction()
  .createTracer('customSegment', doTheWork);

doAsyncWork(wrappedCallback);

function doTheWork() {
  // ... do your work ...
}

Voici une chronologie de l'événement pour le chronométrage du traceur :