prefab-cloud-ruby 0.23.8 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c8138cec188afa5191aaa81147ecc44736168da22a69bd4ca8cbb3e3328b78f
-  data.tar.gz: 5292a214e2255abd7b3fa8ad5ec924499fb2bf37751e6a53b5cd4f8d6d3855db
+  metadata.gz: 54b6a2d9575b6e75d0fffe8b209e700da2a026ec33125819152fae208e1c489f
+  data.tar.gz: 33b150761861978aacebdb996bf8da37e9000743fab6a64f4ed11ca7dbd64b51
 SHA512:
-  metadata.gz: ec7023b9395b4570f5e9121eaa946a38fa4ef558e30f207e3d1cb84d4185e5d50d08fbe8f73cd5a01447ded89c0e2c8c6df2341d84e5697e55547851d9dcd836
-  data.tar.gz: 9d03d3685767082a9767f0547ee15183003fdcd38664418d21f1b01547f2be88fab4f5a33d338055987d02467c87cf22ac80865c916339dd17065e2bd1290e59
+  metadata.gz: e1be3cf89ba752245325c07e0b04e3db6f4dec5670e08b14e9b53b588b6ea0a1d801a595465a2ae49d83a8f82cdddc316c1434c8a079c3a7ca87c1fce19c191c
+  data.tar.gz: c19b9ff06a9735adab6f320d52be3349e8600773cbcc3fd40b07b3be0f8a0af0329e5ae9fd975978cfb1ff199577943ff7e5b458f5078c5a9f0cf182a2a8a8bd

data/README.md

@@ -5,18 +5,20 @@ Ruby Client for Prefab Feature Flags, Dynamic log levels, and Config as a Servic
 ```ruby
 client = Prefab::Client.new
 
-lookup_key = "user-123"
-identity_attributes = {
-  team_id: 432,
-  user_id: 123,
-  subscription_level: 'pro',
-  email: "alice@example.com"
+context = {
+  user: {
+    team_id: 432,
+    id: 123,
+    subscription_level: 'pro',
+    email: "alice@example.com"
+  }
 }
 
-result = client.enabled? "my-first-feature-flag", lookup_key, identity_attributes
+result = client.enabled? "my-first-feature-flag", context
 
-puts "my-first-feature-flag is: #{result} for #{lookup_key}"
+puts "my-first-feature-flag is: #{result}"
 ```
+
 See full documentation https://docs.prefab.cloud/docs/ruby-sdk/ruby
 
 ## Supports

data/VERSION

@@ -1 +1 @@
-0.23.8
+0.24.0

data/lib/prefab/client.rb

@@ -6,16 +6,8 @@ module Prefab
   class Client
     MAX_SLEEP_SEC = 10
     BASE_SLEEP_SEC = 0.5
-    NO_DEFAULT_PROVIDED = :no_default_provided
 
-    attr_reader :shared_cache
-    attr_reader :stats
-    attr_reader :namespace
-    attr_reader :interceptor
-    attr_reader :api_key
-    attr_reader :prefab_api_url
-    attr_reader :options
-    attr_reader :instance_hash
+    attr_reader :shared_cache, :stats, :namespace, :interceptor, :api_key, :prefab_api_url, :options, :instance_hash
 
     def initialize(options = Prefab::Options.new)
       @options = options.is_a?(Prefab::Options) ? options : Prefab::Options.new(options)
@@ -34,18 +26,23 @@ module Prefab
         @prefab_api_url = @options.prefab_api_url
         log_internal ::Logger::INFO, "Prefab Connecting to: #{@prefab_api_url}"
       end
+
+      context.clear
       # start config client
       config_client
     end
 
-    def with_log_context(lookup_key, properties)
-      Thread.current[:prefab_log_lookup_key] = lookup_key
-      Thread.current[:prefab_log_properties] = properties
+    def with_log_context(_lookup_key, properties, &block)
+      warn '[DEPRECATION] `$prefab.with_log_context` is deprecated.  Please use `with_context` instead.'
+      with_context(properties, &block)
+    end
 
