prefab-cloud-ruby 0

data/lib/prefab/config_value_unwrapper.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Prefab
+  class ConfigValueUnwrapper
+    LOG = Prefab::InternalLogger.new(ConfigValueUnwrapper)
+    CONFIDENTIAL_PREFIX = "*****"
+    attr_reader :weighted_value_index
+
+    def initialize(config_value, resolver, weighted_value_index = nil)
+      @config_value = config_value
+      @resolver = resolver
+      @weighted_value_index = weighted_value_index
+    end
+
+    def reportable_wrapped_value
+      if @config_value.confidential || @config_value.decrypt_with&.length&.positive?
+        # Unique hash for differentiation
+        Prefab::ConfigValueWrapper.wrap("#{CONFIDENTIAL_PREFIX}#{Digest::MD5.hexdigest(unwrap)[0, 5]}")
+      else
+        @config_value
+      end
+    end
+
+    def reportable_value
+      Prefab::ConfigValueUnwrapper.new(reportable_wrapped_value, @resolver, @weighted_value_index).unwrap
+    end
+
+    def raw_config_value
+      @config_value
+    end
+
+    # this will return the actual value of confidential, use reportable_value unless you need it
+    def unwrap
+      raw = case @config_value.type
+            when :int, :string, :double, :bool, :log_level
+              @config_value.public_send(@config_value.type)
+            when :string_list
+              @config_value.string_list.values
+            else
+              LOG.error "Unknown type: #{@config_value.type}"
+              raise "Unknown type: #{@config_value.type}"
+            end
+      if @config_value.has_decrypt_with?
+        decryption_key = @resolver.get(@config_value.decrypt_with)&.unwrapped_value
+        if decryption_key.nil?
+          LOG.warn "No value for decryption key #{@config_value.decrypt_with} found."
+          return ""
+        else
+          unencrypted = Prefab::Encryption.new(decryption_key).decrypt(raw)
+          return unencrypted
+        end
+      end
+
+      raw
+    end
+
+    def self.deepest_value(config_value, config, context, resolver)
+      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
+
+        new(deepest_value(value.value, config, context, resolver).raw_config_value, resolver, index)
+
+      elsif config_value&.type == :provided
+        if :ENV_VAR == config_value.provided.source
+          raw = ENV[config_value.provided.lookup]
+          if raw.nil?
+            raise Prefab::Errors::MissingEnvVarError.new("Missing environment variable #{config_value.provided.lookup}")
+          else
+            coerced = coerce_into_type(raw, config, config_value.provided.lookup)
+            new(Prefab::ConfigValueWrapper.wrap(coerced, confidential: config_value.confidential), resolver)
+          end
+        else
+          raise "Unknown Provided Source #{config_value.provided.source}"
+        end
+      else
+        new(config_value, resolver)
+      end
+    end
+
+    # Don't allow env vars to resolve to a value_type other than the config's value_type
+    def self.coerce_into_type(value_string, config, env_var_name)
+      case config.value_type
+      when :INT then Integer(value_string)
+      when :DOUBLE then Float(value_string)
+      when :STRING then String(value_string)
+      when :STRING_LIST then
+        maybe_string_list = YAML.load(value_string)
+        case maybe_string_list
+        when Array
+          maybe_string_list
+        else
+          raise raise Prefab::Errors::EnvVarParseError.new(value_string, config, env_var_name)
+        end
+      when :BOOL then
+        maybe_bool = YAML.load(value_string)
+        case maybe_bool
+        when TrueClass, FalseClass
+          maybe_bool
+        else
+          raise Prefab::Errors::EnvVarParseError.new(value_string, config, env_var_name)
+        end
+      when :NOT_SET_VALUE_TYPE
+        YAML.load(value_string)
+      else
+        raise Prefab::Errors::EnvVarParseError.new(value_string, config, env_var_name)
+      end
+    rescue ArgumentError
+      raise Prefab::Errors::EnvVarParseError.new(value_string, config, env_var_name)
+    end
+  end
+end

data/lib/prefab/config_value_wrapper.rb

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

data/lib/prefab/context.rb

@@ -0,0 +1,179 @@
+# 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
+
+      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, :seen_at
+
+    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 with_merged_context(context)
+        old_context = Thread.current[THREAD_KEY]
+        Thread.current[THREAD_KEY] = merge_with_current(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.to_h))
+      end
+    end
+
+    def initialize(context = {})
+      @contexts = {}
+      @seen_at = Time.now.utc.to_i
+
+      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 blank?
+      contexts.empty?
+    end
+
+    def set(name, hash)
+      @contexts[name.to_s] = NamedContext.new(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]&.get(key)
+    end
+
+    def to_h
+      contexts.transform_values(&:to_h)
+    end
+
+    def clear
+      @contexts = {}
+    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 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|
+          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.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,65 @@
+# frozen_string_literal: true
+
+require_relative 'periodic_sync'
+
+module Prefab
+  class ContextShapeAggregator
+    include Prefab::PeriodicSync
+
+    LOG = Prefab::InternalLogger.new(ContextShapeAggregator)
+
+    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.debug "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 = post('/api/v1/context-shapes', shapes)
+
+        LOG.debug "Uploaded #{to_ship.values.size} shapes: #{result.status}"
+      end
+    end
+  end
+end

