okta-mcp-server/dist/infrastructure/circuit-breaker/monitoring-types.d.ts

Model Context Protocol (MCP) server for Okta API operations with support for bulk operations and caching

/**
 * Circuit Breaker Monitoring Types
 *
 * Type definitions for the monitoring and metrics system
 */
import { CircuitState, CircuitBreakerStats } from './types.js';
export { CircuitState };
/**
 * Metric types for monitoring
 */
export declare enum MetricType {
    COUNTER = "counter",
    GAUGE = "gauge",
    HISTOGRAM = "histogram",
    SUMMARY = "summary"
}
/**
 * Individual metric data point
 */
export interface MetricPoint {
    timestamp: number;
    value: number;
    labels?: Record<string, string>;
}
/**
 * Time series data for a metric
 */
export interface TimeSeries {
    name: string;
    type: MetricType;
    help: string;
    points: MetricPoint[];
    labels?: Record<string, string>;
}
/**
 * Circuit breaker metrics snapshot
 */
export interface CircuitBreakerMetrics {
    circuitName: string;
    state: CircuitState;
    stateChanges: TimeSeries;
    requests: {
        total: TimeSeries;
        success: TimeSeries;
        failure: TimeSeries;
        timeout: TimeSeries;
        rejected: TimeSeries;
        cacheHit: TimeSeries;
        cacheMiss: TimeSeries;
    };
    latency: {
        histogram: TimeSeries;
        percentiles: {
            p50: number;
            p90: number;
            p95: number;
            p99: number;
        };
    };
    rates: {
        successRate: TimeSeries;
        failureRate: TimeSeries;
        errorRate: TimeSeries;
    };
    rateLimits: {
        occurrences: TimeSeries;
        remaining: TimeSeries;
    };
}
/**
 * Alert condition configuration
 */
export interface AlertCondition {
    name: string;
    metric: string;
    threshold: number;
    operator: 'gt' | 'lt' | 'gte' | 'lte' | 'eq';
    duration: number;
    cooldown: number;
}
/**
 * Alert event
 */
export interface Alert {
    id: string;
    condition: AlertCondition;
    timestamp: number;
    value: number;
    message: string;
    severity: 'info' | 'warning' | 'error' | 'critical';
}
/**
 * Dashboard data for real-time monitoring
 */
export interface DashboardData {
    circuits: Map<string, {
        current: CircuitBreakerStats;
        metrics: CircuitBreakerMetrics;
        alerts: Alert[];
        health: 'healthy' | 'degraded' | 'unhealthy';
    }>;
    systemHealth: {
        totalRequests: number;
        avgSuccessRate: number;
        activeAlerts: number;
        lastUpdated: number;
    };
}
/**
 * Monitoring event types
 */
export interface MonitoringEvents {
    stateChange: (event: {
        circuit: string;
        from: CircuitState;
        to: CircuitState;
        timestamp: number;
    }) => void;
    alert: (alert: Alert) => void;
    metricsUpdate: (metrics: Map<string, CircuitBreakerMetrics>) => void;
    healthChange: (event: {
        circuit: string;
        health: 'healthy' | 'degraded' | 'unhealthy';
        timestamp: number;
    }) => void;
}
/**
 * Monitor configuration options
 */
export interface MonitorConfig {
    /**
     * How long to retain metrics data in milliseconds
     * @default 3600000 (1 hour)
     */
    metricsRetention?: number;
    /**
     * Interval for metric collection in milliseconds
     * @default 1000 (1 second)
     */
    metricsInterval?: number;
    /**
     * Enable automatic alert notifications
     * @default true
     */
    enableAlerts?: boolean;
    /**
     * Custom alert handler
     */
    onAlert?: (alert: Alert) => void;
}
/**
 * Prometheus exporter configuration
 */
export interface PrometheusConfig {
    /**
     * Metric prefix
     * @default "circuit_breaker_"
     */
    prefix?: string;
    /**
     * Additional labels to add to all metrics
     */
    labels?: Record<string, string>;
    /**
     * Include timestamp in export
     * @default false
     */
    includeTimestamp?: boolean;
}
//# sourceMappingURL=monitoring-types.d.ts.map