-      yield
-    ensure
-      Thread.current[:prefab_log_lookup_key] = nil
-      Thread.current[:prefab_log_properties] = {}
+    def with_context(properties, &block)
+      Prefab::Context.with_context(properties, &block)
+    end
+
+    def context
+      Prefab::Context.current
     end
 
     def config_client(timeout: 5.0)
@@ -78,19 +75,27 @@ module Prefab
       ActiveStorage.logger = log if defined?(ActiveStorage)
     end
 
+    def on_update(&block)
+      resolver.on_update(&block)
+    end
+
     def log_internal(level, msg, path = nil)
       log.log_internal msg, path, nil, level
     end
 
-    def enabled?(feature_name, lookup_key = nil, attributes = {})
-      feature_flag_client.feature_is_on_for?(feature_name, lookup_key, attributes: attributes)
+    def enabled?(feature_name, lookup_key = NO_DEFAULT_PROVIDED, properties = NO_DEFAULT_PROVIDED)
+      _, properties = handle_positional_arguments(lookup_key, properties, :enabled?)
+
+      feature_flag_client.feature_is_on_for?(feature_name, properties)
     end
 
-    def get(key, default_or_lookup_key = NO_DEFAULT_PROVIDED, properties = {}, ff_default = nil)
+    def get(key, default_or_lookup_key = NO_DEFAULT_PROVIDED, properties = NO_DEFAULT_PROVIDED, ff_default = nil)
+      default, properties = handle_positional_arguments(default_or_lookup_key, properties, :get)
+
       if is_ff?(key)
-        feature_flag_client.get(key, default_or_lookup_key, properties, default: ff_default)
+        feature_flag_client.get(key, properties, default: ff_default)
       else
-        config_client.get(key, default_or_lookup_key, properties)
+        config_client.get(key, default, properties)
       end
     end
 
@@ -98,6 +103,14 @@ module Prefab
       Prefab::HttpConnection.new(@options.prefab_api_url, @api_key).post(path, body)
     end
 
+    def inspect
+      "#<Prefab::Client:#{object_id} namespace=#{namespace}>"
+    end
+
+    def resolver
+      config_client.resolver
+    end
+
     private
 
     def is_ff?(key)
@@ -105,5 +118,26 @@ module Prefab
 
       raw && raw.allowable_values.any?
     end
+
+    # The goal here is to ease transition from the old API to the new one. The
+    # old API had a lookup_key parameter that is deprecated. This method
+    # handles the transition by checking if the first parameter is a string and
+    # if so, it is assumed to be the lookup_key and a deprecation warning is
+    # issued and we know the second argument is the properties. If the first
+    # parameter is a hash, you're on the new API and no further action is
+    # required.
+    def handle_positional_arguments(lookup_key, properties, method)
+      # handle JIT context
+      if lookup_key.is_a?(Hash) && properties == NO_DEFAULT_PROVIDED
+        properties = lookup_key
+        lookup_key = nil
+      end
+
+      if lookup_key.is_a?(String)
+        warn "[DEPRECATION] `$prefab.#{method}`'s lookup_key argument is deprecated. Please use remove it or use context instead."
+      end
+
+      [lookup_key, properties]
+    end
   end
 end

data/lib/prefab/config_client.rb

@@ -41,36 +41,24 @@ module Prefab
       end
     end
 
-    def upsert(key, config_value, namespace = nil, previous_key = nil)
-      raise "Key must not contain ':' set namespaces separately" if key.include? ':'
-      raise "Namespace must not contain ':'" if namespace&.include?(':')
-
-      config_delta = Prefab::ConfigClient.value_to_delta(key, config_value, namespace)
-      upsert_req = Prefab::UpsertRequest.new(config_delta: config_delta)
-      upsert_req.previous_key = previous_key if previous_key&.present?
-
-      @base_client.request Prefab::ConfigService, :upsert, req_options: { timeout: @timeout }, params: upsert_req
-      @base_client.stats.increment('prefab.config.upsert')
-      @config_loader.set(config_delta, :upsert)
-      @config_loader.rm(previous_key) if previous_key&.present?
-      @config_resolver.update
-    end
-
     def to_s
       @config_resolver.to_s
     end
 
