Protokollierung

Inoffizielle Beta-Übersetzung

Diese Seite wurde von PageTurner AI übersetzt (Beta). Nicht offiziell vom Projekt unterstützt. Fehler gefunden? Problem melden →

Protokollierung aktivieren

Sie können die Protokollierung aller Abfragen und Fehler aktivieren, indem Sie einfach logging: true in den Datenquellen-Optionen setzen:

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

Protokollierungsoptionen

Sie können verschiedene Arten der Protokollierung in den Datenquellen-Optionen aktivieren:

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

Wenn Sie nur fehlgeschlagene Abfragen protokollieren möchten, fügen Sie lediglich error hinzu:

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

Weitere verfügbare Optionen:

• query - protokolliert alle Abfragen.

• error - protokolliert fehlgeschlagene Abfragen und Fehler.

• schema - protokolliert den Schema-Erstellungsprozess.

• warn - protokolliert interne ORM-Warnungen.

• info - protokolliert informative ORM-Meldungen.

• log - protokolliert interne ORM-Logmeldungen.

Sie können beliebig viele Optionen angeben.
Um die gesamte Protokollierung zu aktivieren, können Sie einfach logging: "all" setzen:

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

Langlaufende Abfragen protokollieren

Bei Performance-Problemen können Sie Abfragen protokollieren, die zu lange zur Ausführung benötigen, indem Sie maxQueryExecutionTime in den Datenquellen-Optionen setzen:

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

Dieser Code protokolliert alle Abfragen, die länger als 1 second laufen.

Standard-Logger ändern

TypeORM bietet 4 verschiedene Logger-Typen:

• advanced-console - der Standard-Logger, der alle Meldungen farbig mit SQL-Syntaxhervorhebung in der Konsole ausgibt.

• simple-console - ein einfacher Konsolen-Logger, identisch zum Advanced-Logger, aber ohne farbliche Hervorhebung. Ideal bei Problemen mit farbigen Logs oder persönlicher Präferenz.

• formatted-console - ähnlich dem Advanced-Logger, formatiert SQL-Abfragen für bessere Lesbarkeit (mittels @sqltools/formatter).

• file - schreibt alle Logs in ormlogs.log im Projektstammverzeichnis (neben package.json).

• debug - nutzt das debug-Paket. Aktivierung über Umgebungsvariable DEBUG=typeorm:* (Hinweis: Die logging-Option hat hier keine Wirkung).

Aktivierung in den Datenquellen-Optionen:

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

Eigene Logger verwenden

Erstellen Sie einen eigenen Logger, indem Sie das Logger-Interface implementieren:

import { Logger } from "typeorm"

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

Oder erweitern Sie die AbstractLogger-Klasse:

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

Anschließend in den Datenquellen-Optionen angeben:

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

Logger-Methoden können optional ein QueryRunner-Objekt erhalten. Dies ist hilfreich für zusätzliche Protokollinformationen.
Über den Query Runner erhalten Sie auch Zugriff auf zusätzliche Daten während persist/remove-Operationen, z.B.:

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