magiclogger - v0.1.0
    Preparing search index...

    Interface TransportEvents

    Transport lifecycle events.

    interface TransportEvents {
        acknowledged?: (message: unknown) => void;
        backpressure?: (info: unknown) => void;
        batch: (entries: LogEntry[], size: number) => void;
        circuitBreakerOpen?: (
            info: { failures: number; transport: string; until: Date },
        ) => void;
        closed: () => void;
        closing: () => void;
        config?: (config: unknown) => void;
        connected?: (info?: unknown) => void;
        connectionError?: (error: Error) => void;
        connectionFailed?: (info: { attempts: number; error: Error }) => void;
        disabled: () => void;
        disconnected?: (info: unknown) => void;
        enabled: () => void;
        error: (error: Error, entry?: LogEntry) => void;
        fallback?: (
            info: { count: number; fallback: string; transport: string },
        ) => void;
        healthCheckFailed?: (error: unknown) => void;
        healthCheckPassed?: () => void;
        indexesCreated?: (info: unknown) => void;
        inserted?: (info: unknown) => void;
        keepAliveFailed?: (error: unknown) => void;
        logged: (entry: LogEntry) => void;
        message?: (message: unknown) => void;
        mongoInsert?: (info: unknown) => void;
        offlineQueueFull?: (info: { dropped: number }) => void;
        offlineQueueOverflow?: (info: { dropped: number; queued: number }) => void;
        offlineQueueProcessed?: (info: { count: number }) => void;
        piped?: (info: { source: unknown }) => void;
        processingOfflineQueue?: (info: { count: number }) => void;
        ready: () => void;
        reconnecting?: (info: { attempt: number; delay: number }) => void;
        retry?: (
            info: {
                attempt: number;
                batch: string;
                delay: number;
                error: string;
                transport: string;
            },
        ) => void;
        sent?: (info: unknown) => void;
        streamClosed?: () => void;
        streamFinished?: () => void;
        unpipe?: (info: { source: unknown }) => void;
        uploaded?: (info: unknown) => void;
    }
    Index

    Properties

    acknowledged?: (message: unknown) => void

    Emitted when a WebSocket message is acknowledged.

    backpressure?: (info: unknown) => void

    Emitted when backpressure occurs.

    batch: (entries: LogEntry[], size: number) => void

    Emitted when a batch is sent (for batching transports).

    circuitBreakerOpen?: (
        info: { failures: number; transport: string; until: Date },
    ) => void

    Emitted when circuit breaker opens.

    closed: () => void

    Emitted when transport is closed.

    closing: () => void

    Emitted when transport is closing.

    config?: (config: unknown) => void

    Emitted when configuration is received.

    connected?: (info?: unknown) => void

    Emitted when connected.

    connectionError?: (error: Error) => void

    Emitted on connection error.

    connectionFailed?: (info: { attempts: number; error: Error }) => void

    Emitted when connection fails after all retries.

    disabled: () => void

    Emitted when transport is disabled.

    disconnected?: (info: unknown) => void

    Emitted when disconnected.

    enabled: () => void

    Emitted when transport is enabled.

    error: (error: Error, entry?: LogEntry) => void

    Emitted on transport errors.

    fallback?: (
        info: { count: number; fallback: string; transport: string },
    ) => void

    Emitted when using fallback transport.

    healthCheckFailed?: (error: unknown) => void

    Emitted when health check fails.

    healthCheckPassed?: () => void

    Emitted when health check passes.

    indexesCreated?: (info: unknown) => void

    Emitted when MongoDB indexes are created.

    inserted?: (info: unknown) => void

    Emitted when data is inserted.

    keepAliveFailed?: (error: unknown) => void

    Emitted when keep-alive fails.

    logged: (entry: LogEntry) => void

    Emitted when a log is successfully sent.

    message?: (message: unknown) => void

    Emitted when a message is received.

    mongoInsert?: (info: unknown) => void

    Emitted when MongoDB insert occurs.

    offlineQueueFull?: (info: { dropped: number }) => void

    Emitted when offline queue is full.

    offlineQueueOverflow?: (info: { dropped: number; queued: number }) => void

    Emitted when offline queue overflows.

    offlineQueueProcessed?: (info: { count: number }) => void

    Emitted when offline queue is processed.

    piped?: (info: { source: unknown }) => void

    Emitted when a stream is piped.

    processingOfflineQueue?: (info: { count: number }) => void

    Emitted when processing offline queue.

    ready: () => void

    Emitted when transport is ready to accept logs.

    reconnecting?: (info: { attempt: number; delay: number }) => void

    Emitted when reconnecting.

    retry?: (
        info: {
            attempt: number;
            batch: string;
            delay: number;
            error: string;
            transport: string;
        },
    ) => void

    Emitted on retry attempt.

    sent?: (info: unknown) => void

    Emitted when a message/data is successfully sent.

    streamClosed?: () => void

    Emitted when a stream is closed.

    streamFinished?: () => void

    Emitted when a stream is finished.

    unpipe?: (info: { source: unknown }) => void

    Emitted when a stream is unpiped.

    uploaded?: (info: unknown) => void

    Emitted when upload/data transfer is complete.