data/lib/prefab/criteria_evaluator.rb

@@ -0,0 +1,136 @@
+# 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
+  # This class evaluates a config's criteria. `evaluate` returns the value of
+  # the first match based on the provided properties.
+  class CriteriaEvaluator
+    LOG = Prefab::InternalLogger.new(CriteriaEvaluator)
+    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.debug "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)
+      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
+
+    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,
+            resolver: @resolver
+          )
+        end
+      end
+
+      nil
+    end
+
+    def in_segment?(criterion, properties)
+      segment = @resolver.get(criterion.value_to_match.string, properties)
+
+      @base_client.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 = Prefab::ConfigValueUnwrapper.deepest_value(criterion.value_to_match, @config.key,
+                                                                             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
+  end
+end
+# rubocop:enable Naming/MethodName

data/lib/prefab/encryption.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Prefab
+  class Encryption
+    CIPHER_TYPE = "aes-256-gcm" # 32/12
+    SEPARATOR = "--"
+
+    # Hexadecimal format ensures that generated keys are representable with
+    # plain text
+    #
+    # To convert back to the original string with the desired length:
+    #   [ value ].pack("H*")
+    def self.generate_new_hex_key
+      generate_random_key.unpack("H*")[0]
+    end
+
+    def initialize(key_string_hex)
+      @key = [key_string_hex].pack("H*")
+    end
+
+    def encrypt(clear_text)
+      cipher = OpenSSL::Cipher.new(CIPHER_TYPE)
+      cipher.encrypt
+      iv = cipher.random_iv
+
+      # load them into the cipher
+      cipher.key = @key
+      cipher.iv = iv
+      cipher.auth_data = ""
+
+      # encrypt the message
+      encrypted = cipher.update(clear_text)
+      encrypted << cipher.final
+      tag = cipher.auth_tag
+
+      # pack and join
+      [encrypted, iv, tag].map { |p| p.unpack("H*")[0] }.join(SEPARATOR)
+    end
+
+    def decrypt(encrypted_string)
+      unpacked_parts = encrypted_string.split(SEPARATOR).map { |p| [p].pack("H*") }
+
+      cipher = OpenSSL::Cipher.new(CIPHER_TYPE)
+      cipher.decrypt
+      cipher.key = @key
+      cipher.iv = unpacked_parts[1]
+      cipher.auth_tag = unpacked_parts[2]
+
+      # and decrypt it
+      decrypted = cipher.update(unpacked_parts[0])
+      decrypted << cipher.final
+      decrypted
+    end
+
+    private
+
+    def self.generate_random_key
+      SecureRandom.random_bytes(key_length)
+    end
+
+    def self.key_length
+      OpenSSL::Cipher.new(CIPHER_TYPE).key_len
+    end
+  end
+end

data/lib/prefab/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Prefab
+  class Error < StandardError
+  end
+end

data/lib/prefab/errors/env_var_parse_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Prefab
+  module Errors
+    class EnvVarParseError < Prefab::Error
+      def initialize(env_var, config, env_var_name)
+        super("Evaluating #{config.key} couldn't coerce #{env_var_name} of #{env_var} to #{config.value_type}")
+      end
+    end
+  end
+end

data/lib/prefab/errors/initialization_timeout_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Prefab
+  module Errors
+    class InitializationTimeoutError < Prefab::Error
+      def initialize(timeout_sec, key)
+        message = "Prefab couldn't initialize in #{timeout_sec} second timeout. Trying to fetch key `#{key}`."
+
+        super(message)
+      end
+    end
+  end
+end

data/lib/prefab/errors/invalid_api_key_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Prefab
+  module Errors
+    class InvalidApiKeyError < Prefab::Error
+      def initialize(key)
+        if key.nil? || key.empty?
+          message = 'No API key. Set PREFAB_API_KEY env var or use PREFAB_DATASOURCES=LOCAL_ONLY'
+
+          super(message)
+        else
+          message = "Your API key format is invalid. Expecting something like 123-development-yourapikey-SDK. You provided `#{key}`"
+
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/prefab/errors/missing_default_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Prefab
+  module Errors
+    class MissingDefaultError < Prefab::Error
+      def initialize(key)
+        message = "No value found for key '#{key}' and no default was provided.\n\nIf you'd prefer returning `nil` rather than raising when this occurs, modify the `on_no_default` value you provide in your Prefab::Options."
+
+        super(message)
+      end
+    end
+  end
+end

data/lib/prefab/errors/missing_env_var_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Prefab
+  module Errors
+    class MissingEnvVarError < Prefab::Error
+      def initialize(message)
+        super(message)
+      end
+    end
+  end
+end

data/lib/prefab/errors/uninitialized_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Prefab
+  module Errors
+    class UninitializedError < Prefab::Error
+      def initialize(key=nil)
+        message = "Use Prefab.initialize before calling Prefab.get #{key}"
+
+        super(message)
+      end
+    end
+  end
+end