star_gates 0.0.0 → 0.2.0

data/lib/star_gates/configuration.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module StarGates
+  class Configuration
+    attr_accessor :instrumentation, :telemetry_adapter, :default_timeout, :default_retry_count,
+                  :circuit_breaker_threshold, :cache_ttl, :environment, :feature_defaults,
+                  :enable_performance_monitoring, :log_level, :error_reporting
+
+    def initialize
+      @instrumentation = true
+      @telemetry_adapter = detect_default_telemetry_adapter
+      @default_timeout = 5.0 # seconds
+      @default_retry_count = 3
+      @circuit_breaker_threshold = 5
+      @cache_ttl = 300 # 5 minutes
+      @environment = detect_environment
+      @feature_defaults = {}
+      @enable_performance_monitoring = true
+      @log_level = :info
+      @error_reporting = true
+    end
+
+    # Environment-specific configurations
+    def development?
+      environment == :development
+    end
+
+    def test?
+      environment == :test
+    end
+
+    def production?
+      environment == :production
+    end
+
+    def staging?
+      environment == :staging
+    end
+
+    # Feature-specific defaults
+    def feature_config_for(feature_name)
+      base_config = {
+        timeout: default_timeout,
+        retry_count: default_retry_count,
+        circuit_breaker_threshold: circuit_breaker_threshold,
+        cache_ttl: cache_ttl,
+        instrumentation: instrumentation,
+        performance_monitoring: enable_performance_monitoring
+      }
+
+      # Merge with feature-specific overrides
+      feature_specific = feature_defaults[feature_name.to_sym] || {}
+      base_config.merge(feature_specific)
+    end
+
+    # Configure feature-specific defaults
+    def configure_feature(feature_name, config = {})
+      feature_defaults[feature_name.to_sym] = config
+    end
+
+    # Load from YAML file (Rails-style)
+    def load_from_file(file_path)
+      return unless File.exist?(file_path)
+
+      require 'yaml'
+      # Use safe_load_file to prevent arbitrary code execution
+      config_data = YAML.safe_load_file(
+        file_path,
+        permitted_classes: [Symbol, Time, Date],
+        aliases: true
+      )
+      env_config = config_data[environment.to_s] || {}
+
+      env_config.each do |key, value|
+        setter_method = "#{key}="
+        if respond_to?(setter_method)
+          send(setter_method, value)
+        elsif key == 'features'
+          # Handle feature-specific configurations
+          value.each { |feature_name, feature_config| configure_feature(feature_name, feature_config) }
+        end
+      end
+    end
+
+    # Environment-aware defaults
+    def apply_environment_defaults!
+      case environment
+      when :development
+        @log_level = :debug
+        @default_timeout = 10.0 # More generous timeout for dev
+        @telemetry_adapter = :memory
+      when :test
+        @instrumentation = false
+        @telemetry_adapter = :memory
+        @default_timeout = 1.0  # Fast tests
+        @enable_performance_monitoring = false
+      when :production
+        @log_level = :warn
+        @default_timeout = 2.0  # Strict timeout for prod
+        @telemetry_adapter = :prometheus
+        @error_reporting = true
+      when :staging
+        @log_level = :info
+        @default_timeout = 5.0
+        @telemetry_adapter = :prometheus
+      end
+    end
+
+    # Convert to hash for serialization
+    def to_h
+      {
+        instrumentation: instrumentation,
+        telemetry_adapter: telemetry_adapter,
+        default_timeout: default_timeout,
+        default_retry_count: default_retry_count,
+        circuit_breaker_threshold: circuit_breaker_threshold,
+        cache_ttl: cache_ttl,
+        environment: environment,
+        enable_performance_monitoring: enable_performance_monitoring,
+        log_level: log_level,
+        error_reporting: error_reporting,
+        feature_defaults: feature_defaults
+      }
+    end
+
+    private
+
+    def detect_environment
+      if defined?(Rails) && Rails.respond_to?(:env)
+        Rails.env.to_sym
+      elsif ENV['RACK_ENV']
+        ENV['RACK_ENV'].to_sym
+      elsif ENV['RAILS_ENV']
+        ENV['RAILS_ENV'].to_sym
+      elsif ENV['RUBY_ENV']
+        ENV['RUBY_ENV'].to_sym
+      else
+        :development
+      end
+    end
+
+    def detect_default_telemetry_adapter
+      return :prometheus if defined?(Prometheus)
+      return :opentelemetry if defined?(OpenTelemetry)
+
+      :memory
+    end
+  end
+
+  # Global configuration instance
+  def self.configuration
+    @configuration ||= Configuration.new.tap(&:apply_environment_defaults!)
+  end
+
+  def self.configure
+    yield(configuration) if block_given?
+  end
+
+  # Load configuration from file
+  def self.load_config!(file_path = nil)
+    file_path ||= default_config_file_path
+    configuration.load_from_file(file_path) if file_path
+  end
+
+  def self.default_config_file_path
+    if defined?(Rails)
+      Rails.root.join('config', 'star_gates.yml')
+    else
+      File.join(Dir.pwd, 'config', 'star_gates.yml')
+    end
+  end
+end

