Classes

ReplicationMetricsStorage

Constructor

constructor(config?: Partial<StorageConfig> | undefined)

Parameters:

Methods

storeSnapshot

Store a metric snapshot

storeSnapshot(snapshot: MetricSnapshot): void

Parameters:

storeEvent

Store replication event

storeEvent(event: ReplicationEvent): void

Parameters:

batchStoreSnapshots

Batch store multiple snapshots

batchStoreSnapshots(snapshots: MetricSnapshot[]): void

Parameters:

getCurrentMetrics

Get current metrics for all collections

getCurrentMetrics(): ReplicationMetrics[]

Returns:

ReplicationMetrics[] -

getHistoricalMetrics

Get historical metrics for a time range

getHistoricalMetrics(query: HistoricalQuery): Promise<ReplicationMetrics[]>

Parameters:

Returns:

Promise<ReplicationMetrics[]> -

getTimeSeriesData

Get time series data for specific metrics

getTimeSeriesData(collections: string[], metrics: string[], timeRange: { start: Date; end: Date; }, granularity?: "minute" | "hour" | "day"): TimeSeriesData[]

Parameters:

Returns:

TimeSeriesData[] -

getTrendAnalysis

Get trend analysis

getTrendAnalysis(collection: string, metric: string, timeRange: { start: Date; end: Date; }): TrendAnalysis

Parameters:

Returns:

TrendAnalysis -

exportMetrics

Export metrics in various formats

exportMetrics(options: ExportOptions): Promise<string>

Parameters:

Returns:

Promise<string> -

getSnapshotStream

Get snapshot stream

getSnapshotStream(): Observable<MetricSnapshot>

Returns:

Observable<MetricSnapshot> -

getAlertStream

Get alert stream

getAlertStream(): Observable<PerformanceAlert>

Returns:

Observable<PerformanceAlert> -

getTrendsStream

Get trends stream

getTrendsStream(): Observable<Map<string, TrendAnalysis>>

Returns:

Observable<Map<string, TrendAnalysis>> -

addAlertThreshold

Add performance alert threshold

addAlertThreshold(collection: string, metric: string, threshold: number, condition: "above" | "below" | "equals", severity?: "warning" | "info" | "critical"): void

Parameters:

cleanup

Clear old data

cleanup(): Promise<{ removedSnapshots: number; freedBytes: number; }>

Returns:

Promise<{ removedSnapshots: number; freedBytes: number; }> -

getStorageStats

Get storage statistics

getStorageStats(): { totalSnapshots: number; storageUsage: number; collections: number; oldestSnapshot: Date | null; newestSnapshot: Date | null; quotaUsed: number; }

Returns:

{ totalSnapshots: number; storageUsage: number; collections: number; oldestSnapshot: Date \| null; newestSnapshot: Date \| null; quotaUsed: number; } -

destroy

Cleanup resources

destroy(): void

PerformanceThresholdMonitor

Performance threshold monitor

Constructor

constructor(thresholds?: Partial<PerformanceThresholds>)

Parameters:

Methods

checkThresholds

Check if current metrics violate thresholds

checkThresholds(metrics: PerformanceMetricsResult, resourceUsage: ResourceUsageMetrics): ThresholdViolation[]

Parameters:

Returns:

ThresholdViolation[] -

onThresholdViolation

Register alert callback

onThresholdViolation(callback: (violation: ThresholdViolation) => void): () => void

Parameters:

Returns:

() => void -

updateThresholds

Update thresholds

updateThresholds(newThresholds: Partial<PerformanceThresholds>): void

Parameters:

getViolationStats

Get violation statistics

getViolationStats(): Record<string, number>

Returns:

Record<string, number> -

clearViolationHistory

Clear violation history

clearViolationHistory(): void

PerformanceOptimizationEngine

Performance optimization engine

Constructor

constructor(thresholds?: Partial<PerformanceThresholds> | undefined)

Parameters:

Methods

