star_gates 0.0.0 → 0.2.0

data/lib/star_gates/projections/feature_projection.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module StarGates
+  module Projections
+    class FeatureProjection
+      def initialize(adapter)
+        @adapter = adapter
+        @mutex = Mutex.new
+      end
+
+      # Handle events to build read model
+      def handle_event(event)
+        case event
+        when Events::FeatureCreated
+          handle_feature_created(event)
+        when Events::FeatureStateChanged
+          handle_state_changed(event)
+        when Events::FeatureConfigurationChanged
+          handle_configuration_changed(event)
+        when Events::FeatureExecuted
+          handle_execution_recorded(event)
+        when Events::FeatureEvaluated
+          handle_evaluation_recorded(event)
+        end
+      end
+
+      # Query methods
+      def find_feature(feature_id)
+        @adapter.fetch("feature:#{feature_id}")
+      end
+
+      def find_features_by_state(state)
+        state_key = "features_by_state:#{state}"
+        feature_ids = @adapter.fetch(state_key) || []
+        feature_ids.map { |id| find_feature(id) }.compact
+      end
+
+      def all_features
+        feature_ids = @adapter.fetch('all_features') || []
+        feature_ids.map { |id| find_feature(id) }.compact
+      end
+
+      def feature_stats
+        {
+          total_features: all_features.size,
+          by_state: features_by_state_count,
+          recent_transitions: recent_transitions_count,
+          total_executions: total_executions_count
+        }
+      end
+
+      def recent_transitions(limit: 10)
+        transitions = @adapter.fetch('recent_transitions') || []
+        transitions.last(limit).reverse
+      end
+
+      def feature_exists?(feature_id)
+        @adapter.exists?("feature:#{feature_id}")
+      end
+
+      # Clear projection (for testing)
+      def clear!
+        return unless @adapter.respond_to?(:clear!)
+
+        @adapter.clear!
+      end
+
+      private
+
+      def handle_feature_created(event)
+        @mutex.synchronize do
+          feature_data = {
+            id: event.aggregate_id,
+            state: :disabled,
+            rollout_percentage: event.data[:rollout_percentage],
+            group_matcher: event.data[:group_matcher],
+            metadata: event.data[:metadata],
+            created_at: event.occurred_at,
+            updated_at: event.occurred_at,
+            transition_count: 0,
+            execution_count: 0,
+            evaluation_count: 0
+          }
+
+          # Store feature
+          @adapter.store("feature:#{event.aggregate_id}", feature_data)
+
+          # Update indexes
+          update_all_features_index(event.aggregate_id, :add)
+          update_state_index(event.aggregate_id, :disabled, :add)
+        end
+      end
+
+      def handle_state_changed(event)
+        @mutex.synchronize do
+          feature_data = @adapter.fetch("feature:#{event.aggregate_id}")
+          return unless feature_data
+
+          old_state = feature_data[:state]
+          new_state = event.to_state
+
+          # Update feature data
+          feature_data[:state] = new_state
+          feature_data[:updated_at] = event.occurred_at
+          feature_data[:transition_count] += 1
+
+          @adapter.store("feature:#{event.aggregate_id}", feature_data)
+
+          # Update state indexes
+          update_state_index(event.aggregate_id, old_state, :remove)
+          update_state_index(event.aggregate_id, new_state, :add)
+
+          # Update recent transitions
+          update_recent_transitions(event)
+        end
+      end
+
+      def handle_configuration_changed(event)
+        @mutex.synchronize do
+          feature_data = @adapter.fetch("feature:#{event.aggregate_id}")
+          return unless feature_data
+
+          feature_data[:updated_at] = event.occurred_at
+          @adapter.store("feature:#{event.aggregate_id}", feature_data)
+        end
+      end
+
+      def handle_execution_recorded(event)
+        @mutex.synchronize do
+          feature_data = @adapter.fetch("feature:#{event.aggregate_id}")
+          return unless feature_data
+
+          feature_data[:execution_count] += 1
+          feature_data[:updated_at] = event.occurred_at
+          @adapter.store("feature:#{event.aggregate_id}", feature_data)
+        end
+      end
+
+      def handle_evaluation_recorded(event)
+        @mutex.synchronize do
+          feature_data = @adapter.fetch("feature:#{event.aggregate_id}")
+          return unless feature_data
+
+          feature_data[:evaluation_count] += 1
+          feature_data[:updated_at] = event.occurred_at
+          @adapter.store("feature:#{event.aggregate_id}", feature_data)
+        end
+      end
+
+      def update_all_features_index(feature_id, operation)
+        key = 'all_features'
+        feature_ids = @adapter.fetch(key) || []
+
+        case operation
+        when :add
+          feature_ids << feature_id unless feature_ids.include?(feature_id)
+        when :remove
+          feature_ids.delete(feature_id)
+        end
+
+        @adapter.store(key, feature_ids)
+      end
+
+      def update_state_index(feature_id, state, operation)
+        key = "features_by_state:#{state}"
+        feature_ids = @adapter.fetch(key) || []
+
+        case operation
+        when :add
+          feature_ids << feature_id unless feature_ids.include?(feature_id)
+        when :remove
+          feature_ids.delete(feature_id)
+        end
+
+        @adapter.store(key, feature_ids)
+      end
+
+      def update_recent_transitions(event)
+        transitions = @adapter.fetch('recent_transitions') || []
+
+        transition_data = {
+          feature_id: event.aggregate_id,
+          from_state: event.from_state,
+          to_state: event.to_state,
+          event_name: event.event_name,
+          context: event.context,
+          occurred_at: event.occurred_at
+        }
+
+        transitions << transition_data
+
+        # Keep only last 100 transitions
+        transitions = transitions.last(100) if transitions.size > 100
+
+        @adapter.store('recent_transitions', transitions)
+      end
+
+      def features_by_state_count
+        states = %i[disabled canary enabled]
+        counts = {}
+
+        states.each do |state|
+          feature_ids = @adapter.fetch("features_by_state:#{state}") || []
+          counts[state] = feature_ids.size
+        end
+
+        counts
+      end
+
+      def recent_transitions_count(days: 7)
+        transitions = @adapter.fetch('recent_transitions') || []
+        cutoff = Time.now - (days * 24 * 60 * 60)
+
+        transitions.count do |transition|
+          Time.parse(transition[:occurred_at].to_s) > cutoff
+        end
+      end
+
+      def total_executions_count
+        all_features.sum { |feature| feature[:execution_count] || 0 }
+      end
+    end
+  end
+end

