Correlacionar Database Monitoring y trazas

En esta guía se considera que has configurado Database Monitoring y usas APM. La conexión de APM y DBM inyecta identificadores de traza (trace) de APM en la recopilación de datos de DBM, lo que permite la correlación de estas dos fuentes de datos. Esto permite que las funciones del producto muestren información sobre la base de datos en el producto de APM, y datos de APM en el producto de DBM.

Antes de empezar

Bases de datos compatibles
Postgres, MySQL, SQL Server, Oracle
Versiones compatibles del Agent
7.46 o posterior
Privacidad de los datos
Al habilitar la propagación de comentarios de SQL, se almacenan datos potencialmente confidenciales (nombres de servicios) en las bases de datos, a los que luego pueden acceder terceros a los que se les ha otorgado acceso a la base de datos.

Las integraciones del rastreador de APM admiten un Modo de propagación, que controla la cantidad de información que pasa de las aplicaciones a la base de datos.

  • El modo full envía información completa sobre la traza a la base de datos, lo que te permite investigar trazas individuales en DBM. Esta es la solución recomendada para la mayoría de las integraciones.
  • El modo service envía el nombre del servicio, lo que te permite conocer qué servicios contribuyen a la carga de la base de datos. Este es el único modo compatible con las aplicaciones de Oracle.
  • El modo disabled deshabilita la propagación y no envía información desde las aplicaciones.
DD_DBM_PROPAGATION_MODEPostgresMySQLSQL ServerOracle
full * **
service

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

** SQL Server solo es compatible con el modo completo con los rastreadores de Java y .NET.

Rastreadores y controladores de aplicaciones compatibles

LenguajeBiblioteca o marcoPostgresMySQLSQL ServerOracle
Go: dd-trace-go >= 1.44.0
base de datos/sqlsolo el modo servicesolo el modo service
sqlxsolo el modo servicesolo el modo service
Java dd-trace-java >= 1.11.0
jdbc **solo el modo service
Ruby: dd-trace-rb >= 1.8.0
pg
mysql2
Python: dd-trace-py >= 1.9.0
psycopg2
dd-trace-py >= 2.9.0
asyncpg
aiomysql
mysql-connector-python
mysqlclient
pymysql
.NET dd-trace-dotnet >= 2.35.0
Npgsql *
MySql.Data *
MySqlConnector *
System.Data.SqlClient * **
Microsoft.Data.SqlClient * **
PHP dd-trace-php >= 0.86.0
pdo
MySQLi
Node.js: dd-trace-js >= 3.17.0
postgres
mysql
mysql2

* CommandType.StoredProcedure no compatible

** Modo completo de SQL Server para Java/.NET:

  • La instrumentación ejecuta un comando SET context_info cuando el cliente emite una consulta, lo que realiza un recorrido completo adicional a la base de datos.
  • Si tus aplicaciones usan context_info para instrumentar la aplicación, el rastreador de APM lo sobrescribe.
  • Requisitos previos:
    • Versión 7.55.0 o posterior del Agent
    • Versión 1.39.0 o posterior del rastreador de Java
    • Versión del rastreador .NET 3.3 o posterior

Configuración

Para obtener la mejor experiencia de usuario, asegúrate de que las siguientes variables de entorno se hayan configurado en tu aplicación:

DD_SERVICE=(nombre de la aplicación)
DD_ENV=(entorno de la aplicación)
DD_VERSION=(versión de la aplicación)

Actualiza las dependencias de tu aplicación para incluir dd-trace-go@v1.44.0 o posterior:

go get gopkg.in/DataDog/dd-trace-go.v1@v1.44.0

Actualiza tu código para importar el paquete contrib/database/sql:

import (
   "database/sql"
   "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
   sqltrace "gopkg.in/DataDog/dd-trace-go.v1/contrib/database/sql"
)