data/lib/star_gates/dsl.rb

@@ -2,6 +2,75 @@
 
 module StarGates
   module DSL
-    # DSL methods will be implemented here
+    class GateBuilder
+      attr_reader :name, :feature_config, :circuit_config, :run_block, :fallback_block
+
+      def initialize(name)
+        @name = name
+        @feature_config = {}
+        @circuit_config = {}
+        @run_block = nil
+        @fallback_block = nil
+      end
+
+      def feature(rollout: 0, group: nil)
+        @feature_config = { rollout: rollout, group: group }
+      end
+
+      def circuit(threshold: 5, within: 30.seconds, reset_after: 1.minute, retry_config: nil)
+        @circuit_config = {
+          threshold: threshold,
+          within: within,
+          reset_after: reset_after,
+          retry_config: retry_config
+        }
+      end
+
+      def run(&block)
+        @run_block = block
+      end
+
+      def fallback(&block)
+        @fallback_block = block
+      end
+
+      def build
+        feature_instance = build_feature if feature_config.any?
+        circuit_instance = build_circuit(feature_instance) if circuit_config.any?
+
+        StarGates::Gate.new(
+          name,
+          feature: feature_instance,
+          circuit: circuit_instance,
+          run_block: run_block,
+          fallback_block: fallback_block
+        )
+      end
+
+      private
+
+      def build_feature
+        StarGates::Feature.new(**feature_config)
+      end
+
+      def build_circuit(feature)
+        # Wire circuit to feature for self-healing behavior
+        StarGates::Circuit.new(**circuit_config, feature: feature)
+      end
+    end
+
+    class DefineContext
+      def initialize(registry)
+        @registry = registry
+      end
+
+      def gate(name, &)
+        builder = GateBuilder.new(name)
+        builder.instance_eval(&) if block_given?
+        gate_instance = builder.build
+        @registry.register(name, gate_instance)
+        gate_instance
+      end
+    end
   end
-end
+end

data/lib/star_gates/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module StarGates
+  class Error < StandardError; end
+  class UnavailableError < Error; end
+  class GateNotFoundError < Error; end
+  class InvalidConfigurationError < Error; end
+end

data/lib/star_gates/event_store/event_store.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module StarGates
+  module EventStore
+    class EventStore
+      def initialize(adapter: nil)
+        @adapter = adapter || MemoryAdapter.new
+        @subscribers = Hash.new { |h, k| h[k] = [] }
+      end
+
+      # Append events to the store
+      def append(aggregate_id, events, expected_version: nil)
+        events = Array(events)
+        return if events.empty?
+
+        # Validate expected version for optimistic concurrency
+        if expected_version
+          current_version = @adapter.get_version(aggregate_id)
+          if current_version != expected_version
+            raise ConcurrencyError, "Expected version #{expected_version}, got #{current_version}"
+          end
+        end
+
+        # Store events
+        @adapter.append(aggregate_id, events)
+
+        # Notify subscribers
+        events.each do |event|
+          notify_subscribers(event)
+        end
+
+        events.size
+      end
+
+      # Get events for an aggregate
+      def get_events(aggregate_id, from_version: 0)
+        @adapter.get_events(aggregate_id, from_version: from_version)
+      end
+
+      # Get all events from a specific time
+      def get_events_from(timestamp, limit: 100)
+        @adapter.get_events_from(timestamp, limit: limit)
+      end
+
+      # Get events by type
+      def get_events_by_type(event_type, limit: 100)
+        @adapter.get_events_by_type(event_type, limit: limit)
+      end
+
+      # Subscribe to events
+      def subscribe(event_type = nil, &block)
+        key = event_type || :all
+        @subscribers[key] << block
+      end
+
+      # Get current version of aggregate
+      def get_version(aggregate_id)
+        @adapter.get_version(aggregate_id)
+      end
+
+      # Replay all events to rebuild projections
+      def replay_all(&)
+        @adapter.replay_all(&)
+      end
+
+      private
+
+      def notify_subscribers(event)
+        # Notify specific event type subscribers
+        @subscribers[event.event_type].each { |subscriber| subscriber.call(event) }
+
+        # Notify all event subscribers
+        @subscribers[:all].each { |subscriber| subscriber.call(event) }
+      end
+    end
+
+    class ConcurrencyError < StandardError; end
+  end
+end

