prefab-cloud-ruby 0.24.1 → 0.24.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b54e4d5e0b52064cc19b41e33d9c7552cc8534bcab59cc42b48e4fc77fd5b58
-  data.tar.gz: bd6901fcb99e35fc859ae382fb7d0354c1cd484fb75a1dbba27d0d0e07cdb397
+  metadata.gz: 29a3d9257f166fad534f81a44879cd82abc0cdd729714ab6feb2423d7b913a4d
+  data.tar.gz: b11f8e29260760dd64a78f26c016bd936fe0a5e75100329c645915bddd094ebc
 SHA512:
-  metadata.gz: 96249d926438ccf2b4c239ae3b65a3649bb8b8e279e05774431376188b9ee330e71211f52bb7a51d5edf457be1997bfb5609e2a91debde4a2719f9ff4f34ae4a
-  data.tar.gz: fd42fd6be60e9572eb5a857253eabbb44693d46927ecef0b57ed72213c1af875511c4b2ad86bd5e7257e75ac063bde78a49f03f62a0d0350348d18d696d4a59d
+  metadata.gz: f74cda2cf6f657f72c15d118d9fb622d24d049261436691bff28e42ad5656beb53ec192e148e30e0f025a5becb094682fc68f4860c2cf5b3ed351b7954e3b587
+  data.tar.gz: 90125b61cd874c12376eecc726aa2fef0d6158565150830f95f642f97fad849b53570238593ce617dc39b05960abb47d4c2e6cd4a974e30c69fc40ec2720958b

data/README.md

@@ -41,7 +41,7 @@ $prefab.set_rails_loggers
 ```ruby
 #puma.rb
 on_worker_boot do
-  $prefab = Prefab::Client.new
+  $prefab = $prefab.fork
   $prefab.set_rails_loggers
 end
 ```
@@ -49,7 +49,7 @@ end
 ```ruby
 # unicorn.rb
 after_fork do |server, worker|
-  $prefab = Prefab::Client.new(options)
+  $prefab = $prefab.fork
   $prefab.set_rails_loggers
 end
 ```

data/VERSION

@@ -1 +1 @@
-0.24.1
+0.24.3

data/lib/prefab/client.rb

@@ -111,6 +111,15 @@ module Prefab
       config_client.resolver
     end
 
+    # When starting a forked process, use this to re-use the options
+    # on_worker_boot do
+    #   $prefab = $prefab.fork
+    #   $prefab.set_rails_loggers
+    # end
+    def fork
+      Prefab::Client.new(@options)
+    end
+
     private
 
     def is_ff?(key)

data/lib/prefab/config_client.rb

@@ -55,10 +55,11 @@ module Prefab
     end
 
     def get(key, default = NO_DEFAULT_PROVIDED, properties = NO_DEFAULT_PROVIDED)
-      value = _get(key, properties)
+      context = @config_resolver.make_context(properties)
+      value = _get(key, context)
 
       if value
-        Prefab::ConfigValueUnwrapper.unwrap(value, key, properties)
+        Prefab::ConfigValueUnwrapper.unwrap(value, key, context)
       else
         handle_default(key, default)
       end

data/lib/prefab/config_resolver.rb

@@ -42,7 +42,7 @@ module Prefab
                                     project_env_id: @project_env_id,
                                     resolver: self,
                                     namespace: @base_client.options.namespace,
-                                    base_client: @base_client).evaluate(context(properties))
+                                    base_client: @base_client).evaluate(make_context(properties))
     end
 
     def update
@@ -55,9 +55,7 @@ module Prefab
       @on_update = block
     end
 
-    private
-
-    def context(properties)
+    def make_context(properties)
       if properties == NO_DEFAULT_PROVIDED
         Context.current
       elsif properties.is_a?(Context)
@@ -67,6 +65,8 @@ module Prefab
       end
     end
 
+    private
+
     def make_local
       @lock.with_write_lock do
         @local_store = @config_loader.calc_config

data/lib/prefab/config_value_unwrapper.rb

