prefab-cloud-ruby 0.19.0 → 0.21.0

data/lib/prefab/config_loader.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'yaml'
 module Prefab
   class ConfigLoader
     attr_reader :highwater_mark
@@ -19,21 +18,19 @@ module Prefab
       @api_config.each_key do |k|
         rtn[k] = @api_config[k]
       end
-      rtn = rtn.merge(@local_overrides)
-      rtn
+      rtn.merge(@local_overrides)
     end
 
     def set(config, source)
       # don't overwrite newer values
-      if @api_config[config.key] && @api_config[config.key][:config].id >= config.id
-        return
-      end
+      return if @api_config[config.key] && @api_config[config.key][:config].id >= config.id
 
       if config.rows.empty?
         @api_config.delete(config.key)
       else
         if @api_config[config.key]
-          @base_client.log_internal Logger::DEBUG, "Replace #{config.key} with value from #{source} #{ @api_config[config.key][:config].id} -> #{config.id}"
+          @base_client.log_internal Logger::DEBUG,
+                                    "Replace #{config.key} with value from #{source} #{@api_config[config.key][:config].id} -> #{config.id}"
         end
         @api_config[config.key] = { source: source, config: config }
       end
@@ -56,7 +53,7 @@ module Prefab
 
     def load_classpath_config
       classpath_dir = @prefab_options.prefab_config_classpath_dir
-      rtn = load_glob(File.join(classpath_dir, ".prefab.default.config.yaml"))
+      rtn = load_glob(File.join(classpath_dir, '.prefab.default.config.yaml'))
       @prefab_options.prefab_envs.each do |env|
         rtn = rtn.merge load_glob(File.join(classpath_dir, ".prefab.#{env}.config.yaml"))
       end
@@ -65,7 +62,7 @@ module Prefab
 
     def load_local_overrides
       override_dir = @prefab_options.prefab_config_override_dir
-      rtn = load_glob(File.join(override_dir, ".prefab.overrides.config.yaml"))
+      rtn = load_glob(File.join(override_dir, '.prefab.default.config.yaml'))
       @prefab_options.prefab_envs.each do |env|
         rtn = rtn.merge load_glob(File.join(override_dir, ".prefab.#{env}.config.yaml"))
       end
@@ -75,113 +72,9 @@ module Prefab
     def load_glob(glob)
       rtn = {}
       Dir.glob(glob).each do |file|
-        @base_client.log_internal Logger::INFO, "Load #{file}"
-        yaml = load(file)
-        yaml.each do |k, v|
-          load_kv(k, v, rtn, file)
-        end
+        Prefab::YAMLConfigParser.new(file, @base_client).merge(rtn)
       end
       rtn
     end
-
-    def load_kv(k, v, rtn, file)
-      if v.class == Hash
-        if v['feature_flag']
-          rtn[k] = feature_flag_config(file, k, v)
-        else
-          v.each do |nest_k, nest_v|
-            nested_key = "#{k}.#{nest_k}"
-            nested_key = k if nest_k == "_"
-            load_kv(nested_key, nest_v, rtn, file)
-          end
-        end
-      else
-        rtn[k] = {
-          source: file,
-          match: "default",
-          config: Prefab::Config.new(
-            key: k,
-            rows: [
-              Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(value_from(k, v)))
-            ]
-          )
-        }
-      end
-    end
-
-    def load(filename)
-      if File.exist? filename
-        @base_client.log_internal Logger::INFO, "Load #{filename}"
-        YAML.load_file(filename)
-      else
-        @base_client.log_internal Logger::INFO, "No file #{filename}"
-        {}
-      end
-    end
-
-    def value_from(key, raw)
-      case raw
-      when String
-        if key.start_with? Prefab::LoggerClient::BASE_KEY
-          prefab_log_level_resolve = Prefab::LogLevel.resolve(raw.upcase.to_sym) || Prefab::LogLevel::NOT_SET_LOG_LEVEL
-          { log_level: prefab_log_level_resolve }
-        else
-          { string: raw }
-        end
-      when Integer
-        { int: raw }
-      when TrueClass, FalseClass
-        { bool: raw }
-      when Float
-        { double: raw }
-      end
-    end
-
-    def feature_flag_config(file, key, value)
-      criteria = Prefab::Criteria.new(operator: 'ALWAYS_TRUE')
-
-      if value['criteria']
-        criteria = Prefab::Criteria.new(criteria_values(value['criteria']))
-      end
-
-      row = Prefab::ConfigRow.new(
-        value: Prefab::ConfigValue.new(
-          feature_flag: Prefab::FeatureFlag.new(
-            active: true,
-            inactive_variant_idx: -1, # not supported
-            rules: [
-              Prefab::Rule.new(
-                variant_weights: [
-                  Prefab::VariantWeight.new(variant_idx: 0, weight: 1000)
-                ],
-                criteria: criteria
-              )
-            ]
-          )
-        )
-      )
-
-      unless value.has_key?('value')
-        raise Prefab::Error, "Feature flag config `#{key}` #{file} must have a `value`"
-      end
-
-      {
-        source: file,
-        match: key,
-        config: Prefab::Config.new(
-          key: key,
-          variants: [Prefab::FeatureFlagVariant.new(value_from(key, value['value']))],
-          rows: [row]
-        )
-      }
-    end
-
-    def criteria_values(criteria_hash)
-      if RUBY_VERSION < '2.7'
-        criteria_hash.transform_keys(&:to_sym)
-      else
-        criteria_hash
-      end
-    end
   end
 end

