prefab-cloud-ruby 0.24.4 → 0.24.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a88b7d4c3a88af4b66a623208ec2673453ce763660d2cca7993e0623c39e35e5
-  data.tar.gz: 125b830fb204a7085fa6a3e5b365646f27d8bc4bcf42df0c2a6f2f0e0925dcd9
+  metadata.gz: 36d1b27d1c03aef56882735b73835b65b508b5eef821f65e89ab5ba77f54a8ab
+  data.tar.gz: 00a336ac664ab495ce1c5fff4b5ab6972169a095087887958c3a0881016ba273
 SHA512:
-  metadata.gz: 7a73efdcad8211cd709f0b074db0bf46ae448362387ba6215c94314050087988909d3993a8377422a6a6ef5e09da703f3f40b017b751025d6dbbcbaffd35d012
-  data.tar.gz: 3e2b3e9cbf7686843abfc13f948a87840da068a823c9740eb0ceba7ea13a24502f249aebb1d1fa1931a735b2042ee989b291b8d513e1504ba534df30ab5658ea
+  metadata.gz: b0dc48a30fd50f53e9709e138afd408bfc2e91e6badb473c1d141db56c7cdfa507aef81db0f06674b8d640dec2a7ac147654def0cdd7e7bcebdd3b0eb2a79854
+  data.tar.gz: a3bd2f91776a25d646f1ab28d54d395bd24283e16dbca2f0bc7a1d1f77c9bb063488e9f62e00030a8acc84b2ecb8b07791bf84c1893e091f40edbb75e55870ca

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 # Changelog
 
-## Unreleased
+## 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)
 
 ## [0.24.4] - 2023-07-06
 

data/VERSION

@@ -1 +1 @@
-0.24.4
+0.24.6

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

@@ -80,11 +80,24 @@ module Prefab
                                                                  sync_interval: @options.collect_sync_interval)
     end
 
-    def evaluated_configs_aggregator
-      return nil if @options.collect_max_evaluations <= 0
+    def example_contexts_aggregator
+      return nil if @options.collect_max_example_contexts <= 0
 
-      @evaluated_configs_aggregator ||= EvaluatedConfigsAggregator.new(client: self, max_configs: @options.collect_max_evaluations,
-                                                                       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 evaluation_summary_aggregator
+      return nil if @options.collect_max_evaluation_summaries <= 0
+
+      @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

data/lib/prefab/config_client.rb

@@ -58,18 +58,17 @@ module Prefab
     def get(key, default = NO_DEFAULT_PROVIDED, properties = NO_DEFAULT_PROVIDED)
       context = @config_resolver.make_context(properties)
 
-      value = _get(key, context)
+      if properties != NO_DEFAULT_PROVIDED && @base_client.example_contexts_aggregator
+        @base_client.example_contexts_aggregator.record(context)
+      end
+
+      evaluation = _get(key, context)
 
       @base_client.context_shape_aggregator&.push(context)
       @base_client.evaluated_keys_aggregator&.push(key)
 
-      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
-
-        Prefab::ConfigValueUnwrapper.unwrap(value, key, context)
+      if evaluation
+        evaluation.report_and_return(@base_client.evaluation_summary_aggregator)
       else
         handle_default(key, default)
       end
@@ -183,7 +182,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
 
@@ -192,7 +191,8 @@ module Prefab
       auth_string = Base64.strict_encode64(auth)
       headers = {
         'x-prefab-start-at-id' => start_at_id,
-        'Authorization' => "Basic #{auth_string}"
+        'Authorization' => "Basic #{auth_string}",
+        'X-PrefabCloud-Client-Version' => "prefab-cloud-ruby-#{Prefab::VERSION}"
       }
       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_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
@@ -113,15 +127,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/evaluated_keys_aggregator.rb

@@ -27,7 +27,7 @@ module Prefab
     private
 
     def flush(to_ship, _)
-      @pool.post do
+      pool.post do
         log_internal "Uploading evaluated keys for #{to_ship.size}"
 
         keys = PrefabProto::EvaluatedKeys.new(keys: to_ship.to_a, namespace: @client.namespace)

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/http_connection.rb

@@ -3,7 +3,11 @@
 module Prefab
   class HttpConnection
     AUTH_USER = 'authuser'
-    PROTO_HEADERS = { 'Content-Type' => 'application/x-protobuf', 'Accept' => 'application/x-protobuf' }.freeze
+    PROTO_HEADERS = {
+      'Content-Type' => 'application/x-protobuf',
+      'Accept' => 'application/x-protobuf',
+      'X-PrefabCloud-Client-Version' => "prefab-cloud-ruby-#{Prefab::VERSION}"
+    }.freeze
 
     def initialize(api_root, api_key)
       @api_root = api_root

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 }

