prefab-cloud-ruby 1.8.2 → 1.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc28dd551eb4ba62f97902ae49cfa8f474c7a2883a8dce5ea43605d661420407
-  data.tar.gz: f2bba00e271a6947d0394453f21964d4d849f22004747a434efa58f3a97d6f09
+  metadata.gz: ddab427174fc8ee9580364b7f55becb58806d98b94968ee3d903ce67e9b01268
+  data.tar.gz: 181cdf62f18a7c9b09846746597273230f6b13100b302ef4531693f0a3d07085
 SHA512:
-  metadata.gz: d9b2e0a3ce0aaa1812677c06744272f2ac52a92687420c10942f271261be1b9c7a4de64efc8e98ed2537df1597c00a2a1f359408c19114d64b3ba5838aeab917
-  data.tar.gz: 22892c02a6570108400edc76af207e233125e4ec85df3d895db2be90c86e9dba7840a9ea4f8e46c2868e9ba6b1c642115677f47cb90db928be40e354a74d1e13
+  metadata.gz: 784b5d8e0229ec1e953d16a2442561a1cc67e18fc4f398f4878ac4672256892a0d6c314b06b9cd835a8309d184d47a2280d348b8afd396f977c6c57248d7c2b9
+  data.tar.gz: '0865454d8eab0548aff23e3caa338d037babc8d9a49165424e6b8822d6a5f5b5ba67e8395752bebedb9666ff5cd3f1eac46f4d4df66abc1c8f2274770e4d634f'

data/.github/workflows/ruby.yml

@@ -40,7 +40,7 @@ jobs:
     - name: Install dependencies
       run: bundle install --without development --jobs 4 --retry 3
     - name: Run tests
