Logging

Traduzione Beta Non Ufficiale

Questa pagina è stata tradotta da PageTurner AI (beta). Non ufficialmente approvata dal progetto. Hai trovato un errore? Segnala problema →

Abilitazione del logging

Puoi abilitare la registrazione di tutte le query e degli errori impostando semplicemente logging: true nelle opzioni della data source:

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

Opzioni di logging

Puoi abilitare diversi tipi di logging nelle opzioni della data source:

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

Se vuoi registrare solo le query fallite, aggiungi soltanto error:

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

Altre opzioni disponibili:

• query - registra tutte le query.

• error - registra tutte le query fallite e gli errori.

• schema - registra il processo di costruzione dello schema.

• warn - registra i warning interni dell'ORM.

• info - registra i messaggi informativi interni dell'ORM.

• log - registra i messaggi di log interni dell'ORM.

Puoi specificare tutte le opzioni necessarie. Per abilitare completamente il logging, usa logging: "all":

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

Registrazione query lente

In caso di problemi prestazionali, puoi registrare le query che impiegano troppo tempo impostando maxQueryExecutionTime nelle opzioni della data source:

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

Questo codice registrerà tutte le query che superano 1 second di esecuzione.

Modifica del logger predefinito

TypeORM include 5 tipi di logger:

• advanced-console - logger predefinito che registra tutti i messaggi in console utilizzando colori e l'evidenziazione della sintassi SQL.

• simple-console - logger console semplice, identico a quello avanzato ma senza evidenziazione colori. Utile in caso di problemi o se non si gradiscono i log colorati.

• formatted-console - quasi identico al logger avanzato, ma formatta le query SQL per una migliore leggibilità (utilizzando @sqltools/formatter).

• file - scrive tutti i log in ormlogs.log nella cartella principale del progetto (vicino a package.json).

• debug - utilizza il pacchetto debug; per attivarlo imposta la variabile d'ambiente DEBUG=typeorm:* (nota: l'opzione di logging non ha effetto su questo logger).

Puoi abilitarli nelle opzioni della data source:

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

Utilizzo di logger personalizzati

Puoi creare un logger personalizzato implementando l'interfaccia Logger:

import { Logger } from "typeorm"

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

Oppure estendendo la classe 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
            }
        }
    }
}

E specificarlo nelle opzioni della data source:

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

I metodi del logger possono accettare QueryRunner quando disponibile, utile per registrare dati aggiuntivi. Inoltre, tramite il query runner, puoi accedere a dati supplementari passati durante operazioni di persistenza/rimozione. Esempio:

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