data/lib/prefab/config_resolver.rb

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
+
 module Prefab
   class ConfigResolver
-    include Prefab::ConfigHelper
-    NAMESPACE_DELIMITER = "."
-
     attr_accessor :project_env_id # this will be set by the config_client when it gets an API response
 
     def initialize(base_client, config_loader)
       @lock = Concurrent::ReadWriteLock.new
       @local_store = {}
-      @namespace = base_client.options.namespace
+      @additional_properties = { Prefab::CriteriaEvaluator::NAMESPACE_KEY => base_client.options.namespace }
       @config_loader = config_loader
-      @project_env_id = 0
+      @project_env_id = 0 # we don't know this yet, it is set from the API results
+      @base_client = base_client
       make_local
     end
 
@@ -22,82 +21,53 @@ module Prefab
           v = @local_store[k]
           elements = [k.slice(0..49).ljust(50)]
           if v.nil?
-            elements << "tombstone"
+            elements << 'tombstone'
           else
-            value = v[:value]
-            elements << value_of(value).to_s.slice(0..34).ljust(35)
-            elements << value_of(value).class.to_s.slice(0..6).ljust(7)
+            config = evaluate(v[:config], {})
+            value = Prefab::ConfigValueUnwrapper.unwrap(config, k, {})
+            elements << value.to_s.slice(0..34).ljust(35)
+            elements << value.class.to_s.slice(0..6).ljust(7)
             elements << "Match: #{v[:match]}".slice(0..29).ljust(30)
             elements << "Source: #{v[:source]}"
           end
-          str += elements.join(" | ") << "\n"
+          str += elements.join(' | ') << "\n"
         end
       end
       str
     end
 
-    def get(property)
-      config = _get(property)
-      config ? value_of(config[:value]) : nil
-    end
+    def raw(key)
+      via_key = @local_store[key]
 
-    def get_config(property)
-      config = _get(property)
-      config ? config[:config] : nil
+      via_key ? via_key[:config] : nil
     end
 
-    def _get(key)
+    def get(key, lookup_key, properties = {})
       @lock.with_read_lock do
-        @local_store[key]
+        raw_config = raw(key)
+
+        return nil unless raw_config
+
+        evaluate(raw(key), lookup_key, properties)
       end
     end
 
+    def evaluate(config, lookup_key, properties = {})
+      props = properties.merge(@additional_properties).merge(Prefab::CriteriaEvaluator::LOOKUP_KEY => lookup_key)
+
+      Prefab::CriteriaEvaluator.new(config,
+                                    project_env_id: @project_env_id, resolver: self, base_client: @base_client).evaluate(props)
+    end
+
     def update
       make_local
     end
 
     private
 
-    # Should client a.b.c see key in namespace a.b? yes
-    # Should client a.b.c see key in namespace a.b.c? yes
-    # Should client a.b.c see key in namespace a.b.d? no
-    # Should client a.b.c see key in namespace ""? yes
-    #
-    def starts_with_ns?(key_namespace, client_namespace)
-      zipped = key_namespace.split(NAMESPACE_DELIMITER).zip(client_namespace.split(NAMESPACE_DELIMITER))
-      mapped = zipped.map do |k, c|
-        (k.nil? || k.empty?) || k == c
-      end
-      [mapped.all?, mapped.size]
-    end
-
     def make_local