-      run: bundle exec rake
+      run: bundle exec rake --trace
       env:
         PREFAB_INTEGRATION_TEST_API_KEY: ${{ secrets.PREFAB_INTEGRATION_TEST_API_KEY }}
         PREFAB_INTEGRATION_TEST_ENCRYPTION_KEY: ${{ secrets.PREFAB_INTEGRATION_TEST_ENCRYPTION_KEY }}

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.8.3 - 2024-09-16
+
+- Add JavaScript stub & bootstrapping (#200)
+
 ## 1.8.2 - 2024-09-03
 
 - Forbid bad semantic_logger version (#198)

data/Gemfile

@@ -12,6 +12,7 @@ gem 'activesupport', '>= 4'
 gem 'semantic_logger', '!= 4.16.0', require: "semantic_logger/sync"
 
 group :development do
+  gem 'allocation_stats'
   gem 'benchmark-ips'
   gem 'bundler'
   gem 'juwelier', '~> 2.4.9'
@@ -24,4 +25,5 @@ group :test do
   gem 'minitest-focus'
   gem 'minitest-reporters'
   gem 'timecop'
+  gem 'webrick'
 end

data/Gemfile.lock

@@ -13,6 +13,7 @@ GEM
       tzinfo (~> 2.0)
     addressable (2.8.6)
       public_suffix (>= 2.0.2, < 6.0)
+    allocation_stats (0.1.5)
     ansi (1.5.0)
     base64 (0.2.0)
     benchmark-ips (2.13.0)
@@ -151,12 +152,14 @@ GEM
       concurrent-ruby (~> 1.0)
     uuid (2.3.9)
       macaddr (~> 1.0)
+    webrick (1.8.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   activesupport (>= 4)
+  allocation_stats
   benchmark-ips
   bundler
   concurrent-ruby (~> 1.0, >= 1.0.5)
@@ -173,6 +176,7 @@ DEPENDENCIES
   simplecov
   timecop
   uuid
+  webrick
 
 BUNDLED WITH
    2.3.5

data/Rakefile

@@ -11,6 +11,14 @@ rescue Bundler::BundlerError => e
 end
 
 require 'rake'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
 task default: :test
 
 unless ENV['CI']
@@ -28,12 +36,6 @@ unless ENV['CI']
     # dependencies defined in Gemfile
   end
   Juwelier::RubygemsDotOrgTasks.new
-  require 'rake/testtask'
-  Rake::TestTask.new(:test) do |test|
-    test.libs << 'lib' << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
 
   desc 'Code coverage detail'
   task :simplecov do

data/VERSION

@@ -1 +1 @@
-1.8.2
+1.8.3

data/dev/allocation_stats

@@ -20,7 +20,7 @@ require 'prefab-cloud-ruby'
 
 $prefab = Prefab::Client.new(collect_logger_counts: false, collect_evaluation_summaries: false,
                              context_upload_mode: :none)
-$prefab.get('prefab.auth.allowed_origins')
+$prefab.get('a.live.integer')
 
 puts '-' * 80
 
@@ -50,11 +50,11 @@ def measure(description)
 end
 
 measure "no-JIT context (#{$runs} runs)" do
-  $prefab.get('prefab.auth.allowed_origins')
+  $prefab.get('a.live.integer')
 end
 
 puts "\n\n"
 
 measure "with JIT context (#{$runs} runs)" do
-  $prefab.get('prefab.auth.allowed_origins', { a: { b: "c" } })
+  $prefab.get('a.live.integer', { a: { b: "c" } })
 end

data/dev/console

@@ -1,23 +1,8 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env bundle exec ruby
 # frozen_string_literal: true
 
 require 'irb'
-require 'bundler/setup'
-
-gemspec = Dir.glob(File.expand_path("../../*.gemspec", __FILE__)).first
-spec = Gem::Specification.load(gemspec)
-
-# Add the require paths to the $LOAD_PATH
-spec.require_paths.each do |path|
-  full_path = File.expand_path("../" + path, __dir__)
-  $LOAD_PATH.unshift(full_path) unless $LOAD_PATH.include?(full_path)
-end
-
-spec.require_paths.each do |path|
-  require "./lib/prefab-cloud-ruby"
-end
-
-SemanticLogger.add_appender(io: $stdout)
+require_relative "./script_setup"
 
 if !ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL']
   puts "run with PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL=debug (or trace) for more output"

data/dev/script_setup.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+gemspec = Dir.glob(File.expand_path("../../*.gemspec", __FILE__)).first
+spec = Gem::Specification.load(gemspec)
+
+# Add the require paths to the $LOAD_PATH
+spec.require_paths.each do |path|
+  full_path = File.expand_path("../" + path, __dir__)
+  $LOAD_PATH.unshift(full_path) unless $LOAD_PATH.include?(full_path)
+end
+
+spec.require_paths.each do |path|
+  require "./lib/prefab-cloud-ruby"
+end
+
+SemanticLogger.add_appender(io: $stdout)

data/lib/prefab/config_client.rb

@@ -46,9 +46,9 @@ module Prefab
         stream_lock = Concurrent::ReadWriteLock.new
         @sse_config_client = Prefab::SSEConfigClient.new(@options, @config_loader)
 
-        @sse_config_client.start do |configs|
+        @sse_config_client.start do |configs, _event, source|
           stream_lock.with_write_lock do
-            load_configs(configs, :sse)
+            load_configs(configs, source)
           end
         end
       end

data/lib/prefab/config_resolver.rb

@@ -23,6 +23,10 @@ module Prefab
       Prefab::ResolvedConfigPresenter.new(self, @lock, @local_store)
     end
 
+    def keys
+      @local_store.keys
+    end
+
     def raw(key)
       @local_store.dig(key, :config)
     end

data/lib/prefab/criteria_evaluator.rb

@@ -21,8 +21,10 @@ module Prefab
 
     def evaluate(properties)
       rtn = evaluate_for_env(@project_env_id, properties) ||
-        evaluate_for_env(0, properties)
-      LOG.trace "Eval Key #{@config.key} Result #{rtn&.reportable_value} with #{properties.to_h}" unless @config.config_type == :LOG_LEVEL
+            evaluate_for_env(0, properties)
+      LOG.trace {
+        "Eval Key #{@config.key} Result #{rtn&.reportable_value} with #{properties.to_h}"
+      } unless @config.config_type == :LOG_LEVEL
       rtn
     end
 

data/lib/prefab/duration.rb

@@ -50,5 +50,9 @@ module Prefab
     def to_f
       in_seconds.to_f
     end
+
+    def as_json
+      { ms:  in_seconds * 1000, seconds: in_seconds }
+    end
   end
 end

data/lib/prefab/javascript_stub.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Prefab
+  class JavaScriptStub
+    LOG = Prefab::InternalLogger.new(self)
+
+    def initialize(client = nil)
+      @client = client || Prefab.instance
+    end
+
+    # Generate the JavaScript snippet to bootstrap the client SDK. This will
+    # include the configuration values that are permitted to be sent to the
+    # client SDK.
+    #
+    # If the context provided to the client SDK is not the same as the context
+    # used to generate the configuration values, the client SDK will still
+    # generate a fetch to get the correct values for the context.
+    #
+    # Any keys that could not be resolved will be logged as a warning to the
+    # console.
+    def bootstrap(context)
+      configs, warnings = data(context)
+      <<~JS
+        window._prefabBootstrap = {
+          configs: #{JSON.dump(configs)},
+          context: #{JSON.dump(context)}
+        }
+        #{log_warnings(warnings)}
+      JS
+    end
+
+    # Generate the JavaScript snippet to *replace* the client SDK. Use this to
+    # get `prefab.get` and `prefab.isEnabled` functions on the window object.
+    #
+    # Only use this if you are not using the client SDK and do not need
+    # client-side context.
+    #
+    # Any keys that could not be resolved will be logged as a warning to the
+    # console.
+    def generate_stub(context)
+      configs, warnings = data(context)
+      <<~JS
+        window.prefab = window.prefab || {};
+        window.prefab.config = #{JSON.dump(configs)};
+        window.prefab.get = function(key) {
+          return window.prefab.config[key];
+        };
+        window.prefab.isEnabled = function(key) {
+          return window.prefab.config[key] === true;
+        };
+        #{log_warnings(warnings)}
+      JS
+    end
+
+    private
+
+    def underlying_value(value)
+      v = Prefab::ConfigValueUnwrapper.new(value, @client.resolver).unwrap
+      case v
+      when Google::Protobuf::RepeatedField
+        v.to_a
+      when Prefab::Duration
+        v.as_json
+      else
+        v
+      end
+    end
+
+    def log_warnings(warnings)
+      return '' if warnings.empty?
+
+      <<~JS
+        console.warn('The following keys could not be resolved:', #{JSON.dump(@warnings)});
+      JS
+    end
+
+    def data(context)
+      permitted = {}
+      warnings = []
+      resolver_keys = @client.resolver.keys
+
+      resolver_keys.each do |key|
+        begin
+          config = @client.resolver.raw(key)
+
+          if config.config_type == :FEATURE_FLAG || config.send_to_client_sdk
+            permitted[key] = underlying_value(@client.resolver.get(key, context).value)
+          end
+        rescue StandardError => e
+          LOG.warn("Could not resolve key #{key}: #{e}")
+
+          warnings << key
+        end
+      end
+
+      [permitted, warnings]
+    end
+  end
+end

data/lib/prefab/prefab.rb

@@ -78,6 +78,16 @@ module Prefab
     @singleton.is_ff?(key)
   end
 
+  def self.bootstrap_javascript(context)
+    ensure_initialized
+    Prefab::JavaScriptStub.new(@singleton).bootstrap(context)
+  end
+
+  def self.generate_javascript_stub(context)
+    ensure_initialized
+    Prefab::JavaScriptStub.new(@singleton).generate_stub(context)
+  end
+
   private
 
   def self.ensure_initialized(key = nil)

data/lib/prefab/sse_config_client.rb

@@ -2,15 +2,33 @@
 
 module Prefab
   class SSEConfigClient
-    SSE_READ_TIMEOUT = 300
-    SECONDS_BETWEEN_RECONNECT = 5
+    class Options
+      attr_reader :sse_read_timeout, :seconds_between_new_connection,
+                  :sse_default_reconnect_time, :sleep_delay_for_new_connection_check,
+                  :errors_to_close_connection
+
+      def initialize(sse_read_timeout: 300,
+                     seconds_between_new_connection: 5,
+                     sleep_delay_for_new_connection_check: 1,
+                     sse_default_reconnect_time: SSE::Client::DEFAULT_RECONNECT_TIME,
+                     errors_to_close_connection: [HTTP::ConnectionError])
+        @sse_read_timeout = sse_read_timeout
+        @seconds_between_new_connection = seconds_between_new_connection
+        @sse_default_reconnect_time = sse_default_reconnect_time
+        @sleep_delay_for_new_connection_check = sleep_delay_for_new_connection_check
+        @errors_to_close_connection = errors_to_close_connection
+      end
+    end
+
     AUTH_USER = 'authuser'
     LOG = Prefab::InternalLogger.new(self)
 
-    def initialize(options, config_loader)
-      @options = options
+    def initialize(prefab_options, config_loader, options = nil, logger = nil)
+      @prefab_options = prefab_options
+      @options = options || Options.new
       @config_loader = config_loader
       @connected = false
+      @logger = logger || LOG
     end
 
     def close
@@ -19,8 +37,8 @@ module Prefab
     end
 
     def start(&load_configs)
-      if @options.sse_sources.empty?
-        LOG.debug 'No SSE sources configured'
+      if @prefab_options.sse_sources.empty?
+        @logger.debug 'No SSE sources configured'
         return
       end
 
@@ -30,13 +48,14 @@ module Prefab
 
       @retry_thread = Thread.new do
         loop do
-          sleep 1
+          sleep @options.sleep_delay_for_new_connection_check
 
           if @client.closed?
-            closed_count += 1
+            closed_count += @options.sleep_delay_for_new_connection_check
 
-            if closed_count > SECONDS_BETWEEN_RECONNECT
+            if closed_count > @options.seconds_between_new_connection
               closed_count = 0
+              @logger.debug 'Reconnecting SSE client'
               @client = connect(&load_configs)
             end
           end
@@ -46,22 +65,23 @@ module Prefab
 
     def connect(&load_configs)
       url = "#{source}/api/v1/sse/config"
-      LOG.debug "SSE Streaming Connect to #{url} start_at #{@config_loader.highwater_mark}"
+      @logger.debug "SSE Streaming Connect to #{url} start_at #{@config_loader.highwater_mark}"
 
       SSE::Client.new(url,
                       headers: headers,
-                      read_timeout: SSE_READ_TIMEOUT,
+                      read_timeout: @options.sse_read_timeout,
+                      reconnect_time: @options.sse_default_reconnect_time,
                       logger: Prefab::InternalLogger.new(SSE::Client)) do |client|
         client.on_event do |event|
           configs = PrefabProto::Configs.decode(Base64.decode64(event.data))
-          load_configs.call(configs, :sse)
+          load_configs.call(configs, event, :sse)
         end
 
         client.on_error do |error|
-          LOG.error "SSE Streaming Error: #{error.inspect} for url #{url}"
+          @logger.error "SSE Streaming Error: #{error.inspect} for url #{url}"
 
-          if error.is_a?(HTTP::ConnectionError)
-            LOG.debug "Closing SSE connection for url #{url}"
+          if @options.errors_to_close_connection.any? { |klass| error.is_a?(klass) }
+            @logger.debug "Closing SSE connection for url #{url}"
             client.close
           end
         end
@@ -69,7 +89,7 @@ module Prefab
     end
 
     def headers
-      auth = "#{AUTH_USER}:#{@options.api_key}"
+      auth = "#{AUTH_USER}:#{@prefab_options.api_key}"
       auth_string = Base64.strict_encode64(auth)
       return {
         'x-prefab-start-at-id' => @config_loader.highwater_mark,
@@ -82,11 +102,11 @@ module Prefab
     def source
       @source_index = @source_index.nil? ? 0 : @source_index + 1
 
-      if @source_index >= @options.sse_sources.size
+      if @source_index >= @prefab_options.sse_sources.size
         @source_index = 0
       end
 
-      return @options.sse_sources[@source_index]
+      return @prefab_options.sse_sources[@source_index]
     end
   end
 end

data/lib/prefab-cloud-ruby.rb

@@ -53,3 +53,4 @@ require 'prefab/config_client'
 require 'prefab/feature_flag_client'
 require 'prefab/prefab'
 require 'prefab/murmer3'
+require 'prefab/javascript_stub'

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 1.8.2 ruby lib
+# stub: prefab-cloud-ruby 1.8.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "1.8.2"
+  s.version = "1.8.3"
 
   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 = "2024-09-03"
+  s.date = "2024-09-16"
   s.description = "Feature Flags, Live Config, and Dynamic Log Levels as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.extra_rdoc_files = [
@@ -37,6 +37,7 @@ Gem::Specification.new do |s|
     "dev/allocation_stats",
     "dev/benchmark",
     "dev/console",
+    "dev/script_setup.rb",
     "lib/prefab-cloud-ruby.rb",
     "lib/prefab/client.rb",
     "lib/prefab/config_client.rb",
@@ -65,6 +66,7 @@ Gem::Specification.new do |s|
     "lib/prefab/feature_flag_client.rb",
     "lib/prefab/http_connection.rb",
     "lib/prefab/internal_logger.rb",
+    "lib/prefab/javascript_stub.rb",
     "lib/prefab/local_config_parser.rb",
     "lib/prefab/log_path_aggregator.rb",
     "lib/prefab/logger_client.rb",
@@ -107,6 +109,7 @@ Gem::Specification.new do |s|
     "test/test_helper.rb",
     "test/test_integration.rb",
     "test/test_internal_logger.rb",
+    "test/test_javascript_stub.rb",
     "test/test_local_config_parser.rb",
     "test/test_log_path_aggregator.rb",
     "test/test_logger.rb",
@@ -135,6 +138,7 @@ Gem::Specification.new do |s|
     s.add_runtime_dependency(%q<uuid>.freeze, [">= 0"])
     s.add_runtime_dependency(%q<activesupport>.freeze, [">= 4"])
     s.add_runtime_dependency(%q<semantic_logger>.freeze, ["!= 4.16.0"])
+    s.add_development_dependency(%q<allocation_stats>.freeze, [">= 0"])
     s.add_development_dependency(%q<benchmark-ips>.freeze, [">= 0"])
     s.add_development_dependency(%q<bundler>.freeze, [">= 0"])
     s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.4.9"])
@@ -149,6 +153,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<uuid>.freeze, [">= 0"])
     s.add_dependency(%q<activesupport>.freeze, [">= 4"])
     s.add_dependency(%q<semantic_logger>.freeze, ["!= 4.16.0"])
+    s.add_dependency(%q<allocation_stats>.freeze, [">= 0"])
     s.add_dependency(%q<benchmark-ips>.freeze, [">= 0"])
     s.add_dependency(%q<bundler>.freeze, [">= 0"])
     s.add_dependency(%q<juwelier>.freeze, ["~> 2.4.9"])

data/test/test_javascript_stub.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class JavascriptStubTest < Minitest::Test
+  PROJECT_ENV_ID = 1
+  DEFAULT_VALUE = 'default_value'
+  DEFAULT_VALUE_CONFIG = PrefabProto::ConfigValue.new(string: DEFAULT_VALUE)
+  TRUE_CONFIG = PrefabProto::ConfigValue.new(bool: true)
+  FALSE_CONFIG = PrefabProto::ConfigValue.new(bool: false)
+  DEFAULT_ROW = PrefabProto::ConfigRow.new(
+    values: [
+      PrefabProto::ConditionalValue.new(value: DEFAULT_VALUE_CONFIG)
+    ]
+  )
+
+  def setup
+    super
+
+    log_level = PrefabProto::Config.new(
+      id: 999,
+      key: 'log-level',
+      config_type: PrefabProto::ConfigType::LOG_LEVEL,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [],
+              value: PrefabProto::ConfigValue.new(log_level: PrefabProto::LogLevel::INFO)
+            )
+          ]
+        )
+      ]
+    )
+
+    config_for_sdk = PrefabProto::Config.new(
+      id: 123,
+      key: 'basic-config',
+      config_type: PrefabProto::ConfigType::CONFIG,
+      rows: [DEFAULT_ROW],
+      send_to_client_sdk: true
+    )
+
+    config_not_for_sdk = PrefabProto::Config.new(
+      id: 787,
+      key: 'non-sdk-basic-config',
+      config_type: PrefabProto::ConfigType::CONFIG,
+      rows: [DEFAULT_ROW]
+    )
+
+    ff = PrefabProto::Config.new(
+      id: 456,
+      key: 'feature-flag',
+      config_type: PrefabProto::ConfigType::FEATURE_FLAG,
+      rows: [
+        PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              value: TRUE_CONFIG,
+              criteria: [
+                PrefabProto::Criterion.new(
+                  operator: PrefabProto::Criterion::CriterionOperator::PROP_ENDS_WITH_ONE_OF,
+                  value_to_match: string_list(['hotmail.com', 'gmail.com']),
+                  property_name: 'user.email'
+                )
+              ]
+            ),
+            PrefabProto::ConditionalValue.new(value: FALSE_CONFIG)
+          ]
+        )
+      ]
+    )
+
+    @client = new_client(
+      config: [log_level, config_for_sdk, config_not_for_sdk, ff],
+      project_env_id: PROJECT_ENV_ID,
+      collect_evaluation_summaries: true,
+      prefab_config_override_dir: '/tmp',
+      prefab_config_classpath_dir: '/tmp',
+      context_upload_mode: :periodic_example,
+      allow_telemetry_in_local_mode: true
+    )
+  end
+
+  def test_bootstrap
+    result = Prefab::JavaScriptStub.new(@client).bootstrap({})
+
+    assert_equal %(
+window._prefabBootstrap = {
+  configs: {"basic-config":"default_value","feature-flag":false},
+  context: {}
+}
+    ).strip, result.strip
+
+    result = Prefab::JavaScriptStub.new(@client).bootstrap({ user: { email: 'gmail.com' } })
+
+    assert_equal %(
+window._prefabBootstrap = {
+  configs: {"basic-config":"default_value","feature-flag":true},
+  context: {"user":{"email":"gmail.com"}}
+}
+    ).strip, result.strip
+  end
+
+  def test_generate_stub
+    result = Prefab::JavaScriptStub.new(@client).generate_stub({})
+
+    assert_equal %(
+window.prefab = window.prefab || {};
+window.prefab.config = {"basic-config":"default_value","feature-flag":false};
+window.prefab.get = function(key) {
+  return window.prefab.config[key];
+};
+window.prefab.isEnabled = function(key) {
+  return window.prefab.config[key] === true;
+};
+    ).strip, result.strip
+
+    result = Prefab::JavaScriptStub.new(@client).generate_stub({ user: { email: 'gmail.com' } })
+
+    assert_equal %(
+window.prefab = window.prefab || {};
+window.prefab.config = {"basic-config":"default_value","feature-flag":true};
+window.prefab.get = function(key) {
+  return window.prefab.config[key];
+};
+window.prefab.isEnabled = function(key) {
+  return window.prefab.config[key] === true;
+};
+
+    ).strip, result.strip
+  end
+end