data/lib/star_gates/registry.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module StarGates
+  class Registry
+    def initialize
+      # Use Concurrent::Hash for thread-safe operations (already in dependencies)
+      @gates = Concurrent::Hash.new
+    end
+
+    def register(name, gate)
+      # Concurrent::Hash handles thread-safety automatically
+      @gates[name.to_sym] = gate
+    end
+
+    def [](name)
+      @gates[name.to_sym]
+    end
+
+    def fetch(name, default = nil)
+      @gates.fetch(name.to_sym, default)
+    end
+
+    def include?(name)
+      @gates.key?(name.to_sym)
+    end
+
+    def keys
+      @gates.keys
+    end
+
+    def values
+      @gates.values
+    end
+
+    def each(&)
+      @gates.each(&)
+    end
+
+    def clear
+      # Concurrent::Hash#clear is already thread-safe
+      @gates.clear
+    end
+
+    def size
+      @gates.size
+    end
+
+    def empty?
+      @gates.empty?
+    end
+
+    def to_h
+      @gates.dup
+    end
+  end
+end

data/lib/star_gates/telemetry/opentelemetry_adapter.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require_relative 'telemetry_adapter'
+
+module StarGates
+  module Telemetry
+    class OpentelemetryAdapter < TelemetryAdapter
+      def initialize(config = {})
+        super
+        @tracer = config[:tracer] || default_tracer
+        @meter = config[:meter] || default_meter
+        @service_name = config[:service_name] || 'star_gates'
+        @service_version = config[:service_version] || StarGates::VERSION
+        setup_instruments
+      end
+
+      # OpenTelemetry-specific methods
+      def trace_feature_evaluation(feature_id, _context, &block)
+        return block.call unless enabled?
+
+        @tracer.in_span('feature.evaluate', attributes: {
+                          'feature.id' => feature_id,
+                          'service.name' => @service_name,
+                          'service.version' => @service_version
+                        }) do |span|
+          start_time = Time.now
+          result = block.call
+          duration = ((Time.now - start_time) * 1000).round(2)
+
+          span.set_attribute('feature.eligible', result[:eligible]) if result.is_a?(Hash)
+          span.set_attribute('feature.evaluation.duration_ms', duration)
+          span.status = OpenTelemetry::Trace::Status.ok
+
+          result
+        end
+      end
+
+      def trace_feature_execution(feature_id, state, &block)
+        return block.call unless enabled?
+
+        @tracer.in_span('feature.execute', attributes: {
+                          'feature.id' => feature_id,
+                          'feature.state' => state,
+                          'service.name' => @service_name,
+                          'service.version' => @service_version
+                        }) do |span|
+          start_time = Time.now
+          begin
+            result = block.call
+            duration = ((Time.now - start_time) * 1000).round(2)
+
+            span.set_attribute('feature.execution.duration_ms', duration)
+            span.set_attribute('feature.execution.success', true)
+            span.status = OpenTelemetry::Trace::Status.ok
+
+            result
+          rescue StandardError => e
+            duration = ((Time.now - start_time) * 1000).round(2)
+            span.set_attribute('feature.execution.duration_ms', duration)
+            span.set_attribute('feature.execution.success', false)
+            span.set_attribute('feature.execution.error', e.message)
+            span.status = OpenTelemetry::Trace::Status.error(e.message)
+            raise
+          end
+        end
+      end
+
+      def trace_state_transition(feature_id, from_state, to_state, event_name, &block)
+        return block.call unless enabled?
+
+        @tracer.in_span('feature.state_transition', attributes: {
+                          'feature.id' => feature_id,
+                          'feature.transition.from' => from_state,
+                          'feature.transition.to' => to_state,
+                          'feature.transition.event' => event_name,
+                          'service.name' => @service_name,
+                          'service.version' => @service_version
+                        }) do |span|
+          result = block.call
+          span.status = OpenTelemetry::Trace::Status.ok
+          result
+        end
+      end
+
+      protected
+
+      def send_metric(name, value, tags, _timestamp)
+        # Convert tags to OpenTelemetry attributes
+        attributes = tags.transform_keys(&:to_s)
+        attributes['service.name'] = @service_name
+        attributes['service.version'] = @service_version
+
+        case name
+        when /\.count$/
+          instrument_name = name.gsub(/\.count$/, '').gsub('.', '_')
+          counter = @instruments["#{instrument_name}_total"] ||=
+            @meter.create_counter("star_gates_#{instrument_name}_total",
+                                  unit: '1',
+                                  description: "Total count of #{instrument_name}")
+          counter.add(value, attributes: attributes)
+
+        when /\.gauge$/
+          instrument_name = name.gsub(/\.gauge$/, '').gsub('.', '_')
+          @instruments[instrument_name] ||=
+            @meter.create_observable_gauge("star_gates_#{instrument_name}",
+                                           unit: '1',
+                                           description: "Current value of #{instrument_name}")
+          # NOTE: OpenTelemetry gauges are observable, so we store the value
+          @gauge_values ||= {}
+          @gauge_values["#{instrument_name}_#{attributes.hash}"] = { value: value, attributes: attributes }
+
+        when /\.histogram$/, /\.timing$/
+          instrument_name = name.gsub(/\.(histogram|timing)$/, '').gsub('.', '_')
+          histogram = @instruments["#{instrument_name}_duration"] ||=
+            @meter.create_histogram("star_gates_#{instrument_name}_duration",
+                                    unit: 'ms',
+                                    description: "Duration histogram for #{instrument_name}")
+          histogram.record(value, attributes: attributes)
+        end
+      end
+
+      def healthy?
+        super && @tracer.respond_to?(:in_span) && @meter.respond_to?(:create_counter)
+      end
+
+      private
+
+      def default_tracer
+        unless defined?(OpenTelemetry)
+          raise ArgumentError, "OpenTelemetry gem not available. Install with: gem 'opentelemetry-sdk'"
+        end
+
+        OpenTelemetry.tracer_provider.tracer(@service_name, @service_version)
+      end
+
+      def default_meter
+        unless defined?(OpenTelemetry)
+          raise ArgumentError, "OpenTelemetry gem not available. Install with: gem 'opentelemetry-sdk'"
+        end
+
+        OpenTelemetry.meter_provider.meter(@service_name, @service_version)
+      end
+
+      def setup_instruments
+        @instruments = {}
+        @gauge_values = {}
+
+        # Pre-create common instruments
+        @instruments['feature_evaluations_total'] = @meter.create_counter(
+          'star_gates_feature_evaluations_total',
+          unit: '1',
+          description: 'Total number of feature evaluations'
+        )
+
+        @instruments['feature_executions_total'] = @meter.create_counter(
+          'star_gates_feature_executions_total',
+          unit: '1',
+          description: 'Total number of feature executions'
+        )
+
+        @instruments['state_transitions_total'] = @meter.create_counter(
+          'star_gates_state_transitions_total',
+          unit: '1',
+          description: 'Total number of state transitions'
+        )
+
+        @instruments['evaluation_duration'] = @meter.create_histogram(
+          'star_gates_evaluation_duration',
+          unit: 'ms',
+          description: 'Feature evaluation duration'
+        )
+
+        @instruments['execution_duration'] = @meter.create_histogram(
+          'star_gates_execution_duration',
+          unit: 'ms',
+          description: 'Feature execution duration'
+        )
+
+        # Setup observable gauge for system health
+        @meter.create_observable_gauge(
+          'star_gates_system_health',
+          unit: '1',
+          description: 'System health status'
+        ) do |observer|
+          @gauge_values.each do |key, data|
+            next unless key.include?('system_health')
+
+            observer.observe(data[:value], attributes: data[:attributes])
+          end
+        end
+      end
+
+      # Override specific methods to use pre-created instruments
+      def record_feature_evaluation(feature_id, eligible, _context, execution_time_ms = nil)
+        return unless enabled?
+
+        attributes = {
+          'feature.id' => feature_id.to_s,
+          'feature.eligible' => eligible.to_s,
+          'service.name' => @service_name,
+          'service.version' => @service_version
+        }
+
+        @instruments['feature_evaluations_total'].add(1, attributes: attributes)
+
+        return unless execution_time_ms
+
+        @instruments['evaluation_duration'].record(execution_time_ms, attributes: {
+                                                     'feature.id' => feature_id.to_s,
+                                                     'feature.eligible' => eligible.to_s,
+                                                     'service.name' => @service_name,
+                                                     'service.version' => @service_version
+                                                   })
+      end
+
+      def record_feature_execution(feature_id, state, success, execution_time_ms, _context = {})
+        return unless enabled?
+
+        attributes = {
+          'feature.id' => feature_id.to_s,
+          'feature.state' => state.to_s,
+          'feature.success' => success.to_s,
+          'service.name' => @service_name,
+          'service.version' => @service_version
+        }
+
+        @instruments['feature_executions_total'].add(1, attributes: attributes)
+        @instruments['execution_duration'].record(execution_time_ms, attributes: {
+                                                    'feature.id' => feature_id.to_s,
+                                                    'feature.state' => state.to_s,
+                                                    'service.name' => @service_name,
+                                                    'service.version' => @service_version
+                                                  })
+      end
+
+      def record_state_transition(feature_id, from_state, to_state, event_name)
+        return unless enabled?
+
+        attributes = {
+          'feature.id' => feature_id.to_s,
+          'feature.transition.from' => from_state.to_s,
+          'feature.transition.to' => to_state.to_s,
+          'feature.transition.event' => event_name.to_s,
+          'service.name' => @service_name,
+          'service.version' => @service_version
+        }
+
+        @instruments['state_transitions_total'].add(1, attributes: attributes)
+      end
+    end
+  end
+end