decision_agent 0.1.1 → 0.1.3

data/spec/monitoring/prometheus_exporter_spec.rb

@@ -0,0 +1,242 @@
+require "spec_helper"
+require "decision_agent/monitoring/metrics_collector"
+require "decision_agent/monitoring/prometheus_exporter"
+
+RSpec.describe DecisionAgent::Monitoring::PrometheusExporter do
+  let(:collector) { DecisionAgent::Monitoring::MetricsCollector.new }
+  let(:exporter) { described_class.new(metrics_collector: collector, namespace: "test") }
+
+  let(:decision) do
+    double(
+      "Decision",
+      decision: "approve",
+      confidence: 0.85,
+      evaluations: [double("Evaluation", evaluator_name: "test_evaluator")]
+    )
+  end
+  let(:context) { double("Context", to_h: { user: "test" }) }
+
+  describe "#initialize" do
+    it "initializes with metrics collector" do
+      expect(exporter).to be_a(described_class)
+    end
+
+    it "uses default namespace" do
+      exporter = described_class.new(metrics_collector: collector)
+      output = exporter.export
+      expect(output).to include("decision_agent_")
+    end
+
+    it "uses custom namespace" do
+      output = exporter.export
+      expect(output).to include("test_")
+    end
+  end
+
+  describe "#export" do
+    before do
+      # Record some metrics
+      3.times { collector.record_decision(decision, context, duration_ms: 10.0) }
+      collector.record_performance(operation: "decide", duration_ms: 15.0, success: true)
+      collector.record_error(StandardError.new("Test error"))
+    end
+
+    it "exports in Prometheus text format" do
+      output = exporter.export
+
+      expect(output).to be_a(String)
+      expect(output).to include("# DecisionAgent Metrics Export")
+    end
+
+    it "includes decision metrics" do
+      output = exporter.export
+
+      expect(output).to include("# HELP test_decisions_total")
+      expect(output).to include("# TYPE test_decisions_total counter")
+      expect(output).to include("test_decisions_total 3")
+    end
+
+    it "includes confidence metrics" do
+      output = exporter.export
+
+      expect(output).to include("# HELP test_decision_confidence_avg")
+      expect(output).to include("# TYPE test_decision_confidence_avg gauge")
+      expect(output).to include("test_decision_confidence_avg 0.85")
+    end
+
+    it "includes performance metrics" do
+      output = exporter.export
+
+      expect(output).to include("# HELP test_success_rate")
+      expect(output).to include("# TYPE test_success_rate gauge")
+    end
+
+    it "includes error metrics" do
+      output = exporter.export
+
+      expect(output).to include("# HELP test_errors_total")
+      expect(output).to include("# TYPE test_errors_total counter")
+      expect(output).to include("test_errors_total 1")
+    end
+
+    it "includes system info" do
+      output = exporter.export
+
+      expect(output).to include("# HELP test_info")
+      expect(output).to include("# TYPE test_info gauge")
+      expect(output).to include("version=\"#{DecisionAgent::VERSION}\"")
+    end
+
+    it "includes decision distribution" do
+      output = exporter.export
+
+      expect(output).to include("# HELP test_decisions_by_type")
+      expect(output).to include("test_decisions_by_type{decision=\"approve\"} 3")
+    end
+
+    it "includes error distribution by type" do
+      output = exporter.export
+
+      expect(output).to include("# HELP test_errors_by_type")
+      expect(output).to include("test_errors_by_type{error=\"StandardError\"} 1")
+    end
+
+    it "includes metrics count" do
+      output = exporter.export
+
+      expect(output).to include("# HELP test_metrics_stored")
+      expect(output).to include("test_metrics_stored{type=\"decisions\"} 3")
+      expect(output).to include("test_metrics_stored{type=\"errors\"} 1")
+    end
+  end
+
+  describe "#register_kpi" do
+    it "registers a custom KPI" do
+      exporter.register_kpi(
+        name: "custom_metric",
+        value: 42.5,
+        help: "A custom metric"
+      )
+
+      output = exporter.export
+      expect(output).to include("# HELP test_custom_metric A custom metric")
+      expect(output).to include("# TYPE test_custom_metric gauge")
+      expect(output).to include("test_custom_metric 42.5")
+    end
+
+    it "registers KPI with labels" do
+      exporter.register_kpi(
+        name: "requests",
+        value: 100,
+        labels: { endpoint: "/api/v1", method: "GET" }
+      )
+
+      output = exporter.export
+      expect(output).to include("test_requests{endpoint=\"/api/v1\",method=\"GET\"} 100")
+    end
+
+    it "sanitizes metric names" do
+      exporter.register_kpi(name: "my-custom.metric!", value: 10)
+
+      output = exporter.export
+      expect(output).to include("test_my_custom_metric_")
+    end
+
+    it "escapes label values" do
+      exporter.register_kpi(
+        name: "metric",
+        value: 1,
+        labels: { message: 'Contains "quotes"' }
+      )
+
+      output = exporter.export
+      expect(output).to include('message="Contains \"quotes\""')
+    end
+  end
+
+  describe "#metrics_hash" do
+    before do
+      collector.record_decision(decision, context, duration_ms: 10.0)
+    end
+
+    it "returns metrics as hash" do
+      metrics = exporter.metrics_hash
+
+      expect(metrics).to be_a(Hash)
+      expect(metrics).to have_key(:decisions)
+      expect(metrics).to have_key(:performance)
+      expect(metrics).to have_key(:errors)
+      expect(metrics).to have_key(:system)
+    end
+
+    it "includes metric types" do
+      metrics = exporter.metrics_hash
+
+      expect(metrics[:decisions][:total][:type]).to eq("counter")
+      expect(metrics[:decisions][:avg_confidence][:type]).to eq("gauge")
+    end
+
+    it "includes metric values" do
+      metrics = exporter.metrics_hash
+
+      expect(metrics[:decisions][:total][:value]).to eq(1)
+      expect(metrics[:decisions][:avg_confidence][:value]).to eq(0.85)
+    end
+  end
+
+  describe "thread safety" do
+    it "handles concurrent KPI registration" do
+      threads = 10.times.map do |i|
+        Thread.new do
+          10.times do |j|
+            exporter.register_kpi(
+              name: "metric_#{i}_#{j}",
+              value: (i * 10) + j
+            )
+          end
+        end
+      end
+
+      expect { threads.each(&:join) }.not_to raise_error
+    end
+
+    it "handles concurrent exports" do
+      threads = 5.times.map do
+        Thread.new do
+          10.times { exporter.export }
+        end
+      end
+
+      expect { threads.each(&:join) }.not_to raise_error
+    end
+  end
+
+  describe "performance metrics export" do
+    before do
+      5.times do |i|
+        collector.record_performance(
+          operation: "decide",
+          duration_ms: (i + 1) * 10.0,
+          success: true
+        )
+      end
+    end
+
+    it "exports summary metrics" do
+      output = exporter.export
+
+      expect(output).to include("# TYPE test_operation_duration_ms summary")
+      expect(output).to include("test_operation_duration_ms{quantile=\"0.5\"}")
+      expect(output).to include("test_operation_duration_ms{quantile=\"0.95\"}")
+      expect(output).to include("test_operation_duration_ms{quantile=\"0.99\"}")
+      expect(output).to include("test_operation_duration_ms_sum")
+      expect(output).to include("test_operation_duration_ms_count")
+    end
+  end
+
+  describe "content type" do
+    it "defines Prometheus content type" do
+      expect(described_class::CONTENT_TYPE).to eq("text/plain; version=0.0.4")
+    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