decision_agent 0.1.1 → 0.1.3

data/lib/decision_agent/monitoring/prometheus_exporter.rb

@@ -0,0 +1,247 @@
+require "monitor"
+
+module DecisionAgent
+  module Monitoring
+    # Prometheus-compatible metrics exporter
+    class PrometheusExporter
+      include MonitorMixin
+
+      CONTENT_TYPE = "text/plain; version=0.0.4".freeze
+
+      def initialize(metrics_collector:, namespace: "decision_agent")
+        super()
+        @metrics_collector = metrics_collector
+        @namespace = namespace
+        @custom_metrics = {}
+        freeze_config
+      end
+
+      # Export metrics in Prometheus format
+      def export
+        synchronize do
+          lines = []
+
+          # Add header
+          lines << "# DecisionAgent Metrics Export"
+          lines << "# Timestamp: #{Time.now.utc.iso8601}"
+          lines << ""
+
+          # Decision metrics
+          lines.concat(export_decision_metrics)
+
+          # Performance metrics
+          lines.concat(export_performance_metrics)
+
+          # Error metrics
+          lines.concat(export_error_metrics)
+
+          # Custom KPI metrics
+          lines.concat(export_custom_metrics)
+
+          # System info
+          lines.concat(export_system_metrics)
+
+          lines.join("\n")
+        end
+      end
+
+      # Register custom KPI
+      def register_kpi(name:, value:, labels: {}, help: nil)
+        synchronize do
+          metric_name = sanitize_name(name)
+          @custom_metrics[metric_name] = {
+            value: value,
+            labels: labels,
+            help: help || "Custom KPI: #{name}",
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      # Get metrics in hash format
+      def metrics_hash
+        synchronize do
+          stats = @metrics_collector.statistics
+
+          {
+            decisions: {
+              total: counter_metric("decisions_total", stats.dig(:decisions, :total) || 0),
+              avg_confidence: gauge_metric("decision_confidence_avg", stats.dig(:decisions, :avg_confidence) || 0),
+              avg_duration_ms: gauge_metric("decision_duration_ms_avg", stats.dig(:decisions, :avg_duration_ms) || 0)
+            },
+            performance: {
+              success_rate: gauge_metric("success_rate", stats.dig(:performance, :success_rate) || 0),
+              avg_duration_ms: gauge_metric("operation_duration_ms_avg",
+                                            stats.dig(:performance, :avg_duration_ms) || 0),
+              p95_duration_ms: gauge_metric("operation_duration_ms_p95",
+                                            stats.dig(:performance, :p95_duration_ms) || 0),
+              p99_duration_ms: gauge_metric("operation_duration_ms_p99", stats.dig(:performance, :p99_duration_ms) || 0)
+            },
+            errors: {
+              total: counter_metric("errors_total", stats.dig(:errors, :total) || 0)
+            },
+            system: {
+              version: info_metric("version", DecisionAgent::VERSION)
+            }
+          }
+        end
+      end
+
+      private
+
+      def freeze_config
+        @namespace.freeze
+      end
+
+      def export_decision_metrics
+        stats = @metrics_collector.statistics
+        lines = []
+
+        # Total decisions
+        lines << "# HELP #{metric_name('decisions_total')} Total number of decisions made"
+        lines << "# TYPE #{metric_name('decisions_total')} counter"
+        lines << "#{metric_name('decisions_total')} #{stats.dig(:decisions, :total) || 0}"
+        lines << ""
+
+        # Average confidence
+        lines << "# HELP #{metric_name('decision_confidence_avg')} Average decision confidence"
+        lines << "# TYPE #{metric_name('decision_confidence_avg')} gauge"
+        lines << "#{metric_name('decision_confidence_avg')} #{stats.dig(:decisions, :avg_confidence) || 0}"
+        lines << ""
+
+        # Decision distribution
+        if stats.dig(:decisions, :decision_distribution)
+          lines << "# HELP #{metric_name('decisions_by_type')} Decisions grouped by type"
+          lines << "# TYPE #{metric_name('decisions_by_type')} counter"
+          stats[:decisions][:decision_distribution].each do |decision, count|
+            lines << "#{metric_name('decisions_by_type')}{decision=\"#{decision}\"} #{count}"
+          end
+          lines << ""
+        end
+
+        # Average duration
+        if stats.dig(:decisions, :avg_duration_ms)
+          lines << "# HELP #{metric_name('decision_duration_ms_avg')} Average decision duration in milliseconds"
+          lines << "# TYPE #{metric_name('decision_duration_ms_avg')} gauge"
+          lines << "#{metric_name('decision_duration_ms_avg')} #{stats[:decisions][:avg_duration_ms]}"
+          lines << ""
+        end
+
+        lines
+      end
+
+      def export_performance_metrics
+        stats = @metrics_collector.statistics
+        lines = []
+
+        # Success rate
+        lines << "# HELP #{metric_name('success_rate')} Operation success rate (0-1)"
+        lines << "# TYPE #{metric_name('success_rate')} gauge"
+        lines << "#{metric_name('success_rate')} #{stats.dig(:performance, :success_rate) || 0}"
+        lines << ""
+
+        # Duration metrics
+        if stats.dig(:performance, :avg_duration_ms)
+          lines << "# HELP #{metric_name('operation_duration_ms')} Operation duration in milliseconds"
+          lines << "# TYPE #{metric_name('operation_duration_ms')} summary"
+          lines << "#{metric_name('operation_duration_ms')}{quantile=\"0.5\"} #{stats[:performance][:avg_duration_ms]}"
+          lines << "#{metric_name('operation_duration_ms')}{quantile=\"0.95\"} #{stats[:performance][:p95_duration_ms]}"
+          lines << "#{metric_name('operation_duration_ms')}{quantile=\"0.99\"} #{stats[:performance][:p99_duration_ms]}"
+          lines << "#{metric_name('operation_duration_ms_sum')} #{stats[:performance][:avg_duration_ms] * stats[:performance][:total_operations]}"
+          lines << "#{metric_name('operation_duration_ms_count')} #{stats[:performance][:total_operations]}"
+          lines << ""
+        end
+
+        lines
+      end
+
+      def export_error_metrics
+        stats = @metrics_collector.statistics
+        lines = []
+
+        # Total errors
+        lines << "# HELP #{metric_name('errors_total')} Total number of errors"
+        lines << "# TYPE #{metric_name('errors_total')} counter"
+        lines << "#{metric_name('errors_total')} #{stats.dig(:errors, :total) || 0}"
+        lines << ""
+
+        # Errors by type
+        if stats.dig(:errors, :by_type)
+          lines << "# HELP #{metric_name('errors_by_type')} Errors grouped by type"
+          lines << "# TYPE #{metric_name('errors_by_type')} counter"
+          stats[:errors][:by_type].each do |error_type, count|
+            lines << "#{metric_name('errors_by_type')}{error=\"#{sanitize_label(error_type)}\"} #{count}"
+          end
+          lines << ""
+        end
+
+        lines
+      end
+
+      def export_custom_metrics
+        lines = []
+
+        @custom_metrics.each do |name, metric|
+          full_name = metric_name(name)
+          lines << "# HELP #{full_name} #{metric[:help]}"
+          lines << "# TYPE #{full_name} gauge"
+
+          if metric[:labels].empty?
+            lines << "#{full_name} #{metric[:value]}"
+          else
+            label_str = metric[:labels].map { |k, v| "#{k}=\"#{sanitize_label(v)}\"" }.join(",")
+            lines << "#{full_name}{#{label_str}} #{metric[:value]}"
+          end
+          lines << ""
+        end
+
+        lines
+      end
+
+      def export_system_metrics
+        lines = []
+
+        # Version info
+        lines << "# HELP #{metric_name('info')} DecisionAgent version info"
+        lines << "# TYPE #{metric_name('info')} gauge"
+        lines << "#{metric_name('info')}{version=\"#{DecisionAgent::VERSION}\"} 1"
+        lines << ""
+
+        # Metrics count
+        counts = @metrics_collector.metrics_count
+        lines << "# HELP #{metric_name('metrics_stored')} Number of metrics stored in memory"
+        lines << "# TYPE #{metric_name('metrics_stored')} gauge"
+        counts.each do |type, count|
+          lines << "#{metric_name('metrics_stored')}{type=\"#{type}\"} #{count}"
+        end
+        lines << ""
+
+        lines
+      end
+
+      def metric_name(name)
+        "#{@namespace}_#{sanitize_name(name)}"
+      end
+
+      def sanitize_name(name)
+        name.to_s.gsub(/[^a-zA-Z0-9_]/, "_")
+      end
+
+      def sanitize_label(value)
+        value.to_s.gsub("\\", "\\\\").gsub('"', '\\"').gsub("\n", "\\n")
+      end
+
+      def counter_metric(name, value)
+        { name: name, type: "counter", value: value }
+      end
+
+      def gauge_metric(name, value)
+        { name: name, type: "gauge", value: value }
+      end
+
+      def info_metric(name, value)
+        { name: name, type: "info", value: value }
+      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.1"
+  VERSION = "0.1.3".freeze
 end

data/lib/decision_agent/versioning/activerecord_adapter.rb

@@ -0,0 +1,141 @@
+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
+        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: {})
+        # 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
+
+      def list_versions(rule_id:, limit: nil)
+        query = rule_version_class.where(rule_id: rule_id)
+                                  .order(version_number: :desc)
+        query = query.limit(limit) if limit
+
+        query.map { |v| serialize_version(v) }
+      end
+
+      def get_version(version_id:)
+        version = rule_version_class.find_by(id: version_id)
+        version ? serialize_version(version) : nil
+      end
+
+      def get_version_by_number(rule_id:, version_number:)
+        version = rule_version_class.find_by(
+          rule_id: rule_id,
+          version_number: version_number
+        )
+        version ? serialize_version(version) : nil
+      end
+
+      def get_active_version(rule_id:)
+        version = rule_version_class.find_by(rule_id: rule_id, status: "active")
+        version ? serialize_version(version) : nil
+      end
+
+      def activate_version(version_id:)
+        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
+
+      private
+
+      def rule_version_class
+        # Look for the RuleVersion model in the main app
+        if defined?(::RuleVersion)
+          ::RuleVersion
+        else
+          raise DecisionAgent::ConfigurationError,
+                "RuleVersion model not found. Please run the generator to create it."
+        end
+      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: parsed_content,
+          created_by: version.created_by,
+          created_at: version.created_at,
+          changelog: version.changelog,
+          status: version.status
+        }
+      end
+    end
+  end
+end

