sdk-reforge 1.9.0

data/lib/reforge/context.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Reforge
+  class Context
+    BLANK_CONTEXT_NAME = ''
+
+    class NamedContext
+      attr_reader :name
+
+      def initialize(name, hash)
+        @name = name.to_s
+        @hash = hash.transform_keys(&:to_s)
+      end
+
+      def to_h
+        @hash
+      end
+
+      def key
+        "#{@name}:#{@hash['key']}"
+      end
+
+      def to_proto
+        PrefabProto::Context.new(
+          type: name,
+          values: @hash.transform_values do |value|
+            ConfigValueWrapper.wrap(value)
+          end
+        )
+      end
+    end
+
+    THREAD_KEY = :prefab_context
+    attr_reader :contexts, :seen_at, :id, :parent
+
+    class << self
+      def global_context=(context)
+        @global_context = join(hash: context, parent: nil, id: :global_context)
+      end
+
+      def global_context
+        @global_context ||= join(parent: nil, id: :global_context)
+      end
+
+      def default_context=(context)
+        @default_context = join(hash: context, parent: global_context, id: :default_context)
+
+        self.current.update_parent(@default_context)
+      end
+
+      def default_context
+        @default_context ||= join(parent: global_context, id: :default_context)
+      end
+
+      def current=(context)
+        Thread.current[THREAD_KEY] = join(hash: context || {}, parent: default_context, id: :block)
+      end
+
+      def current
+        Thread.current[THREAD_KEY] ||= join(parent: default_context, id: :block)
+      end
+
+      def with_context(context)
+        old_context = Thread.current[THREAD_KEY]
+        Thread.current[THREAD_KEY] = join(parent: default_context, hash: context, id: :block)
+        yield
+      ensure
+        Thread.current[THREAD_KEY] = old_context
+      end
+
+      def with_merged_context(context)
+        old_context = Thread.current[THREAD_KEY]
+        Thread.current[THREAD_KEY] = join(parent: current, hash: context, id: :merged)
+        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.to_h))
+      end
+    end
+
+    def self.join(hash: {}, parent: nil, id: :not_provided)
+      context = new(hash)
+      context.update_parent(parent)
+      context.instance_variable_set(:@id, id)
+      context
+    end
+
+    def initialize(hash = {})
+      @contexts = {}
+      @flattened = {}
+      @seen_at = Time.now.utc.to_i
+
+      if hash.is_a?(Hash)
+        hash.map do |name, values|
+          unless values.is_a?(Hash)
+            warn "[DEPRECATION] Prefab contexts should be a hash with a key of the context name and a value of a hash."
+            values = { name => values }
+            name = BLANK_CONTEXT_NAME
+          end
+
+          @contexts[name.to_s] = NamedContext.new(name, values)
+          values.each do |key, value|
+            @flattened[name.to_s + '.' + key.to_s] = value
+          end
+        end
+      else
+        raise ArgumentError, 'must be a Hash'
+      end
+    end
+
+    def update_parent(parent)
+      @parent = parent
+    end
+
+    def blank?
+      contexts.empty?
+    end
+
+    def set(name, hash)
+      @contexts[name.to_s] = NamedContext.new(name, hash)
+      hash.each do |key, value|
+        @flattened[name.to_s + '.' + key.to_s] = value
+      end
+    end
+
+    def get(property_key, scope: nil)
+      if !property_key.include?(".")
+        property_key = BLANK_CONTEXT_NAME + '.' + property_key
+      end
+
+      if @flattened.key?(property_key)
+        @flattened[property_key]
+      else
+        scope ||= property_key.split('.').first
+
+        if @contexts[scope]
+          # If the key is in the present scope, parent values should not be used.
+          # We can consider the parent value clobbered by the present scope.
+          nil
+        else
+          @parent&.get(property_key, scope: scope)
+        end
+      end
+    end
+
+    def to_h
+      contexts.transform_values(&:to_h)
+    end
+
+    def to_s
+      "#<Reforge::Context:#{object_id} id=#{@id} #{to_h}>"
+    end
+
+    # Visualize a tree of the context up through its parents
+    #
+    # example:
+    #
+    # | jit:                            {"user"=>{"name"=>"Frank"}}
+    # |-- block:                        {"clock"=>{"timezone"=>"PST"}}
+    # |---- default_context:            {"prefab-api-key"=>{"user-id"=>123}}
+    # |------ global_context:           {"cpu"=>{"count"=>4, "speed"=>"2.4GHz"}, "clock"=>{"timezone"=>"UTC"}}
+    def tree(depth = 0)
+      "|" + ("-" * depth) + " #{id}: #{(" " * (30 - id.to_s.length - depth ))}#{to_h}\n" + (@parent&.tree(depth + 2) || '')
+    end
+
+    def clear
+      @contexts = {}
+      @flattened = {}
+    end
+
+    def context(name)
+      contexts[name.to_s] || NamedContext.new(name, {})
+    end
+
+    def merge_default(defaults)
+      defaults.keys.each do |name|
+        set(name, context(name).merge!(defaults[name]))
+      end
+
+      self
+    end
+
+    def reportable_tree
+      ctx = self
+      reportables = []
+
+      while ctx
+        reportables.unshift(ctx)
+        ctx = ctx.parent
+      end
+
+      reportables
+    end
+
+    def to_proto(namespace)
+      reportable_contexts = {}
+
+      reportable_tree.each do |ctx|
+        ctx.contexts.each do |name, context|
+          reportable_contexts[name] = context
+        end
+      end
+
+      PrefabProto::ContextSet.new(
+        contexts: reportable_contexts.map do |name, context|
+          context.to_proto
+        end
+      )
+    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?(Reforge::Context)
+        to_h <=> other.to_h
+      else
+        super
+      end
+    end
+  end
+end

