decision_agent 0.2.0 → 1.0.1

data/spec/monitoring/monitored_agent_spec.rb

@@ -1,222 +0,0 @@
-require "spec_helper"
-require "decision_agent/monitoring/metrics_collector"
-require "decision_agent/monitoring/monitored_agent"
-
-RSpec.describe DecisionAgent::Monitoring::MonitoredAgent do
-  let(:collector) { DecisionAgent::Monitoring::MetricsCollector.new(storage: :memory) }
-  let(:evaluator) do
-    double(
-      "Evaluator",
-      evaluate: DecisionAgent::Evaluation.new(
-        decision: "approve",
-        weight: 0.9,
-        reason: "Test reason",
-        evaluator_name: "test_evaluator"
-      )
-    )
-  end
-  let(:agent) { DecisionAgent::Agent.new(evaluators: [evaluator]) }
-  let(:monitored_agent) { described_class.new(agent: agent, metrics_collector: collector) }
-
-  describe "#initialize" do
-    it "wraps an agent with metrics collection" do
-      expect(monitored_agent.agent).to eq(agent)
-      expect(monitored_agent.metrics_collector).to eq(collector)
-    end
-  end
-
-  describe "#decide" do
-    let(:context) { { amount: 1000 } }
-
-    it "makes a decision and records metrics" do
-      result = monitored_agent.decide(context: context)
-
-      expect(result).to be_a(DecisionAgent::Decision)
-      expect(result.decision).to eq("approve")
-      expect(collector.metrics_count[:decisions]).to eq(1)
-      expect(collector.metrics_count[:evaluations]).to eq(1)
-      expect(collector.metrics_count[:performance]).to eq(1)
-    end
-
-    it "records decision metrics with duration" do
-      monitored_agent.decide(context: context)
-
-      stats = collector.statistics
-      expect(stats[:decisions][:total]).to eq(1)
-      expect(stats[:decisions][:avg_duration_ms]).to be > 0
-    end
-
-    it "records evaluation metrics" do
-      monitored_agent.decide(context: context)
-
-      stats = collector.statistics
-      expect(stats[:evaluations][:total]).to eq(1)
-      expect(stats[:evaluations][:evaluator_distribution]["test_evaluator"]).to eq(1)
-    end
-
-    it "records performance metrics as successful" do
-      monitored_agent.decide(context: context)
-
-      stats = collector.statistics
-      expect(stats[:performance][:total_operations]).to eq(1)
-      expect(stats[:performance][:successful]).to eq(1)
-      expect(stats[:performance][:success_rate]).to eq(1.0)
-    end
-
-    it "includes metadata in performance metrics" do
-      monitored_agent.decide(context: context)
-
-      collector.statistics
-      perf_metric = collector.instance_variable_get(:@metrics)[:performance].first
-
-      expect(perf_metric[:metadata][:evaluators_count]).to eq(1)
-      expect(perf_metric[:metadata][:decision]).to eq("approve")
-      expect(perf_metric[:metadata][:confidence]).to be_a(Float)
-    end
-
-    context "when decision fails" do
-      before do
-        allow(agent).to receive(:decide).and_raise(StandardError.new("Test error"))
-      end
-
-      it "records error metrics" do
-        expect do
-          monitored_agent.decide(context: context)
-        end.to raise_error(StandardError, "Test error")
-
-        expect(collector.metrics_count[:errors]).to eq(1)
-      end
-
-      it "records failed performance metrics" do
-        expect do
-          monitored_agent.decide(context: context)
-        end.to raise_error(StandardError)
-
-        stats = collector.statistics
-        expect(stats[:performance][:total_operations]).to eq(1)
-        expect(stats[:performance][:failed]).to eq(1)
-        expect(stats[:performance][:success_rate]).to eq(0.0)
-      end
-
-      it "includes error details in metrics" do
-        expect do
-          monitored_agent.decide(context: context)
-        end.to raise_error(StandardError)
-
-        error_metric = collector.instance_variable_get(:@metrics)[:errors].first
-        expect(error_metric[:error_class]).to eq("StandardError")
-        expect(error_metric[:error_message]).to eq("Test error")
-        expect(error_metric[:context]).to eq(context)
-      end
-
-      it "re-raises the error" do
-        expect do
-          monitored_agent.decide(context: context)
-        end.to raise_error(StandardError, "Test error")
-      end
-    end
-
-    it "handles Context objects" do
-      ctx = DecisionAgent::Context.new(context)
-      result = monitored_agent.decide(context: ctx)
-
-      expect(result).to be_a(DecisionAgent::Decision)
-      expect(collector.metrics_count[:decisions]).to eq(1)
-    end
-
-    it "handles hash contexts" do
-      result = monitored_agent.decide(context: context)
-
-      expect(result).to be_a(DecisionAgent::Decision)
-      expect(collector.metrics_count[:decisions]).to eq(1)
-    end
-
-    it "measures decision duration accurately" do
-      # Mock agent to introduce delay
-      allow(agent).to receive(:decide) do |*args|
-        sleep 0.01 # 10ms delay
-        evaluator.evaluate(args.first)
-        DecisionAgent::Decision.new(
-          decision: "approve",
-          confidence: 0.9,
-          explanations: ["Test"],
-          evaluations: [evaluator.evaluate(args.first)],
-          audit_payload: {}
-        )
-      end
-
-      monitored_agent.decide(context: context)
-
-      stats = collector.statistics
-      expect(stats[:decisions][:avg_duration_ms]).to be >= 10
-    end
-  end
-
-  describe "method delegation" do
-    it "delegates methods to wrapped agent" do
-      expect(monitored_agent.evaluators).to eq(agent.evaluators)
-      expect(monitored_agent.scoring_strategy).to eq(agent.scoring_strategy)
-      expect(monitored_agent.audit_adapter).to eq(agent.audit_adapter)
-    end
-
-    it "responds to agent methods" do
-      expect(monitored_agent).to respond_to(:evaluators)
-      expect(monitored_agent).to respond_to(:scoring_strategy)
-      expect(monitored_agent).to respond_to(:audit_adapter)
-    end
-  end
-
-  describe "thread safety" do
-    it "handles concurrent decisions safely" do
-      # Materialize let variables before creating threads
-      test_context = { amount: 1000 }
-      test_monitored_agent = monitored_agent
-      test_collector = collector
-
-      threads = 10.times.map do
-        Thread.new do
-          10.times do
-            test_monitored_agent.decide(context: test_context)
-          end
-        end
-      end
-
-      threads.each(&:join)
-
-      expect(test_collector.metrics_count[:decisions]).to eq(100)
-      expect(test_collector.metrics_count[:evaluations]).to eq(100)
-      expect(test_collector.metrics_count[:performance]).to eq(100)
-    end
-  end
-
-  describe "integration test" do
-    it "provides comprehensive metrics for multiple decisions" do
-      contexts = [
-        { amount: 500 },
-        { amount: 1500 },
-        { amount: 2000 }
-      ]
-
-      contexts.each do |ctx|
-        monitored_agent.decide(context: ctx)
-      end
-
-      stats = collector.statistics
-
-      # Summary
-      expect(stats[:summary][:total_decisions]).to eq(3)
-      expect(stats[:summary][:total_evaluations]).to eq(3)
-      expect(stats[:summary][:total_errors]).to eq(0)
-
-      # Decision stats
-      expect(stats[:decisions][:total]).to eq(3)
-      expect(stats[:decisions][:avg_confidence]).to be > 0
-      expect(stats[:decisions][:decision_distribution]["approve"]).to eq(3)
-
-      # Performance stats
-      expect(stats[:performance][:total_operations]).to eq(3)
-      expect(stats[:performance][:success_rate]).to eq(1.0)
-      expect(stats[:performance][:avg_duration_ms]).to be > 0
-    end
-  end
-end

data/spec/monitoring/prometheus_exporter_spec.rb

@@ -1,242 +0,0 @@
-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(storage: :memory) }
-  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