decision_agent 0.1.3 → 0.1.4

data/spec/issue_verification_spec.rb

@@ -254,6 +254,54 @@ RSpec.describe "Issue Verification Tests" do
             )
           end.to raise_error(ActiveRecord::RecordNotUnique)
         end
+
+        it "verifies application-level constraint for single active version (all databases)" do
+          # For databases that don't support partial unique indexes (like SQLite),
+          # the application should enforce only one active version per rule
+
+          ActiveRecord::Schema.define do
+            create_table :rule_versions, force: true do |t|
+              t.string :rule_id, null: false
+              t.integer :version_number, null: false
+              t.text :content, null: false
+              t.string :status, default: "active", null: false
+              t.timestamps
+            end
+            add_index :rule_versions, %i[rule_id version_number], unique: true
+          end
+
+          class TestRuleVersion6 < ActiveRecord::Base
+            self.table_name = "rule_versions"
+
+            # Application-level validation (works on all databases)
+            validate :only_one_active_per_rule, if: -> { status == "active" }
+
+            def only_one_active_per_rule
+              existing = self.class.where(rule_id: rule_id, status: "active")
+              existing = existing.where.not(id: id) if persisted?
+              return unless existing.exists?
+
+              errors.add(:base, "Only one active version allowed per rule")
+            end
+          end
+
+          TestRuleVersion6.create!(
+            rule_id: "test_rule",
+            version_number: 1,
+            content: { test: "v1" }.to_json,
+            status: "active"
+          )
+
+          # Try to create second active version - should fail with validation error
+          expect do
+            TestRuleVersion6.create!(
+              rule_id: "test_rule",
+              version_number: 2,
+              content: { test: "v2" }.to_json,
+              status: "active"
+            )
+          end.to raise_error(ActiveRecord::RecordInvalid, /Only one active version allowed/)
+        end
       end
     end
   end
@@ -466,7 +514,11 @@ RSpec.describe "Issue Verification Tests" do
           add_index :rule_versions, %i[rule_id version_number], unique: true
         end
 
-        unless defined?(RuleVersion)
+        if defined?(RuleVersion)
+          # Clear existing validations if RuleVersion was defined by another spec
+          RuleVersion.clear_validators!
+          RuleVersion.reset_callbacks(:validate)
+        else
           class ::RuleVersion < ActiveRecord::Base
           end
         end
@@ -495,33 +547,55 @@ RSpec.describe "Issue Verification Tests" do
           end.to raise_error(DecisionAgent::ValidationError, /Invalid JSON/)
         end
 
-        it "raises ValidationError when content is empty string" do
-          # ActiveRecord validation prevents empty string content
-          skip "ActiveRecord validation prevents empty string content"
+        it "handles empty string content in JSON parsing" do
+          # Even if the database allows empty strings (no NOT NULL + no validation),
+          # the adapter should handle it gracefully when parsing JSON
+          version = RuleVersion.create!(
+            rule_id: "test_rule",
+            version_number: 1,
+            content: "", # EMPTY STRING!
+            created_by: "test",
+            status: "active"
+          )
 
-          # This test would only be relevant if the model allowed empty strings
-          # The RuleVersion model has `validates :content, presence: true`
-          # which rejects empty strings before record creation
+          # serialize_version should catch JSON parsing errors
+          expect do
+            adapter.send(:serialize_version, version)
+          end.to raise_error(DecisionAgent::ValidationError, /Invalid JSON/)
         end
 
-        it "raises ValidationError when content is nil (if allowed by DB)" do
-          # Skip this test because the schema has NOT NULL constraint on content
-          # The database won't allow nil content to be saved in the first place
-          skip "Schema has NOT NULL constraint on content column"
+        it "enforces NOT NULL constraint on content column" do
+          # The schema has NOT NULL constraint on content column
+          # The database should raise an error when trying to create with nil content
 
-          # This test would only be relevant if the schema allowed NULL content
-          # In that case, the serialize_version method already handles it with:
-          # rescue TypeError, NoMethodError
-          #   raise DecisionAgent::ValidationError, "content is nil or not a string"
+          expect do
+            RuleVersion.create!(
+              rule_id: "test_rule",
+              version_number: 1,
+              content: nil, # NIL!
+              created_by: "test",
+              status: "active"
+            )
+          end.to raise_error(ActiveRecord::NotNullViolation)
         end
 