@@ -14,7 +14,7 @@ module Prefab
         value = Prefab::WeightedValueResolver.new(
           config_value.weighted_values.weighted_values,
           config_key,
-          context[config_value.weighted_values.hash_by_property_name]
+          context.get(config_value.weighted_values.hash_by_property_name)
         ).resolve
 
         unwrap(value.value, config_key, context)

data/lib/prefab/context.rb

@@ -77,18 +77,10 @@ module Prefab
       end
     end
 
-    def merge!(name, hash)
-      @contexts[name.to_s] = context(name).merge!(hash)
-    end
-
     def set(name, hash)
       @contexts[name.to_s] = NamedContext.new(name, hash)
     end
 
-    def []=(name, hash)
-      set(name, hash)
-    end
-
     def get(property_key)
       name, key = property_key.split('.', 2)
 
@@ -100,10 +92,6 @@ module Prefab
       contexts[name] && contexts[name].get(key)
     end
 
-    def [](property_key)
-      get(property_key)
-    end
-
     def to_h
       contexts.map { |name, context| [name, context.to_h] }.to_h
     end

data/lib/prefab/logger_client.rb

@@ -53,8 +53,9 @@ module Prefab
 
       return true if @logdev.nil? || severity < level_of(path) || @silences[local_log_id]
 
-      progname = "#{path}: #{progname || @progname}"
-
+      if progname.nil?
+        progname = @progname
+      end
       if message.nil?
         if block_given?
           message = yield
@@ -65,7 +66,7 @@ module Prefab
       end
 
       @logdev.write(
-        format_message(format_severity(severity), Time.now, progname, message)
+        format_message(format_severity(severity), Time.now, progname, message, path)
       )
       true
     end
@@ -169,6 +170,20 @@ module Prefab
       path.slice! SEP
       path
     end
+
+    def format_message(severity, datetime, progname, msg, path)
+      formatter = (@formatter || @default_formatter)
+
+      if formatter.arity == 5
+        formatter.call(severity, datetime, progname, msg, path)
+      else
+        formatter.call(severity, datetime, join_path_and_progname(path, progname), msg)
+      end
+    end
+
+    def join_path_and_progname(path, progname)
+      (progname.nil? || progname.empty?) ? path : "#{progname}: #{path}"
+    end
   end
 
   # StubConfigClient to be used while config client initializes

data/lib/prefab/options.rb

@@ -21,6 +21,15 @@ module Prefab
     DEFAULT_LOG_FORMATTER = proc { |severity, datetime, progname, msg|
       "#{severity.ljust(5)} #{datetime}:#{' ' if progname}#{progname} #{msg}\n"
     }
+    JSON_LOG_FORMATTER = proc { |severity, datetime, progname, msg, path|
+      {
+        type: severity,
+        time: datetime,
+        progname: progname,
+        message: msg,
+        path: path
+      }.compact.to_json << "\n"
+    }
 
     module ON_INITIALIZATION_FAILURE
       RAISE = 1

data/lib/prefab/resolved_config_presenter.rb

@@ -45,7 +45,7 @@ module Prefab
               hash[k] = ConfigRow.new(k, nil, nil, nil)
             else
               config = @resolver.evaluate(v[:config])
-              value = Prefab::ConfigValueUnwrapper.unwrap(config, k, {})
+              value = Prefab::ConfigValueUnwrapper.unwrap(config, k, Prefab::Context.new)
               hash[k] = ConfigRow.new(k, value, v[:match], v[:source])
             end
           end
@@ -67,7 +67,7 @@ module Prefab
               elements << 'tombstone'
             else
               config = @resolver.evaluate(v[:config], {})