data/lib/star_gates/event_store/memory_adapter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module StarGates
+  module EventStore
+    class MemoryAdapter
+      def initialize
+        @events = Concurrent::Hash.new { |h, k| h[k] = Concurrent::Array.new }
+        @global_events = Concurrent::Array.new
+        @versions = Concurrent::Hash.new(0)
+        @mutex = Mutex.new
+      end
+
+      def append(aggregate_id, events)
+        @mutex.synchronize do
+          events.each do |event|
+            # Increment version
+            @versions[aggregate_id] += 1
+            versioned_event = event.dup.tap do |e|
+              e.instance_variable_set(:@version, @versions[aggregate_id])
+            end
+
+            # Store by aggregate
+            @events[aggregate_id] << versioned_event
+
+            # Store globally for cross-aggregate queries
+            @global_events << versioned_event
+          end
+        end
+      end
+
+      def get_events(aggregate_id, from_version: 0)
+        @events[aggregate_id].select { |event| event.version > from_version }
+      end
+
+      def get_events_from(timestamp, limit: 100)
+        @global_events
+          .select { |event| event.occurred_at >= timestamp }
+          .sort_by(&:occurred_at)
+          .reverse
+          .first(limit)
+      end
+
+      def get_events_by_type(event_type, limit: 100)
+        @global_events
+          .select { |event| event.event_type == event_type }
+          .sort_by(&:occurred_at)
+          .reverse
+          .first(limit)
+      end
+
+      def get_version(aggregate_id)
+        @versions[aggregate_id]
+      end
+
+      def replay_all(&)
+        @global_events.sort_by(&:occurred_at).each(&)
+      end
+
+      def clear!
+        @mutex.synchronize do
+          @events.clear
+          @global_events.clear
+          @versions.clear
+        end
+      end
+
+      def size
+        @global_events.size
+      end
+
+      def aggregate_count
+        @events.size
+      end
+    end
+  end
+end

data/lib/star_gates/events/base_event.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module StarGates
+  module Events
+    class BaseEvent
+      attr_reader :event_id, :aggregate_id, :event_type, :data, :metadata, :occurred_at, :version
+
+      def initialize(aggregate_id:, data: {}, metadata: {}, version: 1)
+        @event_id = SecureRandom.uuid
+        @aggregate_id = aggregate_id
+        @event_type = self.class.name.split('::').last
+        @data = data.freeze
+        @metadata = metadata.merge(
+          source: 'star_gates',
+          correlation_id: Thread.current[:correlation_id] || SecureRandom.uuid
+        ).freeze
+        @occurred_at = Time.now.utc
+        @version = version
+        freeze
+      end
+
+      def to_h
+        {
+          event_id: event_id,
+          aggregate_id: aggregate_id,
+          event_type: event_type,
+          data: data,
+          metadata: metadata,
+          occurred_at: occurred_at,
+          version: version
+        }
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && event_id == other.event_id
+      end
+
+      def hash
+        event_id.hash
+      end
+    end
+  end
+end

data/lib/star_gates/events/feature_events.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative 'base_event'
+
+module StarGates
+  module Events
+    # Feature lifecycle events
+    class FeatureCreated < BaseEvent; end
+
+    class FeatureStateChanged < BaseEvent
+      def initialize(aggregate_id:, from_state:, to_state:, event_name:, context: {}, **opts)
+        super(
+          aggregate_id: aggregate_id,
+          data: {
+            from_state: from_state,
+            to_state: to_state,
+            event_name: event_name,
+            context: context
+          },
+          **opts
+        )
+      end
+
+      def from_state = data[:from_state]
+      def to_state = data[:to_state]
+      def event_name = data[:event_name]
+      def context = data[:context]
+    end
+
+    class FeatureConfigurationChanged < BaseEvent
+      def initialize(aggregate_id:, configuration_changes:, **opts)
+        super(
+          aggregate_id: aggregate_id,
+          data: { configuration_changes: configuration_changes },
+          **opts
+        )
+      end
+
+      def configuration_changes = data[:configuration_changes]
+    end
+
+    class FeatureExecuted < BaseEvent
+      def initialize(aggregate_id:, context:, result:, execution_time:, **opts)
+        super(
+          aggregate_id: aggregate_id,
+          data: {
+            context: context,
+            result: result,
+            execution_time: execution_time
+          },
+          **opts
+        )
+      end
+
+      def context = data[:context]
+      def result = data[:result]
+      def execution_time = data[:execution_time]
+    end
+
+    class FeatureEvaluated < BaseEvent
+      def initialize(aggregate_id:, context:, eligible:, reason:, **opts)
+        super(
+          aggregate_id: aggregate_id,
+          data: {
+            context: context,
+            eligible: eligible,
+            reason: reason
+          },
+          **opts
+        )
+      end
+
+      def context = data[:context]
+      def eligible = data[:eligible]
+      def reason = data[:reason]
+    end
+
+    # System-level events
+    class GateRegistered < BaseEvent
+      def initialize(aggregate_id:, gate_name:, feature_class:, **opts)
+        super(
+          aggregate_id: aggregate_id,
+          data: {
+            gate_name: gate_name,
+            feature_class: feature_class
+          },
+          **opts
+        )
+      end
+
+      def gate_name = data[:gate_name]
+      def feature_class = data[:feature_class]
+    end
+
+    class SystemReset < BaseEvent; end
+  end
+end