prefab-cloud-ruby 0.13.1 → 0.13.2

data/lib/prefab/errors/invalid_api_key_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Prefab
+  module Errors
+    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"
+
+          super(message)
+        else
+          message = "Your API key format is invalid. Expecting something like 123-development-yourapikey-SDK. You provided `#{key}`"
+
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/prefab/errors/missing_default_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Prefab
+  module Errors
+    class MissingDefaultError < Prefab::Error
+      def initialize(key)
+        message = "No value found for key '#{key}' and no default was provided.\n\nIf you'd prefer returning `nil` rather than raising when this occurs, modify the `on_no_default` value you provide in your Prefab::Options."
+
+        super(message)
+      end
+    end
+  end
+end

data/lib/prefab/feature_flag_client.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
 module Prefab
   class FeatureFlagClient
+    include Prefab::ConfigHelper
     MAX_32_FLOAT = 4294967294.0
 
     def initialize(base_client)
@@ -14,38 +16,154 @@ module Prefab
       feature_is_on_for?(feature_name, nil)
     end
 
-    def feature_is_on_for?(feature_name, lookup_key, attributes: [])
+    def feature_is_on_for?(feature_name, lookup_key, attributes: {})
       @base_client.stats.increment("prefab.featureflag.on", tags: ["feature:#{feature_name}"])
 
-      feature_obj = @base_client.config_client.get(feature_name)
-      return is_on?(feature_name, lookup_key, attributes, feature_obj)
+      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)
+
+      value_of_variant_or_nil(variant, default)
     end
 
     private
 
-    def is_on?(feature_name, lookup_key, attributes, feature_obj)
-      if feature_obj.nil?
+    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
+    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
+
+      variants = config_obj.variants
+      get_variant(feature_name, lookup_key, attributes, feature_obj, variants)
+    end
+
+    def is_on?(variant)
+      if variant.nil?
         return false
       end
 
-      attributes << lookup_key if lookup_key
-      if (attributes & feature_obj.whitelisted).size > 0
-        return true
+      if variant == !!variant
+        return variant
+      end
+
+      variant.bool
+    rescue
+      @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
-        return get_user_pct(feature_name, lookup_key) < feature_obj.pct
+        percent_through_distribution = get_user_pct(feature_name, lookup_key)
       end
 
-      return feature_obj.pct > rand()
+      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 = "#{@base_client.account_id}#{feature}#{lookup_key}"
+      to_hash = "#{@base_client.project_id}#{feature}#{lookup_key}"
       int_value = Murmur3.murmur3_32(to_hash)
       int_value / MAX_32_FLOAT
     end
 
+    # def criteria_match?(rule, lookup_key, attributes)
+    #
+    # end
+    def criteria_match?(criteria, lookup_key, attributes)
+      if criteria.operator == :ALWAYS_TRUE
+        return true
+      elsif criteria.operator == :LOOKUP_KEY_IN
+        return criteria.values.include?(lookup_key)
+      elsif criteria.operator == :LOOKUP_KEY_NOT_IN
+        return !criteria.values.include?(lookup_key)
+      elsif criteria.operator == :IN_SEG
+        return segment_matches(criteria.values, lookup_key, attributes).any?
+      elsif criteria.operator == :NOT_IN_SEG
+        return segment_matches(criteria.values, lookup_key, attributes).none?
+      elsif criteria.operator == :PROP_IS_ONE_OF
+        return criteria.values.include?(attributes[criteria.property]) || criteria.values.include?(attributes[criteria.property.to_sym])
+      elsif criteria.operator == :PROP_IS_NOT_ONE_OF
+        return !(criteria.values.include?(attributes[criteria.property]) || criteria.values.include?(attributes[criteria.property.to_sym]))
+      end
+      @base_client.log.info("Unknown Operator")
+      false
+    end
+
+    # evaluate each segment key and return whether each one matches
+    # there should be an associated segment available as a standard config obj
+    def segment_matches(segment_keys, lookup_key, attributes)
+      segment_keys.map 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.map do |criteria|
+        criteria_match?(criteria, lookup_key, attributes)
+      end.any?
+    end
   end
 end
 

data/lib/prefab/internal_logger.rb

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

data/lib/prefab/logger_client.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 module Prefab
   class LoggerClient < Logger
 
-    SEP = ".".freeze
-    BASE = "log_level".freeze
+    SEP = "."
+    BASE = "log_level"
+    UNKNOWN = "unknown"
 
     def initialize(logdev, formatter: nil)
       super(logdev)
