Ce guide suppose que vous avez configuré Database Monitoring et que vous utilisez la solution APM. En connectant la solution APM et DBM, vous permettez dʼinjecter des identifiants de traces de la solutions APM dans les données collectées par DBM, ce qui permet de corréler ces deux sources de données. Cela permet aux caractéristiques du produit d’afficher les informations relatives à la base de données dans le produit APM et les données de la solution APM dans le produit DBM.

Avant de commencer

Bases de données prises en charge

Postgres, MySQL, SQL Server, Oracle, MongoDB

Versions de l’Agent prises en charge

7.46 et versions ultérieures

Confidentialité des données

l’activation de la propagation des commentaires SQL entraîne le stockage de données potentiellement confidentielles (noms des services) dans les bases de données ; ces données sont alors accessibles aux tierces parties ayant accès à la base de données.

Les intégrations du traceur de lʼAPM fonctionnent avec un mode de propagation, qui permet de contrôler la quantité de données que les applications transmettent à la base de données.

• Le mode full envoie des informations complètes sur les traces à la base de données, ce qui vous permet d’enquêter sur chaque trace dans DBM. C’est la solution conseillée pour la plupart des intégrations.
• Le mode service envoie le nom du service, ce qui vous permet de déterminer quels services contribuent à la charge de la base de données.
• Le mode disabled désactive la propagation et n’envoie aucune information provenant des applications.

\Le mode de propagation complet nécessite la version 3 d’Aurora MySQL.

** Le mode de propagation complet sur Oracle est uniquement pris en charge avec Java.

Traceurs et pilotes d’applications pris en charge

* CommandType.StoredProcedure nʼest pas pris en charge

** Mode complet SQL Server pour Java/.NET :

• L’instrumentation exécute une commande SET context_info lorsque le client émet une requête, ce qui génère un aller-retour supplémentaire vers la base de données.
• Prérequis :
  • Agent version 7.55.0 ou ultérieure
  • Java tracer version 1.39.0 ou ultérieure
  • .NET tracer version 3.3 ou ultérieure

*** Mode complet Oracle pour Java :

• L’instrumentation écrase V$SESSION.ACTION.
• Prérequis : Java tracer 1.45 ou ultérieur

**** Mode service/complet MongoDB pour Node.js :

• Prérequis :
  • Node.js tracer 5.80.0 ou ultérieur

***** Mode service/complet MongoDB pour Python :

• Prérequis :
  • Python tracer 3.5.0 ou ultérieur

****** Mode service/complet MongoDB pour Java :

• Prérequis :
  • Java tracer 1.58.0 ou ultérieur
  • mongo-java-driver v3.8 ou ultérieur

Configuration

Afin de profiter de la meilleure expérience possible, assurez-vous que les variables dʼenvironnement suivantes sont définies dans votre application :

DD_SERVICE=(application name)
DD_ENV=(application environment)
DD_VERSION=(application version)

Datadog recommande de définir le mode d’obfuscation sur obfuscate_and_normalize pour les versions 7.63 et ultérieures de l’Agent. Ajoutez le paramètre suivant dans la section apm_config de votre fichier de configuration de l’Agent APM :

  sql_obfuscation_mode: "obfuscate_and_normalize"

go get github.com/DataDog/dd-trace-go/v2 # 2.x

import (
   "database/sql"
   "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"
   sqltrace "github.com/DataDog/dd-trace-go/contrib/database/sql/v2"
)

import (
    "database/sql"
    "github.com/DataDog/dd-trace-go/v2/ddtrace/tracer"
   sqltrace "github.com/DataDog/dd-trace-go/contrib/database/sql/v2"
)

