decision_agent 0.1.2 → 0.1.4

data/lib/decision_agent/monitoring/storage/memory_adapter.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require_relative "base_adapter"
+require "monitor"
+
+module DecisionAgent
+  module Monitoring
+    module Storage
+      # In-memory adapter for metrics storage (default, no dependencies)
+      class MemoryAdapter < BaseAdapter
+        include MonitorMixin
+
+        def initialize(window_size: 3600)
+          super()
+          @window_size = window_size
+          @metrics = {
+            decisions: [],
+            evaluations: [],
+            performance: [],
+            errors: []
+          }
+        end
+
+        def record_decision(decision, context, confidence: nil, evaluations_count: 0, duration_ms: nil, status: nil)
+          synchronize do
+            @metrics[:decisions] << {
+              decision: decision,
+              context: context,
+              confidence: confidence,
+              evaluations_count: evaluations_count,
+              duration_ms: duration_ms,
+              status: status,
+              timestamp: Time.now
+            }
+            cleanup_old_metrics
+          end
+        end
+
+        def record_evaluation(evaluator_name, score: nil, success: nil, duration_ms: nil, details: {})
+          synchronize do
+            @metrics[:evaluations] << {
+              evaluator_name: evaluator_name,
+              score: score,
+              success: success,
+              duration_ms: duration_ms,
+              details: details,
+              timestamp: Time.now
+            }
+            cleanup_old_metrics
+          end
+        end
+
+        def record_performance(operation, duration_ms: nil, status: nil, metadata: {})
+          synchronize do
+            @metrics[:performance] << {
+              operation: operation,
+              duration_ms: duration_ms,
+              status: status,
+              metadata: metadata,
+              timestamp: Time.now
+            }
+            cleanup_old_metrics
+          end
+        end
+
+        def record_error(error_type, message: nil, stack_trace: nil, severity: nil, context: {})
+          synchronize do
+            @metrics[:errors] << {
+              error_type: error_type,
+              message: message,
+              stack_trace: stack_trace,
+              severity: severity,
+              context: context,
+              timestamp: Time.now
+            }
+            cleanup_old_metrics
+          end
+        end
+
+        def statistics(time_range: 3600)
+          synchronize do
+            cutoff = Time.now - time_range
+            recent_decisions = @metrics[:decisions].select { |m| m[:timestamp] >= cutoff }
+            recent_evaluations = @metrics[:evaluations].select { |m| m[:timestamp] >= cutoff }
+            recent_performance = @metrics[:performance].select { |m| m[:timestamp] >= cutoff }
+            recent_errors = @metrics[:errors].select { |m| m[:timestamp] >= cutoff }
+
+            {
+              decisions: decision_statistics(recent_decisions),
+              evaluations: evaluation_statistics(recent_evaluations),
+              performance: performance_statistics(recent_performance),
+              errors: error_statistics(recent_errors)
+            }
+          end
+        end
+
+        def time_series(metric_type, bucket_size: 60, time_range: 3600)
+          synchronize do
+            cutoff = Time.now - time_range
+            metrics = @metrics[metric_type].select { |m| m[:timestamp] >= cutoff }
+
+            buckets = Hash.new(0)
+            metrics.each do |metric|
+              bucket = (metric[:timestamp].to_i / bucket_size) * bucket_size
+              buckets[bucket] += 1
+            end
+
+            timestamps = buckets.keys.sort
+            {
+              timestamps: timestamps.map { |ts| Time.at(ts).iso8601 },
+              data: timestamps.map { |ts| buckets[ts] }
+            }
+          end
+        end
+
+        def metrics_count
+          synchronize do
+            {
+              decisions: @metrics[:decisions].size,
+              evaluations: @metrics[:evaluations].size,
+              performance: @metrics[:performance].size,
+              errors: @metrics[:errors].size
+            }
+          end
+        end
+
+        def cleanup(older_than:)
+          synchronize do
+            cutoff = Time.now - older_than
+            count = 0
+
+            @metrics.each_value do |metric_array|
+              before_size = metric_array.size
+              metric_array.reject! { |m| m[:timestamp] < cutoff }
+              count += before_size - metric_array.size
+            end
+
+            count
+          end
+        end
+
+        def self.available?
+          true # Always available, no dependencies
+        end
+
+        private
+
+        def cleanup_old_metrics
+          cutoff = Time.now - @window_size
+          @metrics.each_value do |metric_array|
+            metric_array.reject! { |m| m[:timestamp] < cutoff }
+          end
+        end
+
+        def decision_statistics(decisions)
+          total = decisions.size
+          confidences = decisions.map { |d| d[:confidence] }.compact
+          statuses = decisions.map { |d| d[:status] }.compact
+
+          {
+            total: total,
+            by_decision: decisions.group_by { |d| d[:decision] }.transform_values(&:count),
+            average_confidence: confidences.empty? ? 0.0 : confidences.sum / confidences.size.to_f,
+            success_rate: calculate_success_rate(statuses)
+          }
+        end
+
+        def evaluation_statistics(evaluations)
+          total = evaluations.size
+          scores = evaluations.map { |e| e[:score] }.compact
+
+          {
+            total: total,
+            by_evaluator: evaluations.group_by { |e| e[:evaluator_name] }.transform_values(&:count),
+            average_score: scores.empty? ? 0.0 : scores.sum / scores.size.to_f,
+            success_rate_by_evaluator: evaluations.select { |e| e[:success] }
+                                                  .group_by { |e| e[:evaluator_name] }
+                                                  .transform_values(&:count)
+          }
+        end
+
+        def performance_statistics(performance_metrics)
+          total = performance_metrics.size
+          durations = performance_metrics.map { |p| p[:duration_ms] }.compact.sort
+          statuses = performance_metrics.map { |p| p[:status] }.compact
+
+          {
+            total: total,
+            average_duration_ms: durations.empty? ? 0.0 : durations.sum / durations.size.to_f,
+            p50: percentile(durations, 0.50),
+            p95: percentile(durations, 0.95),
+            p99: percentile(durations, 0.99),
+            success_rate: calculate_success_rate(statuses)
+          }
+        end
+
+        def error_statistics(errors)
+          {
+            total: errors.size,
+            by_type: errors.group_by { |e| e[:error_type] }.transform_values(&:count),
+            by_severity: errors.group_by { |e| e[:severity] }.transform_values(&:count),
+            critical_count: errors.count { |e| e[:severity] == "critical" }
+          }
+        end
+
+        def percentile(sorted_array, pct)
+          return 0.0 if sorted_array.empty?
+
+          index = ((sorted_array.length - 1) * pct).ceil
+          sorted_array[index].to_f
+        end
+
+        def calculate_success_rate(statuses)
+          return 0.0 if statuses.empty?
+
+          successful = statuses.count { |s| s == "success" }
+          successful.to_f / statuses.size
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/replay/replay.rb

