prefab-cloud-ruby 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: fa80ee91d95324b503253f95a12deb9b0db91291
-  data.tar.gz: 0315d992eb2a87073998e1d7db4864a8c3da289c
+SHA256:
+  metadata.gz: a36d24a94355b3b7a2b3b889734e1f6f6ccafc7dcebfb11ff11d77ba92ea7828
+  data.tar.gz: 326b3166d4fc2589ebb2550114b2cc198617620daa70ecfb6b9fe394c9dd79a5
 SHA512:
-  metadata.gz: e43a7a8dafbfd3a9e6c12cd93b57bed2ee8fd738406fdba166c5eddad03154de66d9150285961f8c08da58d0754fde385b8b68e0bb22f9a27de8441f231a429a
-  data.tar.gz: c3586f0e6b689e0ee5b1fd86e621d79ffab5a2263cf977c004fd7a4618cea403059f075f719a86d5a0b4533a16e398e3acb35dff9ca0930082fb81266ef1e545
+  metadata.gz: fb73839190f23e05540688572b8f47c1300ae9181bdecef0f24fdecb9a9e73ace1c88937e7c228601c20ff68405876c21b977e45bd691ba33f59d71dd4811718
+  data.tar.gz: 792f04aa032c2f9975444a191ddbb8f727e256d12ec2fc4b3c26819bff4a425deabffb3ff262221e7fe90ed4c1d1422d7a2cb447530264cde494b4e149de7e78

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.0.3

data/CODEOWNERS

@@ -0,0 +1 @@
+*    @prefab-cloud/prefabdevs @prefab-cloud/prefabmaintainers @prefab-cloud/prefabadmins

data/Gemfile

@@ -2,13 +2,16 @@ source "https://rubygems.org"
 
 gem 'concurrent-ruby', '~> 1.0', '>= 1.0.5'
 gem 'faraday'
-gem 'grpc'
+gem 'grpc', :platforms => :ruby
+gem 'google-protobuf', :platforms => :ruby
+gem 'googleapis-common-protos-types', :platforms => :ruby
 
 group :development do
-  gem 'grpc-tools', '~> 1.17.1'
+  gem 'grpc-tools', :platforms => :ruby
   gem "shoulda", ">= 0"
   gem "rdoc", "~> 3.12"
-  gem "bundler", "~> 1.0"
+  gem "bundler"
   gem "juwelier", "~> 2.4.9"
   gem "simplecov", ">= 0"
+  gem 'thin'
 end

data/Gemfile.lock

@@ -10,9 +10,11 @@ GEM
       public_suffix (>= 2.0.2, < 5.0)
     builder (3.2.4)
     concurrent-ruby (1.1.8)
+    daemons (1.4.1)
     descendants_tracker (0.0.4)
       thread_safe (~> 0.3, >= 0.3.1)
     docile (1.3.5)
+    eventmachine (1.2.7)
     faraday (1.3.0)
       faraday-net_http (~> 1.0)
       multipart-post (>= 1.2, < 3)
@@ -26,13 +28,13 @@ GEM
       faraday (>= 0.8, < 2)
       hashie (~> 3.5, >= 3.5.2)
       oauth2 (~> 1.0)
-    google-protobuf (3.15.6)
-    googleapis-common-protos-types (1.0.6)
-      google-protobuf (~> 3.14)
-    grpc (1.36.0)
+    google-protobuf (3.19.3)
+    googleapis-common-protos-types (1.3.0)
       google-protobuf (~> 3.14)
+    grpc (1.43.1)
+      google-protobuf (~> 3.18)
       googleapis-common-protos-types (~> 1.0)
-    grpc-tools (1.17.1)
+    grpc-tools (1.43.1)
     hashie (3.6.0)
     highline (2.0.3)
     i18n (1.8.9)
@@ -53,13 +55,14 @@ GEM
     jwt (2.2.2)
     kamelcase (0.0.2)
       semver2 (~> 3)
-    mini_portile2 (2.4.0)
+    mini_portile2 (2.7.1)
     minitest (5.14.4)
     multi_json (1.15.0)
     multi_xml (0.6.0)
     multipart-post (2.1.1)