data/test/test_sse_config_client.rb

@@ -1,12 +1,15 @@
+# frozen_string_literal: true
+
 require 'test_helper'
+require 'webrick'
 
 class TestSSEConfigClient < Minitest::Test
   def test_client
     sources = [
-      "https://api.staging-prefab.cloud/",
+      'https://api.staging-prefab.cloud/'
     ]
 
-    options = Prefab::Options.new(sources: sources, api_key: ENV['PREFAB_INTEGRATION_TEST_API_KEY'])
+    options = Prefab::Options.new(sources: sources, api_key: ENV.fetch('PREFAB_INTEGRATION_TEST_API_KEY', nil))
 
     config_loader = OpenStruct.new(highwater_mark: 4)
 
@@ -17,7 +20,7 @@ class TestSSEConfigClient < Minitest::Test
     result = nil
 
     # fake our load_configs block
-    client.start do |c, source|
+    client.start do |c, _event, source|
       result = c
       assert_equal :sse, source
     end
@@ -31,35 +34,176 @@ class TestSSEConfigClient < Minitest::Test
 
   def test_failing_over
     sources = [
-      "https://does.not.exist.staging-prefab.cloud/",
-      "https://api.staging-prefab.cloud/",
+      'https://does.not.exist.staging-prefab.cloud/',
+      'https://api.staging-prefab.cloud/'
     ]
 
