prefab-cloud-ruby 0.24.3 → 0.24.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29a3d9257f166fad534f81a44879cd82abc0cdd729714ab6feb2423d7b913a4d
-  data.tar.gz: b11f8e29260760dd64a78f26c016bd936fe0a5e75100329c645915bddd094ebc
+  metadata.gz: a88b7d4c3a88af4b66a623208ec2673453ce763660d2cca7993e0623c39e35e5
+  data.tar.gz: 125b830fb204a7085fa6a3e5b365646f27d8bc4bcf42df0c2a6f2f0e0925dcd9
 SHA512:
-  metadata.gz: f74cda2cf6f657f72c15d118d9fb622d24d049261436691bff28e42ad5656beb53ec192e148e30e0f025a5becb094682fc68f4860c2cf5b3ed351b7954e3b587
-  data.tar.gz: 90125b61cd874c12376eecc726aa2fef0d6158565150830f95f642f97fad849b53570238593ce617dc39b05960abb47d4c2e6cd4a974e30c69fc40ec2720958b
+  metadata.gz: 7a73efdcad8211cd709f0b074db0bf46ae448362387ba6215c94314050087988909d3993a8377422a6a6ef5e09da703f3f40b017b751025d6dbbcbaffd35d012
+  data.tar.gz: 3e2b3e9cbf7686843abfc13f948a87840da068a823c9740eb0ceba7ea13a24502f249aebb1d1fa1931a735b2042ee989b291b8d513e1504ba534df30ab5658ea

data/.github/workflows/ruby.yml

@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.6', '2.7', '3.0', '3.1']
+        ruby-version: ['2.7', '3.0', '3.1']
 
     steps:
     - uses: actions/checkout@v3

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  NewCops: enable
+  Exclude:
+    - prefab-cloud-ruby.gemspec
+    - lib/prefab_pb.rb
+
+Metrics:
+  Exclude:
+    - 'test/*.rb'
+
+Layout/LineLength:
+  Exclude:
+    - 'test/*.rb'

data/CHANGELOG.md