-      store = {}
-      @config_loader.calc_config.each do |key, config_resolver_obj|
-        config = config_resolver_obj[:config]
-        sortable = config.rows.map do |row|
-          if row.project_env_id != 0
-            if row.project_env_id == @project_env_id
-              if !row.namespace.empty?
-                (starts_with, count) = starts_with_ns?(row.namespace, @namespace)
-                # rubocop:disable BlockNesting
-                { sortable: 2 + count, match: "nm:#{row.namespace}", value: row.value, config: config} if starts_with
-              else
-                { sortable: 1, match: "env:#{row.project_env_id}", value: row.value, config: config}
-              end
-            end
-          else
-            match = config_resolver_obj[:match] || "default"
-            { sortable: 0, match: match, value: row.value, config: config}
-          end
-        end.compact
-        to_store = sortable.sort_by { |h| h[:sortable] }.last
-        to_store[:source] = config_resolver_obj[:source]
-        store[key] = to_store
-      end
-
       @lock.with_write_lock do
-        @local_store = store
+        @local_store = @config_loader.calc_config
       end
     end
   end

data/lib/prefab/config_value_unwrapper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Prefab
+  class ConfigValueUnwrapper
+    def self.unwrap(config_value, config_key, properties)
+      return nil unless config_value
+
+      case config_value.type
+      when :int, :string, :double, :bool, :log_level
+        config_value.public_send(config_value.type)
+      when :string_list
+        config_value.string_list.values
+      when :weighted_values
+        lookup_key = properties[Prefab::CriteriaEvaluator::LOOKUP_KEY]
+        weights = config_value.weighted_values.weighted_values
+        value = Prefab::WeightedValueResolver.new(weights, config_key, lookup_key).resolve
+        unwrap(value.value, config_key, properties)
+      else
+        raise "Unknown type: #{config_value.type}"
+      end
+    end
+  end
+end

data/lib/prefab/criteria_evaluator.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Prefab
+  class CriteriaEvaluator
+    LOOKUP_KEY = 'LOOKUP'
+    NAMESPACE_KEY = 'NAMESPACE'
+    NO_MATCHING_ROWS = [].freeze
+
+    def initialize(config, project_env_id:, resolver:, base_client:)
+      @config = config
+      @project_env_id = project_env_id
+      @resolver = resolver
+      @base_client = base_client
+    end
+
+    def evaluate(properties)
+      # TODO: optimize this and perhaps do it elsewhere
+      props = properties.transform_keys(&:to_s)
+
+      matching_environment_row_values.each do |conditional_value|
+        return conditional_value.value if all_criteria_match?(conditional_value, props)
+      end
+
+      default_row_values.each do |conditional_value|
+        return conditional_value.value if all_criteria_match?(conditional_value, props)
+      end
+
+      nil
+    end
+
+    def all_criteria_match?(conditional_value, props)
+      conditional_value.criteria.all? do |criterion|
+        evaluate_criteron(criterion, props)
+      end
+    end
+
+    def evaluate_criteron(criterion, properties)
+      value_from_properties = properties[criterion.property_name]
+
+      case criterion.operator
+      when :LOOKUP_KEY_IN, :PROP_IS_ONE_OF
+        matches?(criterion, value_from_properties, properties)
+      when :LOOKUP_KEY_NOT_IN, :PROP_IS_NOT_ONE_OF
+        !matches?(criterion, value_from_properties, properties)
+      when :IN_SEG
+        in_segment?(criterion, properties)
+      when :NOT_IN_SEG
+        !in_segment?(criterion, properties)
+      when :PROP_ENDS_WITH_ONE_OF
+        return false unless value_from_properties
+
+        criterion.value_to_match.string_list.values.any? do |ending|
+          value_from_properties.end_with?(ending)
+        end
+      when :PROP_DOES_NOT_END_WITH_ONE_OF
+        return true unless value_from_properties
+
+        criterion.value_to_match.string_list.values.none? do |ending|
+          value_from_properties.end_with?(ending)
+        end
+      when :HIERARCHICAL_MATCH
+        value_from_properties.start_with?(criterion.value_to_match.string)
+      when :ALWAYS_TRUE
+        true
+      else
+        @base_client.log.info("Unknown Operator: #{criterion.operator}")
+        false
+      end
+    end
+
+    private
+
+    def matching_environment_row_values
+      @config.rows.find { |row| row.project_env_id == @project_env_id }&.values || NO_MATCHING_ROWS
+    end
+
+    def default_row_values
+      @config.rows.find { |row| row.project_env_id != @project_env_id }&.values || NO_MATCHING_ROWS
+    end
+
+    def in_segment?(criterion, properties)
+      @resolver.get(criterion.value_to_match.string, properties[LOOKUP_KEY], properties).bool
+    end
+
+    def matches?(criterion, value_from_properties, properties)
+      criterion_value_or_values = Prefab::ConfigValueUnwrapper.unwrap(criterion.value_to_match, @config.key, properties)
+
+      case criterion_value_or_values
+      when Google::Protobuf::RepeatedField
+        criterion_value_or_values.include?(value_from_properties)
+      else
+        criterion_value_or_values == value_from_properties
+      end
+    end
+  end
+end