-              value = Prefab::ConfigValueUnwrapper.unwrap(config, k, {})
+              value = Prefab::ConfigValueUnwrapper.unwrap(config, k, Prefab::Context.new)
               elements << value.to_s.slice(0..34).ljust(35)
               elements << value.class.to_s.slice(0..6).ljust(7)
               elements << "Match: #{v[:match]}".slice(0..29).ljust(30)

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.24.1 ruby lib
+# stub: prefab-cloud-ruby 0.24.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "prefab-cloud-ruby".freeze
-  s.version = "0.24.1"
+  s.version = "0.24.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 = "2023-04-26"
+  s.date = "2023-05-15"
   s.description = "Feature Flags, Live Config, and Dynamic Log Levels as a service".freeze
   s.email = "jdwyer@prefab.cloud".freeze
   s.extra_rdoc_files = [

data/test/integration_test.rb

@@ -12,7 +12,9 @@ class IntegrationTest
   end
 
   def test_type
-    if @expected[:status] == 'raise'
+    if @input[0] && @input[0].start_with?('log-level.')
+      :log_level
+    elsif @expected[:status] == 'raise'
       :raise
     elsif @expected[:value].nil?
       :nil

data/test/test_config_value_unwrapper.rb

@@ -4,45 +4,46 @@ require 'test_helper'
 
 class TestConfigValueUnwrapper < Minitest::Test
   CONFIG_KEY = 'config_key'
+  EMPTY_CONTEXT = Prefab::Context.new()
 
   def test_unwrapping_int
     config_value = Prefab::ConfigValue.new(int: 123)
-    assert_equal 123, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, {})
+    assert_equal 123, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_string
     config_value = Prefab::ConfigValue.new(string: 'abc')
-    assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, {})
+    assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_double
     config_value = Prefab::ConfigValue.new(double: 1.23)
-    assert_equal 1.23, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, {})
+    assert_equal 1.23, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_bool
     config_value = Prefab::ConfigValue.new(bool: true)
-    assert_equal true, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, {})
+    assert_equal true, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
 
     config_value = Prefab::ConfigValue.new(bool: false)
-    assert_equal false, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, {})
+    assert_equal false, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_log_level
     config_value = Prefab::ConfigValue.new(log_level: :INFO)
-    assert_equal :INFO, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, {})
+    assert_equal :INFO, Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_string_list
     config_value = Prefab::ConfigValue.new(string_list: Prefab::StringList.new(values: %w[a b c]))
-    assert_equal %w[a b c], Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, {})
+    assert_equal %w[a b c], Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
   end
 
   def test_unwrapping_weighted_values
     # single value
     config_value = Prefab::ConfigValue.new(weighted_values: weighted_values([['abc', 1]]))
 
-    assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, {})
+    assert_equal 'abc', Prefab::ConfigValueUnwrapper.unwrap(config_value, CONFIG_KEY, EMPTY_CONTEXT)
 
     # multiple values, evenly distributed
     config_value = Prefab::ConfigValue.new(weighted_values: weighted_values([['abc', 1], ['def', 1], ['ghi', 1]]))

data/test/test_context.rb

@@ -86,7 +86,7 @@ class TestContext < Minitest::Test
     Prefab::Context.with_context(EXAMPLE_PROPERTIES) do
       context = Prefab::Context.current
       assert_equal(stringify(EXAMPLE_PROPERTIES), context.to_h)
-      assert_equal('some-user-key', context['user.key'])
+      assert_equal('some-user-key', context.get('user.key'))
     end
   end
 
@@ -105,34 +105,24 @@ class TestContext < Minitest::Test
   def test_setting
     context = Prefab::Context.new({})
     context.set('user', { key: 'value' })
-    context[:other] = { key: 'different', something: 'other' }
+    context.set(:other, { key: 'different', something: 'other' })
     assert_equal(stringify({ user: { key: 'value' }, other: { key: 'different', something: 'other' } }), context.to_h)
   end
 
   def test_getting
     context = Prefab::Context.new(EXAMPLE_PROPERTIES)
     assert_equal('some-user-key', context.get('user.key'))
-    assert_equal('some-user-key', context['user.key'])
     assert_equal('pro', context.get('team.plan'))
