import type { DesperateAny } from "../internal/misc";
import type { Client, ClientRole } from "./Client";
import type { QueryAnnotation } from "./QueryAnnotation";
/**
 * Loggers are called at different stages of the query lifecycle. We do not use
 * EventEmitter for several reasons:
 * 1. It is not friendly to mocking in Jest.
 * 2. The built-in EventEmitter is not strongly typed.
 */
export interface Loggers<TNode = DesperateAny> {
    /** Logs actual queries to the database (after batching). */
    clientQueryLogger?: (props: ClientQueryLoggerProps) => void;
    /** Logs errors which did not throw through (typically recoverable). */
    swallowedErrorLogger: (props: SwallowedErrorLoggerProps) => void;
    /** Called when Island-from-Shard location fails (e.g. no such Shard), or when
     * a query on a particular Shard fails due to any reason (like transport
     * error). Mostly used in unit tests, since it's called for every retry. */
    runOnShardErrorLogger?: (props: RunOnShardErrorLoggerProps) => void;
    /** Called when a Client gets ended due to dynamic Islands reconfiguration.
     * Allows to debug flaky Island reconfiguration. */
    clientEndLogger?: (props: ClientEndLoggerProps<TNode>) => void;
    /** Called when a Client connects to the database. */
    clientConnectedLogger?: (props: ClientConnectedLoggerProps<TNode>) => void;
}
export interface ClientQueryLoggerProps {
    annotations: QueryAnnotation[];
    op: string;
    shard: string;
    table: string;
    batchFactor: number;
    msg: string;
    output: unknown;
    elapsed: {
        total: number;
        acquire: number;
    };
    connStats: {
        /** The stats related to the used connection. */
        id: string;
        /** The number of queries sent to the connection. */
        queriesSent: number;
    };
    poolStats: {
        /** Total number of connections in the pool. */
        totalConns: number;
        /** Connections not busy running a query. */
        idleConns: number;
        /** Once all idle connections are over, requests are queued waiting for a
         * new available connection. This is the number of such queued requests. */
        queuedReqs: number;
    };
    error: string | undefined;
    role: ClientRole;
    backend: string;
    address: string;
}
export interface SwallowedErrorLoggerProps {
    where: string;
    error: unknown;
    elapsed: number | null;
    importance: "low" | "normal";
}
export interface RunOnShardErrorLoggerProps {
    error: unknown;
    attempt: number;
}
export interface ClientEndLoggerProps<TNode> {
    client: Client;
    key: string;
    node: TNode;
}
export interface ClientConnectedLoggerProps<TNode> {
    node: TNode;
}
//# sourceMappingURL=Loggers.d.ts.map