Habilita la función de propagación de la monitorización de base de datos mediante uno de los siguientes métodos:

  1. Variable de entorno: DD_DBM_PROPAGATION_MODE=full

  2. Uso de código durante el registro del controlador:

    sqltrace.Register("postgres", &pq.Driver{}, sqltrace.WithDBMPropagation(tracer.DBMPropagationModeFull), sqltrace.WithServiceName("my-db-service"))
    
  3. Uso de código en sqltrace.Open:

    sqltrace.Register("postgres", &pq.Driver{}, sqltrace.WithServiceName("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"
    "gopkg.in/DataDog/dd-trace-go.v1/ddtrace/tracer"
    sqltrace "gopkg.in/DataDog/dd-trace-go.v1/contrib/database/sql"
)

func main() {
    // El primer paso es establecer el modo de propagación de dbm al registrar el controlador. Ten en cuenta que esto
    // también se puede hacer en sqltrace.Open para obtener un control más detallado sobre la función.
    sqltrace.Register("postgres", &pq.Driver{}, sqltrace.WithDBMPropagation(tracer.DBMPropagationModeFull))

    // Seguido de una llamada para abrir.
    db, err := sqltrace.Open("postgres", "postgres://pqgotest:password@localhost/pqgotest?sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }

    // Luego, continuamos usando el paquete de base de datos/sql como lo haríamos normalmente, con rastreo.
    rows, err := db.Query("SELECT name FROM users WHERE age=?", 27)
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()
}

Sigue las instrucciones de instrumentación del rastreo de Java e instala la versión 1.11.0, o una posterior, del Agent.

También debes habilitar la instrumentación jdbc-datasource.

Habilita la función de propagación de la monitorización de base de datos mediante uno de los siguientes métodos:

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

Ejemplo completo:

# Inicia el Java Agent con las propiedades del sistema requeridas
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

Realiza un test de la función en tu 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) {
            //  lógica de excepción
        }
    }
}

Nota: Las instrucciones preparadas no son compatibles con el modo full y todas las llamadas a la API de JDBC que usan instrucciones preparadas se degradan de manera automática al modo service. Debido a que la mayoría de las bibliotecas SQL de Java usan instrucciones preparadas de forma predeterminada, esto significa que la mayoría de las aplicaciones Java solo pueden usar el modo service.

En tu archivo GEM, instala o actualiza dd-trace-rb a la versión 1.8.0 o una posterior:

source 'https://rubygems.org'
gem 'datadog' # Usa `'ddtrace', '>= 1.8.0'` si estás usando v1.x

# Depende de tu uso
gem 'mysql2'
gem 'pg'

Habilita la función de propagación de la monitorización de base de datos mediante uno de los siguientes métodos:

  1. Variable de entorno: DD_DBM_PROPAGATION_MODE=full

  2. La opción comment_propagation (de manera predeterminada: 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"

Instala psycopg2:

pip install psycopg2

Habilita la función de propagación de la monitorización de base de datos al establecer la siguiente variable de entorno:

  • DD_DBM_PROPAGATION_MODE=full

Ejemplo completo:


import psycopg2

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

# conecta a la base de datos de Postgres
conn = psycopg2.connect(**POSTGRES_CONFIG)
cursor = conn.cursor()
# ejecuta consultas de SQL
cursor.execute("select 'blah'")
cursor.executemany("select %s", (("foo",), ("bar",)))
Esta función requiere que la instrumentación automática se encuentre habilitada para tu servicio de .NET.

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

Asegúrate de usar una biblioteca de cliente compatible. Por ejemplo, Npgsql.

Habilita la función de propagación de la monitorización de base de datos al establecer 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 Java y rastreadores .NET
  • Para Oracle: DD_DBM_PROPAGATION_MODE=service
Esta función requiere que la extensión del rastreador se encuentre habilitada para tu servicio de PHP.

Sigue las instrucciones de rastreo de PHP a fin de instalar el paquete de instrumentación automática y habilitar el rastreo para tu servicio.

Asegúrate de usar una biblioteca de cliente compatible. Por ejemplo, PDO.

Habilita la función de propagación de la monitorización de base de datos al establecer la siguiente variable de entorno:

  • DD_DBM_PROPAGATION_MODE=full

Instala o actualiza dd-trace-js a una versión posterior a la 3.17.0 (o 2.30.0 si usas la versión 12 de Node.js que está al final de su vida útil):

npm install dd-trace@^3.17.0

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

// Esta línea debe venir antes de importar cualquier módulo instrumentado.
const tracer = require('dd-trace').init();

Habilita la función de propagación de la monitorización de base de datos mediante uno de los siguientes métodos:

  • Establece la siguiente variable de entorno:

    DD_DBM_PROPAGATION_MODE=full
    
  • Establece el rastreador para que use la opción dbmPropagationMode (de manera predeterminada: ENV['DD_DBM_PROPAGATION_MODE']):

    const tracer = require('dd-trace').init({ dbmPropagationMode: 'full' })
    
  • Solo habilítalo en el 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) => {
    // gestiona el resultado
})

