Nota: CommandType.StoredProcedure no es compatible con el controlador .NET.

Nota: CommandType.StoredProcedure no es compatible con los controladores .NET.

Nota: El modo de propagación completa en Aurora MySQL requiere la versión 3.

Nota: CommandType.StoredProcedure no es compatible con los controladores .NET.

Para full modo con Java y .NET:

• La instrumentación ejecuta un SET context_info comando cuando el cliente emite una consulta, lo que provoca una ronda adicional de comunicación con la base de datos.
• Requisitos previos:
  • Versión del agente 7.55.0 o superior
  • Versión del rastreador de Java 1.39.0 o superior
  • Versión del rastreador de .NET 3.3 o superior

Para full modo con Java:

• La instrumentación sobrescribe V$SESSION.ACTION.
• Requisito previo: rastreador de Java 1.45 o superior

Actualice las dependencias de su aplicación para incluir 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

Actualice su código para importar el paquete 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"
)

Habilite la función de propagación de monitoreo de base de datos utilizando uno de los siguientes métodos:

• Variable de entorno: DD_DBM_PROPAGATION_MODE=full

• Usando código durante el registro del controlador:

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

• Usando código en 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)
  }
  

Ejemplo completo:

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

Siga las instrucciones de instrumentación de Java tracing e instale la versión 1.11.0 o superior del Agente.

También debe habilitar la instrumentación jdbc-datasource instrumentation.

Habilite la función de propagación de DBM utilizando una de los siguientes métodos:

• Establezca la propiedad del sistema dd.dbm.propagation.mode=full
• Establezca la variable de entorno DD_DBM_PROPAGATION_MODE=full

Ejemplo completo:

# 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

Pruebe la función en su aplicación:

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

Las versiones del Tracer 1.44 y superiores: Habilite la traza de declaraciones preparadas para Postgres usando uno de los siguientes métodos:

• Establece la propiedad del sistema dd.dbm.trace_prepared_statements=true
• Establece la variable de entorno export DD_DBM_TRACE_PREPARED_STATEMENTS=true

Nota: La instrumentación de declaraciones preparadas sobrescribe la propiedad Application con el texto _DD_overwritten_by_tracer, y causa un viaje adicional a la base de datos. Este viaje adicional tiene un impacto mínimo en el tiempo de ejecución de las declaraciones SQL.

Las versiones del Tracer anteriores a 1.44: Las declaraciones preparadas no son compatibles en full modo para Postgres y MySQL, y todas las llamadas a la API JDBC que utilizan declaraciones preparadas se degradan automáticamente a service modo. Dado que la mayoría de las bibliotecas SQL de Java utilizan declaraciones preparadas por defecto, esto significa que la mayoría de las aplicaciones Java solo pueden usar service modo.

En tu Gemfile, instala o actualiza dd-trace-rb a la versión 1.8.0 o superior:

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'

Habilita la función de propagación de Database Monitoring utilizando uno de los siguientes métodos:

1. Variable de entorno: DD_DBM_PROPAGATION_MODE=full

2. Opción comment_propagation (predeterminado: ENV['DD_DBM_PROPAGATION_MODE']), para mysql2 o pg:

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

Ejemplo completo:

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

Actualiza las dependencias de tu aplicación para incluir dd-trace-py>=1.9.0:

pip install "ddtrace>=1.9.0"

Para Postgres, instala psycopg2:

pip install psycopg2

Para MongoDB, instala pymongo:

pip install pymongo

Nota: El soporte para MongoDB requiere dd-trace-py >= 3.5.0. Si necesitas actualizar: pip install "ddtrace>=3.5.0".

Habilita la función de propagación de Database Monitoring configurando la siguiente variable de entorno:

• DD_DBM_PROPAGATION_MODE=full

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

Ejemplo de 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)

Sigue las instrucciones de trazado de .NET Framework o las instrucciones de trazado de .NET Core para instalar el paquete de instrumentación automática y habilitar el trazado para tu servicio.

Asegúrate de que estás utilizando una biblioteca de cliente compatible. Por ejemplo, Npgsql.

Habilita la función de propagación de Database Monitoring configurando la siguiente variable de entorno:

• Para Postgres y MySQL: DD_DBM_PROPAGATION_MODE=full
• Para SQL Server: DD_DBM_PROPAGATION_MODE=service o DD_DBM_PROPAGATION_MODE=full con rastreadores de Java y .NET
• Para Oracle: DD_DBM_PROPAGATION_MODE=service

Siga las instrucciones de traza de PHP para instalar el paquete de instrumentación automática y habilitar la traza para su servicio.

Asegúrese de que está utilizando una biblioteca de cliente compatible. Por ejemplo, PDO.

Habilita la función de propagación de Database Monitoring configurando la siguiente variable de entorno:

• DD_DBM_PROPAGATION_MODE=full

Instale o actualice dd-trace-js a una versión superior a 3.17.0 (o 2.30.0 si utiliza la versión 12 de Node.js que ha llegado al final de su vida útil):

npm install dd-trace@^3.17.0

Actualiza tu código para importar e inicializar el tracer:

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

Habilita la función de propagación de Database Monitoring utilizando uno de los siguientes métodos:

• Establece la siguiente variable de entorno:

  DD_DBM_PROPAGATION_MODE=full
  

• Establece el SDK para usar la opción dbmPropagationMode (predeterminado: ENV['DD_DBM_PROPAGATION_MODE']):

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

• Habilita solo a nivel de integración:

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

Ejemplo completo:

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