flagger 2.0.8 → 3.1.0

data/lib/flagger/microservice.rb

@@ -1,63 +0,0 @@
-require 'faraday'
-require 'json'
-
-module FlaggerEnvironments
-  class MicroserviceDelegate
-    attr_accessor :env_key
-    attr_accessor :edge_url
-    attr_accessor :request_timeout
-
-    def initialize(env_key, edge_url, request_timeout)
-      @env_key = env_key
-      @edge_url = edge_url
-      @request_timeout = request_timeout
-    end
-
-    def treatment(flag, entity)
-      get_object_values(flag, entity)['treatment'] rescue nil
-    end
-
-    def payload(flag, entity)
-      get_object_values(flag, entity)['payload'] rescue nil
-    end
-
-    def eligible?(flag, entity)
-      get_object_values(flag, entity)['isEligible'] rescue nil
-    end
-
-    def enabled?(flag, entity)
-      get_object_values(flag, entity)['isEnabled'] rescue nil
-    end
-
-    def publish(entities)
-    end
-
-    def cleanup()
-    end
-
-    private
-    def get_object_values(flag, entity)
-      begin
-        conn = Faraday.new(url: "#{@edge_url}/v2/object-values/#{@env_key}")
-        response = conn.post do |req|
-          req.options.timeout = @request_timeout
-          req.headers['Content-Type'] = 'application/json'
-          req.body = JSON.generate({
-                                     'flag' => flag.flag_name,
-                                     'entity' => entity,
-                                   })
-        end
-        if response.status == 200
-          object_values = JSON.parse(response.body)
-          object_values
-        else
-          puts 'Failed to connect to Airship edge server'
-          nil
-        end
-      rescue Exception => e
-        puts 'Failed to connect to Airship edge server', e
-        nil
-      end
-    end
-  end
-end

data/lib/flagger/models.rb