func main() {
    // The first step is to set the dbm propagation mode when registering the driver. Note that this can also
    // be done on sqltrace.Open for more granular control over the feature.
    sqltrace.Register("postgres", &pq.Driver{}, sqltrace.WithDBMPropagation(tracer.DBMPropagationModeFull))

    // Followed by a call to Open.
    db, err := sqltrace.Open("postgres", "postgres://pqgotest:password@localhost/pqgotest?sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }

    // Then, we continue using the database/sql package as we normally would, with tracing.
    rows, err := db.Query("SELECT name FROM users WHERE age=?", 27)
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()
}

# Démarrer l'Agent Java avec les propriétés système requises
java -javaagent:/path/to/dd-java-agent.jar -Ddd.dbm.propagation.mode=full -Ddd.integration.jdbc-datasource.enabled=true -Ddd.service=my-app -Ddd.env=staging -Ddd.version=1.0 -jar path/to/your/app.jar

public class Application {
    public static void main(String[] args) {
        try {
            Connection connection = DriverManager
                    .getConnection("jdbc:postgresql://127.0.0.1/foobar?preferQueryMode=simple", "user", "password");
            Statement stmt = connection.createStatement();
            String sql = "SELECT * FROM foo";
            stmt.execute(sql);
            stmt.close();
            connection.close();
        } catch (SQLException exception) {
            //  exception logic
        }
    }
}

source 'https://rubygems.org'
gem 'datadog' # Utilisez `'ddtrace', '>= 1.8.0'` avec les versions v1.x

# Selon votre utilisation
gem 'mysql2'
gem 'pg'

require 'mysql2'
require 'ddtrace'

Datadog.configure do |c|
    c.service = 'billing-api'
    c.env = 'production'
    c.version = '1.3-alpha'

    c.tracing.instrument :mysql2, comment_propagation: ENV['DD_DBM_PROPAGATION_MODE']
end

client = Mysql2::Client.new(:host => "localhost", :username => "root")
client.query("SELECT 1;")

pip install "ddtrace>=1.9.0"

pip install psycopg2

pip install pymongo

import psycopg2

POSTGRES_CONFIG = {
    "host": "127.0.0.1",
    "port": 5432,
    "user": "postgres_user",
    "password": "postgres_password",
    "dbname": "postgres_db_name",
}

# connect to postgres db
conn = psycopg2.connect(**POSTGRES_CONFIG)
cursor = conn.cursor()
# execute sql queries
cursor.execute("select 'blah'")
cursor.executemany("select %s", (("foo",), ("bar",)))

from pymongo import MongoClient

# Connect to MongoDB
client = MongoClient('mongodb://localhost:27017/')
db = client['test_database']
collection = db['test_collection']

# Insert a document
collection.insert_one({"name": "test", "value": 1})

# Query documents
results = collection.find({"name": "test"})
for doc in results:
    print(doc)

npm install dd-trace@^3.17.0

// Cette ligne doit précéder l'importation des modules instrumentés.
const tracer = require('dd-trace').init();

const pg = require('pg')
const tracer = require('dd-trace').init({ dbmPropagationMode: 'full' })

const client = new pg.Client({
    user: 'postgres',
    password: 'postgres',
    database: 'postgres'
})

client.connect(err => {
    console.error(err);
    process.exit(1);
});

client.query('SELECT $1::text as message', ['Hello world!'], (err, result) => {
    // traitement du résultat
})

Explorer la connexion APM dans Database Monitoring

Attribuer les connexions de base de données actives aux services APM les appelant

Visualisez les différentes connexions actives pour un host donné avec un filtre basé sur les services APM en amont envoyant les requêtes. Vous pouvez attribuer une charge sur une base de données pour certains services précis, afin d’identifier les services les plus actifs sur votre base de données. Basculez sur la page Service du service en amont le plus actif pour poursuivre votre analyse.

Filtrer les hosts de base de données en fonction des services APM les appelant

Filtrez rapidement la liste des bases de données afin d’afficher uniquement les hosts de base de données dont dépendent vos services APM spécifiques. Identifiez facilement si l’une de vos dépendances en aval connaît un blocage susceptible de nuire aux performances du service.

Consulter la trace associée à un échantillon de requête

Si vous consultez un échantillon de requête dans Database Monitoring et que la trace associée a été échantillonnée par APM, vous pouvez afficher l’échantillon de requête DBM dans le contexte de la trace APM. Procéder de la sorte permet de combiner les données de télémétrie DBM (notamment le plan d’exécution ainsi que les performances historiques de la requête) et l’historique de la span au sein de votre infrastructure afin de déterminer si une modification apportée à la base données est à l’origine des mauvaises performances de l’application.

Explorer la connexion Database Monitoring dans APM

Visualisez les hosts de base de données en aval des services APM

Sur la page APM d’un service donné, consultez les dépendances directes aux bases de données en aval du service telles qu’identifiées par Database Monitoring, et déterminez si des hosts présentent une charge disproportionnée pouvant être causée par des voisins bruyants. Pour consulter les dépendances aux bases de données d’un service :

1. Sélectionnez le service dans le Software Catalog pour ouvrir un volet de détails.
2. Sélectionnez Service Page dans le volet.
3. Sur la page du service, sélectionnez la section Databases.
4. Dans la section Databases, sélectionnez l’onglet Databases.

Visualiser les durées des spans et consulter les détails des requêtes

Sélectionnez l’onglet Queries dans la section Databases de la page du service APM pour afficher les valeurs aberrantes de latence et la liste complète des requêtes de l’intervalle sélectionné. Sélectionnez une requête dans le tableau pour afficher le volet de requête et accéder aux diagnostics, aux détails des erreurs et aux informations de trace.

Identifier de potentielles optimisations à l’aide des plans d’exécution pour les requêtes de base de données dans les traces

Consultez les performances historiques de requêtes similaires à celles exécutées dans votre trace, notamment les événements d’attente échantillonnés, la latence moyenne et les plans d’exécution capturés récemment, afin d’apporter du contexte au comportement attendu d’une requête. Déterminez si le comportement est anormal et poursuivez l’examen en basculant sur Database Monitoring pour obtenir encore plus d’informations concernant les hosts de base de données sous-jacents.

Pour aller plus loin

Documentation, liens et articles supplémentaires utiles:

Mettez facilement en corrélation les données de télémétrie de DBM et d'APM afin d'analyser les performances des requêtes de bout en boutBLOG