data/lib/prefab/errors/invalid_api_key_error.rb

@@ -5,7 +5,7 @@ module Prefab
     class InvalidApiKeyError < Prefab::Error
       def initialize(key)
         if key.nil? || key.empty?
-          message = "No API key. Set PREFAB_API_KEY env var or use PREFAB_DATASOURCES=LOCAL_ONLY"
+          message = 'No API key. Set PREFAB_API_KEY env var or use PREFAB_DATASOURCES=LOCAL_ONLY'
 
           super(message)
         else

data/lib/prefab/feature_flag_client.rb

@@ -1,176 +1,44 @@
 # frozen_string_literal: true
+
 module Prefab
   class FeatureFlagClient
-    include Prefab::ConfigHelper
-    MAX_32_FLOAT = 4294967294.0
-
     def initialize(base_client)
       @base_client = base_client
     end
 
-    def upsert(feature_name, feature_obj)
-      @base_client.config_client.upsert(feature_name, Prefab::ConfigValue.new(feature_flag: feature_obj))
-    end
-
     def feature_is_on?(feature_name)
       feature_is_on_for?(feature_name, nil)
     end
 
     def feature_is_on_for?(feature_name, lookup_key, attributes: {})
-      @base_client.stats.increment("prefab.featureflag.on", tags: ["feature:#{feature_name}"])
+      @base_client.stats.increment('prefab.featureflag.on', tags: ["feature:#{feature_name}"])
 
-      return is_on?(_get(feature_name, lookup_key, attributes, default: false))
-    end
-
-    def get(feature_name, lookup_key=nil, attributes={}, default: false)
-      variant = _get(feature_name, lookup_key, attributes, default: default)
+      variant = @base_client.config_client.get(feature_name, false, attributes, lookup_key)
 
-      value_of_variant_or_nil(variant, default)
+      is_on?(variant)
     end
 
-    private
+    def get(feature_name, lookup_key = nil, attributes = {}, default: false)
+      value = _get(feature_name, lookup_key, attributes)
 
-    def value_of_variant_or_nil(variant_maybe, default)
-      if variant_maybe.nil?
-        default != Prefab::Client::NO_DEFAULT_PROVIDED ? default : nil
-      else
-        value_of_variant(variant_maybe)
-      end
+      value.nil? ? default : value
     end
 
-    def _get(feature_name, lookup_key=nil, attributes={}, default:)
-      feature_obj = @base_client.config_client.get(feature_name, default)
-      config_obj = @base_client.config_client.get_config_obj(feature_name)
-
-      return nil if feature_obj.nil? || config_obj.nil?
-
-      if feature_obj == !!feature_obj
-        return feature_obj
-      end
+    private
 
-      variants = config_obj.variants
-      get_variant(feature_name, lookup_key, attributes, feature_obj, variants)
+    def _get(feature_name, lookup_key = nil, attributes = {})
+      @base_client.config_client.get(feature_name, nil, attributes, lookup_key)
     end
 
     def is_on?(variant)
-      if variant.nil?
-        return false
-      end
+      return false if variant.nil?
 
-      if variant == !!variant
-        return variant
-      end
+      return variant if variant == !!variant
 
       variant.bool
-    rescue
+    rescue StandardError
       @base_client.log.info("is_on? methods only work for boolean feature flags variants. This feature flags variant is '#{variant}'. Returning false")
       false
     end