+    def resolver
+      @config_resolver
+    end
+
     def self.value_to_delta(key, config_value, namespace = nil)
       Prefab::Config.new(key: [namespace, key].compact.join(':'),
                          rows: [Prefab::ConfigRow.new(value: config_value)])
     end
 
-    def get(key, default = Prefab::Client::NO_DEFAULT_PROVIDED, properties = {}, lookup_key = nil)
-      value = _get(key, lookup_key, properties)
+    def get(key, default = NO_DEFAULT_PROVIDED, properties = NO_DEFAULT_PROVIDED)
+      value = _get(key, properties)
 
       if value
-        lookup = lookup_key == Prefab::Client::NO_DEFAULT_PROVIDED ? nil : lookup_key
-        Prefab::ConfigValueUnwrapper.unwrap(value, key, properties.merge(Prefab::CriteriaEvaluator::LOOKUP_KEY => lookup))
+        Prefab::ConfigValueUnwrapper.unwrap(value, key, properties)
       else
         handle_default(key, default)
       end
@@ -83,14 +71,14 @@ module Prefab
     end
 
     def handle_default(key, default)
-      return default if default != Prefab::Client::NO_DEFAULT_PROVIDED
+      return default if default != NO_DEFAULT_PROVIDED
 
       raise Prefab::Errors::MissingDefaultError, key if @options.on_no_default == Prefab::Options::ON_NO_DEFAULT::RAISE
 
       nil
     end
 
-    def _get(key, lookup_key, properties)
+    def _get(key, properties)
       # wait timeout sec for the initalization to be complete
       @initialized_future.value(@options.initialization_timeout_sec)
       if @initialized_future.incomplete?
@@ -101,9 +89,9 @@ module Prefab
         @base_client.log_internal ::Logger::WARN,
                                   "Couldn't Initialize In #{@options.initialization_timeout_sec}. Key #{key}. Returning what we have"
         @initialization_lock.release_write_lock
-
       end
-      @config_resolver.get(key, lookup_key, properties)
+
+      @config_resolver.get key, properties
     end
 
     def load_checkpoint
@@ -192,8 +180,8 @@ module Prefab
       auth = "#{AUTH_USER}:#{@base_client.api_key}"
       auth_string = Base64.strict_encode64(auth)
       headers = {
-        "x-prefab-start-at-id": start_at_id,
-        "Authorization": "Basic #{auth_string}"
+        '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} start_at #{start_at_id}"

data/lib/prefab/config_resolver.rb

@@ -7,7 +7,6 @@ module Prefab
     def initialize(base_client, config_loader)
       @lock = Concurrent::ReadWriteLock.new
       @local_store = {}
-      @additional_properties = { Prefab::CriteriaEvaluator::NAMESPACE_KEY => base_client.options.namespace }
       @config_loader = config_loader
       @project_env_id = 0 # we don't know this yet, it is set from the API results
       @base_client = base_client
@@ -15,27 +14,11 @@ module Prefab
     end
 
     def to_s
-      str = "\n"
-      @lock.with_read_lock do
-        @local_store.keys.sort.each do |k|
-          v = @local_store[k]
-          elements = [k.slice(0..49).ljust(50)]
-          if v.nil?
-            elements << 'tombstone'
-          else
-            config = evaluate(v[:config], {})
-            value = Prefab::ConfigValueUnwrapper.unwrap(config, k, {})
-            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)
-            elements << "Source: #{v[:source]}"
-          end
-          str += elements.join(' | ') << "\n"
-        end
-      end
-      str
-    rescue StandardError => e
-      "Error printing resolved config: #{e.message}"
+      presenter.to_s
+    end
+
+    def presenter
+      Prefab::ResolvedConfigPresenter.new(self, @lock, @local_store)
     end
 
     def raw(key)
