Remarque : CommandType.StoredProcedure n’est pas pris en charge pour le pilote .NET.

Remarque : CommandType.StoredProcedure n’est pas pris en charge pour les pilotes .NET.

Remarque : Le mode de propagation complet sur Aurora MySQL nécessite la version 3.

Remarque : CommandType.StoredProcedure n’est pas pris en charge pour les pilotes .NET.

Pour le mode full avec Java et .NET :

• L’instrumentation exécute une commande SET context_info lorsque le client émet une requête, ce qui entraîne un aller-retour supplémentaire vers la base de données.
• Prérequis :
  • Version de l’agent 7.55.0 ou supérieure
  • Version du traceur Java 1.39.0 ou supérieure
  • Version du traceur .NET 3.3 ou supérieure

Pour le mode full avec Java :

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

Mettez à jour vos dépendances d’application pour inclure dd-trace-go v2. Note: This documentation uses v2 of the Go tracer, which Datadog recommends for all users. If you are using v1, see the migration guide to upgrade to v2.

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

Mettez à jour votre code pour importer le package contrib/database/sql :

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

Activez la fonctionnalité de propagation de Database Monitoring via l’une des méthodes suivantes :

• Variable d’environnement : DD_DBM_PROPAGATION_MODE=full

• Utilisation du code lors de l’enregistrement du conducteur :

  sqltrace.Register("postgres", &pq.Driver{}, sqltrace.WithDBMPropagation(tracer.DBMPropagationModeFull), sqltrace.WithService("my-db-service"))
  

• Utilisation du code sur sqltrace.Open :

  sqltrace.Register("postgres", &pq.Driver{}, sqltrace.WithService("my-db-service"))
  
  db, err := sqltrace.Open("postgres", "postgres://pqgotest:password@localhost/pqgotest?sslmode=disable", sqltrace.WithDBMPropagation(tracer.DBMPropagationModeFull))
  if err != nil {
      log.Fatal(err)
  }
  

Exemple complet :

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()
}

Suivez les instructions d’instrumentation de Java tracing et installez la version 1.11.0 ou supérieure de l’Agent.

Vous devez également activer jdbc-datasource l’instrumentation.

Activez la fonctionnalité de propagation de la surveillance de la base de données en utilisant une des méthodes suivantes :

• Définissez la propriété système dd.dbm.propagation.mode=full
• Définissez la variable d’environnement DD_DBM_PROPAGATION_MODE=full

Exemple complet :

# Start the Java Agent with the required system properties
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

Testez la fonctionnalité dans votre application :

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
        }
    }
}

Versions du traceur 1.44 et supérieures : Activez le traçage des instructions préparées pour Postgres en utilisant une des méthodes suivantes :

• Définissez la propriété système dd.dbm.trace_prepared_statements=true
• Définissez la variable d’environnement export DD_DBM_TRACE_PREPARED_STATEMENTS=true

Remarque : L’instrumentation des instructions préparées écrase la propriété Application avec le texte _DD_overwritten_by_tracer, et entraîne un aller-retour supplémentaire vers la base de données. Ce voyage supplémentaire a un impact minimal sur le temps d’exécution des instructions SQL.

Versions du traceur inférieures à 1.44 : Les instructions préparées ne sont pas prises en charge en mode full pour Postgres et MySQL, et tous les appels d’API JDBC qui utilisent des instructions préparées sont automatiquement rétrogradés en mode service. Étant donné que la plupart des bibliothèques SQL Java utilisent des instructions préparées par défaut, cela signifie que la plupart des applications Java ne peuvent utiliser que le mode service.

Dans votre Gemfile, installez ou mettez à jour dd-trace-rb vers la version 1.8.0 ou supérieure :

source 'https://rubygems.org'
gem 'datadog' # Use `'ddtrace', '>= 1.8.0'` if you're using v1.x

# Depends on your usage
gem 'mysql2'
gem 'pg'

Activez la fonctionnalité de propagation de Database Monitoring via l’une des méthodes suivantes :

1. Variable d’environnement : DD_DBM_PROPAGATION_MODE=full

2. Option comment_propagation (par défaut : ENV['DD_DBM_PROPAGATION_MODE']), pour mysql2 ou pg :

    Datadog.configure do |c|
    	c.tracing.instrument :mysql2, comment_propagation: 'full'
    	c.tracing.instrument :pg, comment_propagation: 'full'
    end
   

Exemple complet :

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;")

Mettez à jour les dépendances de vos applications afin d’inclure dd-trace-py>=1.9.0 :

pip install "ddtrace>=1.9.0"

Pour Postgres, installez psycopg2 :

pip install psycopg2

Pour MongoDB, installez pymongo :

pip install pymongo

Remarque : Le support de MongoDB nécessite dd-trace-py >= 3.5.0. Si vous devez mettre à niveau : pip install "ddtrace>=3.5.0".

Activez la fonctionnalité de propagation de Database Monitoring en définissant la variables d’environnement suivante :

• DD_DBM_PROPAGATION_MODE=full

Exemple Postgres :

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",)))

Exemple MongoDB :

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)

Suivez les instructions de tracing .NET Framework ou les instructions de tracing .NET Core pour installer le package de l’instrumentation automatique et activer le tracing pour votre service.

Assurez-vous d’utiliser une bibliothèque cliente prise en charge. Par exemple, Npgsql.

Activez la fonctionnalité de propagation de Database Monitoring en définissant la variables d’environnement suivante :

• Pour Postgres et MySQL : DD_DBM_PROPAGATION_MODE=full
• Pour SQL Server : DD_DBM_PROPAGATION_MODE=service ou DD_DBM_PROPAGATION_MODE=full avec des traceurs Java et .NET
• Pour Oracle : DD_DBM_PROPAGATION_MODE=service

Suivez les instructions de tracing PHP pour installer le package de l’instrumentation automatique et activer le tracing pour votre service.

Assurez-vous d’utiliser une bibliothèque cliente prise en charge. Par exemple, PDO.

Activez la fonctionnalité de propagation de Database Monitoring en définissant la variables d’environnement suivante :

• DD_DBM_PROPAGATION_MODE=full

Installez ou mettez à jour dd-trace-js vers une version supérieure à 3.17.0 (ou 2.30.0 si vous utilisez la version 12 de Node.js en fin de vie) :

npm install dd-trace@^3.17.0

Mettez à jour votre code pour importer et initialiser le traceur :

// This line must come before importing any instrumented module.
const tracer = require('dd-trace').init();

Activez la fonctionnalité de propagation de Database Monitoring via l’une des méthodes suivantes :

• Définissez la variable d’environnement suivante :

  DD_DBM_PROPAGATION_MODE=full
  

• Définissez le SDK pour utiliser l’option dbmPropagationMode (par défaut : ENV['DD_DBM_PROPAGATION_MODE']) :

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

• Activez uniquement au niveau de l’intégration :

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

Exemple complet :

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) => {
	// handle result
})