decision_agent 0.1.2 → 0.1.4

data/spec/monitoring/storage/memory_adapter_spec.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "decision_agent/monitoring/storage/memory_adapter"
+
+RSpec.describe DecisionAgent::Monitoring::Storage::MemoryAdapter do
+  let(:adapter) { described_class.new(window_size: 3600) }
+
+  describe ".available?" do
+    it "is always available" do
+      expect(described_class.available?).to be true
+    end
+  end
+
+  describe "#record_decision" do
+    it "stores decision in memory" do
+      expect do
+        adapter.record_decision(
+          "approve_loan",
+          { user_id: 123, amount: 10_000 },
+          confidence: 0.85,
+          evaluations_count: 3,
+          duration_ms: 45.5,
+          status: "success"
+        )
+      end.to change { adapter.metrics_count[:decisions] }.by(1)
+    end
+  end
+
+  describe "#record_evaluation" do
+    it "stores evaluation in memory" do
+      expect do
+        adapter.record_evaluation(
+          "CreditScoreEvaluator",
+          score: 0.92,
+          success: true,
+          duration_ms: 12.3,
+          details: { credit_score: 750 }
+        )
+      end.to change { adapter.metrics_count[:evaluations] }.by(1)
+    end
+  end
+
+  describe "#record_performance" do
+    it "stores performance metric in memory" do
+      expect do
+        adapter.record_performance(
+          "database_query",
+          duration_ms: 150.5,
+          status: "success",
+          metadata: { query: "SELECT * FROM users" }
+        )
+      end.to change { adapter.metrics_count[:performance] }.by(1)
+    end
+  end
+
+  describe "#record_error" do
+    it "stores error in memory" do
+      expect do
+        adapter.record_error(
+          "ArgumentError",
+          message: "Invalid input",
+          stack_trace: ["line 1", "line 2"],
+          severity: "medium",
+          context: { input: "bad_value" }
+        )
+      end.to change { adapter.metrics_count[:errors] }.by(1)
+    end
+  end
+
+  describe "#statistics" do
+    before do
+      # Create test data
+      5.times do |i|
+        adapter.record_decision(
+          "decision_#{i}",
+          { index: i },
+          confidence: 0.5 + (i * 0.05),
+          evaluations_count: 2,
+          duration_ms: 100,
+          status: i.even? ? "success" : "failure"
+        )
+      end
+
+      3.times do |i|
+        adapter.record_evaluation(
+          "Evaluator#{i}",
+          score: 0.8 + (i * 0.05),
+          success: true
+        )
+      end
+
+      6.times do |i|
+        adapter.record_performance(
+          "operation",
+          duration_ms: 100 + (i * 20),
+          status: "success"
+        )
+      end
+
+      2.times do
+        adapter.record_error("RuntimeError", severity: "critical")
+      end
+    end
+
+    it "returns comprehensive statistics" do
+      stats = adapter.statistics(time_range: 3600)
+
+      expect(stats[:decisions][:total]).to eq(5)
+      expect(stats[:decisions][:average_confidence]).to be_within(0.01).of(0.6)
+      expect(stats[:decisions][:success_rate]).to eq(0.6) # 3 out of 5
+
+      expect(stats[:evaluations][:total]).to eq(3)
+      expect(stats[:evaluations][:average_score]).to be_within(0.01).of(0.85)
+
+      expect(stats[:performance][:total]).to eq(6)
+      expect(stats[:performance][:average_duration_ms]).to eq(150.0)
+      expect(stats[:performance][:success_rate]).to eq(1.0)
+
+      expect(stats[:errors][:total]).to eq(2)
+      expect(stats[:errors][:critical_count]).to eq(2)
+    end
+
+    it "filters by time range" do
+      # Record an old metric that should be filtered out
+      adapter.instance_variable_get(:@metrics)[:decisions] << {
+        decision: "old_decision",
+        confidence: 0.5,
+        timestamp: Time.now - 7200 # 2 hours ago
+      }
+
+      stats = adapter.statistics(time_range: 3600) # Last hour only
+
+      expect(stats[:decisions][:total]).to eq(5) # Doesn't include the old one
+    end
+  end
+
+  describe "#time_series" do
+    before do
+      # Create metrics at different times
+      now = Time.now
+      adapter.instance_variable_get(:@metrics)[:decisions] << { timestamp: now - 120 }
+      adapter.instance_variable_get(:@metrics)[:decisions] << { timestamp: now - 70 }
+      adapter.instance_variable_get(:@metrics)[:decisions] << { timestamp: now - 10 }
+    end
+
+    it "groups metrics into time buckets" 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) # All 3 metrics
+    end
+
+    it "uses correct bucket size" do
+      series = adapter.time_series(:decisions, bucket_size: 60, time_range: 200)
+
+      # Metrics should be grouped into 60-second buckets
+      expect(series[:data].max).to be <= 2 # No bucket should have more than 2
+    end
+  end
+
+  describe "#metrics_count" do
+    before do
+      adapter.record_decision("test", {}, confidence: 0.8)
+      adapter.record_decision("test2", {}, confidence: 0.9)
+      adapter.record_evaluation("eval1", score: 0.85)
+      adapter.record_performance("perf1", duration_ms: 100)
+      adapter.record_error("Error1")
+    end
+
+    it "returns count for each metric type" do
+      counts = adapter.metrics_count
+
+      expect(counts[:decisions]).to eq(2)
+      expect(counts[:evaluations]).to eq(1)
+      expect(counts[:performance]).to eq(1)
+      expect(counts[:errors]).to eq(1)
+    end
+  end
+
+  describe "#cleanup" do
+    let(:long_window_adapter) { described_class.new(window_size: 30 * 24 * 3_600) } # 30 day window
+
+    before do
+      now = Time.now
+
+      # Add old metrics (8 days ago) to adapter with long window
+      long_window_adapter.instance_variable_get(:@metrics)[:decisions] << {
+        decision: "old",
+        timestamp: now - (8 * 24 * 3600)
+      }
+      long_window_adapter.instance_variable_get(:@metrics)[:evaluations] << {
+        evaluator_name: "old",
+        timestamp: now - (8 * 24 * 3600)
+      }
+
+      # Add recent metrics
+      long_window_adapter.record_decision("recent", {}, confidence: 0.8)
+      long_window_adapter.record_evaluation("recent", score: 0.9)
+    end
+
+    it "removes old metrics and returns count" do
+      count = long_window_adapter.cleanup(older_than: 7 * 24 * 3600) # 7 days
+
+      expect(count).to eq(2) # 2 old metrics removed
+      expect(long_window_adapter.metrics_count[:decisions]).to eq(1) # Only recent one
+      expect(long_window_adapter.metrics_count[:evaluations]).to eq(1)
+    end
+  end
+
+  describe "window-based cleanup" do
+    let(:short_window_adapter) { described_class.new(window_size: 60) } # 1 minute window
+
+    it "automatically removes metrics older than window_size" do
+      now = Time.now
+
+      # Add old metric
+      short_window_adapter.instance_variable_get(:@metrics)[:decisions] << {
+        decision: "old",
+        timestamp: now - 120 # 2 minutes ago
+      }
+
+      # Add new metric (this should trigger cleanup)
+      short_window_adapter.record_decision("new", {}, confidence: 0.8)
+
+      # Only the new metric should remain
+      expect(short_window_adapter.metrics_count[:decisions]).to eq(1)
+    end
+  end
+
+  describe "thread safety" do
+    it "handles concurrent writes" do
+      threads = 10.times.map do
+        Thread.new do
+          100.times do |i|
+            adapter.record_decision("concurrent_#{i}", {}, confidence: 0.8)
+          end
+        end
+      end
+
+      threads.each(&:join)
+
+      expect(adapter.metrics_count[:decisions]).to eq(1000)
+    end
+  end
+end