-    assert_equal('pro', context['team.plan'])
   end
 
   def test_dot_notation_getting
     context = Prefab::Context.new({ 'user' => { 'key' => 'value' } })
     assert_equal('value', context.get('user.key'))
-    assert_equal('value', context['user.key'])
   end
 
   def test_dot_notation_getting_with_symbols
     context = Prefab::Context.new({ user: { key: 'value' } })
     assert_equal('value', context.get('user.key'))
-    assert_equal('value', context['user.key'])
-  end
-
-  def test_merge
-    context = Prefab::Context.new(EXAMPLE_PROPERTIES)
-    context.merge!(:other, { key: 'different' })
-    assert_equal(stringify(EXAMPLE_PROPERTIES.merge(other: { key: 'different' })), context.to_h)
   end
 
   def test_clear

data/test/test_integration.rb

@@ -13,7 +13,7 @@ class TestIntegration < Minitest::Test
       parent_context = test['context']
 
       test['cases'].each do |test_case|
-        define_method(:"test_#{test_case['name']}") do
+        define_method(:"test_#{test['name']}_#{test_case['name']}") do
           it = IntegrationTest.new(test_case)
 
           with_parent_context_maybe(parent_context) do
@@ -30,6 +30,10 @@ class TestIntegration < Minitest::Test
               assert_equal it.expected[:value], it.test_client.send(it.func, flag, context)
             when :simple_equality
               assert_equal it.expected[:value], it.test_client.send(it.func, *it.input)
+            when :log_level
+              assert_equal it.expected[:value].to_sym, it.test_client.send(it.func, *it.input)
+            else
+              raise "Unknown test type: #{it.test_type}"
             end
           end
         end

data/test/test_logger.rb

@@ -85,46 +85,47 @@ class TestLogger < Minitest::Test
   end
 
   def test_log_internal
-    logger, mock_logdev = mock_logger_expecting(/W, \[.*\]  WARN -- cloud.prefab.client.test.path: : test message/)
-    logger.log_internal('test message', 'test.path', '', ::Logger::WARN)
-    mock_logdev.verify
+    prefab, io = captured_logger
+    prefab.log.log_internal('test message', 'test.path', '', ::Logger::WARN)
+    assert_logged io, 'WARN', "cloud.prefab.client.test.path", "test message"
   end
 
   def test_log_internal_unknown
-    logger, mock_logdev = mock_logger_expecting(/A, \[.*\]   ANY -- cloud.prefab.client.test.path: : test message/)
-    logger.log_internal('test message', 'test.path', '', ::Logger::UNKNOWN)
-    mock_logdev.verify
+    prefab, io = captured_logger
+    prefab.log.log_internal('test message', 'test.path', '', ::Logger::UNKNOWN)
+    assert_logged io, 'ANY', "cloud.prefab.client.test.path", "test message"
   end
 
   def test_log_internal_silencing
-    logger, mock_logdev = mock_logger_expecting(/W, \[.*\]  WARN -- cloud.prefab.client.test.path: : should log/,
-                                                calls: 2)
-    logger.silence do
-      logger.log_internal('should not log', 'test.path', '', ::Logger::WARN)
+    prefab, io = captured_logger
+    prefab.log.silence do
+      prefab.log.log_internal('should not log', 'test.path', '', ::Logger::WARN)
     end
-    logger.log_internal('should log', 'test.path', '', ::Logger::WARN)
-    mock_logdev.verify
+    prefab.log.log_internal('should log', 'test.path', '', ::Logger::WARN)
+    assert_logged io, 'WARN', "cloud.prefab.client.test.path", "should log"
+    refute_logged io, 'should not log'
   end
 
   def test_log
-    logger, mock_logdev = mock_logger_expecting(/W, \[.*\]  WARN -- test.path: : test message/)
-    logger.log('test message', 'test.path', '', ::Logger::WARN)
-    mock_logdev.verify
+    prefab, io = captured_logger
+    prefab.log.log('test message', 'test.path', '', ::Logger::WARN)
+    assert_logged io, 'WARN', "test.path", "test message"
   end
 
   def test_log_unknown