-    nokogiri (1.10.10)
-      mini_portile2 (~> 2.4.0)
+    nokogiri (1.13.1)
+      mini_portile2 (~> 2.7.0)
+      racc (~> 1.4)
     oauth2 (1.4.7)
       faraday (>= 0.8, < 2.0)
       jwt (>= 1.0, < 3.0)
@@ -68,6 +71,7 @@ GEM
       rack (>= 1.2, < 3)
     psych (3.3.1)
     public_suffix (4.0.6)
+    racc (1.6.0)
     rack (2.2.3)
     rake (13.0.3)
     rchardet (1.8.0)
@@ -85,6 +89,10 @@ GEM
       docile (~> 1.1)
       simplecov-html (~> 0.11)
     simplecov-html (0.12.3)
+    thin (1.8.1)
+      daemons (~> 1.0, >= 1.0.9)
+      eventmachine (~> 1.0, >= 1.0.4)
+      rack (>= 1, < 3)
     thread_safe (0.3.6)
     tzinfo (1.2.9)
       thread_safe (~> 0.1)
@@ -93,15 +101,18 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.0)
+  bundler
   concurrent-ruby (~> 1.0, >= 1.0.5)
   faraday
+  google-protobuf
+  googleapis-common-protos-types
   grpc
-  grpc-tools (~> 1.17.1)
+  grpc-tools
   juwelier (~> 2.4.9)
   rdoc (~> 3.12)
   shoulda
   simplecov
+  thin
 
 BUNDLED WITH
-   1.16.0
+   2.3.5

data/README.md

@@ -55,5 +55,5 @@ end
 
 ## Copyright
 
-Copyright (c) 2018 Jeff Dwyer. See LICENSE.txt for
+Copyright (c) 2022 Jeff Dwyer. See LICENSE.txt for
 further details.

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.7.0

data/compile_protos.sh

@@ -1,2 +1,5 @@
 #!/usr/bin/env bash
 grpc_tools_ruby_protoc -I ../prefab-cloud/ --ruby_out=lib --grpc_out=lib prefab.proto
+# on M1 you need to
+# 1. run in rosetta
+# 2. mv gems/2.6.0/gems/grpc-tools-1.43.1/bin/x86_64-macos x86-macos

data/lib/prefab/client.rb

@@ -8,7 +8,7 @@ module Prefab
     }
 
 
-    attr_reader :account_id, :shared_cache, :stats, :namespace, :interceptor, :api_key
+    attr_reader :project_id, :shared_cache, :stats, :namespace, :interceptor, :api_key, :environment
 
     def initialize(api_key: ENV['PREFAB_API_KEY'],
                    logdev: nil,
@@ -19,13 +19,15 @@ module Prefab
                    log_formatter: DEFAULT_LOG_FORMATTER
     )
       raise "No API key. Set PREFAB_API_KEY env var" if api_key.nil? || api_key.empty?
+      raise "PREFAB_API_KEY format invalid. Expecting 123-development-yourapikey" unless api_key.count("-") == 2
       @logdev = (logdev || $stdout)
       @log_formatter = log_formatter
       @local = local
       @stats = (stats || NoopStats.new)
       @shared_cache = (shared_cache || NoopCache.new)
       @api_key = api_key
-      @account_id = api_key.split("|")[0].to_i
+      @project_id = api_key.split("-")[0].to_i
+      @environment = api_key.split("-")[1]
       @namespace = namespace
       @interceptor = Prefab::AuthInterceptor.new(api_key)
       @stubs = {}
@@ -37,7 +39,8 @@ module Prefab
 
     def channel
       credentials = ENV["PREFAB_CLOUD_HTTP"] == "true" ? :this_channel_is_insecure : creds
-      url = ENV["PREFAB_API_URL"] || 'api.prefab.cloud:443'
+      url = ENV["PREFAB_API_URL"] || 'grpc.prefab.cloud:443'
+      log_internal Logger::DEBUG, "GRPC Channel #{url} #{credentials}"
       @_channel ||= GRPC::Core::Channel.new(url, nil, credentials)
     end
 