data/spec/replay_edge_cases_spec.rb

@@ -23,7 +23,7 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         rules: [
           {
             id: "auto_approve",
-            if: { field: "score", op: "gte", value: 90 },  # Changed threshold
+            if: { field: "score", op: "gte", value: 90 }, # Changed threshold
             then: { decision: "approve", weight: 0.9, reason: "Very high score" }
           }
         ]
@@ -36,9 +36,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
 
       original_result = agent.decide(context: { score: 85 })
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(original_result.audit_payload, strict: true)
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it "detects differences in strict mode when rules have changed" do
@@ -52,9 +52,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
 
       # Replay uses the stored evaluations (not re-evaluating rules)
       # So it should succeed because replay uses static evaluators from the audit payload
-      expect {
+      expect do
         DecisionAgent::Replay.run(original_result.audit_payload, strict: true)
-      }.not_to raise_error
+      end.not_to raise_error
 
       # The replayed result should match the original
       replayed_result = DecisionAgent::Replay.run(original_result.audit_payload, strict: true)
@@ -69,9 +69,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
       original_result = agent.decide(context: { score: 85 })
 
       # In non-strict mode, differences are logged but don't raise errors
-      expect {
+      expect do
         DecisionAgent::Replay.run(original_result.audit_payload, strict: false)
-      }.not_to raise_error
+      end.not_to raise_error
     end
   end
 
