prefab-cloud-ruby 0.24.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf743673dab06e2777321f7fb867417478a383864dd6b982860abbb21375450b
-  data.tar.gz: 47a0ba475095d9e773fafc684efc43bc4ac05bc9ec318b70ee321cf2c6b59428
+  metadata.gz: 318e4b03e0089cfe68fa20b00e3c400c1005b739f63ed4183b071418342e4bbe
+  data.tar.gz: 46e467acdeb1dea78cc2e5c97031c952fa6c2caf9be235a217d9341f54505389
 SHA512:
-  metadata.gz: 5ce8f48e9c4584a34deead09528e1b90cd33a3e80994433d999abb32ccfd31eae7883eedf18b99d8351c55cf00e1e1dc7ef6f0b5a7d45819b300f573ff068533
-  data.tar.gz: 416c9f5271b62cef7469db992dde3238c982d15f442f22d3c273c5dfe07935caa1777c26684c98b5ed3c92a67cb41bb10fb9b00d188d4cecaa34507b425fdbb4
+  metadata.gz: fac2499f7fc5f4ba46eb6bb0f8a8671ac6fa8412600e8f3fbdeb61db68b60f491def31bd7faf1ee78711644ff4e1c253386c54e08d40f075404ab0b22d5977db
+  data.tar.gz: 9b112dcdbe22b2cadc6c20e5d10df94b1f1e269f49e3a12ada73550294a55154db098cc3662c5e25f2d569111b870f09df6abf2fc7af1cbc447983b3b3378bce

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 1.0.0 - 2023-08-10
+
+- Removed EvaluatedKeysAggregator (#137)
+- Change `collect_evaluation_summaries` default to true (#136)
+- Removed some backwards compatibility shims (#133)
+- Standardizing options (#132)
+  - Note that the default value for `context_upload_mode` is `:periodic_example` which means example contexts will be collected.
+    This enables easy variant override assignment in our UI. More at https://prefab.cloud/blog/feature-flag-variant-assignment/
+
+## 0.24.6 - 2023-07-31
+
+- Logger Client compatibility (#129)
+- Replace EvaluatedConfigs with ExampleContexts (#128)
+- Add ConfigEvaluationSummaries (opt-in for now) (#123)
+
 ## 0.24.5 - 2023-07-10
 
 - Report Client Version (#121)

data/VERSION

@@ -1 +1 @@
-0.24.5
+1.0.0

data/compile_protos.sh

@@ -1,7 +1,14 @@
 #!/usr/bin/env bash
 
+set -e
+
 gem install grpc-tools
 
+(
+  cd ../prefab-cloud
+  git pull --rebase
+)
+
 grpc_tools_ruby_protoc -I ../prefab-cloud/ --ruby_out=lib --grpc_out=lib prefab.proto
 
 gsed -i 's/^module Prefab$/module PrefabProto/g' lib/prefab_pb.rb

data/lib/prefab/client.rb

@@ -7,12 +7,10 @@ module Prefab
     MAX_SLEEP_SEC = 10
     BASE_SLEEP_SEC = 0.5
 
-    attr_reader :shared_cache, :stats, :namespace, :interceptor, :api_key, :prefab_api_url, :options, :instance_hash
+    attr_reader :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)
-      @shared_cache = @options.shared_cache
-      @stats = @options.stats
       @namespace = @options.namespace
       @stubs = {}
       @instance_hash = UUID.new.generate
@@ -32,11 +30,6 @@ module Prefab
       config_client
     end
 
-    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
-
     def with_context(properties, &block)
       Prefab::Context.with_context(properties, &block)
     end
@@ -73,18 +66,24 @@ module Prefab
                                                                sync_interval: @options.collect_sync_interval)
     end
 
-    def evaluated_keys_aggregator
-      return nil if @options.collect_max_keys <= 0
+    def example_contexts_aggregator
+      return nil if @options.collect_max_example_contexts <= 0
 
-      @evaluated_keys_aggregator ||= EvaluatedKeysAggregator.new(client: self, max_keys: @options.collect_max_keys,
-                                                                 sync_interval: @options.collect_sync_interval)
+      @example_contexts_aggregator ||= ExampleContextsAggregator.new(
+        client: self,
+        max_contexts: @options.collect_max_example_contexts,
+        sync_interval: @options.collect_sync_interval
+      )
     end
 
-    def evaluated_configs_aggregator
-      return nil if @options.collect_max_evaluations <= 0
+    def evaluation_summary_aggregator
+      return nil if @options.collect_max_evaluation_summaries <= 0
 
-      @evaluated_configs_aggregator ||= EvaluatedConfigsAggregator.new(client: self, max_configs: @options.collect_max_evaluations,
-                                                                       sync_interval: @options.collect_sync_interval)
+      @evaluation_summary_aggregator ||= EvaluationSummaryAggregator.new(
+        client: self,
+        max_keys: @options.collect_max_evaluation_summaries,
+        sync_interval: @options.collect_sync_interval
+      )
     end
 
     def set_rails_loggers
@@ -104,19 +103,15 @@ module Prefab
       log.log_internal msg, path, nil, level
     end
 
-    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)
+    def enabled?(feature_name, jit_context = NO_DEFAULT_PROVIDED)
+      feature_flag_client.feature_is_on_for?(feature_name, jit_context)
     end
 
-    def get(key, default_or_lookup_key = NO_DEFAULT_PROVIDED, properties = NO_DEFAULT_PROVIDED, ff_default = nil)
+    def get(key, default = NO_DEFAULT_PROVIDED, jit_context = NO_DEFAULT_PROVIDED)
       if is_ff?(key)
-        default, properties = handle_positional_arguments(default_or_lookup_key, properties, :get)
-
-        feature_flag_client.get(key, properties, default: ff_default)
+        feature_flag_client.get(key, jit_context, default: default)
       else
-        config_client.get(key, default_or_lookup_key, properties)
+        config_client.get(key, default, jit_context)
       end
     end
 
@@ -148,26 +143,5 @@ 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 remove it or use context instead."
-      end
-
-      [lookup_key, properties]
-    end
   end
 end

data/lib/prefab/config_client.rb

@@ -58,18 +58,16 @@ module Prefab
     def get(key, default = NO_DEFAULT_PROVIDED, properties = NO_DEFAULT_PROVIDED)
       context = @config_resolver.make_context(properties)
 
-      value = _get(key, context)
+      if !context.blank? && @base_client.example_contexts_aggregator
+        @base_client.example_contexts_aggregator.record(context)
+      end
 
-      @base_client.context_shape_aggregator&.push(context)
-      @base_client.evaluated_keys_aggregator&.push(key)
+      evaluation = _get(key, context)
 
-      if value
-        # NOTE: we don't &.push here because some of the args aren't already available
-        if @base_client.evaluated_configs_aggregator && key != Prefab::LoggerClient::BASE_KEY && !key.start_with?(LOGGING_KEY_PREFIX)
-          @base_client.evaluated_configs_aggregator.push([raw(key), value, context])
-        end
+      @base_client.context_shape_aggregator&.push(context)
 
-        Prefab::ConfigValueUnwrapper.unwrap(value, key, context)
+      if evaluation
+        evaluation.report_and_return(@base_client.evaluation_summary_aggregator)
       else
         handle_default(key, default)
       end
@@ -90,7 +88,7 @@ module Prefab
     end
 
     def _get(key, properties)
-      # wait timeout sec for the initalization to be complete
+      # wait timeout sec for the initialization to be complete
       @initialized_future.value(@options.initialization_timeout_sec)
       if @initialized_future.incomplete?
         unless @options.on_init_failure == Prefab::Options::ON_INITIALIZATION_FAILURE::RETURN
@@ -158,7 +156,6 @@ module Prefab
         @base_client.log_internal ::Logger::DEBUG,
                                   "Checkpoint with highwater id #{@config_loader.highwater_mark} from #{source}. No changes.", 'load_configs'
       end
-      @base_client.stats.increment('prefab.config.checkpoint.load')
       @config_resolver.update
       finish_init!(source)
     end
@@ -183,7 +180,7 @@ module Prefab
 
       @base_client.log_internal ::Logger::INFO, "Unlocked Config via #{source}"
       @initialization_lock.release_write_lock
-      @base_client.log.set_config_client(self)
+      @base_client.log.config_client = self
       @base_client.log_internal ::Logger::INFO, to_s
     end
 

data/lib/prefab/config_resolver.rb

@@ -10,6 +10,7 @@ module Prefab
       @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
+      @on_update = nil
       make_local
     end
 
@@ -54,7 +55,7 @@ module Prefab
     end
 
     def make_context(properties)
-      if properties == NO_DEFAULT_PROVIDED
+      if properties == NO_DEFAULT_PROVIDED || properties.nil?
         Context.current
       elsif properties.is_a?(Context)
         properties

data/lib/prefab/config_value_unwrapper.rb

@@ -2,24 +2,35 @@
 
 module Prefab
   class ConfigValueUnwrapper
-    def self.unwrap(config_value, config_key, context)
-      return nil unless config_value
+    attr_reader :value, :weighted_value_index
 
-      case config_value.type
+    def initialize(value, weighted_value_index = nil)
+      @value = value
+      @weighted_value_index = weighted_value_index
+    end
+
+    def unwrap
+      case value.type
       when :int, :string, :double, :bool, :log_level
-        config_value.public_send(config_value.type)
+        value.public_send(value.type)
       when :string_list
-        config_value.string_list.values
-      when :weighted_values
-        value = Prefab::WeightedValueResolver.new(
+        value.string_list.values
+      else
+        raise "Unknown type: #{config_value.type}"
+      end
+    end
+
+    def self.deepest_value(config_value, config_key, context)
+      if config_value&.type == :weighted_values
+        value, index = Prefab::WeightedValueResolver.new(
           config_value.weighted_values.weighted_values,
           config_key,
           context.get(config_value.weighted_values.hash_by_property_name)
         ).resolve
 
-        unwrap(value.value, config_key, context)
+        new(deepest_value(value.value, config_key, context).value, index)
       else
-        raise "Unknown type: #{config_value.type}"
+        new(config_value)
       end
     end
   end

data/lib/prefab/context.rb

@@ -25,10 +25,23 @@ module Prefab
       def to_h
         @hash
       end
+
+      def key
+        "#{@name}:#{get('key')}"
+      end
+
+      def to_proto
+        PrefabProto::Context.new(
+          type: name,
+          values: to_h.transform_values do |value|
+            ConfigValueWrapper.wrap(value)
+          end
+        )
+      end
     end
 
     THREAD_KEY = :prefab_context
-    attr_reader :contexts
+    attr_reader :contexts, :seen_at
 
     class << self
       def current=(context)
@@ -58,6 +71,7 @@ module Prefab
 
     def initialize(context = {})
       @contexts = {}
+      @seen_at = Time.now.utc.to_i
 
       if context.is_a?(NamedContext)
         @contexts[context.name] = context
@@ -77,6 +91,10 @@ module Prefab
       end
     end
 
+    def blank?
+      contexts.empty?
+    end
+
     def set(name, hash)
       @contexts[name.to_s] = NamedContext.new(name, hash)
     end
@@ -113,15 +131,33 @@ module Prefab
 
       PrefabProto::ContextSet.new(
         contexts: contexts.map do |name, context|
-          PrefabProto::Context.new(
-            type: name,
-            values: context.to_h.transform_values do |value|
-              ConfigValueWrapper.wrap(value)
-            end
-          )
+          context.to_proto
         end.concat([PrefabProto::Context.new(type: 'prefab',
                                              values: prefab_context)])
       )
     end
+
+    def slim_proto
+      PrefabProto::ContextSet.new(
+        contexts: contexts.map do |_, context|
+          context.to_proto
+        end
+      )
+    end
+
+    def grouped_key
+      contexts.map do |_, context|
+        context.key
+      end.sort.join('|')
+    end
+
+    include Comparable
+    def <=>(other)
+      if other.is_a?(Prefab::Context)
+        to_h <=> other.to_h
+      else
+        super
+      end
+    end
   end
 end

data/lib/prefab/context_shape_aggregator.rb

@@ -42,7 +42,7 @@ module Prefab
     private
 
     def flush(to_ship, _)
-      @pool.post do
+      pool.post do
         log_internal "Uploading context shapes for #{to_ship.values.size}"
 
         shapes = PrefabProto::ContextShapes.new(

data/lib/prefab/criteria_evaluator.rb

@@ -4,6 +4,8 @@
 # We're intentionally keeping the UPCASED method names to match the protobuf
 # and avoid wasting CPU cycles lowercasing things
 module Prefab
+  # This class evaluates a config's criteria. `evaluate` returns the value of
+  # the first match based on the provided properties.
   class CriteriaEvaluator
     NAMESPACE_KEY = 'NAMESPACE'
     NO_MATCHING_ROWS = [].freeze
@@ -17,15 +19,8 @@ module Prefab
     end
 
     def evaluate(properties)
-      matching_environment_row_values.each do |conditional_value|
-        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, properties)
-      end
-
-      nil
+      evaluate_for_env(@project_env_id, properties) ||
+        evaluate_for_env(0, properties)
     end
 
     def all_criteria_match?(conditional_value, props)
@@ -83,12 +78,24 @@ module Prefab
 
     private
 
-    def matching_environment_row_values
-      @config.rows.find { |row| row.project_env_id == @project_env_id }&.values || NO_MATCHING_ROWS
-    end
+    def evaluate_for_env(env_id, properties)
+      @config.rows.each_with_index do |row, index|
+        next unless row.project_env_id == env_id
+
+        row.values.each_with_index do |conditional_value, value_index|
+          next unless all_criteria_match?(conditional_value, properties)
+
+          return Prefab::Evaluation.new(
+            config: @config,
+            value: conditional_value.value,
+            value_index: value_index,
+            config_row_index: index,
+            context: properties
+          )
+        end
+      end
 
-    def default_row_values
-      @config.rows.find { |row| row.project_env_id != @project_env_id }&.values || NO_MATCHING_ROWS
+      nil
     end
 
     def in_segment?(criterion, properties)
@@ -96,11 +103,12 @@ module Prefab
 
       @base_client.log.info("Segment #{criterion.value_to_match.string} not found") unless segment
 
-      segment&.bool
+      segment&.report_and_return(@base_client.evaluation_summary_aggregator)
     end
 
     def matches?(criterion, value, properties)
-      criterion_value_or_values = Prefab::ConfigValueUnwrapper.unwrap(criterion.value_to_match, @config.key, properties)
+      criterion_value_or_values = Prefab::ConfigValueUnwrapper.deepest_value(criterion.value_to_match, @config.key,
+                                                                             properties).unwrap
 
       case criterion_value_or_values
       when Google::Protobuf::RepeatedField

data/lib/prefab/evaluation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Prefab
+  # Records the result of evaluating a config's criteria and forensics for reporting
+  class Evaluation
+    attr_reader :value
+
+    def initialize(config:, value:, value_index:, config_row_index:, context:)
+      @config = config
+      @value = value
+      @value_index = value_index
+      @config_row_index = config_row_index
+      @context = context
+    end
+
+    def unwrapped_value
+      deepest_value.unwrap
+    end
+
+    def report_and_return(evaluation_summary_aggregator)
+      report(evaluation_summary_aggregator)
+
+      unwrapped_value
+    end
+
+    private
+
+    def report(evaluation_summary_aggregator)
+      return if @config.config_type == :LOG_LEVEL
+
+      evaluation_summary_aggregator&.record(
+        config_key: @config.key,
+        config_type: @config.config_type,
+        counter: {
+          config_id: @config.id,
+          config_row_index: @config_row_index,
+          conditional_value_index: @value_index,
+          selected_value: deepest_value.value,
+          weighted_value_index: deepest_value.weighted_value_index,
+          selected_index: nil # TODO
+        })
+    end
+
+    def deepest_value
+      @deepest_value ||= Prefab::ConfigValueUnwrapper.deepest_value(@value, @config.key, @context)
+    end
+  end
+end

data/lib/prefab/evaluation_summary_aggregator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative 'periodic_sync'
+
+module Prefab
+  # This class aggregates the number of times each config is evaluated, and
+  # details about how the config is evaluated This data is reported to the
+  # server at a regular interval defined by `sync_interval`.
+  class EvaluationSummaryAggregator
+    include Prefab::PeriodicSync
+
+    attr_reader :data
+
+    def initialize(client:, max_keys:, sync_interval:)
+      @client = client
+      @max_keys = max_keys
+      @name = 'evaluation_summary_aggregator'
+
+      @data = Concurrent::Hash.new
+
+      start_periodic_sync(sync_interval)
+    end
+
+    def record(config_key:, config_type:, counter:)
+      return if @data.size >= @max_keys
+
+      key = [config_key, config_type]
+      @data[key] ||= Concurrent::Hash.new
+
+      @data[key][counter] ||= 0
+      @data[key][counter] += 1
+    end
+
+    private
+
+    def counter_proto(counter, count)
+      PrefabProto::ConfigEvaluationCounter.new(
+        config_id: counter[:config_id],
+        selected_index: counter[:selected_index],
+        config_row_index: counter[:config_row_index],
+        conditional_value_index: counter[:conditional_value_index],
+        weighted_value_index: counter[:weighted_value_index],
+        selected_value: counter[:selected_value],
+        count: count
+      )
+    end
+
+    def flush(to_ship, start_at_was)
+      pool.post do
+        log_internal "Flushing #{to_ship.size} summaries"
+
+        summaries_proto = PrefabProto::ConfigEvaluationSummaries.new(
+          start: start_at_was,
+          end: Prefab::TimeHelpers.now_in_ms,
+          summaries: summaries(to_ship)
+        )
+
+        result = @client.post('/api/v1/telemetry', events(summaries_proto))
+
+        log_internal "Uploaded #{to_ship.size} summaries: #{result.status}"
+      end
+    end
+
+    def events(summaries)
+      event = PrefabProto::TelemetryEvent.new(summaries: summaries)
+
+      PrefabProto::TelemetryEvents.new(
+        instance_hash: @client.instance_hash,
+        events: [event]
+      )
+    end
+
+    def summaries(data)
+      data.map do |(config_key, config_type), counters|
+        counter_protos = counters.map { |counter, count| counter_proto(counter, count) }
+
+        PrefabProto::ConfigEvaluationSummary.new(
+          key: config_key,
+          type: config_type,
+          counters: counter_protos
+        )
+      end
+    end
+  end
+end

data/lib/prefab/example_contexts_aggregator.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'periodic_sync'
+
+module Prefab
+  # This class aggregates example contexts. It dedupes based on the
+  # concatenation of the keys of the contexts.
+  #
+  # It shouldn't send the same context more than once per hour.
+  class ExampleContextsAggregator
+    include Prefab::PeriodicSync
+
+    attr_reader :data, :cache
+
+    ONE_HOUR = 60 * 60
+
+    def initialize(client:, max_contexts:, sync_interval:)
+      @client = client
+      @max_contexts = max_contexts
+      @name = 'example_contexts_aggregator'
+
+      @data = Concurrent::Array.new
+      @cache = Prefab::RateLimitCache.new(ONE_HOUR)
+
+      start_periodic_sync(sync_interval)
+    end
+
+    def record(contexts)
+      key = contexts.grouped_key
+
+      return unless @data.size < @max_contexts && !@cache.fresh?(key)
+
+      @cache.set(key)
+
+      @data.push(contexts)
+    end
+
+    private
+
+    def on_prepare_data
+      @cache.prune
+    end
+
+    def flush(to_ship, _)
+      pool.post do
+        log_internal "Flushing #{to_ship.size} examples"
+
+        result = @client.post('/api/v1/telemetry', events(to_ship))
+
+        log_internal "Uploaded #{to_ship.size} examples: #{result.status}"
+      end
+    end
+
+    def example_contexts(to_ship)
+      to_ship.map do |contexts|
+        PrefabProto::ExampleContext.new(
+          timestamp: contexts.seen_at * 1000,
+          contextSet: contexts.slim_proto
+        )
+      end
+    end
+
+    def events(to_ship)
+      event = PrefabProto::TelemetryEvent.new(
+        example_contexts: PrefabProto::ExampleContexts.new(
+          examples: example_contexts(to_ship)
+        )
+      )
+
+      PrefabProto::TelemetryEvents.new(
+        instance_hash: @client.instance_hash,
+        events: [event]
+      )
+    end
+  end
+end

data/lib/prefab/exponential_backoff.rb

@@ -1,4 +1,9 @@
+# frozen_string_literal: true
+
 module Prefab
+  # This class implements exponential backoff with a maximum delay.
+  #
+  # This is the default sync interval for aggregators.
   class ExponentialBackoff
     def initialize(max_delay:, initial_delay: 2, multiplier: 2)
       @initial_delay = initial_delay

data/lib/prefab/feature_flag_client.rb

@@ -11,8 +11,6 @@ module Prefab
     end
 
     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, properties)
 
       is_on?(variant)

data/lib/prefab/log_path_aggregator.rb

@@ -37,7 +37,7 @@ module Prefab
     private
 
     def flush(to_ship, start_at_was)
-      @pool.post do
+      pool.post do
         log_internal "Uploading stats for #{to_ship.size} paths"
 
         aggregate = Hash.new { |h, k| h[k] = PrefabProto::Logger.new }