prefab-cloud-ruby 0.8.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 171f3c104141000ec55b8c331f9f0439d56e991936c69a032f7c78394560ddea
-  data.tar.gz: bb2fa93f2bc589c7e58bda95f7ab9519d780d80de212b62e1a29b1e187ab55a1
+  metadata.gz: 22d564bcc76424b3308623b4d2e27a4acaf4217c285bcca02542291d8cc15827
+  data.tar.gz: c097169d379d9f477a66d20fc378f693173de044baecad08059263fd239257e5
 SHA512:
-  metadata.gz: c883ea3ba1f608c5fd88e0371302dca440968ad34fae8c279b735f180a73986498c9a87b95d2d51571daa2be723944568824bf8444425a8ff463c210bb9c7429
-  data.tar.gz: 278cccca1c2e834e79971394310fdba30c03e806b31708094d90d62ed1623c7c5d2e19cdd204165437a75a8711c979f915f0b1ecd86220991fa22697ddad3a49
+  metadata.gz: cdf6ca3b1b28bf83caa629193b21e2d26e4d22d64ee4cd30b7a88fdce623adc7f3feb3605df7107cdca00e7823709f9eeac2a68176db1d10b6616196d2bcb580
+  data.tar.gz: c61b171a2be217c016fad1cc0a1ce9faed159c6f894065db4202ec200ec1f8ac22caabb880fae0f358fcced0930ce49d4e273f800a0fb72c39c6d6f19cc59d07

data/Gemfile

@@ -2,6 +2,7 @@ source "https://rubygems.org"
 
 gem 'concurrent-ruby', '~> 1.0', '>= 1.0.5'
 gem 'faraday'
+gem 'ld-eventsource'
 gem 'grpc', :platforms => :ruby
 gem 'google-protobuf', :platforms => :ruby
 gem 'googleapis-common-protos-types', :platforms => :ruby

data/Gemfile.lock

@@ -14,12 +14,18 @@ GEM
     descendants_tracker (0.0.4)
       thread_safe (~> 0.3, >= 0.3.1)
     docile (1.3.5)
+    domain_name (0.5.20190701)
+      unf (>= 0.0.5, < 1.0.0)
     eventmachine (1.2.7)
     faraday (1.3.0)
       faraday-net_http (~> 1.0)
       multipart-post (>= 1.2, < 3)
       ruby2_keywords
     faraday-net_http (1.0.1)
+    ffi (1.15.5)
+    ffi-compiler (1.0.1)
+      ffi (>= 1.0.0)
+      rake
     git (1.8.1)
       rchardet (~> 1.8)
     github_api (0.19.0)
@@ -37,6 +43,14 @@ GEM
     grpc-tools (1.43.1)
     hashie (3.6.0)
     highline (2.0.3)
+    http (5.0.1)
+      addressable (~> 2.3)
+      http-cookie (~> 1.0)
+      http-form_data (~> 2.2)
+      llhttp-ffi (~> 0.3.0)
+    http-cookie (1.0.4)
+      domain_name (~> 0.5)
+    http-form_data (2.3.0)
     i18n (1.8.9)
       concurrent-ruby (~> 1.0)
     json (1.8.6)
@@ -55,6 +69,12 @@ GEM
     jwt (2.2.2)
     kamelcase (0.0.2)
       semver2 (~> 3)
+    ld-eventsource (2.2.0)
+      concurrent-ruby (~> 1.0)
+      http (>= 4.4.1, < 6.0.0)
+    llhttp-ffi (0.3.1)
+      ffi-compiler (~> 1.0)
+      rake (~> 13.0)
     mini_portile2 (2.7.1)
     minitest (5.14.4)
     multi_json (1.15.0)
@@ -96,6 +116,9 @@ GEM
     thread_safe (0.3.6)
     tzinfo (1.2.9)
       thread_safe (~> 0.1)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.8)
 
 PLATFORMS
   ruby
@@ -109,6 +132,7 @@ DEPENDENCIES
   grpc
   grpc-tools
   juwelier (~> 2.4.9)
+  ld-eventsource
   rdoc (~> 3.12)
   shoulda
   simplecov

data/README.md

@@ -56,6 +56,9 @@ end
 ## Release
 
 ```shell
+update VERSION
+bundle exec rake gemspec:generate
+git commit & push
 REMOTE_BRANCH=main LOCAL_BRANCH=main bundle exec rake release
 ```
 

data/VERSION

@@ -1 +1 @@
-0.8.0
+0.11.0

data/lib/prefab/client.rb

@@ -8,7 +8,7 @@ module Prefab
     }
 
 
-    attr_reader :project_id, :shared_cache, :stats, :namespace, :interceptor, :api_key, :environment
+    attr_reader :project_id, :shared_cache, :stats, :namespace, :interceptor, :api_key, :prefab_api_url
 
     def initialize(api_key: ENV['PREFAB_API_KEY'],
                    logdev: nil,
@@ -26,22 +26,22 @@ module Prefab
       @stats = (stats || NoopStats.new)
       @shared_cache = (shared_cache || NoopCache.new)
       @api_key = api_key
-      @project_id = api_key.split("-")[0].to_i
-      @environment = api_key.split("-")[1]
+      @project_id = api_key.split("-")[0].to_i # unvalidated, but that's ok. APIs only listen to the actual passwd
       @namespace = namespace
       @interceptor = Prefab::AuthInterceptor.new(api_key)
       @stubs = {}
-
+      @prefab_api_url = ENV["PREFAB_API_URL"] || 'https://api.prefab.cloud'
+      @prefab_grpc_url = ENV["PREFAB_GRPC_URL"] || 'grpc.prefab.cloud:443'
+      log_internal Logger::INFO, "Prefab Connecting to: #{@prefab_api_url} and #{@prefab_grpc_url} Secure: #{http_secure?}"
       at_exit do
         channel.destroy
       end
     end
 
     def channel
-      credentials = ENV["PREFAB_CLOUD_HTTP"] == "true" ? :this_channel_is_insecure : creds
-      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)
+      credentials = http_secure? ? creds : :this_channel_is_insecure
+      log_internal Logger::DEBUG, "GRPC Channel #{@prefab_grpc_url} #{credentials}"
+      @_channel ||= GRPC::Core::Channel.new(@prefab_grpc_url, nil, credentials)
     end
 
     def config_client(timeout: 5.0)
@@ -101,6 +101,10 @@ module Prefab
 
     private
 
+    def http_secure?
+      ENV["PREFAB_CLOUD_HTTP"] != "true"
+    end
+
     def stub_for(service, timeout)
       @stubs["#{service}_#{timeout}"] ||= service::Stub.new(nil,
                                                             nil,

data/lib/prefab/config_client.rb

@@ -29,7 +29,8 @@ module Prefab
 
     def start_streaming
       @streaming = true
-      start_api_connection_thread(@config_loader.highwater_mark)
+      # start_grpc_streaming_connection_thread(@config_loader.highwater_mark)
+      start_sse_streaming_connection_thread(@config_loader.highwater_mark)
     end
 
     def get(key)
@@ -62,8 +63,14 @@ module Prefab
     end
 
     def self.value_to_delta(key, config_value, namespace = nil)
-      Prefab::ConfigDelta.new(key: [namespace, key].compact.join(":"),
-                              value: config_value)
+      Prefab::Config.new(key: [namespace, key].compact.join(":"),
+                         rows: [Prefab::ConfigRow.new(value: config_value)])
+    end
+
+    def get_config_obj(key)
+      @initialization_lock.with_read_lock do
+        @config_resolver.get_config(key)
+      end
     end
 
     private
@@ -92,14 +99,11 @@ module Prefab
     def load_checkpoint_from_config
       @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)
+      config_req = Prefab::ConfigServicePointer.new(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)
-      end
+      load_configs(resp, :api)
       @config_resolver.update
       finish_init!(:api)
       true
@@ -112,16 +116,20 @@ module Prefab
       url = "#{@s3_cloud_front}/#{@base_client.api_key.gsub("|", "/")}"
       resp = Faraday.get url
       if resp.status == 200
-        deltas = Prefab::ConfigDeltas.decode(resp.body)
-        load_deltas(deltas, :s3)
+        configs = Prefab::Configs.decode(resp.body)
+        load_configs(configs, :s3)
       else
         @base_client.log_internal Logger::INFO, "No S3 checkpoint. Response #{resp.status} Plan may not support this."
       end
     end
 
-    def load_deltas(deltas, source)
-      deltas.deltas.each do |delta|
-        @config_loader.set(delta)
+    def load_configs(configs, source)
+      project_env_id = configs.config_service_pointer.project_env_id
+      @config_resolver.project_env_id = project_env_id
+
+      @base_client.log_internal Logger::INFO, "Prefab Initializing in project: #{@base_client.project_id} environment: #{project_env_id} and namespace: '#{@namespace}'"
+      configs.configs.each do |config|
+        @config_loader.set(config)
       end
       @base_client.log_internal Logger::INFO, "Found checkpoint with highwater id #{@config_loader.highwater_mark} from #{source}"
       @base_client.stats.increment("prefab.config.checkpoint.load")
@@ -156,11 +164,35 @@ module Prefab
       end
     end
 
+
+    def start_sse_streaming_connection_thread(start_at_id)
+      auth = "#{@base_client.project_id}:#{@base_client.api_key}"
+
+      auth_string = Base64.strict_encode64(auth)
+      headers = {
+        "x-prefab-start-at-id": start_at_id,
+        "Authorization": "Basic #{auth_string}",
+      }
+      url = "#{@base_client.prefab_api_url}/api/v1/sse/config"
+      @base_client.log_internal Logger::INFO, "SSE Streaming Connect to #{url}"
+      SSE::Client.new(url, headers: headers) do |client|
+        client.on_event do |event|
+          configs = Prefab::Configs.decode(Base64.decode64(event.data))
+          @base_client.log_internal Logger::INFO, "SSE received configs."
+          @base_client.log_internal Logger::DEBUG, "SSE received configs: #{configs}"
+          configs.configs.each do |config|
+            @config_loader.set(config)
+          end
+          @config_resolver.update
+          finish_init!(:streaming)
+        end
+      end
+    end
+
     # 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(project_id: @base_client.project_id,
-                                                    start_at_id: start_at_id)
+    def start_grpc_streaming_connection_thread(start_at_id)
+      config_req = Prefab::ConfigServicePointer.new(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")
 
@@ -174,8 +206,8 @@ module Prefab
           begin
             resp = stub.get_config(config_req)
             resp.each do |r|
-              r.deltas.each do |delta|
-                @config_loader.set(delta)
+              r.configs.each do |config|
+                @config_loader.set(config)
               end
               @config_resolver.update
               finish_init!(:streaming)

data/lib/prefab/config_loader.rb

@@ -20,18 +20,18 @@ module Prefab
       rtn
     end
 
-    def set(delta)
+    def set(config)
       # don't overwrite newer values
-      if @api_config[delta.key] && @api_config[delta.key].id > delta.id
+      if @api_config[config.key] && @api_config[config.key].id > config.id
         return
       end
 
-      if delta.default.nil?
-        @api_config.delete(delta.key)
+      if config.rows.empty?
+        @api_config.delete(config.key)
       else
-        @api_config[delta.key] = delta
+        @api_config[config.key] = config
       end
-      @highwater_mark = [delta.id, @highwater_mark].max
+      @highwater_mark = [config.id, @highwater_mark].max
     end
 
     def rm(key)
@@ -39,11 +39,11 @@ module Prefab
     end
 
     def get_api_deltas
-      deltas = Prefab::ConfigDeltas.new
+      configs = Prefab::Configs.new
       @api_config.each_value do |config_value|
-        deltas.deltas << config_value
+        configs.configs << config_value
       end
-      deltas
+      configs
     end
 
     private
@@ -63,7 +63,9 @@ module Prefab
       Dir.glob(glob).each do |file|
         yaml = load(file)
         yaml.each do |k, v|
-          rtn[k] = Prefab::ConfigDelta.new(key: k, default: Prefab::ConfigValue.new(value_from(v)))
+          rtn[k] = Prefab::Config.new(key: k, rows: [
+            Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(value_from(v)))
+          ])
         end
       end
       rtn

data/lib/prefab/config_resolver.rb

@@ -3,12 +3,14 @@ module Prefab
     include Prefab::ConfigHelper
     NAMESPACE_DELIMITER = ".".freeze
 
+    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 = {}
-      @environment = base_client.environment
       @namespace = base_client.namespace
       @config_loader = config_loader
+      @project_env_id = 0
       make_local
     end
 
@@ -16,20 +18,27 @@ module Prefab
       str = ""
       @lock.with_read_lock do
         @local_store.each do |k, v|
-          value = v[:value]
-          str << "|#{k}| from #{v[:match]} |#{value_of(value)}|#{value_of(value).class}\n"
+          if v.nil?
+            str<< "|#{k}| tombstone\n"
+          else
+            value = v[:value]
+            str << "|#{k}| from #{v[:match]} |#{value_of(value)}|#{value_of(value).class}\n"
+          end
         end
       end
       str
     end
 
     def get(property)
-      config = @lock.with_read_lock do
-        @local_store[property]
-      end
+      config = _get(property)
       config ? value_of(config[:value]) : nil
     end
 
+    def get_config(property)
+      config = _get(property)
+      config ? config[:config] : nil
+    end
+
     def update
       make_local
     end
@@ -55,46 +64,35 @@ module Prefab
 
     def make_local
       store = {}
