Nouvelles annonces sur les technologies sans serveur et réseau ainsi que sur le RUM (Real-User Monitoring) dévoilées à la conférence Dash ! Nouvelles annonces dévoilées à la conférence Dash !

Ajouter des tags de span

Ajoutez des tags sous la forme de paires clé/valeur à une span pour corréler les traces avec d’autres produits Datadog et ainsi obtenir plus de détails sur des spans spécifiques. Les tags peuvent être ajoutés à une seule span ou à l’ensemble des spans.

Remarque : les métadonnées de tracing sont ajoutées via des tags, mais les tags ont déjà une signification spécifique dans Datadog.

Ajouter des tags à une span

L’IU Datadog utilise des tags pour définir des métadonnées au niveau des spans. La liste complète de ces tags est disponible dans les API de Datadog et OpenTracing.

Vous pouvez définir 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.Tracer;
import io.opentracing.util.GlobalTracer;

import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet
class ServletImpl extends AbstractHttpServlet {
  @Override
  void doGet(HttpServletRequest req, HttpServletResponse resp) {
    final Span span = GlobalTracer.get().activeSpan();
    if (span != null) {
      span.setTag("customer.id", 12345);
      span.setTag("http.url", "/login");
    }
    // servlet impl
  }
}

Ajoutez directement des tags à une span en appelant set_tag. Par exemple, avec le gestionnaire de routage suivant :

from ddtrace import tracer

@app.route('/customer/<int:id_client>')
def handle_customer(customer_id):
  with tracer.trace('web.request') as span:
    span.set_tag('customer.id', customer_id)

La span actuelle peut être récupérée à partir du contexte afin d’appliquer ses tags. Ainsi, si une span a été initiée par l’instrumentation, vous pouvez la récupérer et ajouter des tags personnalisés. Remarque : si une span n’existe pas, None est renvoyé :

from ddtrace import tracer

@app.route('/customer/<int:customer_id>')
@tracer.wrap()
def handle_customer(customer_id):
  # récupère la span active dans le contexte, placée ici par tracer.wrap()
  current_span = tracer.current_span()
  if current_span:
    current_span.set_tag('customer.id', customer_id)

Ajoutez directement des tags aux objets Datadog::Span en appelant #set_tag :

# Un exemple d'endpoint Sinatra,
# avec le tracing Datadog autour de la requête.
get '/posts' do
  Datadog.tracer.trace('web.request') do |span|
    span.set_tag('http.url', request.path)
  end
end

Accédez à la span actuellement active au sein de votre code à l’aide de la méthode de votre choix. Remarque : si la méthode est appelée et qu’aucune span n’est actuellement active, active_span est nil.

# exemple : ajouter un tag à une span active

current_span = Datadog.tracer.active_span
current_span.set_tag('<CLÉ_TAG>', '<VALEUR_TAG>') unless current_span.nil?

Ajoutez directement des tags à une interface Span en appelant SetTag :

package main

import (
    "log"
    "net/http"

    "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
)

func handler(w http.ResponseWriter, r *http.Request) {
    // Créer une span pour une requête Web au niveau de l'URL /posts.
    span := tracer.StartSpan("web.request", tracer.ResourceName("/posts"))
    defer span.Finish()

    // Définir le tag
    span.SetTag("http.url", r.URL.Path)
}

