prefab-cloud-ruby 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 171f3c104141000ec55b8c331f9f0439d56e991936c69a032f7c78394560ddea
-  data.tar.gz: bb2fa93f2bc589c7e58bda95f7ab9519d780d80de212b62e1a29b1e187ab55a1
+  metadata.gz: 80a03ec9a75bc4c5d827c746354ff1353fe135a5ab6e31e9beaaf1ca1c27c931
+  data.tar.gz: d4c9f02e6bbb54d8d4884cc2d94179f39e859aafe3966188b1a00f7b7e5ccc48
 SHA512:
-  metadata.gz: c883ea3ba1f608c5fd88e0371302dca440968ad34fae8c279b735f180a73986498c9a87b95d2d51571daa2be723944568824bf8444425a8ff463c210bb9c7429
-  data.tar.gz: 278cccca1c2e834e79971394310fdba30c03e806b31708094d90d62ed1623c7c5d2e19cdd204165437a75a8711c979f915f0b1ecd86220991fa22697ddad3a49
+  metadata.gz: 67f8b5ed6f61f01943736f9abbb685c9d7f7fd4c029ff3e051356f6e65936595f18899160fd842c415d86c371b0f9d915d795c6b9adafbdebeadd5b6fc6cc75b
+  data.tar.gz: c56dd76208ad8bbfd9d7add1bbc317a951671c2590cecf93389fbb5170aa9da13898bb3501e396450df2eaa93a67d7041b24fbdc2ca77f2a414056d0cbf471f9

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.9.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, :environment, :prefab_api_url
 
     def initialize(api_key: ENV['PREFAB_API_KEY'],
                    logdev: nil,
@@ -31,17 +31,19 @@ module Prefab
       @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 Initializing in environment: '#{@environment}' and namespace: '#{@namespace}'"
+      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 +103,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,12 +99,12 @@ 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|
+      load_configs(resp, :api)
+      resp.configs.each do |delta|
         @config_loader.set(delta)
       end
       @config_resolver.update
@@ -112,16 +119,16 @@ 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)
+      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 +163,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 +205,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

@@ -24,12 +24,15 @@ module Prefab
     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 +58,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.env_key.empty?
+            if row.env_key == @environment
+              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.env_key, 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

@@ -24,11 +24,12 @@ module Prefab
 
     def get(feature_name, lookup_key, attributes)
       feature_obj = @base_client.config_client.get(feature_name)
-      evaluate(feature_name, lookup_key, attributes, feature_obj)
+      variants = @base_client.config_client.get_config_obj(feature_name).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
@@ -40,9 +41,9 @@ module Prefab
       variant.bool
     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
@@ -50,7 +51,7 @@ module Prefab
       # 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
 
@@ -73,11 +74,11 @@ module Prefab
         variant_idx = get_variant_idx_from_weights(variant_distribution.variant_weights.weights, distribution_bucket, feature_name)
       end
 
-      return get_variant_obj(feature_obj, variant_idx)
+      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)
+      return variants[idx] if variants.length >= idx
       nil
     end
 

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'

data/lib/prefab_pb.rb

@@ -22,28 +22,21 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
         optional :segment, :message, 8, "prefab.Segment"
       end
     end
-    add_message "prefab.NamespaceValue" do
-      optional :namespace, :string, 1
-      optional :config_value, :message, 2, "prefab.ConfigValue"
+    add_message "prefab.Configs" do
+      repeated :configs, :message, 1, "prefab.Config"
     end
-    add_message "prefab.EnvironmentValues" do
-      optional :environment, :string, 1
-      repeated :namespace_values, :message, 2, "prefab.NamespaceValue"
-      optional :default, :message, 3, "prefab.ConfigValue"
-    end
-    add_message "prefab.ConfigDelta" do
+    add_message "prefab.Config" do
       optional :id, :int64, 1
-      optional :key, :string, 2
-      optional :default, :message, 3, "prefab.ConfigValue"
-      repeated :envs, :message, 4, "prefab.EnvironmentValues"
-    end
-    add_message "prefab.ConfigDeltas" do
-      repeated :deltas, :message, 1, "prefab.ConfigDelta"
-    end
-    add_message "prefab.UpsertRequest" do
-      optional :project_id, :int64, 1
-      optional :config_delta, :message, 2, "prefab.ConfigDelta"
+      optional :project_id, :int64, 2
+      optional :key, :string, 3
       optional :changed_by, :string, 4
