@sailboat-computer/event-bus/dist/metrics.d.ts

Standardized event bus for sailboat computer v3 with resilience features and offline capabilities

/**
 * Metrics collector for event bus
 */
import { EventBusMetrics } from '@sailboat-computer/sailboat-types';
/**
 * Extended event bus metrics
 */
export interface ExtendedEventBusMetrics extends EventBusMetrics {
    /**
     * Average event processing time in milliseconds
     */
    averageProcessingTime: number;
    /**
     * Processing time samples
     */
    processingTimeSamples: number[];
    /**
     * Number of events in the dead letter queue
     */
    deadLetterQueueSize: number;
    /**
     * Number of events sent to the dead letter queue
     */
    deadLetterQueueEvents: number;
    /**
     * Last time an event was sent to the dead letter queue
     */
    lastDeadLetterQueueEventTime: Date | null;
}
/**
 * Metrics collector for event bus
 */
export declare class MetricsCollector {
    /**
     * Number of published events
     */
    private publishedEvents;
    /**
     * Number of failed publishes
     */
    private failedPublishes;
    /**
     * Number of processed events
     */
    private processedEvents;
    /**
     * Number of active subscriptions
     */
    private activeSubscriptions;
    /**
     * Number of reconnection attempts
     */
    private reconnectionAttempts;
    /**
     * Number of events in the offline buffer
     */
    private bufferedEvents;
    /**
     * Last reconnection time
     */
    private lastReconnectionTime;
    /**
     * Total processing time
     */
    private totalProcessingTime;
    /**
     * Number of events in the dead letter queue
     */
    private deadLetterQueueSize;
    /**
     * Number of events sent to the dead letter queue
     */
    private deadLetterQueueEvents;
    /**
     * Last time an event was sent to the dead letter queue
     */
    private lastDeadLetterQueueEventTime;
    /**
     * Whether to collect detailed timings
     */
    private detailedTimings;
    /**
     * Processing times array for calculating average
     */
    private processingTimes;
    /**
     * Maximum number of processing times to store
     */
    private maxProcessingTimes;
    /**
     * Create a new metrics collector
     *
     * @param detailedTimings - Whether to collect detailed timings
     */
    constructor(detailedTimings?: boolean);
    /**
     * Increment the published events counter
     */
    incrementPublishedEvents(): void;
    /**
     * Increment the failed publishes counter
     */
    incrementFailedPublishes(): void;
    /**
     * Increment the processed events counter
     */
    incrementProcessedEvents(): void;
    /**
     * Increment the active subscriptions counter
     */
    incrementActiveSubscriptions(): void;
    /**
     * Decrement the active subscriptions counter
     */
    decrementActiveSubscriptions(): void;
    /**
     * Set the active subscriptions count
     *
     * @param count - Active subscriptions count
     */
    setActiveSubscriptions(count: number): void;
    /**
     * Increment the reconnection attempts counter
     */
    incrementReconnectionAttempts(): void;
    /**
     * Set the buffered events count
     *
     * @param count - Buffered events count
     */
    setBufferedEvents(count: number): void;
    /**
     * Set the dead letter queue size
     *
     * @param size - Dead letter queue size
     */
    setDeadLetterQueueSize(size: number): void;
    /**
     * Increment the dead letter queue events counter
     */
    incrementDeadLetterQueueEvents(): void;
    /**
     * Record event processing time
     *
     * @param startTime - Start time in milliseconds
     */
    recordProcessingTime(startTime: number): void;
    /**
     * Get metrics
     *
     * @returns Event bus metrics
     */
    getMetrics(): ExtendedEventBusMetrics;
    /**
     * Reset metrics
     */
    reset(): void;
}
//# sourceMappingURL=metrics.d.ts.map