-
-    def get_variant(feature_name, lookup_key, attributes, feature_obj, variants)
-      if !feature_obj.active
-        return get_variant_obj(variants, feature_obj.inactive_variant_idx)
-      end
-
-      #default to inactive
-      variant_weights = [Prefab::VariantWeight.new(variant_idx: feature_obj.inactive_variant_idx, weight: 1)]
-
-      # if rules.match
-      feature_obj.rules.each do |rule|
-        if criteria_match?(rule.criteria, lookup_key, attributes)
-          variant_weights = rule.variant_weights
-          break
-        end
-      end
-
-      percent_through_distribution = rand()
-      if lookup_key
-        percent_through_distribution = get_user_pct(feature_name, lookup_key)
-      end
-
-      variant_idx = get_variant_idx_from_weights(variant_weights, percent_through_distribution, feature_name)
-
-      return get_variant_obj(variants, variant_idx)
-    end
-
-    def get_variant_obj(variants, idx)
-      # our array is 0 based, but the idx are 1 based so the protos are clearly set
-      return variants[idx - 1] if variants.length >= idx
-      nil
-    end
-
-    def get_variant_idx_from_weights(variant_weights, percent_through_distribution, feature_name)
-      distrubution_space = variant_weights.inject(0) { |sum, v| sum + v.weight }
-      bucket = distrubution_space * percent_through_distribution
-      sum = 0
-      variant_weights.each do |variant_weight|
-        if bucket < sum + variant_weight.weight
-          return variant_weight.variant_idx
-        else
-          sum += variant_weight.weight
-        end
-      end
-      # variants didn't add up to 100%
-      @base_client.log.info("Variants of #{feature_name} did not add to 100%")
-      return variant_weights.last.variant_idx
-    end
-
-    def get_user_pct(feature, lookup_key)
-      to_hash = "#{feature}#{lookup_key}"
-      int_value = Murmur3.murmur3_32(to_hash)
-      int_value / MAX_32_FLOAT
-    end
-
-    def criteria_match?(criteria, lookup_key, attributes)
-      case criteria.operator
-      when :ALWAYS_TRUE
-        true
-      when :LOOKUP_KEY_IN
-        criteria.values.include?(lookup_key)
-      when :LOOKUP_KEY_NOT_IN
-        !criteria.values.include?(lookup_key)
-      when :IN_SEG
-        segment_matches?(criteria.values, lookup_key, attributes)
-      when :NOT_IN_SEG
-        !segment_matches?(criteria.values, lookup_key, attributes)
-      when :PROP_IS_ONE_OF
-        criteria.values.include?(attribute_value(attributes, criteria.property))
-      when :PROP_IS_NOT_ONE_OF
-        !criteria.values.include?(attribute_value(attributes, criteria.property))
-      when :PROP_ENDS_WITH_ONE_OF
-        criteria.values.any? { |value| attribute_value(attributes, criteria.property)&.end_with?(value) }
-      when :PROP_DOES_NOT_END_WITH_ONE_OF
-        criteria.values.none? { |value| attribute_value(attributes, criteria.property)&.end_with?(value) }
-      else
-        @base_client.log.info("Unknown Operator: #{criteria.operator}")
-        false
-      end
-    end
-
-    def attribute_value(attributes, property)
-      attributes[property] || attributes[property.to_sym]
-    end
-
-    # evaluate each segment key and return whether any match
-    # there should be an associated segment available as a standard config obj
-    def segment_matches?(segment_keys, lookup_key, attributes)
-      segment_keys.any? do |segment_key|
-        segment = @base_client.config_client.get(segment_key)
-        if segment.nil?
-          @base_client.log.info("Missing Segment")
-          false
-        else
-          segment_match?(segment, lookup_key, attributes)
-        end
-      end
-    end
-
-    # does a given segment match?
-    def segment_match?(segment, lookup_key, attributes)
-      segment.criterion.any? do |criteria|
-        criteria_match?(criteria, lookup_key, attributes)
-      end
-    end
   end
 end
-

data/lib/prefab/internal_logger.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Prefab
   class InternalLogger < Logger
     def initialize(path, logger)
@@ -6,23 +7,23 @@ module Prefab
       @logger = logger
     end
 
-    def debug(progname = nil, &block)
+    def debug(progname = nil)
       @logger.log_internal yield, @path, progname, DEBUG
     end
 
-    def info(progname = nil, &block)
+    def info(progname = nil)
       @logger.log_internal yield, @path, progname, INFO
     end
 
-    def warn(progname = nil, &block)
+    def warn(progname = nil)
       @logger.log_internal yield, @path, progname, WARN
     end
 
-    def error(progname = nil, &block)
+    def error(progname = nil)
       @logger.log_internal yield, @path, progname, ERROR
     end
 
-    def fatal(progname = nil, &block)
+    def fatal(progname = nil)
       @logger.log_internal yield, @path, progname, FATAL
     end
   end