@@ -44,29 +27,46 @@ module Prefab
       via_key ? via_key[:config] : nil
     end
 
-    def get(key, lookup_key, properties = {})
+    def get(key, properties = NO_DEFAULT_PROVIDED)
       @lock.with_read_lock do
         raw_config = raw(key)
 
         return nil unless raw_config
 
-        evaluate(raw(key), lookup_key, properties)
+        evaluate(raw(key), properties)
       end
     end
 
-    def evaluate(config, lookup_key, properties = {})
-      props = properties.merge(@additional_properties).merge(Prefab::CriteriaEvaluator::LOOKUP_KEY => lookup_key)
-
+    def evaluate(config, properties = NO_DEFAULT_PROVIDED)
       Prefab::CriteriaEvaluator.new(config,
-                                    project_env_id: @project_env_id, resolver: self, base_client: @base_client).evaluate(props)
+                                    project_env_id: @project_env_id,
+                                    resolver: self,
+                                    namespace: @base_client.options.namespace,
+                                    base_client: @base_client).evaluate(context(properties))
     end
 
     def update
       make_local
+
+      @on_update ? @on_update.call : nil
+    end
+
+    def on_update(&block)
+      @on_update = block
     end
 
     private
 
+    def context(properties)
+      if properties == NO_DEFAULT_PROVIDED
+        Context.current
+      elsif properties.is_a?(Context)
+        properties
+      else
+        Context.merge_with_current(properties)
+      end
+    end
+
     def make_local
       @lock.with_write_lock do
         @local_store = @config_loader.calc_config

data/lib/prefab/config_value_unwrapper.rb

@@ -2,7 +2,7 @@
 
 module Prefab
   class ConfigValueUnwrapper
-    def self.unwrap(config_value, config_key, properties)
+    def self.unwrap(config_value, config_key, context)
       return nil unless config_value
 
       case config_value.type
@@ -11,10 +11,13 @@ module Prefab
       when :string_list
         config_value.string_list.values
       when :weighted_values
-        lookup_key = properties[Prefab::CriteriaEvaluator::LOOKUP_KEY]
-        weights = config_value.weighted_values.weighted_values
-        value = Prefab::WeightedValueResolver.new(weights, config_key, lookup_key).resolve
-        unwrap(value.value, config_key, properties)
+        value = Prefab::WeightedValueResolver.new(
+          config_value.weighted_values.weighted_values,
+          config_key,
+          context[config_value.weighted_values.hash_by_property_name]
+        ).resolve
+
+        unwrap(value.value, config_key, context)
       else
         raise "Unknown type: #{config_value.type}"
       end

data/lib/prefab/context.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Prefab
+  class Context
+    BLANK_CONTEXT_NAME = ''
+
+    class NamedContext
+      attr_reader :name
+
+      def initialize(name, hash)
+        @hash = {}
+        @name = name.to_s
+
+        merge!(hash)
+      end
+
+      def get(parts)
+        @hash[parts]
+      end
+
+      def merge!(other)
+        @hash = @hash.merge(other.transform_keys(&:to_s))
+      end
+
+      def to_h
+        @hash
+      end
+    end
+
+    THREAD_KEY = :prefab_context
+    attr_reader :contexts
+
+    class << self
+      def current=(context)
+        Thread.current[THREAD_KEY] = context
+      end
+
+      def current
+        Thread.current[THREAD_KEY] ||= new
+      end
+
+      def with_context(context)
+        old_context = Thread.current[THREAD_KEY]
+        Thread.current[THREAD_KEY] = new(context)
+        yield
+      ensure
+        Thread.current[THREAD_KEY] = old_context
+      end
+
+      def clear_current
+        Thread.current[THREAD_KEY] = nil
+      end
+
+      def merge_with_current(new_context_properties = {})
+        new(current.to_h.merge(new_context_properties))
+      end
+    end
+
+    def initialize(context = {})
+      @contexts = {}
+
+      if context.is_a?(NamedContext)
+        @contexts[context.name] = context
+      elsif context.is_a?(Hash)
+        context.map do |name, values|
+          if values.is_a?(Hash)
+            @contexts[name.to_s] = NamedContext.new(name, values)
+          else
+            warn '[DEPRECATION] Prefab contexts should be a hash with a key of the context name and a value of a hash.'
+
+            @contexts[BLANK_CONTEXT_NAME] ||= NamedContext.new(BLANK_CONTEXT_NAME, {})
+            @contexts[BLANK_CONTEXT_NAME].merge!({ name => values })
+          end
+        end
+      else
+        raise ArgumentError, 'must be a Hash or a NamedContext'
+      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)
+
+      if key.nil?
+        name = BLANK_CONTEXT_NAME
+        key = property_key
+      end
+
+      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
+
+    def clear
+      @contexts = {}
+    end
+
+    def context(name)
+      contexts[name.to_s] || NamedContext.new(name, {})
+    end
+  end
+end