data/lib/reforge/context_shape.rb

@@ -0,0 +1,20 @@
+module Reforge
+  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/reforge/context_shape_aggregator.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative 'periodic_sync'
+
+module Reforge
+  class ContextShapeAggregator
+    include Reforge::PeriodicSync
+    LOG = Reforge::InternalLogger.new(self)
+
+    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, Reforge::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.debug "Uploading context shapes for #{to_ship.values.size}"
+
+        events = PrefabProto::TelemetryEvents.new(
+          instance_hash: instance_hash,
+          events: [
+            PrefabProto::TelemetryEvent.new(context_shapes:
+              PrefabProto::ContextShapes.new(
+                shapes: to_ship.map do |name, shape|
+                  PrefabProto::ContextShape.new(
+                    name: name,
+                    field_types: shape
+                  )
+                end
+              ))
+          ]
+        )
+
+        result = post('/api/v1/telemetry', events)
+
+        LOG.debug "Uploaded #{to_ship.values.size} shapes: #{result.status}"
+      end
+    end
+  end
+end

data/lib/reforge/criteria_evaluator.rb

@@ -0,0 +1,345 @@
+# 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 Reforge
+  # This class evaluates a config's criteria. `evaluate` returns the value of
+  # the first match based on the provided properties.
+  class CriteriaEvaluator
+    LOG = Reforge::InternalLogger.new(self)
+    NAMESPACE_KEY = 'NAMESPACE'
+    NO_MATCHING_ROWS = [].freeze
+
+    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)
+      rtn = evaluate_for_env(@project_env_id, properties) ||
+        evaluate_for_env(0, properties)
+      LOG.trace {
+        "Eval Key #{@config.key} Result #{rtn&.reportable_value} with #{properties.to_h}"
+      } unless @config.config_type == :LOG_LEVEL
+      rtn
+    end
+
+    def all_criteria_match?(conditional_value, props)
+      conditional_value.criteria.all? do |criterion|
+        public_send(criterion.operator, criterion, props)
+      end
+    end
+
+    def IN_SEG(criterion, properties)
+      in_segment?(criterion, properties)
+    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)
+      Array(value_from_properties(criterion, properties)).any? do |prop|
+        matches?(criterion, prop, properties)
+      end
+    end
+
+    def PROP_IS_NOT_ONE_OF(criterion, properties)
+      !PROP_IS_ONE_OF(criterion, 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, properties)
+    end
+
+    def PROP_STARTS_WITH_ONE_OF(criterion, properties)
+      prop_starts_with_one_of?(criterion, value_from_properties(criterion, properties))
+    end
+
+    def PROP_DOES_NOT_START_WITH_ONE_OF(criterion, properties)
+      !PROP_STARTS_WITH_ONE_OF(criterion, properties)
+    end
+
+    def PROP_CONTAINS_ONE_OF(criterion, properties)
+      prop_contains_one_of?(criterion, value_from_properties(criterion, properties))
+    end
+
+    def PROP_DOES_NOT_CONTAIN_ONE_OF(criterion, properties)
+      !PROP_CONTAINS_ONE_OF(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 = value_from_properties(criterion, properties)
+      value && value >= criterion.value_to_match.int_range.start && value < criterion.value_to_match.int_range.end
+    end
+
+    def PROP_MATCHES(criterion, properties)
+      result = check_regex_match(criterion, properties)
+      if result.error
+        false
+      else
+        result.matched
+      end
+    end
+
+    def PROP_DOES_NOT_MATCH(criterion, properties)
+      result = check_regex_match(criterion, properties)
+      if result.error
+        false
+      else
+        !result.matched
+      end
+    end
+
+    def PROP_LESS_THAN(criterion, properties)
+      evaluate_number_comparison(criterion, properties, COMPARE_TO_OPERATORS[:less_than]).matched
+    end
+
+    def PROP_LESS_THAN_OR_EQUAL(criterion, properties)
+      evaluate_number_comparison(criterion, properties, COMPARE_TO_OPERATORS[:less_than_or_equal]).matched
+    end
+
+    def PROP_GREATER_THAN(criterion, properties)
+      evaluate_number_comparison(criterion, properties, COMPARE_TO_OPERATORS[:greater_than]).matched
+    end
+
+    def PROP_GREATER_THAN_OR_EQUAL(criterion, properties)
+      evaluate_number_comparison(criterion, properties,COMPARE_TO_OPERATORS[:greater_than_or_equal]) .matched
+    end
+
+    def PROP_BEFORE(criterion, properties)
+      evaluate_date_comparison(criterion, properties, COMPARE_TO_OPERATORS[:less_than]).matched
+    end
+
+    def PROP_AFTER(criterion, properties)
+      evaluate_date_comparison(criterion, properties, COMPARE_TO_OPERATORS[:greater_than]).matched
+    end
+
+    def PROP_SEMVER_LESS_THAN(criterion, properties)
+      evaluate_semver_comparison(criterion, properties, COMPARE_TO_OPERATORS[:less_than]).matched
+    end
+
+    def PROP_SEMVER_EQUAL(criterion, properties)
+      evaluate_semver_comparison(criterion, properties, COMPARE_TO_OPERATORS[:equal_to]).matched
+    end
+
+    def PROP_SEMVER_GREATER_THAN(criterion, properties)
+      evaluate_semver_comparison(criterion, properties, COMPARE_TO_OPERATORS[:greater_than]).matched
+    end
+
+    def value_from_properties(criterion, properties)
+      case criterion.property_name
+      when NAMESPACE_KEY
+        @namespace
+      when 'prefab.current-time','reforge.current-time'
+        Time.now.utc.to_i * 1000
+      else
+        properties.get(criterion.property_name)
+      end
+    end
+
+    COMPARE_TO_OPERATORS = {
+      less_than_or_equal: -> cmp {  cmp <= 0 },
+      less_than: -> cmp {  cmp < 0 },
+      equal_to: -> cmp {  cmp == 0 },
+      greater_than: -> cmp {  cmp > 0 },
+      greater_than_or_equal: -> cmp {  cmp >= 0 },
+    }
+
+    private
+
+    def evaluate_semver_comparison(criterion, properties, predicate)
+      context_version = value_from_properties(criterion, properties)&.then { |v| SemanticVersion.parse_quietly(v) }
+      config_version = criterion.value_to_match&.string&.then {|v| SemanticVersion.parse_quietly(criterion.value_to_match.string) }
+
+      unless context_version && config_version
+        return MatchResult.error
+      end
+      predicate.call(context_version <=> config_version) ? MatchResult.matched : MatchResult.not_matched
+    end
+
+    def evaluate_date_comparison(criterion, properties, predicate)
+      context_millis = as_millis(value_from_properties(criterion, properties))
+      config_millis = as_millis(Reforge::ConfigValueUnwrapper.deepest_value(criterion.value_to_match, @config,
+                                                                           properties, @resolver).unwrap)
+
+      unless config_millis && context_millis
+        return MatchResult.error
+      end
+
+      predicate.call(context_millis <=> config_millis) ? MatchResult.matched : MatchResult.not_matched
+    end
+
+    def evaluate_number_comparison(criterion, properties, predicate)
+      context_value = value_from_properties(criterion, properties)
+      value_to_match = extract_numeric_value(criterion.value_to_match)
+
+      return MatchResult.error if value_to_match.nil?
+      return MatchResult.error unless context_value.is_a?(Numeric)
+
+      # Compare the values and apply the predicate method
+      comparison_result = context_value <=> value_to_match
+      return MatchResult.error if comparison_result.nil?
+
+      predicate.call(comparison_result) ? MatchResult.matched : MatchResult.not_matched
+    end
+
+    def extract_numeric_value(config_value)
+      case config_value.type
+      when :int
+        config_value.int
+      when :double
+        config_value.double
+      end
+    end
+
+    def as_millis(obj)
+      if obj.is_a?(Numeric)
+        return obj.to_int if obj.respond_to?(:to_int)
+      end
+      if obj.is_a?(String)
+        Time.iso8601(obj).utc.to_i * 1000 rescue nil
+      end
+    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 Reforge::Evaluation.new(
+            config: @config,
+            value: conditional_value.value,
+            value_index: value_index,
+            config_row_index: index,
+            context: properties,
+            resolver: @resolver
+          )
+        end
+      end
+
+      nil
+    end
+
+    def in_segment?(criterion, properties)
+      segment = @resolver.get(criterion.value_to_match.string, properties)
+
+      LOG.info("Segment #{criterion.value_to_match.string} not found") unless segment
+
+      segment&.report_and_return(@base_client.evaluation_summary_aggregator)
+    end
+
+    def matches?(criterion, value, properties)
+      criterion_value_or_values = Reforge::ConfigValueUnwrapper.deepest_value(criterion.value_to_match, @config,
+                                                                             properties, @resolver).unwrap
+
+      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.to_s)
+      else
+        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
+
+    def prop_starts_with_one_of?(criterion, value)
+      return false unless value
+
+      criterion.value_to_match.string_list.values.any? do |beginning|
+        value.start_with?(beginning)
+      end
+    end
+
+    def prop_contains_one_of?(criterion, value)
+      return false unless value
+
+      criterion.value_to_match.string_list.values.any? do |substring|
+        value.include?(substring)
+      end
+    end
+
+    def check_regex_match(criterion, properties)
+      begin
+        regex_definition = Reforge::ConfigValueUnwrapper.deepest_value(criterion.value_to_match, @config.key,
+                                                                      properties, @resolver).unwrap
+
+        return MatchResult.error unless regex_definition.is_a?(String)
+
+        value = value_from_properties(criterion, properties)
+
+        regex = compile_regex_safely(ensure_anchored_regex(regex_definition))
+        return MatchResult.error unless regex
+
+        matches = regex.match?(value.to_s)
+        matches ? MatchResult.matched : MatchResult.not_matched
+      rescue RegexpError
+        MatchResult.error
+      end
+    end
+
+    def compile_regex_safely(pattern)
+      begin
+        Regexp.new(pattern)
+      rescue RegexpError
+        nil
+      end
+    end
+
+    def ensure_anchored_regex(pattern)
+      return pattern if pattern.start_with?("^") && pattern.end_with?("$")
+
+      "^#{pattern}$"
+    end
+
+    class MatchResult
+      attr_reader :matched, :error
+
+      def self.matched
+        new(matched: true)
+      end
+
+      def self.not_matched
+        new(matched: false)
+      end
+
+      def self.error
+        new(matched: false, error: true)
+      end
+
+      def initialize(matched:, error: false)
+        @matched = matched
+        @error = error
+      end
+    end
+  end
+end
+# rubocop:enable Naming/MethodName