@@ -88,7 +91,7 @@ module Prefab
     end
 
     def cache_key(post_fix)
-      "prefab:#{account_id}:#{post_fix}"
+      "prefab:#{project_id}:#{post_fix}"
     end
 
     def reset!

data/lib/prefab/config_client.rb

@@ -6,6 +6,7 @@ module Prefab
 
     def initialize(base_client, timeout)
       @base_client = base_client
+      @base_client.log_internal Logger::DEBUG, "Initialize ConfigClient"
       @timeout = timeout
       @initialization_lock = Concurrent::ReadWriteLock.new
 
@@ -14,11 +15,14 @@ module Prefab
       @config_loader = Prefab::ConfigLoader.new(@base_client)
       @config_resolver = Prefab::ConfigResolver.new(@base_client, @config_loader)
 
+      @base_client.log_internal Logger::DEBUG, "Initialize ConfigClient: AcquireWriteLock"
       @initialization_lock.acquire_write_lock
+      @base_client.log_internal Logger::DEBUG, "Initialize ConfigClient: AcquiredWriteLock"
 
       @cancellable_interceptor = Prefab::CancellableInterceptor.new(@base_client)
 
       @s3_cloud_front = ENV["PREFAB_S3CF_BUCKET"] || DEFAULT_S3CF_BUCKET
+
       load_checkpoint
       start_checkpointing_thread
     end
@@ -28,9 +32,9 @@ module Prefab
       start_api_connection_thread(@config_loader.highwater_mark)
     end
 
-    def get(prop)
+    def get(key)
       @initialization_lock.with_read_lock do
-        @config_resolver.get(prop)
+        @config_resolver.get(key)
       end
     end
 
@@ -86,9 +90,12 @@ module Prefab
     end
 
     def load_checkpoint_from_config