data/lib/prefab/criteria_evaluator.rb

@@ -2,27 +2,24 @@
 
 module Prefab
   class CriteriaEvaluator
-    LOOKUP_KEY = 'LOOKUP'
     NAMESPACE_KEY = 'NAMESPACE'
     NO_MATCHING_ROWS = [].freeze
 
-    def initialize(config, project_env_id:, resolver:, base_client:)
+    def initialize(config, project_env_id:, resolver:, namespace:, base_client:)
       @config = config
       @project_env_id = project_env_id
       @resolver = resolver
+      @namespace = namespace
       @base_client = base_client
     end
 
     def evaluate(properties)
-      # TODO: optimize this and perhaps do it elsewhere
-      props = properties.transform_keys(&:to_s)
-
       matching_environment_row_values.each do |conditional_value|
-        return conditional_value.value if all_criteria_match?(conditional_value, props)
+        return conditional_value.value if all_criteria_match?(conditional_value, properties)
       end
 
       default_row_values.each do |conditional_value|
-        return conditional_value.value if all_criteria_match?(conditional_value, props)
+        return conditional_value.value if all_criteria_match?(conditional_value, properties)
       end
 
       nil
@@ -35,17 +32,22 @@ module Prefab
     end
 
     def evaluate_criteron(criterion, properties)
-      value_from_properties = properties[criterion.property_name]
+      case criterion.operator
+      when :IN_SEG
+        return in_segment?(criterion, properties)
+      when :NOT_IN_SEG
+        return !in_segment?(criterion, properties)
+      when :ALWAYS_TRUE
+        return true
+      end
+
+      value_from_properties = criterion.property_name === NAMESPACE_KEY ? @namespace : properties.get(criterion.property_name)
 
       case criterion.operator
-      when :LOOKUP_KEY_IN, :PROP_IS_ONE_OF
+      when :PROP_IS_ONE_OF
         matches?(criterion, value_from_properties, properties)
-      when :LOOKUP_KEY_NOT_IN, :PROP_IS_NOT_ONE_OF
+      when :PROP_IS_NOT_ONE_OF
         !matches?(criterion, value_from_properties, properties)
-      when :IN_SEG
-        in_segment?(criterion, properties)
-      when :NOT_IN_SEG
-        !in_segment?(criterion, properties)
       when :PROP_ENDS_WITH_ONE_OF
         return false unless value_from_properties
 
@@ -60,8 +62,6 @@ module Prefab
         end
       when :HIERARCHICAL_MATCH
         value_from_properties.start_with?(criterion.value_to_match.string)
-      when :ALWAYS_TRUE
-        true
       else
         @base_client.log.info("Unknown Operator: #{criterion.operator}")
         false
@@ -79,7 +79,13 @@ module Prefab
     end
 
     def in_segment?(criterion, properties)
-      @resolver.get(criterion.value_to_match.string, properties[LOOKUP_KEY], properties).bool
+      segment = @resolver.get(criterion.value_to_match.string, properties)
+
+      if !segment
+        @base_client.log.info( "Segment #{criterion.value_to_match.string} not found")
+      end
+
+      segment&.bool
     end
 
     def matches?(criterion, value_from_properties, properties)