-    options = Prefab::Options.new(sources: sources, api_key: ENV['PREFAB_INTEGRATION_TEST_API_KEY'])
+    prefab_options = Prefab::Options.new(sources: sources, api_key: ENV.fetch('PREFAB_INTEGRATION_TEST_API_KEY', nil))
 
     config_loader = OpenStruct.new(highwater_mark: 4)
 
-    client = Prefab::SSEConfigClient.new(options, config_loader)
+    sse_options = Prefab::SSEConfigClient::Options.new(seconds_between_new_connection: 0.01, sleep_delay_for_new_connection_check: 0.01)
+
+    client = Prefab::SSEConfigClient.new(prefab_options, config_loader, sse_options)
 
     assert_equal 4, client.headers['x-prefab-start-at-id']
 
     result = nil
 
     # fake our load_configs block
-    client.start do |c, source|
+    client.start do |c, _event, source|
       result = c
       assert_equal :sse, source
     end
 
-    wait_for -> { !result.nil? }, max_wait: 10
+    wait_for -> { !result.nil? }
 
     assert result.configs.size > 30
   ensure
     client.close
 
     assert_logged [
-      /failed to connect: .*https:\/\/does.not.exist/,
-      /HTTP::ConnectionError/,
+      %r{failed to connect: .*https://does.not.exist},
+      /HTTP::ConnectionError/
     ]
   end
+
+  def test_recovering_from_disconnection
+    server, = start_webrick_server(4567, DisconnectingEndpoint)
+
+    config_loader = OpenStruct.new(highwater_mark: 4)
+
+    prefab_options = OpenStruct.new(sse_sources: ['http://localhost:4567'], api_key: 'test')
+    last_event_id = nil
+    client = nil
+
+    begin
+      Thread.new do
+        server.start
+      end
+
+      sse_options = Prefab::SSEConfigClient::Options.new(
+        sse_default_reconnect_time: 0.1
+      )
+      client = Prefab::SSEConfigClient.new(prefab_options, config_loader, sse_options)
+
+      client.start do |_configs, event, _source|
+        last_event_id = event.id.to_i
+      end
+
+      wait_for -> { last_event_id && last_event_id > 1 }
+    ensure
+      client.close
+      server.stop
+
+      refute_nil last_event_id, 'Expected to have received an event'
+      assert last_event_id > 1, 'Expected to have received multiple events (indicating a retry)'
+    end
+  end
+
+  def test_recovering_from_an_error
+    log_output = StringIO.new
+    logger = Logger.new(log_output)
+
+    server, = start_webrick_server(4568, ErroringEndpoint)
+
+    config_loader = OpenStruct.new(highwater_mark: 4)
+
+    prefab_options = OpenStruct.new(sse_sources: ['http://localhost:4568'], api_key: 'test')
+    last_event_id = nil
+    client = nil
+
+    begin
+      Thread.new do
+        server.start
+      end
+
+      sse_options = Prefab::SSEConfigClient::Options.new(
+        sse_default_reconnect_time: 0.1,
+        seconds_between_new_connection: 0.1,
+        sleep_delay_for_new_connection_check: 0.1,
+        errors_to_close_connection: [SSE::Errors::HTTPStatusError]
+      )
+      client = Prefab::SSEConfigClient.new(prefab_options, config_loader, sse_options, logger)
+
+      client.start do |_configs, event, _source|
+        last_event_id = event.id.to_i
+      end
+
+      wait_for -> { last_event_id && last_event_id > 2 }
+    ensure
+      server.stop
+      client.close
+
+      refute_nil last_event_id, 'Expected to have received an event'
+      assert last_event_id > 2, 'Expected to have received multiple events (indicating a reconnect)'
+    end
+
+    log_lines = log_output.string.split("\n")
+
+    assert_match(/SSE Streaming Connect/, log_lines[0])
+    assert_match(/SSE Streaming Error/, log_lines[1], 'Expected to have logged an error. If this starts failing after an ld-eventsource upgrade, you might need to tweak NUMBER_OF_FAILURES below')
+    assert_match(/Closing SSE connection/, log_lines[2])
+    assert_match(/Reconnecting SSE client/, log_lines[3])
+    assert_match(/SSE Streaming Connect/, log_lines[4])
+  end
+
+  def start_webrick_server(port, endpoint_class)
+    log_string = StringIO.new
+    logger = WEBrick::Log.new(log_string)
+    server = WEBrick::HTTPServer.new(Port: port, Logger: logger, AccessLog: [])
+    server.mount '/api/v1/sse/config', endpoint_class
+
+    [server, log_string]
+  end
+
+  module SharedEndpointLogic
+    def event_id
+      @@event_id ||= 0
+      @@event_id += 1
+    end
+
+    def setup_response(response)
+      response.status = 200
+      response['Content-Type'] = 'text/event-stream'
+      response['Cache-Control'] = 'no-cache'
+      response['Connection'] = 'keep-alive'
+
+      response.chunked = false
+    end
+  end
+
+  class DisconnectingEndpoint < WEBrick::HTTPServlet::AbstractServlet
+    include SharedEndpointLogic
+
+    def do_GET(_request, response)
+      setup_response(response)
+
+      output = response.body
+
+      output << "id: #{event_id}\n"
+      output << "event: message\n"
+      output << "data: CmYIu8fh4YaO0x4QZBo0bG9nLWxldmVsLmNsb3VkLnByZWZhYi5zZXJ2ZXIubG9nZ2luZy5FdmVudFByb2Nlc3NvciIfCAESG2phbWVzLmtlYmluZ2VyQHByZWZhYi5jbG91ZDgGSAkSDQhkELvH4eGGjtMeGGU=\n\n"
+    end
+  end
+
+  class ErroringEndpoint < WEBrick::HTTPServlet::AbstractServlet
+    include SharedEndpointLogic
+    NUMBER_OF_FAILURES = 5
+
+    def do_GET(_request, response)
+      setup_response(response)
+
+      output = response.body
+
+      output << "id: #{event_id}\n"
+
+      if event_id < NUMBER_OF_FAILURES
+        raise 'ErroringEndpoint' # This manifests as an SSE::Errors::HTTPStatusError
+      end
+
+      output << "event: message\n"
+      output << "data: CmYIu8fh4YaO0x4QZBo0bG9nLWxldmVsLmNsb3VkLnByZWZhYi5zZXJ2ZXIubG9nZ2luZy5FdmVudFByb2Nlc3NvciIfCAESG2phbWVzLmtlYmluZ2VyQHByZWZhYi5jbG91ZDgGSAkSDQhkELvH4eGGjtMeGGU=\n\n"
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 1.8.2
+  version: 1.8.3
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-03 00:00:00.000000000 Z
+date: 2024-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -128,6 +128,20 @@ dependencies:
     - - "!="
       - !ruby/object:Gem::Version
         version: 4.16.0
+- !ruby/object:Gem::Dependency
+  name: allocation_stats
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
@@ -224,6 +238,7 @@ files:
 - dev/allocation_stats
 - dev/benchmark
 - dev/console
+- dev/script_setup.rb
 - lib/prefab-cloud-ruby.rb
 - lib/prefab/client.rb
 - lib/prefab/config_client.rb
@@ -252,6 +267,7 @@ files:
 - lib/prefab/feature_flag_client.rb
 - lib/prefab/http_connection.rb
 - lib/prefab/internal_logger.rb
+- lib/prefab/javascript_stub.rb
 - lib/prefab/local_config_parser.rb
 - lib/prefab/log_path_aggregator.rb
 - lib/prefab/logger_client.rb
@@ -294,6 +310,7 @@ files:
 - test/test_helper.rb
 - test/test_integration.rb
 - test/test_internal_logger.rb
+- test/test_javascript_stub.rb
 - test/test_local_config_parser.rb
 - test/test_log_path_aggregator.rb
 - test/test_logger.rb