Registro de actividad (Logging)

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Habilitar el registro

Puedes activar el registro de todas las consultas y errores simplemente configurando logging: true en las opciones del origen de datos:

{
    name: "mysql",
    type: "mysql",
    host: "localhost",
    port: 3306,
    username: "test",
    password: "test",
    database: "test",
    ...
    logging: true
}

Opciones de registro

Puedes habilitar diferentes tipos de registro en las opciones del origen de datos:

{
    host: "localhost",
    ...
    logging: ["query", "error"]
}

Si deseas registrar solo las consultas fallidas, agrega únicamente error:

{
    host: "localhost",
    ...
    logging: ["error"]
}

Existen otras opciones disponibles:

• query - registra todas las consultas.

• error - registra todas las consultas fallidas y errores.

• schema - registra el proceso de construcción del esquema.

• warn - registra advertencias internas del ORM.

• info - registra mensajes informativos internos del ORM.

• log - registra mensajes de registro internos del ORM.

Puedes especificar tantas opciones como necesites. Si quieres habilitar todo el registro, simplemente usa logging: "all":

{
    host: "localhost",
    ...
    logging: "all"
}

Registrar consultas lentas

Si tienes problemas de rendimiento, puedes registrar las consultas que tardan demasiado en ejecutarse configurando maxQueryExecutionTime en las opciones del origen de datos:

{
    host: "localhost",
    ...
    maxQueryExecutionTime: 1000
}

Este código registrará todas las consultas que tarden más de 1 second.

Cambiar el logger predeterminado

TypeORM incluye 5 tipos diferentes de loggers:

• advanced-console - logger predeterminado que registra todos los mensajes en la consola usando colores y resaltado de sintaxis SQL.

• simple-console - logger de consola simple idéntico al avanzado, pero sin resaltado de colores. Útil si tienes problemas o prefieres registros sin colores.

• formatted-console - similar al logger avanzado, pero formatea consultas SQL para mejorar su legibilidad (usa @sqltools/formatter).

• file - escribe todos los registros en ormlogs.log en la raíz del proyecto (junto a package.json).

• debug - utiliza el paquete debug. Actívalo con la variable de entorno DEBUG=typeorm:* (nota: la opción logging no afecta este logger).

Puedes habilitar cualquiera en las opciones del origen de datos:

{
    host: "localhost",
    ...
    logging: true,
    logger: "file"
}

Usar un logger personalizado

Puedes crear tu propia clase de logger implementando la interfaz Logger:

import { Logger } from "typeorm"

export class MyCustomLogger implements Logger {
    // implement all methods from logger class
}

O extender la clase AbstractLogger:

import { AbstractLogger } from "typeorm"

export class MyCustomLogger extends AbstractLogger {
    /**
     * Write log to specific output.
     */
    protected writeLog(
        level: LogLevel,
        logMessage: LogMessage | LogMessage[],
        queryRunner?: QueryRunner,
    ) {
        const messages = this.prepareLogMessages(
            logMessage,
            {
                highlightSql: false,
            },
            queryRunner,
        )

        for (let message of messages) {
            switch (message.type ?? level) {
                case "log":
                case "schema-build":
                case "migration":
                    console.log(message.message)
                    break

                case "info":
                case "query":
                    if (message.prefix) {
                        console.info(message.prefix, message.message)
                    } else {
                        console.info(message.message)
                    }
                    break

                case "warn":
                case "query-slow":
                    if (message.prefix) {
                        console.warn(message.prefix, message.message)
                    } else {
                        console.warn(message.message)
                    }
                    break

                case "error":
                case "query-error":
                    if (message.prefix) {
                        console.error(message.prefix, message.message)
                    } else {
                        console.error(message.message)
                    }
                    break
            }
        }
    }
}

Y especificarlo en las opciones del origen de datos:

import { DataSource } from "typeorm"
import { MyCustomLogger } from "./logger/MyCustomLogger"

const dataSource = new DataSource({
    name: "mysql",
    type: "mysql",
    host: "localhost",
    port: 3306,
    username: "test",
    password: "test",
    database: "test",
    logger: new MyCustomLogger(),
})

Los métodos del logger pueden aceptar QueryRunner cuando esté disponible. Esto es útil para registrar datos adicionales. Además, a través del query runner puedes acceder a datos adicionales pasados durante operaciones de persistencia/eliminación. Por ejemplo:

// user sends request during entity save
postRepository.save(post, { data: { request: request } });

// in logger you can access it this way:
logQuery(query: string, parameters?: any[], queryRunner?: QueryRunner) {
    const requestUrl = queryRunner && queryRunner.data["request"] ? "(" + queryRunner.data["request"].url + ") " : "";
    console.log(requestUrl + "executing query: " + query);
}