data/lib/decision_agent/versioning/adapter.rb

@@ -0,0 +1,100 @@
+module DecisionAgent
+  module Versioning
+    # Abstract base class for version storage adapters
+    # Allows framework-agnostic versioning with pluggable storage backends
+    class Adapter
+      # Create a new version for a rule
+      # @param rule_id [String] Unique identifier for the rule
+      # @param content [Hash] Rule definition as a hash
+      # @param metadata [Hash] Additional metadata (created_by, changelog, etc.)
+      # @return [Hash] The created version
+      def create_version(rule_id:, content:, metadata: {})
+        raise NotImplementedError, "#{self.class} must implement #create_version"
+      end
+
+      # List all versions for a specific rule
+      # @param rule_id [String] The rule identifier
+      # @param limit [Integer, nil] Optional limit for number of versions
+      # @return [Array<Hash>] Array of version hashes
+      def list_versions(rule_id:, limit: nil)
+        raise NotImplementedError, "#{self.class} must implement #list_versions"
+      end
+
+      # Get a specific version by ID
+      # @param version_id [String, Integer] The version identifier
+      # @return [Hash, nil] The version hash or nil if not found
+      def get_version(version_id:)
+        raise NotImplementedError, "#{self.class} must implement #get_version"
+      end
+
+      # Get a specific version by rule_id and version_number
+      # @param rule_id [String] The rule identifier
+      # @param version_number [Integer] The version number
+      # @return [Hash, nil] The version hash or nil if not found
+      def get_version_by_number(rule_id:, version_number:)
+        raise NotImplementedError, "#{self.class} must implement #get_version_by_number"
+      end
+
+      # Get the active version for a rule
+      # @param rule_id [String] The rule identifier
+      # @return [Hash, nil] The active version or nil
+      def get_active_version(rule_id:)
+        raise NotImplementedError, "#{self.class} must implement #get_active_version"
+      end
+
+      # Activate a specific version
+      # @param version_id [String, Integer] The version to activate
+      # @return [Hash] The activated version
+      def activate_version(version_id:)
+        raise NotImplementedError, "#{self.class} must implement #activate_version"
+      end
+
+      # Compare two versions
+      # @param version_id_1 [String, Integer] First version ID
+      # @param version_id_2 [String, Integer] Second version ID
+      # @return [Hash] Comparison result with differences
+      def compare_versions(version_id_1:, version_id_2:)
+        v1 = get_version(version_id: version_id_1)
+        v2 = get_version(version_id: version_id_2)
+
+        return nil if v1.nil? || v2.nil?
+
+        {
+          version_1: v1,
+          version_2: v2,
+          differences: calculate_diff(v1[:content], v2[:content])
+        }
+      end
+
+      # Delete a specific version
+      # @param version_id [String, Integer] The version to delete
+      # @return [Boolean] True if deleted successfully
+      def delete_version(version_id:)
+        raise NotImplementedError, "#{self.class} must implement #delete_version"
+      end
+
+      private
+
+      # Calculate differences between two content hashes
+      # @param content1 [Hash] First content
+      # @param content2 [Hash] Second content
+      # @return [Hash] Differences
+      def calculate_diff(content1, content2)
+        {
+          added: content2.to_a - content1.to_a,
+          removed: content1.to_a - content2.to_a,
+          changed: detect_changes(content1, content2)
+        }
+      end
+
+      def detect_changes(hash1, hash2)
+        changes = {}
+        hash1.each do |key, value1|
+          value2 = hash2[key]
+          changes[key] = { old: value1, new: value2 } if value1 != value2 && !value2.nil?
+        end
+        changes
+      end
+    end
+  end
+end