prefab-cloud-ruby 0.20.0 → 0.22.0

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,28 +1,29 @@
 # frozen_string_literal: true
+
 module Prefab
-  class InternalLogger < Logger
+  class InternalLogger < ::Logger
     def initialize(path, logger)
       @path = path
       @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

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/log_path_collector.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Prefab
+  class LogPathCollector
+    INCREMENT = ->(count) { (count || 0) + 1 }
+
+    SEVERITY_KEY = {
+      ::Logger::DEBUG => 'debugs',
+      ::Logger::INFO => 'infos',
+      ::Logger::WARN => 'warns',
+      ::Logger::ERROR => 'errors',
+      ::Logger::FATAL => 'fatals'
+    }.freeze
+
+    def initialize(client:, max_paths:, sync_interval:)
+      @max_paths = max_paths
+      @sync_interval = sync_interval
+      @client = client
+      @start_at = now
+
+      @pool = Concurrent::ThreadPoolExecutor.new(
+        fallback_policy: :discard,
+        max_queue: 5,
+        max_threads: 4,
+        min_threads: 1,
+        name: 'prefab-log-paths'
+      )
+
+      @paths = Concurrent::Map.new
+
+      start_periodic_sync
+    end
+
+    def push(path, severity)
+      return unless @paths.size < @max_paths
+
+      @paths.compute([path, severity], &INCREMENT)
+    end
+
+    private
+
+    def sync
+      return if @paths.size.zero?
+
+      log_internal "Syncing #{@paths.size} paths"
+
+      flush
+    end
+
+    def flush
+      to_ship = @paths.dup
+      @paths.clear
+
+      start_at_was = @start_at
+      @start_at = now
+
+      @pool.post do
+        log_internal "Uploading stats for #{to_ship.size} paths"
+
+        aggregate = Hash.new { |h, k| h[k] = Prefab::Logger.new }
+
+        to_ship.each do |(path, severity), count|
+          aggregate[path][SEVERITY_KEY[severity]] = count
+          aggregate[path]['logger_name'] = path
+        end
+
+        loggers = Prefab::Loggers.new(
+          loggers: aggregate.values,
+          start_at: start_at_was,
+          end_at: now,
+          instance_hash: @client.instance_hash,
+          namespace: @client.namespace
+        )
+
+        @client.request Prefab::LoggerReportingService, :send, req_options: {}, params: loggers
+      end
+    end
+
+    def start_periodic_sync
+      Thread.new do
+        log_internal "Initialized log path collector instance_hash=#{@client.instance_hash} max_paths=#{@max_paths} sync_interval=#{@sync_interval}"
+
+        loop do
+          sleep @sync_interval
+          sync
+        end
+      end
+    end
+
+    def log_internal(message)
+      @client.log.log_internal message, 'log_path_collector', nil, ::Logger::INFO
+    end
+
+    def now
+      (Time.now.utc.to_f * 1000).to_i
+    end
+  end
+end

data/lib/prefab/logger_client.rb

@@ -1,52 +1,57 @@
 # frozen_string_literal: true
-module Prefab
-  class LoggerClient < Logger
 
-    SEP = "."
-    BASE_KEY = "log-level"
-    UNKNOWN_PATH = "unknown."
-    INTERNAL_PREFIX = "cloud.prefab.client"
+require 'prefab/log_path_collector'
+
+module Prefab
+  class LoggerClient < ::Logger
+    SEP = '.'
+    BASE_KEY = 'log-level'
+    UNKNOWN_PATH = 'unknown.'
+    INTERNAL_PREFIX = 'cloud.prefab.client'
 
     LOG_LEVEL_LOOKUPS = {
-      Prefab::LogLevel::NOT_SET_LOG_LEVEL => Logger::DEBUG,
-      Prefab::LogLevel::TRACE => Logger::DEBUG,
-      Prefab::LogLevel::DEBUG => Logger::DEBUG,
-      Prefab::LogLevel::INFO => Logger::INFO,
-      Prefab::LogLevel::WARN => Logger::WARN,
-      Prefab::LogLevel::ERROR => Logger::ERROR,
-      Prefab::LogLevel::FATAL => Logger::FATAL
+      Prefab::LogLevel::NOT_SET_LOG_LEVEL => ::Logger::DEBUG,
+      Prefab::LogLevel::TRACE => ::Logger::DEBUG,
+      Prefab::LogLevel::DEBUG => ::Logger::DEBUG,
+      Prefab::LogLevel::INFO => ::Logger::INFO,
+      Prefab::LogLevel::WARN => ::Logger::WARN,
+      Prefab::LogLevel::ERROR => ::Logger::ERROR,
+      Prefab::LogLevel::FATAL => ::Logger::FATAL
     }
 
-    def initialize(logdev, formatter: nil, prefix: nil)
+    def initialize(logdev, log_path_collector: nil, formatter: nil, prefix: nil)
       super(logdev)
       self.formatter = formatter
       @config_client = BootstrappingConfigClient.new
       @silences = Concurrent::Map.new(initial_capacity: 2)
-      @prefix = prefix
+      @prefix = "#{prefix}#{prefix && '.'}"
+
+      @log_path_collector = log_path_collector
     end
 
     def add(severity, message = nil, progname = nil, loc, &block)
-      path = get_loc_path(loc)
-      path = "#{@prefix}#{@prefix && '.'}#{path}"
+      path_loc = get_loc_path(loc)
+      path = @prefix + path_loc
+
+      @log_path_collector&.push(path_loc, severity)
 
       log(message, path, progname, severity, &block)
     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)
-      severity ||= Logger::UNKNOWN
-      if @logdev.nil? || severity < level_of(path) || @silences[local_log_id]
-        return true
-      end
+    def log(message, path, progname, severity)
+      severity ||= ::Logger::UNKNOWN
+
+      return true if @logdev.nil? || severity < level_of(path) || @silences[local_log_id]
 
       progname = "#{path}: #{progname || @progname}"
 
@@ -60,7 +65,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 +91,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 +134,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 +153,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 +165,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