-      config_req = Prefab::ConfigServicePointer.new(account_id: @base_client.account_id,
+      @base_client.log_internal Logger::DEBUG, "Load Checkpoint From Config"
+
+      config_req = Prefab::ConfigServicePointer.new(project_id: @base_client.project_id,
                                                     start_at_id: @config_loader.highwater_mark)
       resp = stub.get_all_config(config_req)
+      @base_client.log_internal Logger::DEBUG, "Got Response #{resp}"
       load_deltas(resp, :api)
       resp.deltas.each do |delta|
         @config_loader.set(delta)
@@ -112,7 +119,6 @@ module Prefab
       end
     end
 
-
     def load_deltas(deltas, source)
       deltas.deltas.each do |delta|
         @config_loader.set(delta)
@@ -153,7 +159,7 @@ module Prefab
     # Setup a streaming connection to the API
     # Save new config values into the loader
     def start_api_connection_thread(start_at_id)
-      config_req = Prefab::ConfigServicePointer.new(account_id: @base_client.account_id,
+      config_req = Prefab::ConfigServicePointer.new(project_id: @base_client.project_id,
                                                     start_at_id: start_at_id)
       @base_client.log_internal Logger::DEBUG, "start api connection thread #{start_at_id}"
       @base_client.stats.increment("prefab.config.api.start")

data/lib/prefab/config_helper.rb

@@ -0,0 +1,20 @@
+module Prefab
+  module ConfigHelper
+    def value_of(config_value)
+      case config_value.type
+      when :string
+        config_value.string
+      when :int
+        config_value.int
+      when :double
+        config_value.double
+      when :bool
+        config_value.bool
+      when :feature_flag
+        config_value.feature_flag
+      when :segment
+        config_value.segment
+      end
+    end
+  end
+end

data/lib/prefab/config_loader.rb

@@ -14,7 +14,7 @@ module Prefab
     def calc_config
       rtn = @classpath_config.clone
       @api_config.each_key do |k|
-        rtn[k] = @api_config[k].value
+        rtn[k] = @api_config[k]
       end
       rtn = rtn.merge(@local_overrides)
       rtn
@@ -26,7 +26,7 @@ module Prefab
         return
       end
 
-      if delta.value.nil?
+      if delta.default.nil?
         @api_config.delete(delta.key)
       else
         @api_config[delta.key] = delta
@@ -63,7 +63,7 @@ module Prefab
       Dir.glob(glob).each do |file|
         yaml = load(file)
         yaml.each do |k, v|
-          rtn[k] = Prefab::ConfigValue.new(value_from(v))
+          rtn[k] = Prefab::ConfigDelta.new(key: k, default: Prefab::ConfigValue.new(value_from(v)))
         end
       end
       rtn

data/lib/prefab/config_resolver.rb

@@ -1,11 +1,12 @@
 module Prefab
   class ConfigResolver
+    include Prefab::ConfigHelper
     NAMESPACE_DELIMITER = ".".freeze
-    NAME_KEY_DELIMITER = ":".freeze
 
     def initialize(base_client, config_loader)
       @lock = Concurrent::ReadWriteLock.new
       @local_store = {}
+      @environment = base_client.environment
       @namespace = base_client.namespace
       @config_loader = config_loader
       make_local
@@ -16,7 +17,7 @@ module Prefab
       @lock.with_read_lock do
         @local_store.each do |k, v|
           value = v[:value]
-          str << "|#{k}| in #{v[:namespace]} |#{value_of(value)}|#{value_of(value).class}\n"
+          str << "|#{k}| from #{v[:match]} |#{value_of(value)}|#{value_of(value).class}\n"
         end
       end
       str
@@ -39,21 +40,6 @@ module Prefab
 
     private
 
-    def value_of(config_value)
-      case config_value.type
-      when :string
-        config_value.string
-      when :int
-        config_value.int
-      when :double
-        config_value.double
-      when :bool
-        config_value.bool
-      when :feature_flag
-        config_value.feature_flag
-      end
-    end
-
     # 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
@@ -61,32 +47,50 @@ module Prefab
     #
     def starts_with_ns?(key_namespace, client_namespace)
       zipped = key_namespace.split(NAMESPACE_DELIMITER).zip(client_namespace.split(NAMESPACE_DELIMITER))
-      zipped.map do |k, c|
-        (k.nil? || k.empty?) || c == k
-      end.all?
+      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 |prop, value|
-        property = prop
-        key_namespace = ""
+      @config_loader.calc_config.each do |key, delta|
+        # start with the top level default
+        to_store = { match: "default", value: delta.default }
+        if delta.envs.any?
+          env_values = delta.envs.select { |e| e.environment == @environment }
 
-        split = prop.split(NAME_KEY_DELIMITER)
+          # do we have and env_values that match our env?
+          if env_values.any?
+            env_value = env_values.first
 
-        if split.size > 1
-          property = split[1..-1].join(NAME_KEY_DELIMITER)
-          key_namespace = split[0]
-        end
+            # override the top level default with env default
+            to_store = { match: "env_default", env: env_value.environment, value: env_value.default }
 
-        if starts_with_ns?(key_namespace, @namespace)
-          existing = store[property]
-          if existing.nil?
-            store[property] = { namespace: key_namespace, value: value }
-          elsif existing[:namespace].split(NAMESPACE_DELIMITER).size < key_namespace.split(NAMESPACE_DELIMITER).size
-            store[property] = { namespace: key_namespace, value: value }
+            if env_value.namespace_values.any?
+              # check all namespace_values for match
+              env_value.namespace_values.each do |namespace_value|
+                (starts_with, count) = starts_with_ns?(namespace_value.namespace, @namespace)
+                if starts_with
+                  # is this match the best match?
+                  if count > (to_store[:match_depth_count] || 0)
+                    to_store = { match: namespace_value.namespace, count: count, value: namespace_value.config_value }
+                  end
+                end
+              end
+            end
           end
         end
+
+        # feature flags are a funny case
+        # we only define the variants in the default in order to be DRY
+        # but we want to access them in environments, clone them over
+        if to_store[:value].type == :feature_flag
+          to_store[:value].feature_flag.variants = delta.default.feature_flag.variants
+        end
+
+        store[key] = to_store
       end
       @lock.with_write_lock do
         @local_store = store

data/lib/prefab/feature_flag_client.rb

@@ -1,6 +1,8 @@
 module Prefab
   class FeatureFlagClient
+    include Prefab::ConfigHelper
     MAX_32_FLOAT = 4294967294.0
+    DISTRIBUTION_SPACE = 1000
 
     def initialize(base_client)
       @base_client = base_client
@@ -14,38 +16,124 @@ 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}"])
 
+      return is_on?(get(feature_name, lookup_key, attributes))
+    end
+
+    def get(feature_name, lookup_key, attributes)
       feature_obj = @base_client.config_client.get(feature_name)
-      return is_on?(feature_name, lookup_key, attributes, feature_obj)
+      evaluate(feature_name, lookup_key, attributes, feature_obj)
+    end
+
+    def evaluate(feature_name, lookup_key, attributes, feature_obj)
+      value_of(get_variant(feature_name, lookup_key, attributes, feature_obj))
     end
 
     private
 
-    def is_on?(feature_name, lookup_key, attributes, feature_obj)
-      if feature_obj.nil?
+    def is_on?(variant)
+      if variant.nil?
         return false
       end
+      variant.bool
+    end
+
+    def get_variant(feature_name, lookup_key, attributes, feature_obj)
+      if !feature_obj.active
+        return get_variant_obj(feature_obj, feature_obj.inactive_variant_idx)
+      end
+
+      variant_distribution = feature_obj.default
+
+      # if user_targets.match
+      feature_obj.user_targets.each do |target|
+        if (target.identifiers.include? lookup_key)
+          return get_variant_obj(feature_obj, target.variant_idx)
+        end
+      end
 
-      attributes << lookup_key if lookup_key
-      if (attributes & feature_obj.whitelisted).size > 0
-        return true
+      # if rules.match
+      feature_obj.rules.each do |rule|
+        if criteria_match?(rule, lookup_key, attributes)
+          variant_distribution = rule.distribution
+        end
       end
 
-      if lookup_key
-        return get_user_pct(feature_name, lookup_key) < feature_obj.pct
+      if variant_distribution.type == :variant_idx
+        variant_idx = variant_distribution.variant_idx
+      else
+        percent_through_distribution = rand()
+        if lookup_key
+          percent_through_distribution = get_user_pct(feature_name, lookup_key)
+        end
+        distribution_bucket = DISTRIBUTION_SPACE * percent_through_distribution
+
+        variant_idx = get_variant_idx_from_weights(variant_distribution.variant_weights.weights, distribution_bucket, feature_name)
       end
 
-      return feature_obj.pct > rand()
+      return get_variant_obj(feature_obj, variant_idx)
+    end
+
+    def get_variant_obj(feature_obj, idx)
+      return feature_obj.variants[idx] if feature_obj.variants.length >= idx
+      nil
+    end
+
+    def get_variant_idx_from_weights(variant_weights, bucket, feature_name)
+      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
     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)
+      if rule.criteria.operator == :IN
+        return rule.criteria.values.include?(lookup_key)
+      elsif rule.criteria.operator == :NOT_IN
+        return !rule.criteria.values.include?(lookup_key)
+      elsif rule.criteria.operator == :IN_SEG
+        return segment_matches(rule.criteria.values, lookup_key, attributes).any?
+      elsif rule.criteria.operator == :NOT_IN_SEG
+        return segment_matches(rule.criteria.values, lookup_key, attributes).none?
+      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
+
+    def segment_match?(segment, lookup_key, attributes)
+      includes = segment.includes.include?(lookup_key)
+      excludes = segment.excludes.include?(lookup_key)
+      includes && !excludes
+    end
   end
 end
 

data/lib/prefab-cloud-ruby.rb

@@ -4,6 +4,7 @@ require 'faraday'
 require 'openssl'
 require 'prefab_pb'
 require 'prefab_services_pb'
+require 'prefab/config_helper'
 require 'prefab/config_loader'
 require 'prefab/config_resolver'
 require 'prefab/client'