@@ -42,15 +42,11 @@ module DecisionAgent
       replayed_result
     end
 
-    private
-
     def self.validate_payload!(payload)
-      required_keys = ["context", "evaluations", "decision", "confidence"]
+      required_keys = %w[context evaluations decision confidence]
 
       required_keys.each do |key|
-        unless payload.key?(key) || payload.key?(key.to_sym)
-          raise InvalidRuleDslError, "Audit payload missing required key: #{key}"
-        end
+        raise InvalidRuleDslError, "Audit payload missing required key: #{key}" unless payload.key?(key) || payload.key?(key.to_sym)
       end
     end
 
@@ -111,30 +107,24 @@ module DecisionAgent
       end
 
       conf_diff = (original_confidence.to_f - replayed_confidence.to_f).abs
-      if conf_diff > 0.0001
-        differences << "confidence mismatch (expected: #{original_confidence}, got: #{replayed_confidence})"
-      end
+      differences << "confidence mismatch (expected: #{original_confidence}, got: #{replayed_confidence})" if conf_diff > 0.0001
 
-      if differences.any?
-        raise ReplayMismatchError.new(
-          expected: { decision: original_decision, confidence: original_confidence },
-          actual: { decision: replayed_decision, confidence: replayed_confidence },
-          differences: differences
-        )
-      end
+      return unless differences.any?
+
+      raise ReplayMismatchError.new(
+        expected: { decision: original_decision, confidence: original_confidence },
+        actual: { decision: replayed_decision, confidence: replayed_confidence },
+        differences: differences
+      )
     end
 
     def self.log_differences(original_decision:, original_confidence:, replayed_decision:, replayed_confidence:)
       differences = []
 