+      repeated :rows, :message, 5, "prefab.ConfigRow"
+      repeated :variants, :message, 6, "prefab.FeatureFlagVariant"
+    end
+    add_message "prefab.ConfigRow" do
+      optional :env_key, :string, 1
+      optional :namespace, :string, 2
+      optional :value, :message, 3, "prefab.ConfigValue"
     end
     add_message "prefab.LimitResponse" do
       optional :passed, :bool, 1
@@ -137,7 +130,6 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
       optional :default, :message, 3, "prefab.VariantDistribution"
       repeated :user_targets, :message, 4, "prefab.UserTarget"
       repeated :rules, :message, 5, "prefab.Rule"
-      repeated :variants, :message, 6, "prefab.FeatureFlagVariant"
     end
     add_message "prefab.LimitDefinition" do
       optional :policy_name, :enum, 2, "prefab.LimitResponse.LimitPolicyNames"
@@ -177,6 +169,10 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     add_message "prefab.BasicResponse" do
       optional :message, :string, 1
     end
+    add_message "prefab.CreationResponse" do
+      optional :message, :string, 1
+      optional :new_id, :int64, 2
+    end
     add_enum "prefab.OnFailure" do
       value :NOT_SET, 0
       value :LOG_AND_PASS, 1
@@ -189,11 +185,9 @@ end
 module Prefab
   ConfigServicePointer = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ConfigServicePointer").msgclass
   ConfigValue = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ConfigValue").msgclass
-  NamespaceValue = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.NamespaceValue").msgclass
-  EnvironmentValues = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.EnvironmentValues").msgclass
-  ConfigDelta = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ConfigDelta").msgclass
-  ConfigDeltas = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ConfigDeltas").msgclass
-  UpsertRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.UpsertRequest").msgclass
+  Configs = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.Configs").msgclass
+  Config = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.Config").msgclass
+  ConfigRow = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.ConfigRow").msgclass
   LimitResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.LimitResponse").msgclass
   LimitResponse::LimitPolicyNames = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.LimitResponse.LimitPolicyNames").enummodule
   LimitRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.LimitRequest").msgclass
@@ -214,5 +208,6 @@ module Prefab
   BufferedRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.BufferedRequest").msgclass
   BatchRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.BatchRequest").msgclass
   BasicResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.BasicResponse").msgclass
+  CreationResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.CreationResponse").msgclass
   OnFailure = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.OnFailure").enummodule
 end

data/lib/prefab_services_pb.rb

@@ -28,9 +28,9 @@ module Prefab
       self.unmarshal_class_method = :decode
       self.service_name = 'prefab.ConfigService'
 
-      rpc :GetConfig, ::Prefab::ConfigServicePointer, stream(::Prefab::ConfigDeltas)
-      rpc :GetAllConfig, ::Prefab::ConfigServicePointer, ::Prefab::ConfigDeltas
-      rpc :Upsert, ::Prefab::UpsertRequest, ::Prefab::ConfigServicePointer
+      rpc :GetConfig, ::Prefab::ConfigServicePointer, stream(::Prefab::Configs)
+      rpc :GetAllConfig, ::Prefab::ConfigServicePointer, ::Prefab::Configs
+      rpc :Upsert, ::Prefab::Config, ::Prefab::CreationResponse
     end
 
     Stub = Service.rpc_stub_class

data/prefab-cloud-ruby.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: prefab-cloud-ruby 0.8.0 ruby lib
+# stub: prefab-cloud-ruby 0.9.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "0.8.0"
+  s.version = "0.9.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Jeff Dwyer".freeze]
-  s.date = "2022-02-24"
+  s.date = "2022-03-18"
   s.description = "RateLimits & Config as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.extra_rdoc_files = [
@@ -67,6 +67,7 @@ Gem::Specification.new do |s|
   if s.respond_to? :add_runtime_dependency then
     s.add_runtime_dependency(%q<concurrent-ruby>.freeze, ["~> 1.0", ">= 1.0.5"])
     s.add_runtime_dependency(%q<faraday>.freeze, [">= 0"])
+    s.add_runtime_dependency(%q<ld-eventsource>.freeze, [">= 0"])
     s.add_runtime_dependency(%q<grpc>.freeze, [">= 0"])
     s.add_runtime_dependency(%q<google-protobuf>.freeze, [">= 0"])
     s.add_runtime_dependency(%q<googleapis-common-protos-types>.freeze, [">= 0"])
@@ -80,6 +81,7 @@ Gem::Specification.new do |s|
   else
     s.add_dependency(%q<concurrent-ruby>.freeze, ["~> 1.0", ">= 1.0.5"])
     s.add_dependency(%q<faraday>.freeze, [">= 0"])
+    s.add_dependency(%q<ld-eventsource>.freeze, [">= 0"])
     s.add_dependency(%q<grpc>.freeze, [">= 0"])
     s.add_dependency(%q<google-protobuf>.freeze, [">= 0"])
     s.add_dependency(%q<googleapis-common-protos-types>.freeze, [">= 0"])

data/run_test_harness_server.sh

@@ -1,2 +1,2 @@
-PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL=debug PREFAB_CLOUD_HTTP=true PREFAB_API_KEY="1|local_development_api_key" PREFAB_API_URL="localhost:50051" ruby -Ilib test/harness_server.rb
+PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL=debug PREFAB_CLOUD_HTTP=true PREFAB_GRPC_URL="localhost:50051" ruby -Ilib test/harness_server.rb
 #GRPC_TRACE=all GRPC_VERBOSITY=DEBUG PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL=debug PREFAB_CLOUD_HTTP=true PREFAB_API_KEY="1|local_development_api_key" PREFAB_API_URL="localhost:50051" ruby -Ilib test/harness_server.rb

data/test/harness_server.rb

@@ -20,7 +20,7 @@ class RackApp
     is_feature_flag = !props["feature_flag"].nil?
 
     client = Prefab::Client.new(
-      api_key: "1-#{environment}-local_development_api_key", #sets environment
+      api_key: "1-#{environment}-local_development_api_key-SDK", #sets environment
       namespace: namespace,
     )
 
@@ -40,6 +40,11 @@ class RackApp
     puts "return #{rtn}"
 
     [200, { "Content-Type" => "text/plain" }, rtn]
+
+    rescue Exception => e
+      puts "ERROR #{e.message}"
+      puts e.backtrace
+      [500, { "Content-Type" => "text/plain" }, e.message]
   end
 end
 

data/test/test_config_loader.rb

@@ -16,26 +16,26 @@ class TestConfigLoader < Minitest::Test
 
   def test_highwater
     assert_equal 0, @loader.highwater_mark
-    @loader.set(Prefab::ConfigDelta.new(id: 1, key: "sample_int", default: Prefab::ConfigValue.new(int: 456)))
+    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
     assert_equal 1, @loader.highwater_mark
 
-    @loader.set(Prefab::ConfigDelta.new(id: 5, key: "sample_int", default: Prefab::ConfigValue.new(int: 456)))
+    @loader.set(Prefab::Config.new(id: 5, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
     assert_equal 5, @loader.highwater_mark
-    @loader.set(Prefab::ConfigDelta.new(id: 2, key: "sample_int", default: Prefab::ConfigValue.new(int: 456)))
+    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
     assert_equal 5, @loader.highwater_mark
   end
 
   def test_keeps_most_recent
     assert_equal 0, @loader.highwater_mark
-    @loader.set(Prefab::ConfigDelta.new(id: 1, key: "sample_int", default: Prefab::ConfigValue.new(int: 1)))
+    @loader.set(Prefab::Config.new(id: 1, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 1))]))
     assert_equal 1, @loader.highwater_mark
     should_be :int, 1, "sample_int"
 
-    @loader.set(Prefab::ConfigDelta.new(id: 4, key: "sample_int", default: Prefab::ConfigValue.new(int: 4)))
+    @loader.set(Prefab::Config.new(id: 4, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 4))]))
     assert_equal 4, @loader.highwater_mark
     should_be :int, 4, "sample_int"
 
-    @loader.set(Prefab::ConfigDelta.new(id: 2, key: "sample_int", default: Prefab::ConfigValue.new(int: 2)))
+    @loader.set(Prefab::Config.new(id: 2, key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 2))]))
     assert_equal 4, @loader.highwater_mark
     should_be :int, 4, "sample_int"
   end
@@ -43,37 +43,37 @@ class TestConfigLoader < Minitest::Test
   def test_api_precedence
     should_be :int, 123, "sample_int"
 
-    @loader.set(Prefab::ConfigDelta.new(key: "sample_int", default: Prefab::ConfigValue.new(int: 456)))
+    @loader.set(Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: Prefab::ConfigValue.new(int: 456))]))
     should_be :int, 456, "sample_int"
   end
 
   def test_api_deltas
     val = Prefab::ConfigValue.new(int: 456)
-    delta = Prefab::ConfigDelta.new(key: "sample_int", default: val)
-    @loader.set(delta)
+    config = Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: val)])
+    @loader.set(config)
 
-    deltas = Prefab::ConfigDeltas.new
-    deltas.deltas << delta
-    assert_equal deltas, @loader.get_api_deltas
+    configs = Prefab::Configs.new
+    configs.configs << config
+    assert_equal configs, @loader.get_api_deltas
   end
 
   def test_loading_tombstones_removes_entries
     val = Prefab::ConfigValue.new(int: 456)
-    delta = Prefab::ConfigDelta.new(key: "sample_int", default: val)
-    @loader.set(delta)
+    config = Prefab::Config.new(key: "sample_int", rows: [Prefab::ConfigRow.new(value: val)])
+    @loader.set(config)
 
-    delta = Prefab::ConfigDelta.new(key: "sample_int", default: nil)
-    @loader.set(delta)
+    config = Prefab::Config.new(key: "sample_int", rows: [])
+    @loader.set(config)
 
-    deltas = Prefab::ConfigDeltas.new
-    assert_equal deltas, @loader.get_api_deltas
+    configs = Prefab::Configs.new
+    assert_equal configs, @loader.get_api_deltas
   end
 
   private
 
   def should_be(type, value, key)
-    assert_equal type, @loader.calc_config[key].default.type
-    assert_equal value, @loader.calc_config[key].default.send(type)
+    assert_equal type, @loader.calc_config[key].rows[0].value.type
+    assert_equal value, @loader.calc_config[key].rows[0].value.send(type)
   end
 
 end

data/test/test_config_resolver.rb

@@ -6,35 +6,44 @@ class TestConfigResolver < Minitest::Test
     @loader = MockConfigLoader.new
 
     loaded_values = {
-      "key" => Prefab::ConfigDelta.new(
+      "key" => Prefab::Config.new(
         key: "key",
-        default: Prefab::ConfigValue.new(string: "value_no_env_default"),
-        envs: [{
-                 environment: "test",
-                 default: Prefab::ConfigValue.new(string: "value_none"),
-                 namespace_values: [
-                   {
-                     namespace: "projectA",
-                     config_value: Prefab::ConfigValue.new(string: "valueA")
-                   },
-                   {
-                     namespace: "projectB",
-                     config_value: Prefab::ConfigValue.new(string: "valueB")
-                   },
-                   {
-                     namespace: "projectB.subprojectX",
-                     config_value: Prefab::ConfigValue.new(string: "projectB.subprojectX")
-                   },
-                   {
-                     namespace: "projectB.subprojectY",
-                     config_value: Prefab::ConfigValue.new(string: "projectB.subprojectY")
-                   },
-                 ]
-               }]
+        rows: [
+          Prefab::ConfigRow.new(
+            value: Prefab::ConfigValue.new(string: "value_no_env_default"),
+          ),
+          Prefab::ConfigRow.new(
+            env_key: "test",
+            value: Prefab::ConfigValue.new(string: "value_none"),
+          ),
+          Prefab::ConfigRow.new(
+            env_key: "test",
+            namespace: "projectA",
+            value: Prefab::ConfigValue.new(string: "valueA"),
+          ),
+          Prefab::ConfigRow.new(
+            env_key: "test",
+            namespace: "projectB",
+            value: Prefab::ConfigValue.new(string: "valueB"),
+          ),
+          Prefab::ConfigRow.new(
+            env_key: "test",
+            namespace: "projectB.subprojectX",
+            value: Prefab::ConfigValue.new(string: "projectB.subprojectX"),
+          ),
+          Prefab::ConfigRow.new(
+            env_key: "test",
+            namespace: "projectB.subprojectY",
+            value: Prefab::ConfigValue.new(string: "projectB.subprojectY"),
+          ),
+
+        ]
       ),
-      "key2" => Prefab::ConfigDelta.new(
+      "key2" => Prefab::Config.new(
         key: "key2",
-        default: Prefab::ConfigValue.new(string: "valueB2"),
+        rows: [
+          value: Prefab::ConfigValue.new(string: "valueB2"),
+        ]
       )
     }
 
@@ -93,32 +102,31 @@ class TestConfigResolver < Minitest::Test
   def test_special_ff_variant_copying
     @loader = MockConfigLoader.new
     loaded_values = {
-      "ff" => Prefab::ConfigDelta.new(
+      "ff" => Prefab::Config.new(
         key: "ff",
-        default: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
-          variants: [
-            Prefab::FeatureFlagVariant.new(string: "inactive"),
-            Prefab::FeatureFlagVariant.new(string: "default"),
-            Prefab::FeatureFlagVariant.new(string: "env"),
-          ],
-          inactive_variant_idx: 0,
-          default: Prefab::VariantDistribution.new(variant_idx: 1)
-        )),
-        envs: [
-          Prefab::EnvironmentValues.new(
-            environment: "test",
-            default: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
+        variants: [
+          Prefab::FeatureFlagVariant.new(string: "inactive"),
+          Prefab::FeatureFlagVariant.new(string: "default"),
+          Prefab::FeatureFlagVariant.new(string: "env"),
+        ],
+        rows: [
+          { value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
+            inactive_variant_idx: 0,
+            default: Prefab::VariantDistribution.new(variant_idx: 1)
+          )) },
+          { env_key: "test",
+            value: Prefab::ConfigValue.new(feature_flag: Prefab::FeatureFlag.new(
               inactive_variant_idx: 0,
-              default: Prefab::VariantDistribution.new(variant_idx: 2)))
-          )
+              default: Prefab::VariantDistribution.new(variant_idx: 2)
+            )) }
         ]
       )
     }
     @loader.stub :calc_config, loaded_values do
       resolver = Prefab::ConfigResolver.new(MockBaseClient.new, @loader)