func main() {
    tracer.Start(tracer.WithServiceName("<NOM_SERVICE>"))
    defer tracer.Stop()
    http.HandleFunc("/posts", handler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Les intégrations de Datadog utilisent le type Context pour propager la span active. Si vous souhaitez ajouter des tags à une span associée à un Context, appelez la fonction SpanFromContext :

package main

import (
    "net/http"

    "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
)

func handler(w http.ResponseWriter, r *http.Request) {
    // Récupérer une span pour une requête Web associée à un contexte Go.
    if span, ok := tracer.SpanFromContext(r.Context()); ok {
        // Définir un tag
        span.SetTag("http.url", r.URL.Path)
    }
}

Ajoutez directement des tags aux objets span en appelant setTag ou addTags :

// Un exemple d'endpoint Express,
// avec un tracing Datadog autour de la requête.
app.get('/posts', (req, res) => {
  const span = tracer.startSpan('web.request')

  span.setTag('http.url', req.url)
  span.addTags({
    'http.method': req.method
  })
})

Accédez à la span actuellement active au sein de votre code à l’aide de la méthode de votre choix. Attention : si la méthode est appelée et qu’aucune span n’est actuellement active, tracer.scope().active() renvoie null.

// exemple d'ajout de tag à une span active

const span = tracer.scope().active()

span.setTag('<CLÉ_TAG>', '<VALEUR_TAG>')

Ajoutez directement des tags à un objet Datadog.Trace.Span en appelant Span.SetTag(). Par exemple :

using Datadog.Trace;

// accéder au contexte actif par l'intermédiaire du traceur global (peut renvoyer null)
var scope = Tracer.Instance.ActiveScope;

// ajouter un tag à la span
scope.Span.SetTag("<CLÉ_TAG>", "<VALEUR_TAG>");

Remarque : Datadog.Trace.Tracer.Instance.ActiveScope renvoienull si aucune span n’est active.

Ajoutez directement des tags à un objet DDTrace\Span en appelant Span::setTag(). Par exemple :

// Récupérer la span actuellement active (peut être null)
$span = \DDTrace\GlobalTracer::get()->getActiveSpan();
if (null !== $span) {
  // Ajouter un tag à la span
  $span->setTag('<CLÉ_TAG>', '<VALEUR_TAG>');
}

Remarque : Tracer::getActiveSpan() renvoie null si aucune span n’est active.

Ajouter des tags à l’ensemble des spans

Ajoutez des tags à l’ensemble des spans en configurant le traceur à l’aide de la propriété système dd.trace.global.tags :

java -javaagent:<CHEMIN-AGENT-JAVA-DD>.jar \
     -dd.trace.global.tags='env:dev,<CLÉ_TAG>:<VALEUR_TAG>' \
     -jar <CHEMIN_VOTRE_APPLICATION>.jar

Ajoutez des tags à l’ensemble des [spans] en configurant le traceur à l’aide de la méthode tracer.set_tags :

from ddtrace import tracer

tracer.set_tags({ 'env': 'dev' })

Ajoutez des tags à l’ensemble des spans en configurant l’option tags du traceur :

Datadog.configure do |c|
  c.tracer tags: { 'env' => 'dev' }
end

Consultez la documentation relative à l’API pour en savoir plus.

Ajoutez des tags à l’ensemble des spans en configurant l’option tags du traceur :

package main

import "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"

func main() {
    tracer.Start(
        tracer.WithGlobalTag("datacenter", "us-1"),
        tracer.WithGlobalTag("env", "dev"),
    )
    defer tracer.Stop()
}

Ajoutez des tags à l’ensemble des spans en configurant le paramètre tags du traceur :

const tracer = require('dd-trace').init({
  tags: {
    env: 'dev',
    '<CLÉ_TAG>': '<VALEUR_TAG>'
  }
})

Prochainement disponible. Contactez l’assistance Datadog pour en savoir plus.

Utilisez la variable d’environnement DD_TRACE_GLOBAL_TAGS pour ajouter des tags à l’ensemble des spans générées. Consultez la section Configuration PHP pour découvrir comment définir des variables d’environnements.

DD_TRACE_GLOBAL_TAGS=key1:value1,key2:value2

Ajoutez directement des tags à un objet span en appelant Span::SetTag. Par exemple :

auto tracer = ...
auto span = tracer->StartSpan("nom_opération");
span->SetTag("la clé doit être une chaîne de caractères", "Les valeurs sont des types de variables");
span->SetTag("la clé doit être une chaîne de caractères", 1234);

Les valeurs correspondent au type de variable et peuvent être des objets complexes. Les valeurs sont sérialisées en tant que JSON, à l’exception d’une valeur de chaîne de caractères qui est sérialisée telle quelle (sans guillemets supplémentaires).

Pour aller plus loin