decision_agent 0.1.1 → 0.1.3

data/lib/decision_agent/monitoring/alert_manager.rb

@@ -0,0 +1,282 @@
+require "monitor"
+
+module DecisionAgent
+  module Monitoring
+    # Alert manager for anomaly detection and notifications
+    class AlertManager
+      include MonitorMixin
+
+      attr_reader :rules, :alerts
+
+      def initialize(metrics_collector:)
+        super()
+        @metrics_collector = metrics_collector
+        @rules = []
+        @alerts = []
+        @alert_handlers = []
+        @check_interval = 60 # seconds
+        @monitoring_thread = nil
+        freeze_config
+      end
+
+      # Define an alert rule
+      def add_rule(name:, condition:, severity: :warning, threshold: nil, message: nil, cooldown: 300)
+        synchronize do
+          rule = {
+            id: generate_rule_id(name),
+            name: name,
+            condition: condition,
+            severity: severity,
+            threshold: threshold,
+            message: message || "Alert: #{name}",
+            cooldown: cooldown,
+            last_triggered: nil,
+            enabled: true
+          }
+
+          @rules << rule
+          rule
+        end
+      end
+
+      # Remove a rule
+      def remove_rule(rule_id)
+        synchronize do
+          @rules.reject! { |r| r[:id] == rule_id }
+        end
+      end
+
+      # Enable/disable rule
+      def toggle_rule(rule_id, enabled)
+        synchronize do
+          rule = @rules.find { |r| r[:id] == rule_id }
+          rule[:enabled] = enabled if rule
+        end
+      end
+
+      # Register alert handler
+      def add_handler(&block)
+        synchronize do
+          @alert_handlers << block
+        end
+      end
+
+      # Start monitoring
+      def start_monitoring(interval: 60)
+        synchronize do
+          return if @monitoring_thread&.alive?
+
+          @check_interval = interval
+          @monitoring_thread = Thread.new do
+            loop do
+              check_rules
+              sleep @check_interval
+            rescue StandardError => e
+              warn "Alert monitoring error: #{e.message}"
+            end
+          end
+        end
+      end
+
+      # Stop monitoring
+      def stop_monitoring
+        synchronize do
+          @monitoring_thread&.kill
+          @monitoring_thread = nil
+        end
+      end
+
+      # Manually check all rules
+      def check_rules
+        stats = @metrics_collector.statistics
+
+        @rules.each do |rule|
+          next unless rule[:enabled]
+          next if in_cooldown?(rule)
+
+          trigger_alert(rule, stats) if evaluate_condition(rule[:condition], stats)
+        end
+      end
+
+      # Get active alerts
+      def active_alerts
+        synchronize do
+          @alerts.select { |a| a[:status] == :active }
+        end
+      end
+
+      # Get all alerts
+      def all_alerts(limit: 100)
+        synchronize do
+          @alerts.last(limit)
+        end
+      end
+
+      # Acknowledge alert
+      def acknowledge_alert(alert_id, acknowledged_by: "system")
+        synchronize do
+          alert = @alerts.find { |a| a[:id] == alert_id }
+          if alert
+            alert[:status] = :acknowledged
+            alert[:acknowledged_by] = acknowledged_by
+            alert[:acknowledged_at] = Time.now.utc
+          end
+        end
+      end
+
+      # Resolve alert
+      def resolve_alert(alert_id, resolved_by: "system")
+        synchronize do
+          alert = @alerts.find { |a| a[:id] == alert_id }
+          if alert
+            alert[:status] = :resolved
+            alert[:resolved_by] = resolved_by
+            alert[:resolved_at] = Time.now.utc
+          end
+        end
+      end
+
+      # Clear old alerts
+      def clear_old_alerts(older_than: 86_400)
+        synchronize do
+          cutoff = Time.now.utc - older_than
+          @alerts.reject! { |a| a[:triggered_at] < cutoff && a[:status] != :active }
+        end
+      end
+
+      # Built-in alert conditions
+      def self.high_error_rate(threshold: 0.1)
+        lambda do |stats|
+          total_ops = stats.dig(:performance, :total_operations) || 0
+          return false if total_ops.zero?
+
+          success_rate = stats.dig(:performance, :success_rate) || 1.0
+          (1.0 - success_rate) > threshold
+        end
+      end
+
+      def self.low_confidence(threshold: 0.5)
+        lambda do |stats|
+          avg_confidence = stats.dig(:decisions, :avg_confidence)
+          avg_confidence && avg_confidence < threshold
+        end
+      end
+
+      def self.high_latency(threshold_ms: 1000)
+        lambda do |stats|
+          p95 = stats.dig(:performance, :p95_duration_ms)
+          p95 && p95 > threshold_ms
+        end
+      end
+
+      def self.error_spike(threshold: 10, time_window: 300)
+        lambda do |stats|
+          recent_errors = stats.dig(:errors, :total) || 0
+          recent_errors > threshold
+        end
+      end
+
+      def self.decision_anomaly(expected_rate: 100, variance: 0.3)
+        lambda do |stats|
+          total = stats.dig(:decisions, :total) || 0
+          time_range = stats.dig(:summary, :time_range)
+
+          # Simple anomaly detection based on rate
+          return false unless time_range
+
+          lower_bound = expected_rate * (1 - variance)
+          upper_bound = expected_rate * (1 + variance)
+
+          total < lower_bound || total > upper_bound
+        end
+      end
+
+      private
+
+      def freeze_config
+        # No immutable config to freeze yet
+      end
+
+      def generate_rule_id(name)
+        "#{sanitize_name(name)}_#{Time.now.to_i}_#{rand(1000)}"
+      end
+
+      def sanitize_name(name)
+        name.to_s.downcase.gsub(/[^a-z0-9]/, "_")
+      end
+
+      def in_cooldown?(rule)
+        return false unless rule[:last_triggered]
+
+        Time.now.utc - rule[:last_triggered] < rule[:cooldown]
+      end
+
+      def evaluate_condition(condition, stats)
+        case condition
+        when Proc
+          condition.call(stats)
+        when Hash
+          evaluate_hash_condition(condition, stats)
+        else
+          false
+        end
+      end
+
+      def evaluate_hash_condition(condition, stats)
+        # Support simple hash-based conditions
+        # Example: { metric: "decisions.avg_confidence", op: "lt", value: 0.5 }
+        metric_path = condition[:metric]&.split(".")
+        return false unless metric_path
+
+        value = stats.dig(*metric_path.map(&:to_sym))
+        return false if value.nil?
+
+        case condition[:op]
+        when "gt", ">"
+          value > condition[:value]
+        when "lt", "<"
+          value < condition[:value]
+        when "eq", "=="
+          value == condition[:value]
+        when "gte", ">="
+          value >= condition[:value]
+        when "lte", "<="
+          value <= condition[:value]
+        else
+          false
+        end
+      end
+
+      def trigger_alert(rule, stats)
+        alert = {
+          id: "alert_#{Time.now.to_i}_#{rand(10_000)}",
+          rule_id: rule[:id],
+          rule_name: rule[:name],
+          severity: rule[:severity],
+          message: rule[:message],
+          triggered_at: Time.now.utc,
+          status: :active,
+          context: {
+            stats_snapshot: stats
+          }
+        }
+
+        @alerts << alert
+        rule[:last_triggered] = Time.now.utc
+
+        # Notify handlers
+        notify_handlers(alert)
+
+        alert
+      end
+
+      def notify_handlers(alert)
+        @alert_handlers.each do |handler|
+          handler.call(alert)
+        rescue StandardError => e
+          warn "Alert handler failed: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/monitoring/dashboard/public/dashboard.css

@@ -0,0 +1,381 @@
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+    background: #0f1419;
+    color: #e6edf3;
+    line-height: 1.6;
+}
+
+.dashboard {
+    max-width: 1600px;
+    margin: 0 auto;
+    padding: 20px;
+}
+
+.header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 30px;
+    padding: 20px;
+    background: #161b22;
+    border-radius: 8px;
+    border: 1px solid #30363d;
+}
+
+.header h1 {
+    font-size: 28px;
+    color: #58a6ff;
+}
+
+.header-info {
+    display: flex;
+    gap: 20px;
+    align-items: center;
+}
+
+.status-badge {
+    padding: 6px 12px;
+    border-radius: 20px;
+    font-size: 14px;
+    font-weight: 600;
+}
+
+.status-badge.connected {
+    background: #238636;
+    color: #fff;
+}
+
+.status-badge.disconnected {
+    background: #da3633;
+    color: #fff;
+}
+
+#last-update {
+    color: #8b949e;
+    font-size: 14px;
+}
+
+.alert-bar {
+    background: #da3633;
+    color: #fff;
+    padding: 15px 20px;
+    margin-bottom: 20px;
+    border-radius: 8px;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.alert-content {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    width: 100%;
+}
+
+.alert-icon {
+    font-size: 24px;
+}
+
+.alert-close {
+    background: none;
+    border: none;
+    color: #fff;
+    font-size: 24px;
+    cursor: pointer;
+    padding: 0 10px;
+}
+
+.metrics-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+    gap: 20px;
+    margin-bottom: 30px;
+}
+
+.metric-card {
+    background: #161b22;
+    padding: 24px;
+    border-radius: 8px;
+    border: 1px solid #30363d;
+    transition: transform 0.2s, box-shadow 0.2s;
+}
+
+.metric-card:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(88, 166, 255, 0.1);
+}
+
+.metric-card.error-card {
+    border-color: #da3633;
+}
+
+.metric-label {
+    font-size: 14px;
+    color: #8b949e;
+    margin-bottom: 8px;
+}
+
+.metric-value {
+    font-size: 32px;
+    font-weight: 700;
+    color: #58a6ff;
+    margin-bottom: 8px;
+}
+
+.metric-change {
+    font-size: 12px;
+    color: #8b949e;
+}
+
+.metric-change.positive {
+    color: #3fb950;
+}
+
+.metric-change.negative {
+    color: #da3633;
+}
+
+.charts-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(500px, 1fr));
+    gap: 20px;
+    margin-bottom: 30px;
+}
+
+.chart-card {
+    background: #161b22;
+    padding: 24px;
+    border-radius: 8px;
+    border: 1px solid #30363d;
+}
+
+.chart-card h3 {
+    margin-bottom: 20px;
+    color: #e6edf3;
+    font-size: 18px;
+}
+
+.data-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(600px, 1fr));
+    gap: 20px;
+    margin-bottom: 30px;
+}
+
+.data-card {
+    background: #161b22;
+    padding: 24px;
+    border-radius: 8px;
+    border: 1px solid #30363d;
+}
+
+.data-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 20px;
+}
+
+.data-header h3 {
+    color: #e6edf3;
+    font-size: 18px;
+}
+
+.btn-small {
+    background: #238636;
+    color: #fff;
+    border: none;
+    padding: 6px 12px;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 14px;
+    transition: background 0.2s;
+}
+
+.btn-small:hover {
+    background: #2ea043;
+}
+
+.btn-primary {
+    background: #58a6ff;
+    color: #0d1117;
+    border: none;
+    padding: 10px 20px;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 14px;
+    font-weight: 600;
+    transition: background 0.2s;
+}
+
+.btn-primary:hover {
+    background: #79c0ff;
+}
+
+.table-container {
+    overflow-x: auto;
+}
+
+table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+thead {
+    background: #0d1117;
+}
+
+th {
+    padding: 12px;
+    text-align: left;
+    color: #8b949e;
+    font-weight: 600;
+    font-size: 12px;
+    text-transform: uppercase;
+    border-bottom: 1px solid #30363d;
+}
+
+td {
+    padding: 12px;
+    border-bottom: 1px solid #21262d;
+    color: #e6edf3;
+}
+
+tr:hover {
+    background: #0d1117;
+}
+
+.no-data {
+    text-align: center;
+    color: #8b949e;
+    padding: 40px !important;
+}
+
+.severity-badge {
+    padding: 4px 8px;
+    border-radius: 4px;
+    font-size: 12px;
+    font-weight: 600;
+}
+
+.severity-critical {
+    background: #da3633;
+    color: #fff;
+}
+
+.severity-warning {
+    background: #d29922;
+    color: #0d1117;
+}
+
+.severity-info {
+    background: #58a6ff;
+    color: #0d1117;
+}
+
+.alert-actions {
+    display: flex;
+    gap: 8px;
+}
+
+.alert-actions button {
+    background: #238636;
+    color: #fff;
+    border: none;
+    padding: 4px 10px;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 12px;
+}
+
+.alert-actions button:hover {
+    background: #2ea043;
+}
+
+.system-metrics {
+    display: grid;
+    gap: 16px;
+}
+
+.system-metric {
+    display: flex;
+    justify-content: space-between;
+    padding: 12px 0;
+    border-bottom: 1px solid #21262d;
+}
+
+.system-metric:last-child {
+    border-bottom: none;
+}
+
+.metric-name {
+    color: #8b949e;
+    font-size: 14px;
+}
+
+.metric-val {
+    color: #58a6ff;
+    font-weight: 600;
+    font-size: 14px;
+}
+
+.kpi-section {
+    background: #161b22;
+    padding: 24px;
+    border-radius: 8px;
+    border: 1px solid #30363d;
+}
+
+.kpi-section h3 {
+    margin-bottom: 20px;
+    color: #e6edf3;
+    font-size: 18px;
+}
+
+.form-group {
+    display: flex;
+    gap: 12px;
+    align-items: center;
+}
+
+.form-group input {
+    flex: 1;
+    background: #0d1117;
+    border: 1px solid #30363d;
+    color: #e6edf3;
+    padding: 10px 12px;
+    border-radius: 6px;
+    font-size: 14px;
+}
+
+.form-group input:focus {
+    outline: none;
+    border-color: #58a6ff;
+}
+
+@media (max-width: 768px) {
+    .metrics-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .charts-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .data-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .header {
+        flex-direction: column;
+        gap: 15px;
+        text-align: center;
+    }
+}