data/lib/prefab/feature_flag_client.rb

@@ -7,27 +7,27 @@ module Prefab
     end
 
     def feature_is_on?(feature_name)
-      feature_is_on_for?(feature_name, nil)
+      feature_is_on_for?(feature_name, {})
     end
 
-    def feature_is_on_for?(feature_name, lookup_key, attributes: {})
+    def feature_is_on_for?(feature_name, properties)
       @base_client.stats.increment('prefab.featureflag.on', tags: ["feature:#{feature_name}"])
 
-      variant = @base_client.config_client.get(feature_name, false, attributes, lookup_key)
+      variant = @base_client.config_client.get(feature_name, false, properties)
 
       is_on?(variant)
     end
 
-    def get(feature_name, lookup_key = nil, attributes = {}, default: false)
-      value = _get(feature_name, lookup_key, attributes)
+    def get(feature_name, properties, default: false)
+      value = _get(feature_name, properties)
 
       value.nil? ? default : value
     end
 
     private
 
-    def _get(feature_name, lookup_key = nil, attributes = {})
-      @base_client.config_client.get(feature_name, nil, attributes, lookup_key)
+    def _get(feature_name, properties)
+      @base_client.config_client.get(feature_name, nil, properties)
     end
 
     def is_on?(variant)

data/lib/prefab/local_config_parser.rb

@@ -60,14 +60,7 @@ module Prefab
           values: [
             Prefab::ConditionalValue.new(
               criteria: [criterion].compact,
-              value: Prefab::ConfigValue.new(
-                weighted_values: Prefab::WeightedValues.new(weighted_values: [
-                                                              Prefab::WeightedValue.new(
-                                                                weight: 1000,
-                                                                value: variant
-                                                              )
-                                                            ])
-              )
+              value: variant
             )
           ]
         )
@@ -88,18 +81,10 @@ module Prefab
 
       def parse_criterion(criterion)
         Prefab::Criterion.new(operator: criterion['operator'],
-                              property_name: parse_property(criterion),
+                              property_name: criterion['property'],
                               value_to_match: parse_value_to_match(criterion['values']))
       end
 
-      def parse_property(criterion)
-        if criterion['operator'] == 'LOOKUP_KEY_IN'
-          Prefab::CriteriaEvaluator::LOOKUP_KEY
-        else
-          criterion['property']
-        end
-      end
-
       def parse_value_to_match(values)
         raise "Can't handle #{values}" unless values.instance_of?(Array)
 

data/lib/prefab/logger_client.rb

@@ -135,20 +135,17 @@ module Prefab
 
     # Find the closest match to 'log_level.path' in config
     def level_of(path)
-      properties = Thread.current[:prefab_log_properties] || {}
-      lookup_key = Thread.current[:prefab_log_lookup_key] || nil
-
       closest_log_level_match = nil
 
       path.split(SEP).each_with_object([BASE_KEY]) do |n, memo|
         memo << n
-        val = @config_client.get(memo.join(SEP), NO_DEFAULT, properties, lookup_key)
+        val = @config_client.get(memo.join(SEP), NO_DEFAULT)
         closest_log_level_match = val unless val.nil?
       end
 
       if closest_log_level_match.nil?
         # get the top-level setting or default to WARN
-        closest_log_level_match = @config_client.get(BASE_KEY, :WARN, properties, lookup_key)
+        closest_log_level_match = @config_client.get(BASE_KEY, :WARN)
       end
 
       closest_log_level_match_int = Prefab::LogLevel.resolve(closest_log_level_match)
@@ -177,7 +174,7 @@ module Prefab
   # StubConfigClient to be used while config client initializes
   # since it may log
   class BootstrappingConfigClient
-    def get(_key, default = nil, _properties = {}, _lookup_key = nil)
+    def get(_key, default = nil, _properties = {})
       ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'] ? ENV['PREFAB_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'].upcase.to_sym : default
     end
   end