@@ -1,657 +0,0 @@
-require 'digest'
-require 'dry-validation'
-
-module FlaggerModels
-  class BaseEntity
-    SCHEMA = Dry::Validation.Schema do
-      configure do
-        def valid_attribute_names?(attributes)
-          attributes.keys.all? do |name|
-            name.is_a?(String) && /^[a-zA-Z]$|^[a-zA-Z_]{0,48}[a-zA-Z]$/ =~ name
-          end
-        end
-
-        def valid_attribute_values?(attributes)
-          attributes.values.all? do |v|
-            (v.is_a?(String) && v.length <= 3000) || [true, false].include?(v) || v.is_a?(Numeric)
-          end
-        end
-
-        def self.messages
-          super.merge(
-            en: {
-              errors: {
-                :valid_attribute_names? => 'Each attribute must begin and end with an alphabet letter (a-z, A-Z). In between, allowed characters are a-z, A-Z, and "_". For example: isStudent or is_student. Preceding or trailing underscore is not allowed (i.e., _is_student or is_student_).',
-                :valid_attribute_values? => "An entity's attribute value must be a string no more than 3000 characters, boolean, or number."
-              }
-            }
-          )
-        end
-      end
-
-      optional('type') { str? & size?(1..50) & format?(/^([A-Z][a-zA-Z]*)+$/) }
-      required('id') { str? & size?(1..250) }
-      optional('display_name') { str? & size?(1..250) }
-      optional('attributes') { type?(Hash) & size?(0..100) & valid_attribute_names? & valid_attribute_values? }
-      required('is_group') { bool? }
-    end
-
-    attr_accessor :type
-    attr_accessor :id
-    attr_accessor :display_name
-    attr_accessor :attributes
-    attr_accessor :is_group
-
-    def initialize(json)
-      @type = json['type']
-      @id = json['id']
-      if @id.is_a?(Numeric) then
-        @id = @id.to_s
-      end
-      @display_name = json['display_name'] || @id if @id.is_a?(String)
-      @attributes = json['attributes'] || {}
-    end
-
-    def attrs()
-      instance_variables.map do |var|
-        if var == :@group then
-          group = instance_variable_get(var)
-          [var[1..-1], if defined? group.attrs then group.attrs else group end]
-        else
-          [var[1..-1], instance_variable_get(var)]
-        end
-      end.to_h.delete_if { |k,v| v.nil? }
-    end
-
-    def hash()
-      attrs.hash
-    end
-
-    def validation_errors()
-      SCHEMA.(attrs).errors
-    end
-
-    def valid?()
-      validation_errors.length === 0
-    end
-  end
-
-  class GroupEntity < BaseEntity
-    def initialize(json)
-      super(json)
-      @is_group = true
-    end
-  end
-
-  class SingleEntity < BaseEntity
-    SCHEMA = Dry::Validation.Schema do
-      optional('group').schema(GroupEntity::SCHEMA)
-    end
-
-    attr_accessor :group
-
-    def initialize(json)
-      super(json)
-      @group = json['group']&.is_a?(Hash) && GroupEntity.new(json['group'])
-      @is_group = false
-
-      if @type == nil then
-        @type = 'User'
-      end
-
-      if @group && @group.type.nil? then
-        @group.type = @type + 'Group'
-      end
-    end
-
-    def validation_errors()
-      if @group != nil then
-        group_errors = SingleEntity::SCHEMA.(attrs).errors
-        super.merge(group_errors)
-      else
-        super
-      end
-    end
-  end
-
-  class GatingInfoModel
-    def validate()
-      messages = self.class::SCHEMA.(attrs).messages
-      raise RuntimeError.new(messages) if messages.length > 0
-    end
-
-    def attrs()
-      instance_variables.map do |var|
-        value = instance_variable_get(var)
-        if value != nil then
-          [var, value]
-        else
-          nil
-        end
-      end.compact.to_h
-    end
-  end
-
-  class GatingInfo
-    attr_reader :sdk_info
-    attr_reader :flags
-    attr_reader :env
-
-    def initialize(json)
-      @sdk_info = SdkInfo.new(json['sdk_info'] || {})
-      @env = Env.new(json['env'])
-      @flags = Hash[json['flags'].map {|flag| [flag['codename'], Flag.new(flag, @env.hash_key)]}]
-    end
-
-    def flag(name)
-      @flags[name]
-    end
-  end
-
-  class SdkInfo < GatingInfoModel
-    SCHEMA = Dry::Validation.Schema do
-      optional(:@ingestion_interval) { int? }
-      optional(:@ingestion_max_items) { int? }
-      optional(:@should_ingest_entities) { bool? }
-      optional(:@should_ingest_stats) { bool? }
-      optional(:@should_ingest_exposures) { bool? }
-      optional(:@should_ingest_flags) { bool? }
-    end
-
-    attr_reader :ingestion_interval
-    attr_reader :ingestion_max_items
-    attr_reader :should_ingest_entities
-    attr_reader :should_ingest_stats
-    attr_reader :should_ingest_exposures
-    attr_reader :should_ingest_flags
-
-    def initialize(json)
-      @ingestion_interval = json['SDK_INGESTION_INTERVAL']
-      @ingestion_max_items = json['SDK_INGESTION_MAX_ITEMS']
-      @should_ingest_entities = json['SDK_SHOULD_INGEST_OBJECTS']
-      @should_ingest_stats = json['SDK_SHOULD_INGEST_STATS']
-      @should_ingest_exposures = json['SDK_SHOULD_INGEST_EXPOSURES']
-      @should_ingest_flags = json['SDK_SHOULD_INGEST_FLAGS']
-
-      validate
-    end
-  end
-
-  class Env < GatingInfoModel
-    SCHEMA = Dry::Validation.Schema do
-      required(:@env_key) { str? }
-      required(:@hash_key) { str? }
-    end
-
-    attr_reader :env_key
-    attr_reader :hash_key
-
-    def initialize(json)
-      @env_key = json['env_key']
-      @hash_key = json['hash_key']
-
-      validate
-    end
-  end
-
-  class Flag < GatingInfoModel
-    SCHEMA = Dry::Validation.Schema do
-      required(:@codename) { str? }
-      required(:@flag_status) { included_in? ['operational', 'archived'] }
-      required(:@flag_type) { included_in? ['basic', 'experiment', 'uncategorized'] }
-      required(:@hash_key) { str? }
-      optional(:@is_paused) { bool? }
-      required(:@is_web_accessible) { bool? }
-      required(:@overrides) { hash? }
-      required(:@populations) { array? }
-      required(:@splits) { hash? }
-      required(:@treatments) { hash? }
-
-      required(:@env_hash_key) { str? }
-    end
-
-    attr_reader :codename
-    attr_reader :flag_status
-    attr_reader :flag_type
-    attr_reader :hash_key
-    attr_reader :is_paused
-    attr_reader :is_web_accessible
-    attr_reader :overrides
-    attr_reader :populations
-    attr_reader :splits
-    attr_reader :treatments
-
-    attr_reader :env_hash_key
-
-    def initialize(json, env_hash_key)
-      @codename = json['codename']
-      @flag_status = json['flag_status']
-      @flag_type = json['flag_type']
-      @hash_key = json['hash_key']
-      @is_paused = json['is_paused']
-      @is_web_accessible = json['is_web_accessible']
-      @overrides = Hash[(json['overrides'] || []).map {|override| ["#{override['entity_type']}_#{override['entity_id']}", Override.new(override)]}]
-      @populations = (json['populations'] || []).map {|population| Population.new(population)}
-      @splits = Hash[(json['splits'] || []).map {|split| [split['treatment_id'], Split.new(split)]}]
-      @treatments = Hash[(json['treatments'] || []).map {|treatment| [treatment['treatment_id'], Treatment.new(treatment)]}]
-      @off_treatment = json['treatments'].find {|treatment| treatment['is_off_treatment'] }
-
-      @env_hash_key = env_hash_key
-
-      validate
-    end
-
-    def treatment(entity)
-      if @flag_type == 'uncategorized' or !entity then
-        nil
-      else
-        resolved_allocation(@env_hash_key, entity)
-      end
-    end
-
-    def payload(entity)
-      if @flag_type == 'uncategorized' or !entity then
-        nil
-      else
-        resolved_allocation(@env_hash_key, entity)
-      end
-    end
-
-    def eligible?(entity)
-      if @flag_type == 'uncategorized' or !entity then
-        nil
-      else
-        resolved_allocation(@env_hash_key, entity)
-      end
-    end
-
-    def enabled?(entity)
-      if @flag_type == 'uncategorized' or !entity then
-        nil
-      else
-        resolved_allocation(@env_hash_key, entity)
-      end
-    end
-
-    def resolved_allocation(env_hash_key, entity)
-      resolve_allocations(
-        allocation(@env_hash_key, entity),
-        allocation(@env_hash_key, (entity.group if defined? entity.group))
-      )
-    end
-
-    def allocation(env_hash_key, entity)
-      off_allocation = {
-        treatment: @treatments.find {|treatment_id, treatment| treatment.is_off_treatment}[1],
-        eligible: false
-      }
-
-      if !entity.is_a?(BaseEntity) then
-        return off_allocation
-      end
-
-      if @flag_status == 'archived' then
-        STDERR.puts 'The flag has been archived'
-        return off_allocation
-      end
-
-      if @is_paused then
-        return off_allocation
-      end
-
-      treatment = @treatments[@overrides["#{entity.type}_#{entity.id}"]&.treatment_id]
-      if treatment then
-        return {
-          treatment: treatment,
-          eligible: !treatment.is_off_treatment,
-          from_override: true
-        }
-      end
-
-      use_universes = @flag_type == 'experiment'
-
-      is_eligible = false
-      @populations.each do |population|
-        eligible, treatment = population.gate_values(
-                    entity,
-                    env_hash_key,
-                    self,
-                    use_universes
-                  ).values_at(:eligible, :treatment)
-
-        if treatment != nil then
-          return {
-            treatment: treatment,
-            eligible: eligible
-          }
-        end
-
-        is_eligible ||= eligible
-      end
-
-      {
-        treatment: off_allocation[:treatment],
-        eligible: is_eligible
-      }
-    end
-
-    def resolve_allocations(individual_alloc, group_alloc)
-      if individual_alloc[:from_override] then
-        individual_alloc
-      elsif group_alloc[:from_override] then
-        group_alloc
-      elsif not individual_alloc[:treatment].is_off_treatment then
-        individual_alloc
-      elsif not group_alloc[:treatment].is_off_treatment then
-        group_alloc
-      else
-        individual_alloc
-      end
-    end
-  end
-
-  class Override < GatingInfoModel
-    SCHEMA = Dry::Validation.Schema do
-      required(:@treatment_id) { str? }
-      required(:@entity_id) { str? }
-      required(:@entity_type) { str? }
-    end
-
-    attr_reader :treatment_id
-    attr_reader :entity_id
-    attr_reader :entity_type
-
-    def initialize(json)
-      @treatment_id = json['treatment_id']
-      @entity_id = json['entity_id']
-      @entity_type = json['entity_type']
-
-      validate
-    end
-  end
-
-  class Population < GatingInfoModel
-    SCHEMA = Dry::Validation.Schema do
-      required(:@rules) { array? }
-      required(:@universes) { array? }
-      required(:@percentage) { gteq?(0) & lteq?(1) }
-      required(:@hash_key) { str? }
-      required(:@entity_type) { str? }
-    end
-
-    attr_reader :rules
-    attr_reader :universes
-    attr_reader :percentage
-    attr_reader :hash_key
-    attr_reader :entity_type
-
-    def initialize(json)
-      @rules = (json['rules'] || []).map {|rule| Rule.new(rule)}
-      @universes = (json['universes'] || []).map {|universe| Hash[universe.map {|split| [split['treatment_id'], Split.new(split)]}]}
-      @percentage = json['percentage']
-      @hash_key = json['hash_key']
-      @entity_type = json['entity_type']
-
-      validate
-    end
-
-    def gate_values(entity, env_hash_key, flag, sticky)
-      if @entity_type != entity.type
-        return {eligible: false}
-      end
-
-      matches = @rules.all? {|rule| rule.match(entity)}
-      if matches then
-        samplingHashKey = "SAMPLING:control_#{flag.hash_key}:env_#{env_hash_key}:rule_set_#{@hash_key}:client_object_#{entity.type}_#{entity.id}"
-        hashedPercentage = Population.getHashedPercentage(samplingHashKey)
-        if hashedPercentage <= @percentage and @percentage > 0 then
-
-          allocationHashKey = "DISTRIBUTION:control_#{flag.hash_key}:env_#{env_hash_key}:client_object_#{entity.type}_#{entity.id}"
-          allocationHashedPercentage = Population.getHashedPercentage(allocationHashKey)
-
-          splits = if sticky then
-                     @universes[[(hashedPercentage * 100).floor - 1, 0].max]
-                   else
-                     flag.splits
-                   end
-
-          sum = 0
-          {
-            eligible: true,
-            treatment: flag.treatments.find {|treatment_id, treatment|
-              if treatment.is_off_treatment then
-                false
-              else
-                sum = (sum + (splits[treatment.treatment_id]&.percentage || 0)).round(3)
-                allocationHashedPercentage <= sum
-              end
-            }[1]
-          }
-        else
-          {eligible: true}
-        end
-      else
-        {eligible: false}
-      end
-    end
-
-    def self.getHashedPercentage(s)
-      Digest::MD5.hexdigest(s).to_i(16).to_f / 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
-    end
-  end
-
-  module RuleType
-    STRING = 'string'
-    INT = 'int'
-    FLOAT = 'float'
-    BOOLEAN = 'boolean'
-    DATE = 'date'
-    DATETIME = 'datetime'
-  end
-
-  module RuleOperator
-    IS = 'is'
-    IS_NOT = 'is_not'
-    IN = 'in'
-    NOT_IN = 'not_in'
-    LT = 'lt'
-    LTE = 'lte'
-    GT = 'gt'
-    GTE = 'gte'
-    FROM = 'from'
-    UNTIL = 'until'
-    AFTER = 'after'
-    BEFORE = 'before'
-  end
-
-  class Rule < GatingInfoModel
-    SCHEMA = Dry::Validation.Schema do
-      required(:@operator) { included_in? RuleOperator.constants(false).map(&RuleOperator.method(:const_get)) }
-      required(:@attribute_type) { included_in? RuleType.constants(false).map(&RuleType.method(:const_get)) }
-      required(:@attribute_name) { str? }
-      optional(:@value_list) { array? { each { str? | bool? | type?(Numeric) } } }
-      optional(:@value) { str? | bool? | type?(Numeric) }
-    end
-
-    attr_reader :operator
-    attr_reader :attribute_type
-    attr_reader :attribute_name
-    attr_reader :value_list
-    attr_reader :value
-
-    def initialize(json)
-      @operator = json['operator']
-      @attribute_type = json['attribute_type']
-      @attribute_name = json['attribute_name']
-      @value_list = json['value_list']
-      @value = json['value']
-
-      validate
-    end
-
-    def self.categorize_value_type(value)
-      case value
-      when true
-        'boolean'
-      when false
-        'boolean'
-      when Float
-        'float'
-      when Integer
-        'int'
-      when String
-        begin
-          date = DateTime.parse(value)
-          if date.hour == 0 && date.minute == 0 && date.second == 0 && date.second_fraction == 0 then
-            'date'
-          else
-            'datetime'
-          end
-        rescue ArgumentError
-          'string'
-        end
-      else
-        STDERR.puts 'Unexpected attribute value type encountered'
-        nil
-      end
-    end
-
-    def match(entity)
-      begin
-        if not entity.attributes.key?(@attribute_name) then
-          return false
-        end
-
-        value = entity.attributes[@attribute_name]
-        attribute_type = Rule.categorize_value_type(value)
-        number_types = [RuleType::INT, RuleType::FLOAT].sort
-
-        if attribute_type != @attribute_type &&
-           [attribute_type, @attribute_type].sort != number_types then
-          return false
-        end
-
-        if attribute_type == RuleType::STRING then
-          if @operator == RuleOperator::IS then
-            value == @value
-          elsif @operator == RuleOperator::IS_NOT then
-            value != @value
-          elsif @operator == RuleOperator::IN then
-            @value_list.include?(value)
-          elsif @operator == RuleOperator::NOT_IN then
-            not @value_list.include?(value)
-          else
-            STDERR.puts 'Invalid rule operator encountered'
-            false
-          end
-        elsif number_types.include?(attribute_type) then
-          if @operator == RuleOperator::IS then
-            value == @value
-          elsif @operator == RuleOperator::IS_NOT then
-            value != @value
-          elsif @operator == RuleOperator::IN then
-            @value_list.include?(value)
-          elsif @operator == RuleOperator::NOT_IN then
-            not @value_list.include?(value)
-          elsif @operator == RuleOperator::LT then
-            value < @value
-          elsif @operator == RuleOperator::LTE then
-            value <= @value
-          elsif @operator == RuleOperator::GT then
-            value > @value
-          elsif @operator == RuleOperator::GTE then
-            value >= @value
-          else
-            STDERR.puts 'Invalid rule operator encountered'
-            false
-          end
-        elsif attribute_type == RuleType::BOOLEAN then
-          if @operator == RuleOperator::IS then
-            value == @value
-          elsif @operator == RuleOperator::IS_NOT then
-            value != @value
-          else
-            STDERR.puts 'Invalid rule operator encountered'
-            false
-          end
-        elsif attribute_type == RuleType::DATE || attribute_type == RuleType::DATETIME then
-          target_time = @value && DateTime.parse(@value)
-          target_time_list = @value_list&.map {|tv| DateTime.parse(tv)}
-          value_time = DateTime.parse(value)
-
-          if @operator == RuleOperator::IS then
-            value_time == target_time
-          elsif @operator == RuleOperator::IS_NOT then
-            value_time != target_time
-          elsif @operator == RuleOperator::IN then
-            target_time_list.include?(value_time)
-          elsif @operator == RuleOperator::NOT_IN then
-            not target_time_list.include?(value_time)
-          elsif @operator == RuleOperator::FROM then
-            value_time >= target_time
-          elsif @operator == RuleOperator::UNTIL then
-            value_time <= target_time
-          elsif @operator == RuleOperator::AFTER then
-            value_time > target_time
-          elsif @operator == RuleOperator::BEFORE then
-            value_time < target_time
-          else
-            STDERR.puts 'Invalid rule operator encountered'
-            false
-          end
-        else
-          STDERR.puts 'Invalid attribute type encountered'
-          false
-        end
-      rescue Exception => e
-        STDERR.puts "Traceback:"
-        STDERR.puts e.backtrace
-        STDERR.puts "#{e.class} (#{e.message})"
-        false
-      end
-    end
-  end
-
-  class Split < GatingInfoModel
-    SCHEMA = Dry::Validation.Schema do
-      required(:@treatment_id) { str? }
-      required(:@percentage) { gteq?(0) & lteq?(1) }
-    end
-
-    attr_reader :treatment_id
-    attr_reader :percentage
-
-    def initialize(json)
-      @treatment_id = json['treatment_id']
-      @percentage = json['percentage']
-
-      validate
-    end
-  end
-
-  class Treatment < GatingInfoModel
-    SCHEMA = Dry::Validation.Schema do
-      required(:@treatment_id) { str? }
-      required(:@is_ghost) { bool? }
-      required(:@codename) { str? }
-      required(:@is_off_treatment) { bool? }
-      optional(:@payload) { str? | type?(Numeric) | bool? | array? | type?(Hash) }
-    end
-
-    attr_reader :treatment_id
-    attr_reader :is_ghost
-    attr_reader :codename
-    attr_reader :is_off_treatment
-    attr_reader :payload
-
-    def initialize(json)
-      @treatment_id = json['treatment_id']
-      @is_ghost = json['is_ghost']
-      @codename = json['codename']
-      @is_off_treatment = json['is_off_treatment']
-      @payload = json['payload']
-
-      validate
-    end
-  end
-end