-    logger, mock_logdev = mock_logger_expecting(/A, \[.*\]   ANY -- test.path: : test message/)
-    logger.log('test message', 'test.path', '', ::Logger::UNKNOWN)
-    mock_logdev.verify
+    prefab, io = captured_logger
+    prefab.log.log('test message', 'test.path', '', ::Logger::UNKNOWN)
+    assert_logged io, 'ANY', "test.path", "test message"
   end
 
   def test_log_silencing
-    logger, mock_logdev = mock_logger_expecting(/W, \[.*\]  WARN -- test.path: : should log/, calls: 2)
-    logger.silence do
-      logger.log('should not log', 'test.path', '', ::Logger::WARN)
+    prefab, io = captured_logger
+    prefab.log.silence do
+      prefab.log.log('should not log', 'test.path', '', ::Logger::WARN)
     end
-    logger.log('should log', 'test.path', '', ::Logger::WARN)
-    mock_logdev.verify
+    prefab.log.log('should log', 'test.path', '', ::Logger::WARN)
+    assert_logged io, 'WARN', "test.path", "should log"
+    refute_logged io, 'should not log'
   end
 
   def test_logging_with_prefix
@@ -163,7 +164,7 @@ class TestLogger < Minitest::Test
     prefab.log.progname = 'MY_PROGNAME'
     prefab.log.error message
 
-    assert_logged io, 'ERROR', 'MY_PROGNAME test.test_logger.test_logging_with_a_progname', message
+    assert_logged io, 'ERROR', 'MY_PROGNAME: test.test_logger.test_logging_with_a_progname', message
   end
 
   def test_logging_with_a_progname_and_no_message
@@ -172,7 +173,7 @@ class TestLogger < Minitest::Test
     prefab.log.progname = 'MY_PROGNAME'
     prefab.log.error
 
-    assert_logged io, 'ERROR', 'MY_PROGNAME test.test_logger.test_logging_with_a_progname_and_no_message', 'MY_PROGNAME'
+    assert_logged io, 'ERROR', 'MY_PROGNAME: test.test_logger.test_logging_with_a_progname_and_no_message', 'MY_PROGNAME'
   end
 
   def test_logging_with_criteria_on_top_level_key
@@ -399,35 +400,19 @@ class TestLogger < Minitest::Test
       raise 'THIS WILL NEVER BE EVALUATED'
     end
 
-    assert_logged io, 'ERROR', 'test.test_logger.test_logging_with_a_block', ' ' + message
+    assert_logged io, 'ERROR', 'test.test_logger.test_logging_with_a_block', message
   end
 
   private
 
   def assert_logged(logged_io, level, path, message)
-    assert_match(/#{level}\s+\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-+]?\d+:\s+#{path}: #{message}\n/, logged_io.string)
+    assert_match(/#{level}\s+\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-+]?\d+:\s+#{path} #{message}\n/, logged_io.string)
   end
 
   def refute_logged(logged_io, message)
     refute_match(/#{message}/, logged_io.string)
   end
 
-  def mock_logger_expecting(pattern, configs = {}, calls: 1)
-    mock_logdev = Minitest::Mock.new
-    mock_logdev.expect :write, nil do |arg|
-      pattern.match(arg)
-    end
-
-    calls.times.each do
-      mock_logdev.expect(:nil?, false)
-    end
-
-    logger = Prefab::LoggerClient.new($stdout)
-    logger.instance_variable_set('@logdev', mock_logdev)
-    logger.set_config_client(MockConfigClient.new(configs))
-    [logger, mock_logdev]
-  end
-
   def captured_logger(options = {})
     io = StringIO.new
     options = Prefab::Options.new(**options.merge(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prefab-cloud-ruby
 version: !ruby/object:Gem::Version
-  version: 0.24.1
+  version: 0.24.3
 platform: ruby
 authors:
 - Jeff Dwyer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-26 00:00:00.000000000 Z
+date: 2023-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby