prefab-cloud-ruby 0.7.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a36d24a94355b3b7a2b3b889734e1f6f6ccafc7dcebfb11ff11d77ba92ea7828
-  data.tar.gz: 326b3166d4fc2589ebb2550114b2cc198617620daa70ecfb6b9fe394c9dd79a5
+  metadata.gz: c18d5a31a2f535269b3faf262b82a57e67b75ceee5581c5ef6f8cea7bbdb416b
+  data.tar.gz: d7125da40abab76dc25e37459cdde3a891801dc4f630c3f3f2f22f7f65ef2f5d
 SHA512:
-  metadata.gz: fb73839190f23e05540688572b8f47c1300ae9181bdecef0f24fdecb9a9e73ace1c88937e7c228601c20ff68405876c21b977e45bd691ba33f59d71dd4811718
-  data.tar.gz: 792f04aa032c2f9975444a191ddbb8f727e256d12ec2fc4b3c26819bff4a425deabffb3ff262221e7fe90ed4c1d1422d7a2cb447530264cde494b4e149de7e78
+  metadata.gz: 38e1ad427078327f05b01b869d5f0879819271b372d8373996d5d592e3d4efa92bed6b59d061d92dc2a21eb49c6c529140ae9f9b5d8825fc2b828840d1b23a7f
+  data.tar.gz: 88cf63bf9dfdc9c103660240a5d2b35f27103eda55c28a96cb16943da41adf4ffa85928533fd739a868b3b5f5bb5ef565b80073f75712f3bb62305921694d1b2

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

@@ -53,6 +53,15 @@ end
 * Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
 * Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
 
+## Release
+
+```shell
+update VERSION
+bundle exec rake gemspec:generate
+git commit & push
+REMOTE_BRANCH=main LOCAL_BRANCH=main bundle exec rake release
+```
+
 ## Copyright
 
 Copyright (c) 2022 Jeff Dwyer. See LICENSE.txt for

data/VERSION

@@ -1 +1 @@
-0.7.0
+0.10.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, :project_env_id, :prefab_api_url
 
     def initialize(api_key: ENV['PREFAB_API_KEY'],
                    logdev: nil,
@@ -19,7 +19,7 @@ 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
+      raise "PREFAB_API_KEY format invalid. Expecting 123-development-yourapikey-SDK" unless api_key.count("-") == 3
       @logdev = (logdev || $stdout)
       @log_formatter = log_formatter
       @local = local
@@ -27,21 +27,23 @@ module Prefab
       @shared_cache = (shared_cache || NoopCache.new)
       @api_key = api_key
       @project_id = api_key.split("-")[0].to_i
-      @environment = api_key.split("-")[1]
+      @project_env_id = api_key.split("-")[1].to_i
       @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: '#{@project_env_id}' 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

@@ -6,7 +6,7 @@ module Prefab
     def initialize(base_client, config_loader)
       @lock = Concurrent::ReadWriteLock.new
       @local_store = {}
-      @environment = base_client.environment
+      @project_env_id = base_client.project_env_id
       @namespace = base_client.namespace
       @config_loader = config_loader
       make_local
@@ -16,20 +16,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 +62,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

@@ -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

@@ -8,7 +8,7 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     add_message "prefab.ConfigServicePointer" do
       optional :project_id, :int64, 1
       optional :start_at_id, :int64, 2
-      optional :env_key, :string, 3
+      optional :project_env_id, :int64, 3
     end
     add_message "prefab.ConfigValue" do
       oneof :type do
@@ -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 :project_env_id, :int64, 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,23 @@ 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_message "prefab.IdBlock" do
+      optional :project_id, :int64, 1
+      optional :project_env_id, :int64, 2
+      optional :sequence_name, :string, 3
+      optional :start, :int64, 4
+      optional :end, :int64, 5
+    end
+    add_message "prefab.IdBlockRequest" do
+      optional :project_id, :int64, 1
+      optional :project_env_id, :int64, 2
+      optional :sequence_name, :string, 3
+      optional :size, :int64, 4
+    end
     add_enum "prefab.OnFailure" do
       value :NOT_SET, 0
       value :LOG_AND_PASS, 1
@@ -189,11 +198,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 +221,8 @@ 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
+  IdBlock = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.IdBlock").msgclass
+  IdBlockRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.IdBlockRequest").msgclass
   OnFailure = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("prefab.OnFailure").enummodule
 end

data/lib/prefab_services_pb.rb

@@ -28,9 +28,23 @@ 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
+  end
+  module IdService
+    class Service
+
+      include ::GRPC::GenericService
+
+      self.marshal_class_method = :encode
+      self.unmarshal_class_method = :decode
+      self.service_name = 'prefab.IdService'
+
+      rpc :GetBlock, ::Prefab::IdBlockRequest, ::Prefab::IdBlock
     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.7.0 ruby lib
+# stub: prefab-cloud-ruby 0.10.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "0.7.0"
+  s.version = "0.10.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-23"
   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"])