-      if original_decision.to_s != replayed_decision.to_s
-        differences << "Decision changed: #{original_decision} -> #{replayed_decision}"
-      end
+      differences << "Decision changed: #{original_decision} -> #{replayed_decision}" if original_decision.to_s != replayed_decision.to_s
 
       conf_diff = (original_confidence.to_f - replayed_confidence.to_f).abs
-      if conf_diff > 0.0001
-        differences << "Confidence changed: #{original_confidence} -> #{replayed_confidence}"
-      end
+      differences << "Confidence changed: #{original_confidence} -> #{replayed_confidence}" if conf_diff > 0.0001
 
       if differences.any?
         warn "[DecisionAgent::Replay] Non-strict mode differences detected:"

data/lib/decision_agent/scoring/base.rb

@@ -12,7 +12,7 @@ module DecisionAgent
       end
 
       def round_confidence(value)
-        (value * 10000).round / 10000.0
+        (value * 10_000).round / 10_000.0
       end
     end
   end

data/lib/decision_agent/scoring/consensus.rb

@@ -24,11 +24,11 @@ module DecisionAgent
 
         winning_decision, agreement, avg_weight = candidates.first
 
-        if agreement >= @minimum_agreement
-          confidence = agreement * avg_weight
-        else
-          confidence = agreement * avg_weight * 0.5
-        end
+        confidence = if agreement >= @minimum_agreement
+                       agreement * avg_weight
+                     else
+                       agreement * avg_weight * 0.5
+                     end
 
         {
           decision: winning_decision,

data/lib/decision_agent/scoring/weighted_average.rb

@@ -14,7 +14,7 @@ module DecisionAgent
         winning_decision, winning_weight = weighted_scores.max_by { |_, weight| weight }
 
         total_weight = evaluations.sum(&:weight)
-        confidence = total_weight > 0 ? winning_weight / total_weight : 0.0
+        confidence = total_weight.positive? ? winning_weight / total_weight : 0.0
 
         {
           decision: winning_decision,

data/lib/decision_agent/version.rb

@@ -1,3 +1,3 @@
 module DecisionAgent
-  VERSION = "0.1.2"
+  VERSION = "0.1.4".freeze
 end

data/lib/decision_agent/versioning/activerecord_adapter.rb

@@ -1,37 +1,53 @@
 require_relative "adapter"
+require_relative "file_storage_adapter"
 
 module DecisionAgent
   module Versioning
     # ActiveRecord-based version storage adapter for Rails applications
     # Requires ActiveRecord models to be set up in the Rails app
     class ActiveRecordAdapter < Adapter
+      include StatusValidator
+
       def initialize
-        unless defined?(ActiveRecord)
-          raise DecisionAgent::ConfigurationError,
-                "ActiveRecord is not available. Please ensure Rails/ActiveRecord is loaded."
-        end
+        return if defined?(ActiveRecord)
+
+        raise DecisionAgent::ConfigurationError,
+              "ActiveRecord is not available. Please ensure Rails/ActiveRecord is loaded."
       end
 
       def create_version(rule_id:, content:, metadata: {})
-        # Get the next version number for this rule
-        last_version = rule_version_class.where(rule_id: rule_id)
-                                        .order(version_number: :desc)
-                                        .first
-        next_version_number = last_version ? last_version.version_number + 1 : 1
-
-        # Deactivate previous active versions
-        rule_version_class.where(rule_id: rule_id, status: "active")
-                         .update_all(status: "archived")
-
-        # Create new version
-        version = rule_version_class.create!(
-          rule_id: rule_id,
-          version_number: next_version_number,
-          content: content.to_json,
-          created_by: metadata[:created_by] || "system",
-          changelog: metadata[:changelog] || "Version #{next_version_number}",
-          status: metadata[:status] || "active"
-        )
+        # Use a transaction with pessimistic locking to prevent race conditions
+        version = nil
+
+        # Validate status if provided
+        status = metadata[:status] || "active"
+        validate_status!(status)
+
+        rule_version_class.transaction do
+          # Lock the last version for this rule to prevent concurrent reads
+          # This ensures only one thread can calculate the next version number at a time
+          last_version = rule_version_class.where(rule_id: rule_id)
+                                           .order(version_number: :desc)
+                                           .lock
+                                           .first
+          next_version_number = last_version ? last_version.version_number + 1 : 1
+
+          # Deactivate previous active versions
+          # Use update! instead of update_all to trigger validations
+          rule_version_class.where(rule_id: rule_id, status: "active").find_each do |v|
+            v.update!(status: "archived")
+          end
+
+          # Create new version
+          version = rule_version_class.create!(
+            rule_id: rule_id,
+            version_number: next_version_number,
+            content: content.to_json,
+            created_by: metadata[:created_by] || "system",
+            changelog: metadata[:changelog] || "Version #{next_version_number}",
+            status: status
+          )
+        end
 
         serialize_version(version)
       end
@@ -63,15 +79,24 @@ module DecisionAgent
       end
 
       def activate_version(version_id:)
-        version = rule_version_class.find(version_id)
-
-        # Deactivate all other versions for this rule
-        rule_version_class.where(rule_id: version.rule_id, status: "active")
-                         .where.not(id: version_id)
-                         .update_all(status: "archived")
-
-        # Activate this version
-        version.update!(status: "active")
+        version = nil
+
+        rule_version_class.transaction do
+          # Find and lock the version to activate
+          version = rule_version_class.lock.find(version_id)
+
+          # Deactivate all other versions for this rule within the same transaction
+          # The lock ensures only one thread can perform this operation at a time
+          # Use update! instead of update_all to trigger validations
+          rule_version_class.where(rule_id: version.rule_id, status: "active")
+                            .where.not(id: version_id)
+                            .find_each do |v|
+            v.update!(status: "archived")
+          end
+
+          # Activate this version
+          version.update!(status: "active")
+        end
 
         serialize_version(version)
       end
@@ -89,11 +114,22 @@ module DecisionAgent
       end
 
       def serialize_version(version)
+        # Parse JSON content with proper error handling
+        parsed_content = begin
+          JSON.parse(version.content)
+        rescue JSON::ParserError => e
+          raise DecisionAgent::ValidationError,
+                "Invalid JSON in version #{version.id} for rule #{version.rule_id}: #{e.message}"
+        rescue TypeError, NoMethodError
+          raise DecisionAgent::ValidationError,
+                "Invalid content in version #{version.id} for rule #{version.rule_id}: content is nil or not a string"
+        end
+
         {
           id: version.id,
           rule_id: version.rule_id,
           version_number: version.version_number,
-          content: JSON.parse(version.content),
+          content: parsed_content,
           created_by: version.created_by,
           created_at: version.created_at,
           changelog: version.changelog,

data/lib/decision_agent/versioning/adapter.rb

@@ -91,9 +91,7 @@ module DecisionAgent
         changes = {}
         hash1.each do |key, value1|
           value2 = hash2[key]
-          if value1 != value2 && !value2.nil?
-            changes[key] = { old: value1, new: value2 }
-          end
+          changes[key] = { old: value1, new: value2 } if value1 != value2 && !value2.nil?
         end
         changes
       end