prefab-cloud-ruby 0.20.0 → 0.21.0

data/lib/prefab/local_config_parser.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Prefab
+  class LocalConfigParser
+    class << self
+      def parse(key, value, config, file)
+        if value.instance_of?(Hash)
+          if value['feature_flag']
+            config[key] = feature_flag_config(file, key, value)
+          else
+            value.each do |nest_key, nest_value|
+              nested_key = "#{key}.#{nest_key}"
+              nested_key = key if nest_key == '_'
+              parse(nested_key, nest_value, config, file)
+            end
+          end
+        else
+          config[key] = {
+            source: file,
+            match: 'default',
+            config: Prefab::Config.new(
+              config_type: :CONFIG,
+              key: key,
+              rows: [
+                Prefab::ConfigRow.new(values: [
+                                        Prefab::ConditionalValue.new(value: value_from(key, value))
+                                      ])
+              ]
+            )
+          }
+        end
+
+        config
+      end
+
+      def value_from(key, raw)
+        case raw
+        when String
+          if key.to_s.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)
+        criterion = (parse_criterion(value['criterion']) if value['criterion'])
+
+        variant = Prefab::ConfigValue.new(value_from(key, value['value']))
+
+        row = Prefab::ConfigRow.new(
+          values: [
+            Prefab::ConditionalValue.new(
+              criteria: [criterion].compact,
+              value: Prefab::ConfigValue.new(
+                weighted_values: Prefab::WeightedValues.new(weighted_values: [
+                                                              Prefab::WeightedValue.new(
+                                                                weight: 1000,
+                                                                value: variant
+                                                              )
+                                                            ])
+              )
+            )
+          ]
+        )
+
+        raise Prefab::Error, "Feature flag config `#{key}` #{file} must have a `value`" unless value.key?('value')
+
+        {
+          source: file,
+          match: key,
+          config: Prefab::Config.new(
+            config_type: :FEATURE_FLAG,
+            key: key,
+            allowable_values: [variant],
+            rows: [row]
+          )
+        }
+      end
+
+      def parse_criterion(criterion)
+        Prefab::Criterion.new(operator: criterion['operator'],
+                              property_name: parse_property(criterion),
+                              value_to_match: parse_value_to_match(criterion['values']))
+      end
+
+      def parse_property(criterion)
+        if criterion['operator'] == 'LOOKUP_KEY_IN'
+          Prefab::CriteriaEvaluator::LOOKUP_KEY
+        else
+          criterion['property']
+        end
+      end
+
+      def parse_value_to_match(values)
+        raise "Can't handle #{values}" unless values.instance_of?(Array)
+
+        Prefab::ConfigValue.new(string_list: Prefab::StringList.new(values: values))
+      end
+    end
+  end
+end

data/lib/prefab/logger_client.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
+
 module Prefab
   class LoggerClient < Logger
-
-    SEP = "."
-    BASE_KEY = "log-level"
-    UNKNOWN_PATH = "unknown."
-    INTERNAL_PREFIX = "cloud.prefab.client"
+    SEP = '.'
+    BASE_KEY = 'log-level'
+    UNKNOWN_PATH = 'unknown.'
+    INTERNAL_PREFIX = 'cloud.prefab.client'
 
     LOG_LEVEL_LOOKUPS = {
       Prefab::LogLevel::NOT_SET_LOG_LEVEL => Logger::DEBUG,
@@ -33,20 +33,18 @@ module Prefab
     end
 
     def log_internal(message, path = nil, progname, severity, &block)
-      if path
-        path = "#{INTERNAL_PREFIX}.#{path}"
-      else
-        path = INTERNAL_PREFIX
-      end
+      path = if path
+               "#{INTERNAL_PREFIX}.#{path}"
+             else
+               INTERNAL_PREFIX
+             end
 
       log(message, path, progname, severity, &block)
     end
 
-    def log(message, path, progname, severity, &block)
+    def log(message, path, progname, severity)
       severity ||= Logger::UNKNOWN
-      if @logdev.nil? || severity < level_of(path) || @silences[local_log_id]
-        return true
-      end
+      return true if @logdev.nil? || severity < level_of(path) || @silences[local_log_id]
 
       progname = "#{path}: #{progname || @progname}"
 
@@ -60,7 +58,8 @@ module Prefab
       end
 
       @logdev.write(
-        format_message(format_severity(severity), Time.now, progname, message))
+        format_message(format_severity(severity), Time.now, progname, message)
+      )
       true
     end
 
@@ -85,23 +84,23 @@ module Prefab
     end
 
     def debug?