@@ -124,9 +124,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
       # StaticEvaluator adds type: "static" by default
       expect(original_result.evaluations.first.metadata).to eq({ type: "static" })
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(original_result.audit_payload, strict: true)
-      }.not_to raise_error
+      end.not_to raise_error
 
       replayed_result = DecisionAgent::Replay.run(original_result.audit_payload, strict: true)
       expect(replayed_result.evaluations.first.metadata).to eq({ type: "static" })
@@ -140,7 +140,7 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         evaluator_name: "CustomEvaluator",
         metadata: {
           user: { id: 123, role: "admin" },
-          tags: ["urgent", "important"],
+          tags: %w[urgent important],
           history: [
             { action: "created", timestamp: "2025-01-01" },
             { action: "updated", timestamp: "2025-01-02" }
@@ -183,21 +183,21 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
             decision: "allow",
             weight: 0.9,
             reason: "User authenticated successfully",
-            evaluator_name: "DeletedCustomAuthEvaluator",  # This evaluator no longer exists
+            evaluator_name: "DeletedCustomAuthEvaluator", # This evaluator no longer exists
             metadata: { auth_method: "oauth", provider: "google" }
           }
         ],
         decision: "allow",
-        confidence: 1.0,  # WeightedAverage normalizes single eval to 1.0
+        confidence: 1.0, # WeightedAverage normalizes single eval to 1.0
         scoring_strategy: "DecisionAgent::Scoring::WeightedAverage",
         agent_version: "0.1.0",
         deterministic_hash: "abc123"
       }
 
       # Replay should work because it uses StaticEvaluator, not the original evaluator
-      expect {
+      expect do
         DecisionAgent::Replay.run(audit_payload, strict: true)
-      }.not_to raise_error
+      end.not_to raise_error
 
       replayed_result = DecisionAgent::Replay.run(audit_payload, strict: true)
 
@@ -224,12 +224,12 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
             decision: "approve",
             weight: 0.7,
             reason: "ML model prediction",
-            evaluator_name: "NonExistentMLEvaluator",  # Missing evaluator
+            evaluator_name: "NonExistentMLEvaluator", # Missing evaluator
             metadata: { model_version: "v2.1" }
           }
         ],
         decision: "approve",
-        confidence: 1.0,  # Both agree, so 100% confidence
+        confidence: 1.0, # Both agree, so 100% confidence
         scoring_strategy: "DecisionAgent::Scoring::WeightedAverage",
         agent_version: "0.1.0",
         deterministic_hash: "def456"
@@ -260,15 +260,15 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         ],
         decision: "approve",
         confidence: 0.9,
-        scoring_strategy: "DecisionAgent::Scoring::DeprecatedBayesianStrategy",  # Doesn't exist
+        scoring_strategy: "DecisionAgent::Scoring::DeprecatedBayesianStrategy", # Doesn't exist
         agent_version: "0.1.0",
         deterministic_hash: "ghi789"
       }
 
       # Should fall back to WeightedAverage
-      expect {
+      expect do
         DecisionAgent::Replay.run(audit_payload, strict: false)
-      }.not_to raise_error
+      end.not_to raise_error
 
       replayed_result = DecisionAgent::Replay.run(audit_payload, strict: false)
       expect(replayed_result.decision).to eq("approve")
@@ -291,9 +291,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
 
       # Replay uses the stored scoring strategy from the audit payload
       # So it should replay successfully
-      expect {
+      expect do
         DecisionAgent::Replay.run(original_result.audit_payload, strict: true)
-      }.not_to raise_error
+      end.not_to raise_error
     end
   end
 