@@ -0,0 +1,76 @@
+# Changelog
+
+## Unreleased
+
+## [0.24.4] - 2023-07-06
+
+- Support Timed Loggers (#119)
+- Added EvaluatedConfigsAggregator (disabled by default) (#118)
+- Added EvaluatedKeysAggregator (disabled by default) (#117)
+- Dropped Ruby 2.6 support (#116)
+- Capture/report context shapes (#115)
+- Added bin/console (#114)
+
+## [0.24.3] - 2023-05-15
+
+- Add JSON log formatter (#106)
+
+# [0.24.2] - 2023-05-12
+
+- Fix bug in FF rollout eval consistency (#108)
+- Simplify forking (#107)
+
+# [0.24.1] - 2023-04-26
+
+- Fix misleading deprecation warning (#105)
+
+# [0.24.0] - 2023-04-26
+
+- Backwards compatibility for JIT context (#104)
+- Remove upsert (#103)
+- Add resolver presenter and `on_update` callback (#102)
+- Deprecate `lookup_key` and introduce Context (#99)
+
+# [0.23.8] - 2023-04-21
+
+- Update protobuf (#101)
+
+# [0.23.7] - 2023-04-21
+
+- Guard against ActiveJob not being loaded (#100)
+
+# [0.23.6] - 2023-04-17
+
+- Fix bug in FF rollout eval consistency (#98)
+- Add tests for block-form of logging (#96)
+
+# [0.23.5] - 2023-04-13
+
+- Cast the value to string when checking presence in string list (#95)
+
+# [0.23.4] - 2023-04-12
+
+- Remove GRPC (#93)
+
+# [0.23.3] - 2023-04-07
+
+- Use exponential backoff for log level uploading (#92)
+
+# [0.23.2] - 2023-04-04
+
+- Move log collection logs from INFO to DEBUG (#91)
+- Fix: Handle trailing slash in PREFAB_API_URL (#90)
+
+# [0.23.1] - 2023-03-30
+
+- ActiveStorage not defined in Rails < 5.2 (#87)
+
+# [0.23.0] - 2023-03-28
+
+- Convenience for setting Rails.logger (#85)
+- Log evaluation according to rules (#81)
+
+# [0.22.0] - 2023-03-15
+
+- Report log paths and usages (#79)
+- Accept hash or keyword args in `initialize` (#78)

data/Gemfile.lock

@@ -66,7 +66,7 @@ GEM
       rake (~> 13.0)
     macaddr (1.7.2)
       systemu (~> 2.6.5)
-    mini_portile2 (2.8.0)
+    mini_portile2 (2.8.2)
     minitest (5.16.2)
     minitest-focus (1.3.1)
       minitest (>= 4, < 6)
@@ -78,8 +78,8 @@ GEM
     multi_json (1.15.0)
     multi_xml (0.6.0)
     multipart-post (2.1.1)
-    nokogiri (1.13.10)
-      mini_portile2 (~> 2.8.0)
+    nokogiri (1.15.2)
+      mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
     oauth2 (1.4.11)
       faraday (>= 0.17.3, < 3.0)
@@ -89,7 +89,7 @@ GEM
       rack (>= 1.2, < 4)
     psych (3.3.1)
     public_suffix (4.0.6)
-    racc (1.6.1)
+    racc (1.7.0)
     rack (3.0.6.1)
     rake (13.0.6)
     rchardet (1.8.0)

data/VERSION

@@ -1 +1 @@
-0.24.3
+0.24.4

data/bin/console

@@ -0,0 +1,21 @@
+#!/usr/bin/env 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
+
+# Start an IRB session
+IRB.start(__FILE__)

data/compile_protos.sh

@@ -1,5 +1,11 @@
 #!/usr/bin/env bash
+
+gem install grpc-tools
+
 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
+
 # on M1 you need to
 # 1. run in rosetta
 # 2. mv gems/2.6.0/gems/grpc-tools-1.43.1/bin/x86_64-macos x86-macos

data/lib/prefab/client.rb

@@ -53,17 +53,38 @@ module Prefab
       @feature_flag_client ||= Prefab::FeatureFlagClient.new(self)
     end
 
-    def log_path_collector
+    def log_path_aggregator
       return nil if @options.collect_max_paths <= 0
 
-      @log_path_collector ||= LogPathCollector.new(client: self, max_paths: @options.collect_max_paths,
-                                                   sync_interval: @options.collect_sync_interval)
+      @log_path_aggregator ||= LogPathAggregator.new(client: self, max_paths: @options.collect_max_paths,
+                                                     sync_interval: @options.collect_sync_interval)
     end
 
     def log
       @logger_client ||= Prefab::LoggerClient.new(@options.logdev, formatter: @options.log_formatter,
                                                                    prefix: @options.log_prefix,
-                                                                   log_path_collector: log_path_collector)
+                                                                   log_path_aggregator: log_path_aggregator)
+    end
+
+    def context_shape_aggregator
+      return nil if @options.collect_max_shapes <= 0
+
+      @context_shape_aggregator ||= ContextShapeAggregator.new(client: self, max_shapes: @options.collect_max_shapes,
+                                                               sync_interval: @options.collect_sync_interval)
+    end
+
+    def evaluated_keys_aggregator
+      return nil if @options.collect_max_keys <= 0
+
+      @evaluated_keys_aggregator ||= EvaluatedKeysAggregator.new(client: self, max_keys: @options.collect_max_keys,
+                                                                 sync_interval: @options.collect_sync_interval)
+    end
+
+    def evaluated_configs_aggregator
+      return nil if @options.collect_max_evaluations <= 0
+
+      @evaluated_configs_aggregator ||= EvaluatedConfigsAggregator.new(client: self, max_configs: @options.collect_max_evaluations,
+                                                                       sync_interval: @options.collect_sync_interval)
     end
 
     def set_rails_loggers

data/lib/prefab/config_client.rb

@@ -6,6 +6,7 @@ module Prefab
     DEFAULT_CHECKPOINT_FREQ_SEC = 60
     SSE_READ_TIMEOUT = 300
     AUTH_USER = 'authuser'
+    LOGGING_KEY_PREFIX = "#{Prefab::LoggerClient::BASE_KEY}#{Prefab::LoggerClient::SEP}".freeze
 
     def initialize(base_client, timeout)
       @base_client = base_client
@@ -50,15 +51,24 @@ module Prefab
     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)])
+      PrefabProto::Config.new(key: [namespace, key].compact.join(':'),
+                              rows: [PrefabProto::ConfigRow.new(value: config_value)])
     end
 
     def get(key, default = NO_DEFAULT_PROVIDED, properties = NO_DEFAULT_PROVIDED)
       context = @config_resolver.make_context(properties)
+
       value = _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)
       else
         handle_default(key, default)
@@ -120,7 +130,7 @@ module Prefab
     def load_url(conn, source)
       resp = conn.get('')
       if resp.status == 200
-        configs = Prefab::Configs.decode(resp.body)
+        configs = PrefabProto::Configs.decode(resp.body)
         load_configs(configs, source)
         true
       else
@@ -181,8 +191,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}"
@@ -191,7 +201,7 @@ module Prefab
                                           read_timeout: SSE_READ_TIMEOUT,
                                           logger: Prefab::SseLogger.new(@base_client.log)) do |client|
         client.on_event do |event|
-          configs = Prefab::Configs.decode(Base64.decode64(event.data))
+          configs = PrefabProto::Configs.decode(Base64.decode64(event.data))
           load_configs(configs, :sse)
         end
       end

data/lib/prefab/config_loader.rb

@@ -42,7 +42,7 @@ module Prefab
     end
 
     def get_api_deltas
-      configs = Prefab::Configs.new
+      configs = PrefabProto::Configs.new
       @api_config.each_value do |config_value|
         configs.configs << config_value[:config]
       end

data/lib/prefab/config_resolver.rb

@@ -22,9 +22,7 @@ module Prefab
     end
 
     def raw(key)
-      via_key = @local_store[key]
-
-      via_key ? via_key[:config] : nil
+      @local_store.dig(key, :config)
     end
 
     def get(key, properties = NO_DEFAULT_PROVIDED)
@@ -33,7 +31,7 @@ module Prefab
 
         return nil unless raw_config
 
-        evaluate(raw(key), properties)
+        evaluate(raw_config, properties)
       end
     end
 

data/lib/prefab/config_value_wrapper.rb

@@ -0,0 +1,18 @@
+module Prefab
+  class ConfigValueWrapper
+    def self.wrap(value)
+      case value
+      when Integer
+        PrefabProto::ConfigValue.new(int: value)
+      when Float
+        PrefabProto::ConfigValue.new(double: value)
+      when TrueClass, FalseClass
+        PrefabProto::ConfigValue.new(bool: value)
+      when Array
+        PrefabProto::ConfigValue.new(string_list: Prefab::StringList.new(values: value.map(&:to_s)))
+      else
+        PrefabProto::ConfigValue.new(string: value.to_s)
+      end
+    end
+  end
+end

data/lib/prefab/context.rb

@@ -89,11 +89,11 @@ module Prefab
         key = property_key
       end
 
-      contexts[name] && contexts[name].get(key)
+      contexts[name]&.get(key)
     end
 
     def to_h
-      contexts.map { |name, context| [name, context.to_h] }.to_h
+      contexts.transform_values(&:to_h)
     end
 
     def clear
@@ -103,5 +103,25 @@ module Prefab
     def context(name)
       contexts[name.to_s] || NamedContext.new(name, {})
     end
+
+    def to_proto(namespace)
+      prefab_context = {
+        'current-time' => ConfigValueWrapper.wrap(Prefab::TimeHelpers.now_in_ms)
+      }
+
+      prefab_context['namespace'] = ConfigValueWrapper.wrap(namespace) if namespace&.length&.positive?
+
+      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
+          )
+        end.concat([PrefabProto::Context.new(type: 'prefab',
+                                             values: prefab_context)])
+      )
+    end
   end
 end

data/lib/prefab/context_shape.rb

@@ -0,0 +1,20 @@
+module Prefab
+  class ContextShape
+    MAPPING = {
+      Integer => 1,
+      String => 2,
+      Float => 4,
+      TrueClass => 5,
+      FalseClass => 5,
+      Array => 10,
+    }.freeze
+
+    # We default to String if the type isn't a primitive we support.
+    # This is because we do a `to_s` in the CriteriaEvaluator.
+    DEFAULT = MAPPING[String]
+
+    def self.field_type_number(value)
+      MAPPING.fetch(value.class, DEFAULT)
+    end
+  end
+end

data/lib/prefab/context_shape_aggregator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'periodic_sync'
+
+module Prefab
+  class ContextShapeAggregator
+    include Prefab::PeriodicSync
+
+    attr_reader :data
+
+    def initialize(client:, max_shapes:, sync_interval:)
+      @max_shapes = max_shapes
+      @client = client
+      @name = 'context_shape_aggregator'
+
+      @data = Concurrent::Set.new
+
+      start_periodic_sync(sync_interval)
+    end
+
+    def push(context)
+      return if @data.size >= @max_shapes
+
+      context.contexts.each_pair do |name, name_context|
+        name_context.to_h.each_pair do |key, value|
+          @data.add [name, key, Prefab::ContextShape.field_type_number(value)]
+        end
+      end
+    end
+
+    def prepare_data
+      duped = @data.dup
+      @data.clear
+
+      duped.inject({}) do |acc, (name, key, type)|
+        acc[name] ||= {}
+        acc[name][key] = type
+        acc
+      end
+    end
+
+    private
+
+    def flush(to_ship, _)
+      @pool.post do
+        log_internal "Uploading context shapes for #{to_ship.values.size}"
+
+        shapes = PrefabProto::ContextShapes.new(
+          shapes: to_ship.map do |name, shape|
+            PrefabProto::ContextShape.new(
+              name: name,
+              field_types: shape
+            )
+          end
+        )
+
+        result = @client.post('/api/v1/context-shapes', shapes)
+
+        log_internal "Uploaded #{to_ship.values.size} shapes: #{result.status}"
+      end
+    end
+  end
+end

data/lib/prefab/criteria_evaluator.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+# rubocop:disable Naming/MethodName
+# We're intentionally keeping the UPCASED method names to match the protobuf
+# and avoid wasting CPU cycles lowercasing things
 module Prefab
   class CriteriaEvaluator
     NAMESPACE_KEY = 'NAMESPACE'
@@ -27,45 +30,55 @@ module Prefab
 
     def all_criteria_match?(conditional_value, props)
       conditional_value.criteria.all? do |criterion|
-        evaluate_criteron(criterion, props)
+        public_send(criterion.operator, criterion, props)
       end
     end
 
-    def evaluate_criteron(criterion, properties)
-      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
+    def IN_SEG(criterion, properties)
+      in_segment?(criterion, properties)
+    end
 
-      value_from_properties = criterion.property_name === NAMESPACE_KEY ? @namespace : properties.get(criterion.property_name)
-
-      case criterion.operator
-      when :PROP_IS_ONE_OF
-        matches?(criterion, value_from_properties, properties)
-      when :PROP_IS_NOT_ONE_OF
-        !matches?(criterion, value_from_properties, properties)
-      when :PROP_ENDS_WITH_ONE_OF
-        return false unless value_from_properties
-
-        criterion.value_to_match.string_list.values.any? do |ending|
-          value_from_properties.end_with?(ending)
-        end
-      when :PROP_DOES_NOT_END_WITH_ONE_OF
-        return true unless value_from_properties
-
-        criterion.value_to_match.string_list.values.none? do |ending|
-          value_from_properties.end_with?(ending)
-        end
-      when :HIERARCHICAL_MATCH
-        value_from_properties.start_with?(criterion.value_to_match.string)
-      else
-        @base_client.log.info("Unknown Operator: #{criterion.operator}")
-        false
-      end
+    def NOT_IN_SEG(criterion, properties)
+      !in_segment?(criterion, properties)
+    end
+
+    def ALWAYS_TRUE(_criterion, _properties)
+      true
+    end
+
+    def PROP_IS_ONE_OF(criterion, properties)
+      matches?(criterion, value_from_properties(criterion, properties), properties)
+    end
+
+    def PROP_IS_NOT_ONE_OF(criterion, properties)
+      !matches?(criterion, value_from_properties(criterion, properties), properties)
+    end
+
+    def PROP_ENDS_WITH_ONE_OF(criterion, properties)
+      prop_ends_with_one_of?(criterion, value_from_properties(criterion, properties))
+    end
+
+    def PROP_DOES_NOT_END_WITH_ONE_OF(criterion, properties)
+      !prop_ends_with_one_of?(criterion, value_from_properties(criterion, properties))
+    end
+
+    def HIERARCHICAL_MATCH(criterion, properties)
+      value = value_from_properties(criterion, properties)
+      value&.start_with?(criterion.value_to_match.string)
+    end
+
+    def IN_INT_RANGE(criterion, properties)
+      value = if criterion.property_name == 'prefab.current-time'
+                Time.now.utc.to_i * 1000
+              else
+                value_from_properties(criterion, properties)
+              end
+
+      value && value >= criterion.value_to_match.int_range.start && value < criterion.value_to_match.int_range.end
+    end
+
+    def value_from_properties(criterion, properties)
+      criterion.property_name == NAMESPACE_KEY ? @namespace : properties.get(criterion.property_name)
     end
 
     private
@@ -81,24 +94,31 @@ module Prefab
     def in_segment?(criterion, properties)
       segment = @resolver.get(criterion.value_to_match.string, properties)
 
-      if !segment
-        @base_client.log.info( "Segment #{criterion.value_to_match.string} not found")
-      end
+      @base_client.log.info("Segment #{criterion.value_to_match.string} not found") unless segment
 
       segment&.bool
     end
 
-    def matches?(criterion, value_from_properties, properties)
+    def matches?(criterion, value, properties)
       criterion_value_or_values = Prefab::ConfigValueUnwrapper.unwrap(criterion.value_to_match, @config.key, properties)
 
       case criterion_value_or_values
       when Google::Protobuf::RepeatedField
         # we to_s the value from properties for comparison because the
         # criterion_value_or_values is a list of strings
-        criterion_value_or_values.include?(value_from_properties.to_s)
+        criterion_value_or_values.include?(value.to_s)
       else
-        criterion_value_or_values == value_from_properties
+        criterion_value_or_values == value
+      end
+    end
+
+    def prop_ends_with_one_of?(criterion, value)
+      return false unless value
+
+      criterion.value_to_match.string_list.values.any? do |ending|
+        value.end_with?(ending)
       end
     end
   end
 end
+# rubocop:enable Naming/MethodName

data/lib/prefab/evaluated_configs_aggregator.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'periodic_sync'
+
+module Prefab
+  class EvaluatedConfigsAggregator
+    include Prefab::PeriodicSync
+
+    attr_reader :data
+
+    def initialize(client:, max_configs:, sync_interval:)
+      @max_configs = max_configs
+      @client = client
+      @name = 'evaluated_configs_aggregator'
+
+      @data = Concurrent::Array.new
+
+      start_periodic_sync(sync_interval)
+    end
+
+    def push(evaluation)
+      return if @data.size >= @max_configs
+
+      @data.push(evaluation)
+    end
+
+    def prepare_data
+      to_ship = @data.dup
+      @data.clear
+
+      to_ship.map { |e| coerce_to_proto(e) }
+    end
+
+    def coerce_to_proto(evaluation)
+      config, result, context = evaluation
+
+      PrefabProto::EvaluatedConfig.new(
+        key: config.key,
+        config_version: config.id,
+        result: result,
+        context: context.to_proto(@client.namespace),
+        timestamp: Prefab::TimeHelpers.now_in_ms
+      )
+    end
+
+    private
+
+    def flush(to_ship, _)
+      @pool.post do
+        log_internal "Uploading evaluated configs for #{to_ship.size}"
+
+        configs = PrefabProto::EvaluatedConfigs.new(configs: to_ship)
+
+        result = @client.post('/api/v1/evaluated-configs', configs)
+
+        log_internal "Uploaded #{to_ship.size} configs: #{result.status}"
+      end
+    end
+  end
+end