-      true;
+      true
     end
 
     def info?
-      true;
+      true
     end
 
     def warn?
-      true;
+      true
     end
 
     def error?
-      true;
+      true
     end
 
     def fatal?
-      true;
+      true
     end
 
     def level
@@ -128,13 +127,10 @@ module Prefab
     # Find the closest match to 'log_level.path' in config
     def level_of(path)
       closest_log_level_match = @config_client.get(BASE_KEY, :WARN)
-      path.split(SEP).inject([BASE_KEY]) do |memo, n|
+      path.split(SEP).each_with_object([BASE_KEY]) do |n, memo|
         memo << n
         val = @config_client.get(memo.join(SEP), nil)
-        unless val.nil?
-          closest_log_level_match = val
-        end
-        memo
+        closest_log_level_match = val unless val.nil?
       end
       closest_log_level_match_int = Prefab::LogLevel.resolve(closest_log_level_match)
       LOG_LEVEL_LOOKUPS[closest_log_level_match_int]
@@ -150,10 +146,10 @@ module Prefab
     def get_path(absolute_path, base_label)
       path = (absolute_path || UNKNOWN_PATH).dup
       path.slice! Dir.pwd
-      path.gsub!(/(.*)?(?=\/lib)/im, "") # replace everything before first lib
+      path.gsub!(%r{(.*)?(?=/lib)}im, '') # replace everything before first lib
 
-      path = path.gsub("/", SEP).gsub(/.rb.*/, "") + SEP + base_label
-      path.slice! ".lib"
+      path = path.gsub('/', SEP).gsub(/.rb.*/, '') + SEP + base_label
+      path.slice! '.lib'
       path.slice! SEP
       path
     end
@@ -162,9 +158,8 @@ module Prefab
   # StubConfigClient to be used while config client initializes
   # since it may log
   class BootstrappingConfigClient
-    def get(key, default = nil)
-      ENV["PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL"] ? ENV["PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL"].upcase.to_sym : default
+    def get(_key, default = nil)
+      ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'] ? ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'].upcase.to_sym : default
     end
   end
 end
-

data/lib/prefab/murmer3.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class Murmur3
   ## MurmurHash3 was written by Austin Appleby, and is placed in the public
   ## domain. The author hereby disclaims copyright to this source code.
@@ -9,7 +10,6 @@ class Murmur3
     ((x << r) | (x >> (32 - r))) & MASK32
   end
 
-
   def self.murmur3_32_fmix(h)
     h &= MASK32
     h ^= h >> 16
@@ -25,7 +25,7 @@ class Murmur3
     (k1 * 0x1b873593) & MASK32
   end
 
-  def self.murmur3_32(str, seed=0)
+  def self.murmur3_32(str, seed = 0)
     h1 = seed
     numbers = str.unpack('V*C*')
     tailn = str.length % 4
@@ -33,7 +33,7 @@ class Murmur3
     for k1 in numbers
       h1 ^= murmur3_32__mmix(k1)
       h1 = murmur3_32_rotl(h1, 13)
-      h1 = (h1*5 + 0xe6546b64) & MASK32
+      h1 = (h1 * 5 + 0xe6546b64) & MASK32
     end
 
     unless tail.empty?
@@ -47,5 +47,4 @@ class Murmur3
     h1 ^= str.length
     murmur3_32_fmix(h1)
   end
-
 end

data/lib/prefab/noop_cache.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
+
 module Prefab
   class NoopCache
-    def fetch(name, opts, &method)
+    def fetch(_name, _opts)
       yield
     end
 
-    def write(name, value, opts=nil)
-    end
+    def write(name, value, opts = nil); end
 
-    def read(name)
-    end
+    def read(name); end
 
-    def delete(name)
-    end
+    def delete(name); end
   end
 end

data/lib/prefab/noop_stats.rb

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
-module Prefab
 
+module Prefab
   class NoopStats
     # receives increment("prefab.ratelimit.limitcheck", {:tags=>["policy_group:page_view", "pass:true"]})
-    def increment(name, opts={})
-    end
+    def increment(name, opts = {}); end
   end
 end

data/lib/prefab/options.rb

@@ -19,17 +19,19 @@ module Prefab
     attr_reader :prefab_envs
 
     DEFAULT_LOG_FORMATTER = proc { |severity, datetime, progname, msg|
-      "#{severity.ljust(5)} #{datetime}:#{" " if progname}#{progname} #{msg}\n"
+      "#{severity.ljust(5)} #{datetime}:#{' ' if progname}#{progname} #{msg}\n"
     }
 
     module ON_INITIALIZATION_FAILURE
       RAISE = 1
       RETURN = 2
     end