data/lib/prefab/logger_client.rb

@@ -15,7 +15,7 @@ module Prefab
       PrefabProto::LogLevel::WARN => ::Logger::WARN,
       PrefabProto::LogLevel::ERROR => ::Logger::ERROR,
       PrefabProto::LogLevel::FATAL => ::Logger::FATAL
-    }
+    }.freeze
 
     def initialize(logdev, log_path_aggregator: nil, formatter: nil, prefix: nil)
       super(logdev)
@@ -27,7 +27,7 @@ module Prefab
       @log_path_aggregator = log_path_aggregator
     end
 
-    def add(severity, message = nil, progname = nil, loc, &block)
+    def add_internal(severity, message, progname, loc, &block)
       path_loc = get_loc_path(loc)
       path = @prefix + path_loc
 
@@ -36,7 +36,7 @@ module Prefab
       log(message, path, progname, severity, &block)
     end
 
-    def log_internal(message, path = nil, progname, severity, &block)
+    def log_internal(message, path, progname, severity, &block)
       path = if path
                "#{INTERNAL_PREFIX}.#{path}"
              else
@@ -51,9 +51,8 @@ module Prefab
 
       return true if @logdev.nil? || severity < level_of(path) || @silences[local_log_id]
 
-      if progname.nil?
-        progname = @progname
-      end
+      progname = @progname if progname.nil?
+
       if message.nil?
         if block_given?
           message = yield
@@ -70,23 +69,23 @@ module Prefab
     end
 
     def debug(progname = nil, &block)
-      add(DEBUG, nil, progname, caller_locations(1, 1)[0], &block)
+      add_internal(DEBUG, nil, progname, caller_locations(1, 1)[0], &block)
     end
 
     def info(progname = nil, &block)
-      add(INFO, nil, progname, caller_locations(1, 1)[0], &block)
+      add_internal(INFO, nil, progname, caller_locations(1, 1)[0], &block)
     end
 
     def warn(progname = nil, &block)
-      add(WARN, nil, progname, caller_locations(1, 1)[0], &block)
+      add_internal(WARN, nil, progname, caller_locations(1, 1)[0], &block)
     end
 
     def error(progname = nil, &block)
-      add(ERROR, nil, progname, caller_locations(1, 1)[0], &block)
+      add_internal(ERROR, nil, progname, caller_locations(1, 1)[0], &block)
     end
 
     def fatal(progname = nil, &block)
-      add(FATAL, nil, progname, caller_locations(1, 1)[0], &block)
+      add_internal(FATAL, nil, progname, caller_locations(1, 1)[0], &block)
     end
 
     def debug?
@@ -113,7 +112,7 @@ module Prefab
       DEBUG
     end
 
-    def set_config_client(config_client)
+    def config_client=(config_client)
       @config_client = config_client
     end
 
@@ -169,7 +168,7 @@ module Prefab
       path
     end
 
-    def format_message(severity, datetime, progname, msg, path)
+    def format_message(severity, datetime, progname, msg, path = nil)
       formatter = (@formatter || @default_formatter)
 
       if formatter.arity == 5