-      ff = resolver.get("ff")
-      assert_equal 3, ff.variants.size
-      assert_equal %w(inactive default env), ff.variants.map(&:string)
+      config = resolver.get_config("ff")
+      assert_equal 3, config.variants.size
+      assert_equal %w(inactive default env), config.variants.map(&:string)
     end
   end
 
@@ -127,13 +135,17 @@ class TestConfigResolver < Minitest::Test
     @loader = MockConfigLoader.new
 
     loaded_values = {
-      "Key:With:Colons" => Prefab::ConfigDelta.new(
+      "Key:With:Colons" => Prefab::Config.new(
         key: "Key:With:Colons",
-        default: Prefab::ConfigValue.new(string: "value"),
+        rows: [Prefab::ConfigRow.new(
+          value: Prefab::ConfigValue.new(string: "value")
+        )]
       ),
-      "proj:apikey" => Prefab::ConfigDelta.new(
+      "proj:apikey" => Prefab::Config.new(
         key: "proj:apikey",
-        default: Prefab::ConfigValue.new(string: "v2"),
+        rows: [Prefab::ConfigRow.new(
+          value: Prefab::ConfigValue.new(string: "v2")
+        )]
       )
     }
 

data/test/test_feature_flag_client.rb

@@ -13,12 +13,12 @@ class TestFeatureFlagClient < Minitest::Test
   def test_pct
     feature = "FlagName"
 
+    variants = [
+      Prefab::FeatureFlagVariant.new(bool: false),
+      Prefab::FeatureFlagVariant.new(bool: true)
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(bool: false),
-        Prefab::FeatureFlagVariant.new(bool: true)
-      ],
       inactive_variant_idx: 0,
       default: Prefab::VariantDistribution.new(variant_weights:
                                                  Prefab::VariantWeights.new(weights: [
@@ -32,52 +32,52 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     assert_equal false,
-                 @client.evaluate(feature, "hashes high", [], flag)
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
     assert_equal true,
-                 @client.evaluate(feature, "hashes low", [], flag)
+                 @client.evaluate(feature, "hashes low", [], flag, variants)
   end
 
   def test_basic_active_inactive
     feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(bool: false),
+      Prefab::FeatureFlagVariant.new(bool: true)
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(bool: false),
-        Prefab::FeatureFlagVariant.new(bool: true)
-      ],
       inactive_variant_idx: 0,
       default: Prefab::VariantDistribution.new(variant_idx: 1)
     )
     assert_equal true,
-                 @client.evaluate(feature, "hashes high", [], flag)
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
     assert_equal true,
-                 @client.evaluate(feature, "hashes low", [], flag)
+                 @client.evaluate(feature, "hashes low", [], flag, variants)
 
+    variants = [
+      Prefab::FeatureFlagVariant.new(bool: false),
+      Prefab::FeatureFlagVariant.new(bool: true)
+    ]
     flag = Prefab::FeatureFlag.new(
       active: false,
-      variants: [
-        Prefab::FeatureFlagVariant.new(bool: false),
-        Prefab::FeatureFlagVariant.new(bool: true)
-      ],
       inactive_variant_idx: 0,
       default: Prefab::VariantDistribution.new(variant_idx: 1)
     )
     assert_equal false,
-                 @client.evaluate(feature, "hashes high", [], flag)
+                 @client.evaluate(feature, "hashes high", [], flag, variants)
     assert_equal false,
-                 @client.evaluate(feature, "hashes low", [], flag)
+                 @client.evaluate(feature, "hashes low", [], flag, variants)
   end
 
   def test_user_targets
 
     feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "user target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "user target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
       inactive_variant_idx: 0,
       user_targets: [
         variant_idx: 1,
@@ -87,22 +87,22 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     assert_equal "user target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:2", [], flag)
+                 @client.evaluate(feature, "user:2", [], flag, variants)
     assert_equal "user target",
-                 @client.evaluate(feature, "user:3", [], flag)
+                 @client.evaluate(feature, "user:3", [], flag, variants)
   end
 
   def test_inclusion_rule
     feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "rule target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "rule target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
       inactive_variant_idx: 0,
       rules: [Prefab::Rule.new(
         distribution: Prefab::VariantDistribution.new(variant_idx: 1),
@@ -115,9 +115,9 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:2", [], flag)
+                 @client.evaluate(feature, "user:2", [], flag, variants)
 
   end
 
@@ -143,13 +143,13 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "rule target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "rule target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
       inactive_variant_idx: 0,
       rules: [Prefab::Rule.new(
         distribution: Prefab::VariantDistribution.new(variant_idx: 1),
@@ -162,9 +162,9 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:2", [], flag)
+                 @client.evaluate(feature, "user:2", [], flag, variants)
 
   end
 
@@ -187,13 +187,13 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     feature = "FlagName"
+    variants = [
+      Prefab::FeatureFlagVariant.new(string: "inactive"),
+      Prefab::FeatureFlagVariant.new(string: "rule target"),
+      Prefab::FeatureFlagVariant.new(string: "default"),
+    ]
     flag = Prefab::FeatureFlag.new(
       active: true,
-      variants: [
-        Prefab::FeatureFlagVariant.new(string: "inactive"),
-        Prefab::FeatureFlagVariant.new(string: "rule target"),
-        Prefab::FeatureFlagVariant.new(string: "default"),
-      ],
       inactive_variant_idx: 0,
       rules: [Prefab::Rule.new(
         distribution: Prefab::VariantDistribution.new(variant_idx: 1),
@@ -206,15 +206,15 @@ class TestFeatureFlagClient < Minitest::Test
     )
 
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:1", [], flag)
+                 @client.evaluate(feature, "user:1", [], flag, variants)
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:2", [], flag), "matches segment 1"
+                 @client.evaluate(feature, "user:2", [], flag, variants), "matches segment 1"
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:3", [], flag)
+                 @client.evaluate(feature, "user:3", [], flag, variants)
     assert_equal "rule target",
-                 @client.evaluate(feature, "user:4", [], flag)
+                 @client.evaluate(feature, "user:4", [], flag, variants)
     assert_equal "default",
-                 @client.evaluate(feature, "user:5", [], flag)
+                 @client.evaluate(feature, "user:5", [], flag, variants)
 
   end
 end

data/test/test_helper.rb

@@ -25,6 +25,11 @@ class MockBaseClient
   def get(key)
     @config_values[key]
   end
+
+  def get_config(key)
+    puts "HELLOOOO"
+    @config_values[key]
+  end
 end
 
 class MockConfigLoader

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-24 00:00:00.000000000 Z
+date: 2022-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -44,6 +44,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ld-eventsource
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: grpc
   requirement: !ruby/object:Gem::Requirement