-        it "raises ValidationError when content contains malformed UTF-8" do
-          # ActiveRecord validation rejects malformed UTF-8 before record creation
-          skip "ActiveRecord validation rejects malformed UTF-8 strings"
+        it "handles content with special UTF-8 characters correctly" do
+          # Instead of testing malformed UTF-8 (which ActiveRecord rejects),
+          # test that valid UTF-8 special characters are handled correctly
+          special_content = {
+            "unicode" => "Hello \u4E16\u754C",
+            "emoji" => "\u{1F44D}",
+            "special" => "\n\t\r"
+          }
 
-          # This test would only be relevant if ActiveRecord allowed malformed UTF-8
-          # In practice, ActiveRecord's blank? check fails on invalid UTF-8
-          # which prevents the record from being created in the first place
+          version = adapter.create_version(
+            rule_id: "test_rule",
+            content: special_content,
+            metadata: { created_by: "test" }
+          )
+
+          loaded = adapter.get_version(version_id: version[:id])
+          expect(loaded[:content]).to eq(special_content)
         end
 
         it "raises ValidationError when content is truncated JSON" do

data/spec/monitoring/metrics_collector_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "decision_agent/monitoring/metrics_collector"
 
 RSpec.describe DecisionAgent::Monitoring::MetricsCollector do
-  let(:collector) { described_class.new(window_size: 60) }
+  let(:collector) { described_class.new(window_size: 60, storage: :memory) }
   let(:decision) do
     double(
       "Decision",
@@ -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)
+      collector = described_class.new(window_size: 1, storage: :memory)
 
       collector.record_decision(decision, context)
       expect(collector.metrics_count[:decisions]).to eq(1)

data/spec/monitoring/monitored_agent_spec.rb

@@ -3,7 +3,7 @@ require "decision_agent/monitoring/metrics_collector"
 require "decision_agent/monitoring/monitored_agent"
 
 RSpec.describe DecisionAgent::Monitoring::MonitoredAgent do