analyzePerformance

Analyze performance and generate optimization recommendations

analyzePerformance(events: ReplicationEvent[], collections: Map<string, ReplicationStatus>): Promise<OptimizationRecommendation[]>

Parameters:

Returns:

Promise<OptimizationRecommendation[]> -

applyOptimization

Apply an optimization recommendation

applyOptimization(recommendationId: string): Promise<OptimizationResult>

Parameters:

Returns:

Promise<OptimizationResult> -

getRecommendations

Get current optimization recommendations

getRecommendations(): OptimizationRecommendation[]

Returns:

OptimizationRecommendation[] -

getOptimizationHistory

Get optimization history

getOptimizationHistory(): OptimizationResult[]

Returns:

OptimizationResult[] -

clearOldRecommendations

Clear old recommendations

clearOldRecommendations(maxAge?: number): void

Parameters:

ResourceUsageMonitor

Resource usage monitor

Methods

startMonitoring

Start continuous monitoring

startMonitoring(intervalMs?: number): void

Parameters:

stopMonitoring

Stop continuous monitoring

stopMonitoring(): void

getCurrentUsage

Get current resource usage

getCurrentUsage(): Promise<ResourceUsageMetrics>

Returns:

Promise<ResourceUsageMetrics> -

getUsageTrends

Get usage trends over time

getUsageTrends(timeWindow?: number): ResourceUsageMetrics[]

Parameters:

Returns:

ResourceUsageMetrics[] -

ReplicationRecoveryManager

Constructor

constructor(config?: Partial<RecoveryConfig> | undefined)

Parameters:

Methods

recoverFromError

Attempt to recover from a replication error

recoverFromError(error: Error, context: RecoveryContext): Promise<RecoveryResult>

Parameters:

Returns:

Promise<RecoveryResult> -

withRecovery

Create an observable with automatic retry and recovery

withRecovery(source: Observable<T>, context: RecoveryContext): Observable<T>

Parameters:

Returns:

Observable<T> -

registerAuthRefreshCallback

Register an authentication token refresh callback

registerAuthRefreshCallback(domainId: string, callback: () => Promise<string>): void

Parameters:

getRecoveryStream

Get recovery attempt observable

getRecoveryStream(): Observable<RecoveryAttempt>

Returns:

Observable<RecoveryAttempt> -

getConnectionHealthStream

Get connection health observable

getConnectionHealthStream(): Observable<Map<string, ConnectionHealth>>

Returns:

Observable<Map<string, ConnectionHealth>> -

checkConnectionHealth

Manually trigger connection health check

checkConnectionHealth(endpoint?: string | undefined): Promise<ConnectionHealth>

Parameters:

Returns:

Promise<ConnectionHealth> -

resetCircuitBreaker

Reset circuit breaker for a specific endpoint

resetCircuitBreaker(key: string): void

Parameters:

getCircuitBreakerStates

Get current circuit breaker states

getCircuitBreakerStates(): Map<string, CircuitBreakerState>

Returns:

Map<string, CircuitBreakerState> -

addRecoveryStrategy

Add custom recovery strategy

addRecoveryStrategy(strategy: RecoveryStrategy): void

Parameters:

removeRecoveryStrategy

Remove recovery strategy

removeRecoveryStrategy(strategyId: string): void

Parameters:

destroy

Cleanup resources

destroy(): void

ReplicationEventFormatter

Event formatting utilities

Methods

formatEvent

Format a single event for display

formatEvent(event: ReplicationEvent, options?: EventFormatOptions): string

Parameters:

Returns:

string -

formatEventReport

Format multiple events as a report

formatEventReport(events: ReplicationEvent[], options?: EventFormatOptions): string

Parameters:

Returns:

string -

generateEventSummary

Generate event summary statistics

generateEventSummary(events: ReplicationEvent[]): { totalEvents: number; firstEvent: Date; lastEvent: Date; collections: string[]; eventTypes: Record<string, number>; errorCount: number; successCount: number; avgLatency: number; }