@@ -305,9 +305,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         confidence: 0.5
       }
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(incomplete_payload, strict: false)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError, /missing required key: context/)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError, /missing required key: context/)
     end
 
     it "requires evaluations field" do
@@ -317,9 +317,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         confidence: 0.5
       }
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(incomplete_payload, strict: false)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError, /missing required key: evaluations/)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError, /missing required key: evaluations/)
     end
 
     it "requires decision field" do
@@ -329,9 +329,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         confidence: 0.5
       }
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(incomplete_payload, strict: false)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError, /missing required key: decision/)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError, /missing required key: decision/)
     end
 
     it "requires confidence field" do
@@ -341,9 +341,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         decision: "test"
       }
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(incomplete_payload, strict: false)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError, /missing required key: confidence/)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError, /missing required key: confidence/)
     end
 
     it "accepts both symbol and string keys" do
@@ -366,9 +366,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         "scoring_strategy" => "DecisionAgent::Scoring::MaxWeight"
       }
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(payload_with_strings, strict: true)
-      }.not_to raise_error
+      end.not_to raise_error
     end
   end
 
@@ -460,12 +460,12 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
 
       # Modify agent_version
       modified_payload = original_result.audit_payload.dup
-      modified_payload[:agent_version] = "99.0.0"  # Different version
+      modified_payload[:agent_version] = "99.0.0" # Different version
 
       # Non-strict mode should log but not raise
-      expect {
+      expect do
         DecisionAgent::Replay.run(modified_payload, strict: false)
-      }.not_to raise_error
+      end.not_to raise_error
 
       # Should successfully replay despite version difference
       replayed_result = DecisionAgent::Replay.run(modified_payload, strict: false)
@@ -489,7 +489,7 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         decision: "approve",
         confidence: 1.0,
         scoring_strategy: "DecisionAgent::Scoring::WeightedAverage",
-        agent_version: "0.0.1",  # Old version
+        agent_version: "0.0.1", # Old version
         deterministic_hash: "old_hash"
       }
 
@@ -514,9 +514,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
 
       # Strict mode should still work because version is not part of deterministic comparison
       # (only decision and confidence are compared in strict mode)
-      expect {
+      expect do
         DecisionAgent::Replay.run(modified_payload, strict: true)
-      }.not_to raise_error
+      end.not_to raise_error
     end
   end
 
@@ -543,9 +543,9 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
       }
 
       # Should not raise error, just creates new hash during replay
-      expect {
+      expect do
         DecisionAgent::Replay.run(audit_payload, strict: false)
-      }.not_to raise_error
+      end.not_to raise_error
 
       result = DecisionAgent::Replay.run(audit_payload, strict: false)
       expect(result.decision).to eq("approve")
@@ -582,24 +582,24 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
 
     it "validates required fields before replay" do
       # Missing context
-      expect {
+      expect do
         DecisionAgent::Replay.run({ decision: "test", confidence: 0.5, evaluations: [] }, strict: true)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError, /context/)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError, /context/)
 
       # Missing evaluations
-      expect {
+      expect do
         DecisionAgent::Replay.run({ context: {}, decision: "test", confidence: 0.5 }, strict: true)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError, /evaluations/)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError, /evaluations/)
 
       # Missing decision
-      expect {
+      expect do
         DecisionAgent::Replay.run({ context: {}, evaluations: [], confidence: 0.5 }, strict: true)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError, /decision/)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError, /decision/)
 
       # Missing confidence
-      expect {
+      expect do
         DecisionAgent::Replay.run({ context: {}, evaluations: [], decision: "test" }, strict: true)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError, /confidence/)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError, /confidence/)
     end
 
     it "handles evaluation with invalid weight" do