Explorar la conexión de APM en DBM

Atribuir las conexiones de base de datos activas a los servicios de APM que realizan llamadas

Visualiza las conexiones activas a una base de datos desglosadas por el servicio de APM del que se originan.

Desglosa las conexiones activas de un host determinado por los servicios de APM ascendentes que realizan las solicitudes. Puedes atribuir la carga de una base de datos a servicios individuales para comprender qué servicios son los más activos en la base de datos. Dirígete a la página de servicios del servicio ascendente más activo para continuar la investigación.

Filtrar los hosts de bases de datos por los servicios de APM que los llaman

Filtra tus host de base de datos por los servicios de APM que los llaman.

Filtra con rapidez la lista de bases de datos para solo visualizar los hosts de bases de datos de los que dependen tus servicios de APM específicos. Identifica de manera sencilla si alguna de tus dependencias descendentes tiene actividad de bloqueo que pueda afectar el rendimiento del servicio.

Ver la traza asociada a una muestra de consulta

Obtén una vista previa de la traza de APM muestreada a partir del cual se generó la muestra de consulta que se está inspeccionando.

Al visualizar una muestra de consulta en Database Monitoring, si APM ha realizado un muestreo de la traza asociada, puedes ver la muestra de DBM en el contexto de la traza de APM. Esto te permite combinar la telemetría de DBM, incluido el plan de explicación y el rendimiento histórico de la consulta, junto con el linaje del tramo dentro de tu infraestructura para comprender si un cambio en la base de datos es responsable del bajo rendimiento de la aplicación.

Explorar la conexión de DBM en APM

Visualizar los hosts de bases de datos descendentes de los servicios de APM

Visualiza los hosts de bases de datos descendentes de los que dependen tus servicios de APM desde la Página de servicios.

En la página de APM de un servicio determinado, visualiza las dependencias de bases de datos descendentes directas del servicio identificadas por Database Monitoring. Determina con rapidez si algún host tiene una carga desproporcionada que puede ser causada por hosts vecinos ruidosos. Para ver la página de un servicio, haz clic en el servicio en el Service Catalog a fin de abrir un panel de detalles y, a continuación, haz clic en View Service Page (Ver página de servicios) en el panel.

Identificar posibles optimizaciones mediante planes de explicación para consultas de bases de datos en trazas

Identifica ineficiencias mediante planes de explicación para consultas de bases de datos en trazas.

Visualiza el rendimiento histórico de consultas similares a las que se ejecutan en tu traza, incluidos los eventos de espera muestreados, la latencia promedio y los planes de explicación capturados recientemente, para contextualizar cómo se espera que funcione una consulta. Determina si el comportamiento es anormal y continúa la investigación al pasar a Database Monitoring para obtener contexto adicional sobre los hosts de bases de datos subyacentes.

Referencias adicionales