Parameters:

Returns:

{ totalEvents: number; firstEvent: Date; lastEvent: Date; collections: string[]; eventTypes: Record<string, number>; errorCount: number; successCount: number; avgLatency: number; } -

ReplicationEventFilter

Event filtering utilities

Methods

filterEvents

Filter events based on criteria

filterEvents(events: ReplicationEvent[], options: EventFilterOptions): ReplicationEvent[]

Parameters:

Returns:

ReplicationEvent[] -

filterByTimeWindow

Filter events by time window

filterByTimeWindow(events: ReplicationEvent[], windowMs: number, endTime?: Date): ReplicationEvent[]

Parameters:

Returns:

ReplicationEvent[] -

filterByErrorPattern

Filter events by error patterns

filterByErrorPattern(events: ReplicationEvent[], pattern: ReplicationErrorPattern): ReplicationEvent[]

Parameters:

Returns:

ReplicationEvent[] -

ReplicationEventAggregator

Event aggregation utilities

Methods

aggregateEvents

Aggregate events by specified criteria

aggregateEvents(events: ReplicationEvent[], options: EventAggregationOptions): AggregatedEventData[]

Parameters:

Returns:

AggregatedEventData[] -

createErrorAggregation

Create error aggregation summary

createErrorAggregation(events: ReplicationEvent[], period: { start: Date; end: Date; }): ReplicationErrorAggregation

Parameters:

Returns:

ReplicationErrorAggregation -

ReplicationPerformanceCalculator

Performance metrics calculator

Methods

calculateMetrics

Calculate comprehensive performance metrics

calculateMetrics(events: ReplicationEvent[], options?: PerformanceMetricsOptions): PerformanceMetricsResult

Parameters:

Returns:

PerformanceMetricsResult -

ReplicationMetrics

Methods

getInstance

getInstance(): ReplicationMetrics

Returns:

ReplicationMetrics -

record

Record a metric

record(name: string, value: number, tags?: Record<string, string>): void

Parameters:

recordSyncLatency

Record sync latency

recordSyncLatency(operation: "push" | "pull", latencyMs: number, domainId: string): void

Parameters:

recordDocumentThroughput

Record document throughput

recordDocumentThroughput(operation: "push" | "pull", count: number, domainId: string): void

Parameters:

recordConflict

Record conflict

recordConflict(collectionName: string, domainId: string): void

Parameters:

recordError

Record error

recordError(errorType: string, operation: string, domainId: string): void

Parameters:

recordStorageUsage

Record storage usage

recordStorageUsage(domainId: string, bytes: number): void

Parameters:

recordAuthEvent

Record authentication events

recordAuthEvent(event: "retry" | "success" | "failure", domainId?: string | undefined): void

Parameters:

recordNetworkLatency

Record network latency

recordNetworkLatency(endpoint: string, method: string, latencyMs: number, statusCode: number): void

Parameters:

recordRetry

Record retry events

recordRetry(operation: string, attempt: number, domainId: string, successful: boolean): void

Parameters:

recordRateLimit

Record rate limit hits

recordRateLimit(endpoint: string, domainId: string, userId?: string | undefined): void

Parameters:

recordConnectionStatus

Record connection status

recordConnectionStatus(status: "connected" | "disconnected" | "reconnecting", domainId: string): void

Parameters:

recordDocumentOperation

Record document operation performance

recordDocumentOperation(operation: "create" | "update" | "delete", collectionName: string, duration: number, success: boolean): void

Parameters:

getSummary

Get metrics summary

getSummary(domainId?: string | undefined): MetricsSummary

Parameters:

Returns:

MetricsSummary -

exportMetrics

Export metrics for external analysis

exportMetrics(startTime?: number | undefined, endTime?: number | undefined): Metric[]

Parameters:

Returns:

Metric[] -

clear

Clear all metrics

clear(): void