Ajouter des tags de span et filtrer ou regrouper les données de performance de votre application
Temps de lecture : 7 minutes
L’APM Datadog vous permet de personnaliser vos traces pour inclure toute information supplémentaire dont vous pourriez avoir besoin pour optimiser votre visibilité sur votre entreprise. Vous pouvez l’utiliser pour détecter un pic de débit chez un certain client, pour identifier l’utilisateur affichant la latence la plus élevée ou pour localiser le fragment de base de données générant le plus d’erreurs.
Dans cet exemple, un ID client est ajouté aux traces afin d’identifier les clients qui connaissent les plus mauvaises performances. La personnalisation des traces se fait à l’aide de tags qui viennent s’ajouter aux spans sous la forme de paires de métadonnées key:value
. Ils permettent ainsi à l’APM de rester parfaitement intégrée aux autres outils Datadog.
- Suivez cet exemple pour instrumenter votre code.
La méthode à employer pour ajouter des tags à vos spans dépend du langage de programmation utilisé.
Remarque : prenez note du nom du service et du nom de la ressource sur lesquels vous travaillez : ils vous seront utiles plus tard. Dans cet exemple, le serveur Ruby web-store
correspond au service et ShoppingCartController#checkout
correspond à la ressource (l’endpoint).
L’interface utilisateur de Datadog utilise les tags pour définir des métadonnées au niveau des spans. Vous pouvez configurer une instrumentation automatique pour les tags personnalisés en récupérant la span active à partir du traceur global et en définissant un tag avec setTag
.
import io.opentracing.Span;
import io.opentracing.util.GlobalTracer;
@WebServlet
class ShoppingCartServlet extends AbstractHttpServlet {
@Override
void doGet(HttpServletRequest req, HttpServletResponse resp) {
// Récupérer la span active
final Span span = GlobalTracer.get().activeSpan();
if (span != null) {
// customer_id -> 254889
span.setTag("customer.id", customer_id);
}
// [...]
}
}
L’interface utilisateur de Datadog utilise les tags pour définir des métadonnées au niveau des spans. Vous pouvez configurer une instrumentation automatique pour les tags personnalisés en récupérant la span active à partir du traceur global et en définissant un tag avec setTag
.
from ddtrace import tracer
@app.route('/shopping_cart/<int:customer_id>')
@login_required
def shopping_cart(customer_id):
# Get the active span
current_span = tracer.current_span()
if current_span:
# customer_id -> 254889
current_span.set_tag('customer.id', customer_id)
# [...]
L’interface utilisateur de Datadog utilise les tags pour définir des métadonnées au niveau des spans. Vous pouvez configurer une instrumentation automatique pour les tags personnalisés en récupérant la span active à partir du traceur global et en définissant un tag avec setTag
.
require 'ddtrace'
# get '/shopping_cart/:customer_id', to: 'shopping_cart#index'
class ShoppingCartController < ApplicationController
# GET /shopping_cart
def index
# Récupérer la span active et définir customer_id -> 254889
Datadog::Tracing.active_span&.set_tag('customer.id', params.permit([:customer_id]))
# [...]
end
# POST /shopping_cart
def create
# [...]
end
end
L’interface utilisateur de Datadog utilise les tags pour définir des métadonnées au niveau des spans. Vous pouvez configurer une instrumentation automatique pour les tags personnalisés en récupérant la span active à partir du traceur global et en définissant un tag avec setTag
.
package main
import (
muxtrace "gopkg.in/DataDog/dd-trace-go.v1/contrib/gorilla/mux"
"gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
)
func handler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
// Get the active span from a Go Context
if span, ok := tracer.SpanFromContext(r.Context()); ok {
// customer_id -> 254889
span.SetTag("customer.id", vars["customerID"])
}
// [...]
}
func main() {
tracer.Start(tracer.WithServiceName("web-store"))
defer tracer.Stop()
// Use auto-instrumentation
mux := muxtrace.NewRouter()
mux.HandleFunc("/shopping_cart/{customerID}", handler)
http.ListenAndServe(":8080", mux)
}
L’interface utilisateur de Datadog utilise les tags pour définir des métadonnées au niveau des spans. Vous pouvez configurer une instrumentation automatique pour les tags personnalisés en récupérant la span active à partir du traceur global et en définissant un tag avec setTag
.
app.get('/shopping_cart/:customer_id', (req, res) => {
// Get the active span
const span = tracer.scope().active()
if (span !== null) {
// customer_id -> 254889
span.setTag('customer.id', req.params.customer_id)
}
// [...]
})
Ajoutez directement des tags à un objet Datadog.Trace.Span
en appelant Span.SetTag()
. Par exemple :
public class ShoppingCartController : Controller
{
private IShoppingCartRepository _shoppingCartRepository;
[HttpGet]
public IActionResult Index(int customerId)
{
// Access the active scope through the global tracer (can return null)
var scope = Tracer.Instance.ActiveScope;
if (scope != null)
{
// Add a tag to the span for use in the datadog web UI
scope.Span.SetTag("customer.id", customerId.ToString());
}
var cart = _shoppingCartRepository.Get(customerId);
return View(cart);
}
}
Remarque : Datadog.Trace.Tracer.Instance.ActiveScope
renvoienull
si aucune span n’est active.
L’interface utilisateur de Datadog utilise les tags pour définir des métadonnées au niveau des spans. Vous pouvez configurer une instrumentation automatique pour les tags personnalisés en récupérant la span active à partir du traceur global et en définissant un tag dans le tableau meta
.
<?php
namespace App\Http\Controllers;
class ShoppingCartController extends Controller
{
public shoppingCartAction (Request $request) {
// Récupérer la span active
$span = \DDTrace\active_span();
if (null !== $span) {
// customer_id -> 254889
$span->meta['customer_id'] = $request->get('customer_id');
}
// [...]
}
}
?>
Une fois votre nouveau code déployé, quelques minutes peuvent être nécessaires pour que les nouveaux tags s'affichent dans l'interface utilisateur de Datadog.
- Accédez à la page Services et cliquez sur le service auquel vous avez ajouté des tags. Faites défiler la page et cliquez sur la ressource spécifique à laquelle le tag a été ajouté dans le tableau des ressources. Faites défiler la page jusqu’au tableau des traces.
Le tableau des traces affiche la distribution de la latence globale pour l’ensemble des traces incluses dans le contexte actuel (service, ressource et intervalle) ainsi que les liens vers les traces individuelles. Vous pouvez trier ce tableau par durée ou par code d’erreur pour identifier les opérations ayant généré une erreur ou encore des possibilités d’optimisation.
- Cliquez sur l’une de vos traces.
L’écran qui apparaît affiche un flamegraph en haut et des fenêtres d’informations supplémentaires en dessous. Le flamegraph Datadog vous permet de visualiser instantanément la durée et le statut de chaque unité logique (span) ayant une incidence sur une requête. Le flamegraph est entièrement interactif : vous pouvez vous déplacer sur celui-ci (en le faisant glisser) ou zoomer et dézoomer (avec la molette de défilement). Cliquez sur une span pour afficher davantage d’informations sur cette dernière en bas de l’écran.
La partie inférieure de cette vue comprend des informations supplémentaires sur la trace ou toute span sélectionnée. De là, vous pouvez voir l’ensemble des tags par défaut ainsi que ceux qui ont été inclus manuellement. Vous avez également la possibilité de basculer entre les vues pour afficher les informations sur le host et les logs associés.
- Accédez à la page Trace Explorer.
La page Trace Search vous permet d’identifier les traces et les spans indexées spécifiques qui vous intéressent. Depuis cette vue, vous pouvez filtrer un ensemble de tags par défaut (tels que Env
, Service
, Resource
et bien d’autres) en appliquant un intervalle.
Trouvez une trace qui possède le nouveau tag. Pour ce faire, utilisez le Facet Explorer sur la gauche. Recherchez le nom de la ressource que vous avez définie au début de ce guide, puis cliquez sur l’une des lignes que vous voyez à cet endroit.
Trouvez le nouveau tag que vous avez ajouté à la trace. Cliquez dessus et sélectionnez Create facet pour @[nom de votre facette]
(dans notre exemple, il s’agit de customer_id)
Vous pouvez désormais spécifier le nom d’affichage de votre facette ainsi que son emplacement dans le Facet Explorer.
La facette que vous avez créée devrait maintenant apparaître dans le Facet Explorer. Utilisez la case Search facets
pour la retrouver facilement.
- Accédez à la page Analytics.
La page Analytics propose un outil visuel de création de requêtes qui vous permet d’inspecter vos traces sans aucune limite de cardinalité. Cet outil s’appuie sur les facettes pour filtrer et définir le contexte de la requête. Pour en savoir plus, consultez la présentation du Trace Explorer.
- Choisissez le service sur lequel vous avez travaillé dans la liste des facettes de service, sélectionnez Error dans la liste des statuts, puis sélectionnez
customer_id
(ou tout autre tag que vous avez ajouté à vos spans) dans le champ group by.
- Désélectionnez l’option Error de la requête, faites passer la mesure de
count *
à Duration
, puis définissez le type de graphique sur Top List
.
La liste des clients associés aux requêtes moyennes les plus lentes s’affiche alors. Remarque : si vous souhaitez vous assurer que vos clients ne dépassent jamais un certain seuil de performance, vous pouvez exporter cette requête vers un monitor. Il est également possible d’enregistrer cette visualisation dans un dashboard afin de surveiller son évolution.
Enfin, vous pouvez également afficher l’ensemble des traces associées à votre requête en cliquant sur la visualisation et en sélectionnant View traces
.
Pour aller plus loin
Documentation, liens et articles supplémentaires utiles: