decision_agent 0.1.4 → 0.1.6

data/spec/monitoring/metrics_collector_spec.rb

@@ -266,7 +266,7 @@ RSpec.describe DecisionAgent::Monitoring::MetricsCollector do
 
   describe "metric cleanup" do
     it "removes old metrics outside window" do
-      collector = described_class.new(window_size: 1, storage: :memory)
+      collector = described_class.new(window_size: 1, storage: :memory, cleanup_threshold: 1)
 
       collector.record_decision(decision, context)
       expect(collector.metrics_count[:decisions]).to eq(1)
@@ -274,8 +274,226 @@ RSpec.describe DecisionAgent::Monitoring::MetricsCollector do
       sleep 1.5
 
       collector.record_decision(decision, context)
-      # Old metric should be cleaned up
+      # Old metric should be cleaned up (threshold=1 means cleanup on every record)
       expect(collector.metrics_count[:decisions]).to eq(1)
     end
   end
+
+  describe "#record_evaluation" do
+    let(:evaluation) do
+      double(
+        "Evaluation",
+        decision: "approve",
+        weight: 0.9,
+        evaluator_name: "test_evaluator"
+      )
+    end
+
+    it "notifies observers" do
+      observed = []
+      collector.add_observer do |type, metric|
+        observed << [type, metric]
+      end
+
+      collector.record_evaluation(evaluation)
+
+      expect(observed.size).to eq(1)
+      expect(observed[0][0]).to eq(:evaluation)
+      expect(observed[0][1][:decision]).to eq("approve")
+    end
+  end
+
+  describe "#record_performance" do
+    it "notifies observers" do
+      observed = []
+      collector.add_observer do |type, metric|
+        observed << [type, metric]
+      end
+
+      collector.record_performance(operation: "test", duration_ms: 10.0, success: true)
+
+      expect(observed.size).to eq(1)
+      expect(observed[0][0]).to eq(:performance)
+      expect(observed[0][1][:operation]).to eq("test")
+    end
+  end
+
+  describe "#record_error" do
+    it "notifies observers" do
+      observed = []
+      collector.add_observer do |type, metric|
+        observed << [type, metric]
+      end
+
+      collector.record_error(StandardError.new("Test"))
+
+      expect(observed.size).to eq(1)
+      expect(observed[0][0]).to eq(:error)
+      expect(observed[0][1][:error_class]).to eq("StandardError")
+    end
+
+    it "handles different error types" do
+      expect { collector.record_error(ArgumentError.new("Arg error")) }.not_to raise_error
+      expect { collector.record_error(TypeError.new("Type error")) }.not_to raise_error
+      expect { collector.record_error(Exception.new("Exception")) }.not_to raise_error
+    end
+  end
+
+  describe "#add_observer" do
+    it "adds an observer callback" do
+      callback = proc { |type, metric| }
+      collector.add_observer(&callback)
+      # Observer should be stored
+      expect(collector.instance_variable_get(:@observers)).to include(callback)
+    end
+
+    it "handles observer errors gracefully" do
+      # Add observer that raises error
+      collector.add_observer do |_type, _metric|
+        raise "Observer error"
+      end
+
+      # Should not raise, just warn
+      expect { collector.record_decision(decision, context) }.not_to raise_error
+    end
+  end
+
+  describe "#statistics" do
+    before do
+      3.times do
+        evaluation = double("Evaluation", decision: "approve", weight: 0.8, evaluator_name: "eval1")
+        collector.record_evaluation(evaluation)
+      end
+      2.times do
+        evaluation = double("Evaluation", decision: "reject", weight: 0.6, evaluator_name: "eval2")
+        collector.record_evaluation(evaluation)
+      end
+    end
+
+    it "computes evaluation statistics" do
+      stats = collector.statistics
+      expect(stats[:evaluations][:total]).to eq(5)
+      expect(stats[:evaluations][:avg_weight]).to be_within(0.01).of(0.72)
+    end
+
+    it "handles empty decisions gracefully" do
+      empty_collector = described_class.new(storage: :memory)
+      stats = empty_collector.statistics
+      expect(stats[:decisions]).to eq({})
+    end
+
+    it "handles decisions without duration_ms" do
+      decision_no_duration = double(
+        "Decision",
+        decision: "approve",
+        confidence: 0.5,
+        evaluations: []
+      )
+      collector.record_decision(decision_no_duration, context)
+      stats = collector.statistics
+      expect(stats[:decisions][:avg_duration_ms]).to be_nil
+    end
+  end
+
+  describe "#time_series" do
+    it "handles empty metric types" do
+      series = collector.time_series(metric_type: :nonexistent, bucket_size: 60, time_range: 3600)
+      expect(series).to eq([])
+    end
+
+    it "filters metrics by time range" do
+      # Record some old metrics (simulated)
+      old_time = Time.now.utc - 7200
+      allow(Time).to receive(:now).and_return(Time.at(old_time.to_i))
+      5.times { collector.record_decision(decision, context) }
+
+      # Record new metrics
+      allow(Time).to receive(:now).and_call_original
+      3.times { collector.record_decision(decision, context) }
+
+      series = collector.time_series(metric_type: :decisions, bucket_size: 60, time_range: 3600)
+      # Should only include recent metrics
+      total = series.sum { |s| s[:count] }
+      expect(total).to be <= 3
+    end
+  end
+
+  describe "#cleanup_old_metrics_from_storage" do
+    it "delegates to storage adapter if it has cleanup method" do
+      # Using memory adapter which doesn't have cleanup
+      expect(collector.cleanup_old_metrics_from_storage(older_than: 3600)).to eq(0)
+    end
+  end
+
+  describe "#initialize_storage_adapter" do
+    it "uses memory storage when :memory specified" do
+      collector = described_class.new(storage: :memory)
+      expect(collector.storage_adapter).to be_a(DecisionAgent::Monitoring::Storage::MemoryAdapter)
+    end
+
+    it "raises error for unknown storage option" do
+      expect do
+        described_class.new(storage: :unknown)
+      end.to raise_error(ArgumentError, /Unknown storage option/)
+    end
+  end
+
+  describe "error severity determination" do
+    it "determines severity for ArgumentError as medium" do
+      error = ArgumentError.new("test")
+      collector.record_error(error)
+      # Just verify it doesn't raise
+      expect(collector.metrics_count[:errors]).to eq(1)
+    end
+
+    it "determines severity for TypeError as medium" do
+      error = TypeError.new("test")
+      collector.record_error(error)
+      expect(collector.metrics_count[:errors]).to eq(1)
+    end
+
+    it "determines severity for Exception as critical" do
+      error = Exception.new("test")
+      collector.record_error(error)
+      expect(collector.metrics_count[:errors]).to eq(1)
+    end
+  end
+
+  describe "decision status determination" do
+    it "determines status for high confidence decisions" do
+      high_conf_decision = double(
+        "Decision",
+        decision: "approve",
+        confidence: 0.9,
+        evaluations: []
+      )
+      collector.record_decision(high_conf_decision, context)
+      # Just verify it records successfully
+      expect(collector.metrics_count[:decisions]).to eq(1)
+    end
+
+    it "determines status for low confidence decisions" do
+      low_conf_decision = double(
+        "Decision",
+        decision: "approve",
+        confidence: 0.2,
+        evaluations: []
+      )
+      collector.record_decision(low_conf_decision, context)
+      expect(collector.metrics_count[:decisions]).to eq(1)
+    end
+  end
+
+  describe "#compute_performance_stats" do
+    it "computes percentile statistics" do
+      durations = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
+      durations.each do |duration|
+        collector.record_performance(operation: "test", duration_ms: duration, success: true)
+      end
+
+      stats = collector.statistics
+      expect(stats[:performance][:p95_duration_ms]).to be >= 90
+      expect(stats[:performance][:p99_duration_ms]).to be >= 95
+    end
+  end
 end

data/spec/monitoring/storage/activerecord_adapter_spec.rb

@@ -170,6 +170,13 @@ RSpec.describe DecisionAgent::Monitoring::Storage::ActiveRecordAdapter do
       expect(log.status).to eq("success")
       expect(log.parsed_context).to eq(user_id: 123, amount: 500)
     end
+
+    it "handles database errors gracefully" do
+      allow(DecisionLog).to receive(:create!).and_raise(StandardError.new("DB error"))
+      expect do
+        adapter.record_decision("test", {})
+      end.not_to raise_error
+    end
   end
 
   describe "#record_evaluation" do
@@ -191,6 +198,13 @@ RSpec.describe DecisionAgent::Monitoring::Storage::ActiveRecordAdapter do
       expect(metric.duration_ms).to eq(12.3)
       expect(metric.parsed_details).to eq(risk_level: "low")
     end
+
+    it "handles database errors gracefully" do
+      allow(EvaluationMetric).to receive(:create!).and_raise(StandardError.new("DB error"))
+      expect do
+        adapter.record_evaluation("test")
+      end.not_to raise_error
+    end
   end
 
   describe "#record_performance" do
@@ -209,6 +223,13 @@ RSpec.describe DecisionAgent::Monitoring::Storage::ActiveRecordAdapter do
       expect(metric.duration_ms).to eq(250.5)
       expect(metric.status).to eq("success")
     end
+
+    it "handles database errors gracefully" do
+      allow(PerformanceMetric).to receive(:create!).and_raise(StandardError.new("DB error"))
+      expect do
+        adapter.record_performance("test")
+      end.not_to raise_error
+    end
   end
 
   describe "#record_error" do
@@ -229,6 +250,19 @@ RSpec.describe DecisionAgent::Monitoring::Storage::ActiveRecordAdapter do
       expect(error.severity).to eq("critical")
       expect(error.parsed_context).to eq(user_id: 456)
     end
+
+    it "handles nil stack_trace" do
+      adapter.record_error("TestError", stack_trace: nil)
+      error = ErrorMetric.last
+      expect(error.stack_trace).to be_nil
+    end
+
+    it "handles database errors gracefully" do
+      allow(ErrorMetric).to receive(:create!).and_raise(StandardError.new("DB error"))
+      expect do
+        adapter.record_error("test")
+      end.not_to raise_error
+    end
   end
 
   describe "#statistics" do
@@ -275,6 +309,37 @@ RSpec.describe DecisionAgent::Monitoring::Storage::ActiveRecordAdapter do
       expect(stats[:errors][:total]).to eq(1)
       expect(stats[:errors][:critical_count]).to eq(1)
     end
+
+    it "handles empty statistics" do
+      DecisionLog.delete_all
+      EvaluationMetric.delete_all
+      PerformanceMetric.delete_all
+      ErrorMetric.delete_all
+
+      stats = adapter.statistics(time_range: 3600)
+
+      expect(stats[:decisions][:total]).to eq(0)
+      expect(stats[:decisions][:average_confidence]).to eq(0.0)
+      expect(stats[:evaluations][:total]).to eq(0)
+      expect(stats[:performance][:total]).to eq(0)
+      expect(stats[:errors][:total]).to eq(0)
+    end
+
+    it "handles decisions without confidence" do
+      DecisionLog.delete_all
+      adapter.record_decision("test", {}, confidence: nil)
+
+      stats = adapter.statistics(time_range: 3600)
+      expect(stats[:decisions][:average_confidence]).to eq(0.0)
+    end
+
+    it "handles database errors gracefully" do
+      allow(DecisionLog).to receive(:recent).and_raise(StandardError.new("DB error"))
+      stats = adapter.statistics(time_range: 3600)
+
+      expect(stats[:decisions][:total]).to eq(0)
+      expect(stats[:evaluations][:total]).to eq(0)
+    end
   end
 
   describe "#time_series" do
@@ -290,13 +355,77 @@ RSpec.describe DecisionAgent::Monitoring::Storage::ActiveRecordAdapter do
       end
     end
 
-    it "returns time series data grouped by buckets" do
+    it "returns time series data grouped by buckets for decisions" do
       series = adapter.time_series(:decisions, bucket_size: 60, time_range: 200)
 
       expect(series[:timestamps]).to be_an(Array)
       expect(series[:data]).to be_an(Array)
       expect(series[:data].sum).to eq(3)
     end
+
+    it "returns time series data for evaluations" do
+      [10, 70].each do |seconds_ago|
+        travel_back = Time.now - seconds_ago
+        EvaluationMetric.create!(
+          evaluator_name: "test",
+          score: 0.8,
+          created_at: travel_back
+        )
+      end
+
+      series = adapter.time_series(:evaluations, bucket_size: 60, time_range: 200)
+
+      expect(series[:timestamps]).to be_an(Array)
+      expect(series[:data]).to be_an(Array)
+      expect(series[:data].sum).to eq(2)
+    end
+
+    it "returns time series data for performance" do
+      [10, 70].each do |seconds_ago|
+        travel_back = Time.now - seconds_ago
+        PerformanceMetric.create!(
+          operation: "test",
+          duration_ms: 100,
+          created_at: travel_back
+        )
+      end
+
+      series = adapter.time_series(:performance, bucket_size: 60, time_range: 200)
+
+      expect(series[:timestamps]).to be_an(Array)
+      expect(series[:data]).to be_an(Array)
+    end
+
+    it "returns time series data for errors" do
+      [10, 70].each do |seconds_ago|
+        travel_back = Time.now - seconds_ago
+        ErrorMetric.create!(
+          error_type: "TestError",
+          created_at: travel_back
+        )
+      end
+
+      series = adapter.time_series(:errors, bucket_size: 60, time_range: 200)
+
+      expect(series[:timestamps]).to be_an(Array)
+      expect(series[:data]).to be_an(Array)
+      expect(series[:data].sum).to eq(2)
+    end
+
+    it "returns empty data for unknown metric type" do
+      series = adapter.time_series(:unknown, bucket_size: 60, time_range: 200)
+
+      expect(series[:timestamps]).to eq([])
+      expect(series[:data]).to eq([])
+    end
+
+    it "handles database errors gracefully" do
+      allow(DecisionLog).to receive(:recent).and_raise(StandardError.new("DB error"))
+      series = adapter.time_series(:decisions, bucket_size: 60, time_range: 200)
+
+      expect(series[:timestamps]).to eq([])
+      expect(series[:data]).to eq([])
+    end
   end
 
   describe "#metrics_count" do
@@ -315,6 +444,16 @@ RSpec.describe DecisionAgent::Monitoring::Storage::ActiveRecordAdapter do
       expect(counts[:performance]).to eq(1)
       expect(counts[:errors]).to eq(1)
     end
+
+    it "handles database errors gracefully" do
+      allow(DecisionLog).to receive(:count).and_raise(StandardError.new("DB error"))
+      counts = adapter.metrics_count
+
+      expect(counts[:decisions]).to eq(0)
+      expect(counts[:evaluations]).to eq(0)
+      expect(counts[:performance]).to eq(0)
+      expect(counts[:errors]).to eq(0)
+    end
   end
 
   describe "#cleanup" do
@@ -342,5 +481,18 @@ RSpec.describe DecisionAgent::Monitoring::Storage::ActiveRecordAdapter do
       expect(PerformanceMetric.count).to eq(1)
       expect(ErrorMetric.count).to eq(1)
     end
+
+    it "handles database errors gracefully" do
+      allow(DecisionLog).to receive(:where).and_raise(StandardError.new("DB error"))
+      count = adapter.cleanup(older_than: 7.days.to_i)
+
+      expect(count).to eq(0)
+    end
+  end
+
+  describe "#initialize" do
+    it "validates required models exist" do
+      expect { described_class.new }.not_to raise_error
+    end
   end
 end

data/spec/monitoring/storage/base_adapter_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+RSpec.describe DecisionAgent::Monitoring::Storage::BaseAdapter do
+  let(:adapter) { described_class.new }
+
+  describe "abstract methods" do
+    it "raises NotImplementedError for record_decision" do
+      expect do
+        adapter.record_decision("approve", {})
+      end.to raise_error(NotImplementedError)
+    end
+
+    it "raises NotImplementedError for record_evaluation" do
+      expect do
+        adapter.record_evaluation("evaluator1")
+      end.to raise_error(NotImplementedError)
+    end
+
+    it "raises NotImplementedError for record_performance" do
+      expect do
+        adapter.record_performance("operation")
+      end.to raise_error(NotImplementedError)
+    end
+
+    it "raises NotImplementedError for record_error" do
+      expect do
+        adapter.record_error("ErrorType")
+      end.to raise_error(NotImplementedError)
+    end
+
+    it "raises NotImplementedError for statistics" do
+      expect do
+        adapter.statistics
+      end.to raise_error(NotImplementedError)
+    end
+
+    it "raises NotImplementedError for time_series" do
+      expect do
+        adapter.time_series(:decisions)
+      end.to raise_error(NotImplementedError)
+    end
+
+    it "raises NotImplementedError for metrics_count" do
+      expect do
+        adapter.metrics_count
+      end.to raise_error(NotImplementedError)
+    end
+
+    it "raises NotImplementedError for cleanup" do
+      expect do
+        adapter.cleanup(older_than: 3600)
+      end.to raise_error(NotImplementedError)
+    end
+
+    it "raises NotImplementedError for available?" do
+      expect do
+        described_class.available?
+      end.to raise_error(NotImplementedError)
+    end
+  end
+end