+
     module ON_NO_DEFAULT
       RAISE = 1
       RETURN_NIL = 2
     end
+
     module DATASOURCES
       ALL = 1
       LOCAL_ONLY = 2
@@ -40,20 +42,20 @@ module Prefab
       logdev: $stdout,
       stats: NoopStats.new, # receives increment("prefab.limitcheck", {:tags=>["policy_group:page_view", "pass:true"]})
       shared_cache: NoopCache.new, # Something that quacks like Rails.cache ideally memcached
-      namespace: "",
+      namespace: '',
       log_formatter: DEFAULT_LOG_FORMATTER,
       log_prefix: nil,
-      prefab_api_url: ENV["PREFAB_API_URL"] || 'https://api.prefab.cloud',
-      prefab_grpc_url: ENV["PREFAB_GRPC_URL"] || 'grpc.prefab.cloud:443',
+      prefab_api_url: ENV['PREFAB_API_URL'] || 'https://api.prefab.cloud',
+      prefab_grpc_url: ENV['PREFAB_GRPC_URL'] || 'grpc.prefab.cloud:443',
       on_no_default: ON_NO_DEFAULT::RAISE, # options :raise, :warn_and_return_nil,
       initialization_timeout_sec: 10, # how long to wait before on_init_failure
-      on_init_failure: ON_INITIALIZATION_FAILURE::RAISE, #options :unlock_and_continue, :lock_and_keep_trying, :raise
+      on_init_failure: ON_INITIALIZATION_FAILURE::RAISE, # options :unlock_and_continue, :lock_and_keep_trying, :raise
       # new_config_callback: nil, #callback method
       # live_override_url: nil,
-      prefab_datasources: ENV['PREFAB_DATASOURCES'] == "LOCAL_ONLY" ? DATASOURCES::LOCAL_ONLY : DATASOURCES::ALL,
+      prefab_datasources: ENV['PREFAB_DATASOURCES'] == 'LOCAL_ONLY' ? DATASOURCES::LOCAL_ONLY : DATASOURCES::ALL,
       prefab_config_override_dir: Dir.home,
-      prefab_config_classpath_dir: ".",
-      prefab_envs:  ENV['PREFAB_ENVS'].nil? ? [] : ENV['PREFAB_ENVS'].split(",")
+      prefab_config_classpath_dir: '.',
+      prefab_envs: ENV['PREFAB_ENVS'].nil? ? [] : ENV['PREFAB_ENVS'].split(',')
     )
       # debugger
       @api_key = api_key
@@ -80,7 +82,7 @@ module Prefab
 
     # https://api.prefab.cloud -> https://api-prefab-cloud.global.ssl.fastly.net
     def url_for_api_cdn
-      ENV['PREFAB_CDN_URL'] || "#{@prefab_api_url.gsub(/\./, "-")}.global.ssl.fastly.net"
+      ENV['PREFAB_CDN_URL'] || "#{@prefab_api_url.gsub(/\./, '-')}.global.ssl.fastly.net"
     end
   end
 end

data/lib/prefab/ratelimit_client.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Prefab
   class RateLimitClient
-
     def initialize(base_client, timeout)
       @timeout = timeout
       @base_client = base_client
@@ -9,14 +9,14 @@ module Prefab
 
     def pass?(group)
       result = acquire([group], 1)
-      return result.passed
+      result.passed
     end
 
     def acquire(groups, acquire_amount, allow_partial_response: false, on_error: :log_and_pass)
-      expiry_cache_key = "prefab.ratelimit.expiry:#{groups.join(".")}"
+      expiry_cache_key = "prefab.ratelimit.expiry:#{groups.join('.')}"
       expiry = @base_client.shared_cache.read(expiry_cache_key)
       if !expiry.nil? && Integer(expiry) > Time.now.utc.to_f * 1000
-        @base_client.stats.increment("prefab.ratelimit.limitcheck.expirycache.hit", tags: [])
+        @base_client.stats.increment('prefab.ratelimit.limitcheck.expirycache.hit', tags: [])
         return Prefab::LimitResponse.new(passed: false, amount: 0)
       end
 
@@ -27,16 +27,17 @@ module Prefab
         allow_partial_response: allow_partial_response
       )
 
-      result = @base_client.request Prefab::RateLimitService, :limit_check, req_options: {timeout: @timeout}, params: req
+      result = @base_client.request Prefab::RateLimitService, :limit_check, req_options: { timeout: @timeout },
+                                                                            params: req
 
       reset = result.limit_reset_at
       @base_client.shared_cache.write(expiry_cache_key, reset) unless reset < 1 # protobuf default int to 0
 