@@ -610,7 +610,7 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         evaluations: [
           {
             decision: "approve",
-            weight: 2.5,  # Weight > 1.0, invalid
+            weight: 2.5, # Weight > 1.0, invalid
             reason: "Test",
             evaluator_name: "TestEvaluator",
             metadata: {}
@@ -622,21 +622,21 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
       }
 
       # Invalid weight (> 1.0) should raise error when creating Evaluation
-      expect {
+      expect do
         DecisionAgent::Replay.run(audit_payload, strict: false)
-      }.to raise_error(DecisionAgent::InvalidWeightError)
+      end.to raise_error(DecisionAgent::InvalidWeightError)
     end
 
     it "handles completely empty audit payload" do
-      expect {
+      expect do
         DecisionAgent::Replay.run({}, strict: false)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError)
     end
 
     it "handles nil audit payload" do
-      expect {
+      expect do
         DecisionAgent::Replay.run(nil, strict: false)
-      }.to raise_error
+      end.to raise_error
     end
   end
 
@@ -657,14 +657,14 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         ],
         decision: "approve",
         confidence: 0.9,
-        scoring_strategy: "DecisionAgent::Scoring::OldStrategyName",  # Renamed or deleted
+        scoring_strategy: "DecisionAgent::Scoring::OldStrategyName", # Renamed or deleted
         agent_version: "0.1.0"
       }
 
       # Should fall back to default strategy (WeightedAverage)
-      expect {
+      expect do
         DecisionAgent::Replay.run(audit_payload, strict: false)
-      }.not_to raise_error
+      end.not_to raise_error
 
       result = DecisionAgent::Replay.run(audit_payload, strict: false)
       expect(result.decision).to eq("approve")
@@ -686,7 +686,7 @@ RSpec.describe "DecisionAgent::Replay Edge Cases" do
         ],
         decision: "approve",
         confidence: 0.85,
-        scoring_strategy: "MyCompany::CustomMLBasedScoringStrategy",  # Custom strategy
+        scoring_strategy: "MyCompany::CustomMLBasedScoringStrategy", # Custom strategy
         agent_version: "0.1.0"
       }
 

data/spec/replay_spec.rb

@@ -34,9 +34,9 @@ RSpec.describe DecisionAgent::Replay do
       modified_payload = original_result.audit_payload.dup
       modified_payload[:decision] = "reject"
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(modified_payload, strict: true)
-      }.to raise_error(DecisionAgent::ReplayMismatchError) do |error|
+      end.to raise_error(DecisionAgent::ReplayMismatchError) do |error|
         expect(error.differences).to include(/decision mismatch/)
         expect(error.expected[:decision]).to eq("reject")
         expect(error.actual[:decision]).to eq("approve")
@@ -50,9 +50,9 @@ RSpec.describe DecisionAgent::Replay do
       modified_payload = original_result.audit_payload.dup
       modified_payload[:confidence] = 0.5
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(modified_payload, strict: true)
-      }.to raise_error(DecisionAgent::ReplayMismatchError) do |error|
+      end.to raise_error(DecisionAgent::ReplayMismatchError) do |error|
         expect(error.differences).to include(/confidence mismatch/)
       end
     end
@@ -64,9 +64,9 @@ RSpec.describe DecisionAgent::Replay do
       modified_payload = original_result.audit_payload.dup
       modified_payload[:decision] = "reject"
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(modified_payload, strict: false)
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it "logs differences in non-strict mode" do
@@ -76,17 +76,17 @@ RSpec.describe DecisionAgent::Replay do
       modified_payload = original_result.audit_payload.dup
       modified_payload[:decision] = "reject"
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(modified_payload, strict: false)
-      }.to output(/Decision changed/).to_stderr
+      end.to output(/Decision changed/).to_stderr
     end
 
     it "validates required fields in audit payload" do
       invalid_payload = { context: {} }
 
-      expect {
+      expect do
         DecisionAgent::Replay.run(invalid_payload, strict: true)
-      }.to raise_error(DecisionAgent::InvalidRuleDslError, /missing required key/)
+      end.to raise_error(DecisionAgent::InvalidRuleDslError, /missing required key/)
     end
 
     it "reconstructs evaluations from audit payload" do
@@ -112,7 +112,7 @@ RSpec.describe DecisionAgent::Replay do
       )
 
       expect(replayed_result.evaluations.size).to eq(2)
-      expect(replayed_result.evaluations.map(&:evaluator_name)).to match_array(["Evaluator1", "Evaluator2"])
+      expect(replayed_result.evaluations.map(&:evaluator_name)).to match_array(%w[Evaluator1 Evaluator2])
     end
 
     it "uses correct scoring strategy from audit payload" do