@@ -107,10 +109,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) || :warn
+      closest_log_level_match = @config_client.get(BASE, :warn)
       path.split(SEP).inject([BASE]) do |memo, n|
         memo << n
-        val = @config_client.get(memo.join(SEP))
+        val = @config_client.get(memo.join(SEP), nil)
         unless val.nil?
           closest_log_level_match = val
         end
@@ -122,12 +124,12 @@ module Prefab
     # sanitize & clean the path of the caller so the key
     # looks like log_level.app.models.user
     def get_path(absolute_path, base_label)
-      path = absolute_path + ""
+      path = (absolute_path || UNKNOWN).dup
       path.slice! Dir.pwd
 
       path.gsub!(/.*?(?=\/lib\/)/im, "")
 
-      path = "#{path.gsub("/", SEP).gsub(".rb", "")}#{SEP}#{base_label}"
+      path = path.gsub("/", SEP).gsub(".rb", "") + SEP + base_label
       path.slice! ".lib"
       path.slice! SEP
       path
@@ -141,8 +143,8 @@ module Prefab
   # StubConfigClient to be used while config client initializes
   # since it may log
   class BootstrappingConfigClient
-    def get(key)
-      ENV["PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL"] || :info
+    def get(key, default=nil)
+      ENV["PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL"] || default
     end
   end
 end

data/lib/prefab/murmer3.rb

@@ -1,3 +1,4 @@
+# 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.

data/lib/prefab/noop_cache.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Prefab
   class NoopCache
     def fetch(name, opts, &method)

data/lib/prefab/noop_stats.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Prefab
 
   class NoopStats

data/lib/prefab/options.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+module Prefab
+  class Options
+    attr_reader :api_key
+    attr_reader :logdev
+    attr_reader :log_formatter
+    attr_reader :stats
+    attr_reader :shared_cache
+    attr_reader :namespace
+    attr_reader :prefab_api_url
+    attr_reader :prefab_grpc_url
+    attr_reader :on_no_default
+    attr_reader :initialization_timeout_sec
+    attr_reader :on_init_failure
+    attr_reader :prefab_config_override_dir
+    attr_reader :prefab_config_classpath_dir
+    attr_reader :defaults_env
+
+    DEFAULT_LOG_FORMATTER = proc { |severity, datetime, progname, msg|
+      "#{severity.ljust(5)} #{datetime}: #{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
+    end
+
+    def initialize(
+      api_key: ENV['PREFAB_API_KEY'],
+      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: "",
+      log_formatter: DEFAULT_LOG_FORMATTER,
+      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
+      # new_config_callback: nil, #callback method
+      # live_override_url: nil,
+      prefab_datasources: ENV['PREFAB_DATASOURCES'] == "LOCAL_ONLY" ? DATASOURCES::LOCAL_ONLY : DATASOURCES::ALL,
+      prefab_config_override_dir: Dir.home,
+      prefab_config_classpath_dir: ".",
+      defaults_env: ""
+    )
+      # debugger
+      @api_key = api_key
+      @logdev = logdev
+      @stats = stats
+      @shared_cache = shared_cache
+      @namespace = namespace
+      @log_formatter = log_formatter
+      @prefab_api_url = prefab_api_url
+      @prefab_grpc_url = prefab_grpc_url
+      @on_no_default = on_no_default
+      @initialization_timeout_sec = initialization_timeout_sec
+      @on_init_failure = on_init_failure
+      @prefab_datasources = prefab_datasources
+      @prefab_config_classpath_dir = prefab_config_classpath_dir
+      @prefab_config_override_dir = prefab_config_override_dir
+      @defaults_env = defaults_env
+    end
+
+    def local_only?
+      @prefab_datasources == DATASOURCES::LOCAL_ONLY
+    end
+
+    # 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"
+    end
+  end
+end

data/lib/prefab/ratelimit_client.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Prefab
   class RateLimitClient
 

data/lib/prefab-cloud-ruby.rb

@@ -1,9 +1,19 @@
+# frozen_string_literal: true
 require "concurrent/atomics"
 require 'concurrent'
 require 'faraday'
 require 'openssl'
+require 'openssl'
+require 'ld-eventsource'
 require 'prefab_pb'
+require 'prefab/error'
+require 'prefab/errors/initialization_timeout_error'
+require 'prefab/errors/invalid_api_key_error'
+require 'prefab/errors/missing_default_error'
 require 'prefab_services_pb'
+require 'prefab/options'
+require 'prefab/internal_logger'
+require 'prefab/config_helper'
 require 'prefab/config_loader'
 require 'prefab/config_resolver'
 require 'prefab/client'