-  let(:collector) { DecisionAgent::Monitoring::MetricsCollector.new }
+  let(:collector) { DecisionAgent::Monitoring::MetricsCollector.new(storage: :memory) }
   let(:evaluator) do
     double(
       "Evaluator",

data/spec/monitoring/prometheus_exporter_spec.rb

@@ -3,7 +3,7 @@ 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(:collector) { DecisionAgent::Monitoring::MetricsCollector.new(storage: :memory) }
   let(:exporter) { described_class.new(metrics_collector: collector, namespace: "test") }
 
   let(:decision) do

data/spec/monitoring/storage/activerecord_adapter_spec.rb

@@ -0,0 +1,346 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "active_record"
+require "decision_agent/monitoring/storage/activerecord_adapter"
+
+RSpec.describe DecisionAgent::Monitoring::Storage::ActiveRecordAdapter do
+  # Setup in-memory SQLite database for testing
+  before(:all) do
+    ActiveRecord::Base.establish_connection(
+      adapter: "sqlite3",
+      database: ":memory:"
+    )
+
+    # Create tables
+    ActiveRecord::Schema.define do
+      create_table :decision_logs, force: true do |t|
+        t.string :decision, null: false
+        t.float :confidence
+        t.integer :evaluations_count, default: 0
+        t.float :duration_ms
+        t.string :status
+        t.text :context
+        t.text :metadata
+        t.timestamps
+      end
+
+      create_table :evaluation_metrics, force: true do |t|
+        t.references :decision_log, foreign_key: true
+        t.string :evaluator_name, null: false
+        t.float :score
+        t.boolean :success
+        t.float :duration_ms
+        t.text :details
+        t.timestamps
+      end
+
+      create_table :performance_metrics, force: true do |t|
+        t.string :operation, null: false
+        t.float :duration_ms
+        t.string :status
+        t.text :metadata
+        t.timestamps
+      end
+
+      create_table :error_metrics, force: true do |t|
+        t.string :error_type, null: false
+        t.text :message
+        t.text :stack_trace
+        t.string :severity
+        t.text :context
+        t.timestamps
+      end
+    end
+
+    # Define models
+    # rubocop:disable Lint/ConstantDefinitionInBlock
+    class DecisionLog < ActiveRecord::Base
+      has_many :evaluation_metrics, dependent: :destroy
+
+      scope :recent, ->(time_range) { where("created_at >= ?", Time.now - time_range) }
+
+      def self.success_rate(time_range: 3600)
+        total = recent(time_range).where.not(status: nil).count
+        return 0.0 if total.zero?
+
+        recent(time_range).where(status: "success").count.to_f / total
+      end
+
+      def parsed_context
+        JSON.parse(context, symbolize_names: true)
+      rescue StandardError
+        {}
+      end
+    end
+
+    class EvaluationMetric < ActiveRecord::Base
+      belongs_to :decision_log, optional: true
+
+      scope :recent, ->(time_range) { where("created_at >= ?", Time.now - time_range) }
+      scope :successful, -> { where(success: true) }
+
+      def parsed_details
+        JSON.parse(details, symbolize_names: true)
+      rescue StandardError
+        {}
+      end
+    end
+
+    class PerformanceMetric < ActiveRecord::Base
+      scope :recent, ->(time_range) { where("created_at >= ?", Time.now - time_range) }
+
+      def self.average_duration(time_range: 3600)
+        recent(time_range).average(:duration_ms).to_f
+      end
+
+      def self.p50(time_range: 3600)
+        percentile(0.50, time_range: time_range)
+      end
+
+      def self.p95(time_range: 3600)
+        percentile(0.95, time_range: time_range)
+      end
+
+      def self.p99(time_range: 3600)
+        percentile(0.99, time_range: time_range)
+      end
+
+      def self.percentile(pct, time_range: 3600)
+        durations = recent(time_range).where.not(duration_ms: nil).order(:duration_ms).pluck(:duration_ms)
+        return 0.0 if durations.empty?
+
+        durations[(durations.length * pct).ceil - 1].to_f
+      end
+
+      def self.success_rate(time_range: 3600)
+        total = recent(time_range).where.not(status: nil).count
+        return 0.0 if total.zero?
+
+        recent(time_range).where(status: "success").count.to_f / total
+      end
+    end
+
+    class ErrorMetric < ActiveRecord::Base
+      scope :recent, ->(time_range) { where("created_at >= ?", Time.now - time_range) }
+      scope :critical, -> { where(severity: "critical") }
+
+      def parsed_context
+        JSON.parse(context, symbolize_names: true)
+      rescue StandardError
+        {}
+      end
+    end
+    # rubocop:enable Lint/ConstantDefinitionInBlock
+  end
+
+  before do
+    DecisionLog.delete_all
+    EvaluationMetric.delete_all
+    PerformanceMetric.delete_all
+    ErrorMetric.delete_all
+  end
+
+  let(:adapter) { described_class.new }
+
+  describe ".available?" do
+    it "returns true when ActiveRecord and models are defined" do
+      expect(described_class.available?).to be_truthy
+    end
+  end
+
+  describe "#record_decision" do
+    it "creates a decision log record" do
+      expect do
+        adapter.record_decision(
+          "approve_payment",
+          { user_id: 123, amount: 500 },
+          confidence: 0.85,
+          evaluations_count: 3,
+          duration_ms: 45.5,
+          status: "success"
+        )
+      end.to change(DecisionLog, :count).by(1)
+
+      log = DecisionLog.last
+      expect(log.decision).to eq("approve_payment")
+      expect(log.confidence).to eq(0.85)
+      expect(log.evaluations_count).to eq(3)
+      expect(log.duration_ms).to eq(45.5)
+      expect(log.status).to eq("success")
+      expect(log.parsed_context).to eq(user_id: 123, amount: 500)
+    end
+  end
+
+  describe "#record_evaluation" do
+    it "creates an evaluation metric record" do
+      expect do
+        adapter.record_evaluation(
+          "FraudDetector",
+          score: 0.92,
+          success: true,
+          duration_ms: 12.3,
+          details: { risk_level: "low" }
+        )
+      end.to change(EvaluationMetric, :count).by(1)
+
+      metric = EvaluationMetric.last
+      expect(metric.evaluator_name).to eq("FraudDetector")
+      expect(metric.score).to eq(0.92)
+      expect(metric.success).to be true
+      expect(metric.duration_ms).to eq(12.3)
+      expect(metric.parsed_details).to eq(risk_level: "low")
+    end
+  end
+
+  describe "#record_performance" do
+    it "creates a performance metric record" do
+      expect do
+        adapter.record_performance(
+          "api_call",
+          duration_ms: 250.5,
+          status: "success",
+          metadata: { endpoint: "/api/v1/users" }
+        )
+      end.to change(PerformanceMetric, :count).by(1)
+
+      metric = PerformanceMetric.last
+      expect(metric.operation).to eq("api_call")
+      expect(metric.duration_ms).to eq(250.5)
+      expect(metric.status).to eq("success")
+    end
+  end
+
+  describe "#record_error" do
+    it "creates an error metric record" do
+      expect do
+        adapter.record_error(
+          "RuntimeError",
+          message: "Something went wrong",
+          stack_trace: ["line 1", "line 2"],
+          severity: "critical",
+          context: { user_id: 456 }
+        )
+      end.to change(ErrorMetric, :count).by(1)
+
+      error = ErrorMetric.last
+      expect(error.error_type).to eq("RuntimeError")
+      expect(error.message).to eq("Something went wrong")
+      expect(error.severity).to eq("critical")
+      expect(error.parsed_context).to eq(user_id: 456)
+    end
+  end
+
+  describe "#statistics" do
+    before do
+      # Create test data
+      3.times do |i|
+        adapter.record_decision(
+          "decision_#{i}",
+          { index: i },
+          confidence: 0.5 + (i * 0.1),
+          evaluations_count: 2,
+          duration_ms: 100 + (i * 10),
+          status: "success"
+        )
+      end
+
+      2.times do |i|
+        adapter.record_evaluation(
+          "Evaluator#{i}",
+          score: 0.8,
+          success: true,
+          duration_ms: 50
+        )
+      end
+
+      4.times do |i|
+        adapter.record_performance(
+          "operation_#{i}",
+          duration_ms: 100 + (i * 50),
+          status: i.even? ? "success" : "failure"
+        )
+      end
+
+      adapter.record_error("TestError", severity: "critical")
+    end
+
+    it "returns comprehensive statistics" do
+      stats = adapter.statistics(time_range: 3600)
+
+      expect(stats[:decisions][:total]).to eq(3)
+      expect(stats[:decisions][:average_confidence]).to be_within(0.01).of(0.6)
+      expect(stats[:evaluations][:total]).to eq(2)
+      expect(stats[:performance][:total]).to eq(4)
+      expect(stats[:errors][:total]).to eq(1)
+      expect(stats[:errors][:critical_count]).to eq(1)
+    end
+  end
+
+  describe "#time_series" do
+    before do
+      # Create metrics at different times
+      [10, 70, 130].each do |seconds_ago|
+        travel_back = Time.now - seconds_ago
+        DecisionLog.create!(
+          decision: "test",
+          confidence: 0.8,
+          created_at: travel_back
+        )
+      end
+    end
+
+    it "returns time series data grouped by 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)
+    end
+  end
+
+  describe "#metrics_count" do
+    before do
+      adapter.record_decision("test", {}, confidence: 0.8)
+      adapter.record_evaluation("TestEval", score: 0.9)
+      adapter.record_performance("test_op", duration_ms: 100)
+      adapter.record_error("TestError")
+    end
+
+    it "returns count of all metric types" do
+      counts = adapter.metrics_count
+
+      expect(counts[:decisions]).to eq(1)
+      expect(counts[:evaluations]).to eq(1)
+      expect(counts[:performance]).to eq(1)
+      expect(counts[:errors]).to eq(1)
+    end
+  end
+
+  describe "#cleanup" do
+    before do
+      # Create old metrics
+      old_time = Time.now - 8.days
+      DecisionLog.create!(decision: "old", confidence: 0.8, created_at: old_time)
+      EvaluationMetric.create!(evaluator_name: "old", created_at: old_time)
+      PerformanceMetric.create!(operation: "old", created_at: old_time)
+      ErrorMetric.create!(error_type: "old", created_at: old_time)
+
+      # Create recent metrics
+      adapter.record_decision("recent", {}, confidence: 0.8)
+      adapter.record_evaluation("recent", score: 0.9)
+      adapter.record_performance("recent", duration_ms: 100)
+      adapter.record_error("recent")
+    end
+
+    it "removes old metrics and keeps recent ones" do
+      count = adapter.cleanup(older_than: 7.days.to_i)
+
+      expect(count).to eq(4) # 4 old metrics removed
+      expect(DecisionLog.count).to eq(1)
+      expect(EvaluationMetric.count).to eq(1)
+      expect(PerformanceMetric.count).to eq(1)
+      expect(ErrorMetric.count).to eq(1)
+    end
+  end
+end