-      @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 }
-
-          # do we have and env_values that match our env?
-          if env_values.any?
-            env_value = env_values.first
-
-            # override the top level default with env default
-            to_store = { match: "env_default", env: env_value.environment, value: env_value.default }
-
-            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
+      @config_loader.calc_config.each do |key, 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: row.namespace, value: row.value, config: config} if starts_with
+              else
+                { sortable: 1, match: row.project_env_id, value: row.value, config: config}
               end
             end
+          else
+            { sortable: 0, match: "default", value: row.value, config: config}
           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
-
+        end.compact
+        to_store = sortable.sort_by { |h| h[:sortable] }.last
         store[key] = to_store
       end
+
       @lock.with_write_lock do
         @local_store = store
       end
     end
+
+    def _get(property)
+      @lock.with_read_lock do
+        @local_store[property]
+      end
+    end
   end
 end

data/lib/prefab/feature_flag_client.rb

@@ -2,7 +2,6 @@ module Prefab
   class FeatureFlagClient
     include Prefab::ConfigHelper
     MAX_32_FLOAT = 4294967294.0
-    DISTRIBUTION_SPACE = 1000
 
     def initialize(base_client)
       @base_client = base_client
@@ -22,13 +21,16 @@ module Prefab
       return is_on?(get(feature_name, lookup_key, attributes))
     end
 
-    def get(feature_name, lookup_key, attributes)
+    def get(feature_name, lookup_key=nil, attributes={})
       feature_obj = @base_client.config_client.get(feature_name)
-      evaluate(feature_name, lookup_key, attributes, feature_obj)
+      config_obj = @base_client.config_client.get_config_obj(feature_name)
+      return nil if feature_obj.nil? || config_obj.nil?
+      variants = config_obj.variants
+      evaluate(feature_name, lookup_key, attributes, feature_obj, variants)
     end
 
-    def evaluate(feature_name, lookup_key, attributes, feature_obj)
-      value_of(get_variant(feature_name, lookup_key, attributes, feature_obj))
+    def evaluate(feature_name, lookup_key, attributes, feature_obj, variants)
+      value_of(get_variant(feature_name, lookup_key, attributes, feature_obj, variants))
     end
 
     private
@@ -38,50 +40,54 @@ module Prefab
         return false
       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)
+    def get_variant(feature_name, lookup_key, attributes, feature_obj, variants)
       if !feature_obj.active
-        return get_variant_obj(feature_obj, feature_obj.inactive_variant_idx)
+        return get_variant_obj(variants, 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)
+          return get_variant_obj(variants, target.variant_idx)
         end
       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, lookup_key, attributes)
-          variant_distribution = rule.distribution
+          variant_weights = rule.variant_weights
+          break
         end
       end
 
-      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)
+      percent_through_distribution = rand()
+      if lookup_key
+        percent_through_distribution = get_user_pct(feature_name, lookup_key)
       end
 
-      return get_variant_obj(feature_obj, variant_idx)
+      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(feature_obj, idx)
-      return feature_obj.variants[idx] if feature_obj.variants.length >= idx
+    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, bucket, feature_name)
+    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
@@ -92,7 +98,7 @@ module Prefab
       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
+      return variant_weights.last.variant_idx
     end
 
     def get_user_pct(feature, lookup_key)
@@ -102,14 +108,21 @@ module Prefab
     end
 
     def criteria_match?(rule, lookup_key, attributes)
-      if rule.criteria.operator == :IN
+
+      if rule.criteria.operator == :ALWAYS_TRUE
+        return true
+      elsif rule.criteria.operator == :LOOKUP_KEY_IN
         return rule.criteria.values.include?(lookup_key)
-      elsif rule.criteria.operator == :NOT_IN
+      elsif rule.criteria.operator == :LOOKUP_KEY_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?
+      elsif rule.criteria.operator == :PROP_IS_ONE_OF
+        return rule.criteria.values.include?(attributes[rule.criteria.property]) || rule.criteria.values.include?(attributes[rule.criteria.property.to_sym])
+      elsif rule.criteria.operator == :PROP_IS_NOT_ONE_OF
+        return !(rule.criteria.values.include?(attributes[rule.criteria.property]) || rule.criteria.values.include?(attributes[rule.criteria.property.to_sym]))
       end
       @base_client.log.info("Unknown Operator")
       false

data/lib/prefab-cloud-ruby.rb

@@ -2,6 +2,8 @@ require "concurrent/atomics"
 require 'concurrent'
 require 'faraday'
 require 'openssl'
+require 'openssl'
+require 'ld-eventsource'
 require 'prefab_pb'
 require 'prefab_services_pb'
 require 'prefab/config_helper'