-      @base_client.stats.increment("prefab.ratelimit.limitcheck", tags: ["policy_group:#{result.policy_group}", "pass:#{result.passed}"])
+      @base_client.stats.increment('prefab.ratelimit.limitcheck',
+                                   tags: ["policy_group:#{result.policy_group}", "pass:#{result.passed}"])
 
       result
-
-    rescue => e
+    rescue StandardError => e
       handle_error(e, on_error, groups)
     end
 
@@ -48,9 +49,7 @@ module Prefab
         limit: limit,
         burst: burst
       )
-      unless safety_level.nil?
-        limit_definition.safety_level = safety_level
-      end
+      limit_definition.safety_level = safety_level unless safety_level.nil?
       config_value = Prefab::ConfigValue.new(limit_definition: limit_definition)
       config_delta = Prefab::ConfigClient.value_to_delta(key, config_value)
       upsert_req = Prefab::UpsertRequest.new(config_delta: config_delta)
@@ -61,7 +60,7 @@ module Prefab
     private
 
     def handle_error(e, on_error, groups)
-      @base_client.stats.increment("prefab.ratelimit.error", tags: ["type:limit"])
+      @base_client.stats.increment('prefab.ratelimit.error', tags: ['type:limit'])
 
       message = "ratelimit for #{groups} error: #{e.message}"
       case on_error
@@ -77,4 +76,3 @@ module Prefab
     end
   end
 end
-

data/lib/prefab/sse_logger.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
+
 module Prefab
   class SseLogger < InternalLogger
     def initialize(logger)
-      super("sse", logger)
+      super('sse', logger)
     end
 
     # The SSE::Client warns on a perfectly normal stream disconnect, recast to info
-    def warn(progname = nil, &block)
+    def warn(progname = nil)
       @logger.log_internal yield, @path, progname, INFO
     end
   end

data/lib/prefab/weighted_value_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Prefab
+  class WeightedValueResolver
+    MAX_32_FLOAT = 4_294_967_294.0
+
+    def initialize(weights, config_key, lookup_key)
+      @weights = weights
+      @config_key = config_key
+      @lookup_key = lookup_key
+    end
+
+    def resolve
+      percent = @lookup_key ? user_percent : rand
+
+      index = variant_index(percent)
+
+      @weights[index]
+    end
+
+    def user_percent
+      to_hash = "#{@config_key}#{@lookup_key}"
+      int_value = Murmur3.murmur3_32(to_hash)
+      int_value / MAX_32_FLOAT
+    end
+
+    def variant_index(percent_through_distribution)
+      distribution_space = @weights.inject(0) { |sum, v| sum + v.weight }
+      bucket = distribution_space * percent_through_distribution
+
+      sum = 0
+      @weights.each_with_index do |variant_weight, index|
+        return index if bucket < sum + variant_weight.weight
+
+        sum += variant_weight.weight
+      end
+
+      # In the event that all weights are zero, return the last variant
+      @weights.size - 1
+    end
+  end
+end

data/lib/prefab/yaml_config_parser.rb

@@ -0,0 +1,32 @@
+require 'yaml'
+
+module Prefab
+  class YAMLConfigParser
+    def initialize(file, client)
+      @file = file
+      @client = client
+    end
+
+    def merge(config)
+      yaml = load
+
+      yaml.each do |k, v|
+        config = Prefab::LocalConfigParser.parse(k, v, config, @file)
+      end
+
+      config
+    end
+
+    private
+
+    def load
+      if File.exist?(@file)
+        @client.log_internal Logger::INFO, "Load #{@file}"
+        YAML.load_file(@file)
+      else
+        @client.log_internal Logger::INFO, "No file #{@file}"
+        {}
+      end
+    end
+  end
+end

data/lib/prefab-cloud-ruby.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require "concurrent/atomics"
+
+require 'concurrent/atomics'
 require 'concurrent'
 require 'faraday'
 require 'openssl'
@@ -14,8 +15,12 @@ require 'prefab_services_pb'
 require 'prefab/options'
 require 'prefab/internal_logger'
 require 'prefab/sse_logger'
-require 'prefab/config_helper'
+require 'prefab/weighted_value_resolver'
+require 'prefab/config_value_unwrapper'
+require 'prefab/criteria_evaluator'
 require 'prefab/config_loader'
+require 'prefab/local_config_parser'
+require 'prefab/yaml_config_parser'
 require 'prefab/config_resolver'
 require 'prefab/client'
 require 'prefab/ratelimit_client'