prefab-cloud-ruby 0 → 0.0.1

data/lib/prefab/context_shape_aggregator.rb

@@ -1,65 +0,0 @@
-# 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

@@ -1,136 +0,0 @@
-# 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

@@ -1,65 +0,0 @@
-# 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

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

data/lib/prefab/errors/env_var_parse_error.rb

@@ -1,11 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,11 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

data/lib/prefab/evaluation.rb

@@ -1,52 +0,0 @@
-# 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:, resolver:)
-      @config = config
-      @value = value
-      @value_index = value_index
-      @config_row_index = config_row_index
-      @context = context
-      @resolver = resolver
-    end
-
-    def unwrapped_value
-      deepest_value.unwrap
-    end
-
-    def reportable_value
-      deepest_value.reportable_value
-    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.reportable_wrapped_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, @context, @resolver)
-    end
-  end
-end

data/lib/prefab/evaluation_summary_aggregator.rb

@@ -1,87 +0,0 @@
-# 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
-
-    LOG = Prefab::InternalLogger.new(EvaluationSummaryAggregator)
-
-    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.debug "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 = post('/api/v1/telemetry', events(summaries_proto))
-
-        LOG.debug "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

@@ -1,78 +0,0 @@
-# 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
-
-    LOG = Prefab::InternalLogger.new(ExampleContextsAggregator)
-
-    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.debug "Flushing #{to_ship.size} examples"
-
-        result = post('/api/v1/telemetry', events(to_ship))
-
-        LOG.debug "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,21 +0,0 @@
-# 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
-      @max_delay = max_delay
-      @multiplier = multiplier
-      @delay = initial_delay
-    end
-
-    def call
-      delay = @delay
-      @delay = [@delay * @multiplier, @max_delay].min
-      delay
-    end
-  end
-end

data/lib/prefab/feature_flag_client.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Prefab
-  class FeatureFlagClient
-    def initialize(base_client)
-      @base_client = base_client
-    end
-
-    def feature_is_on?(feature_name)
-      feature_is_on_for?(feature_name, {})
-    end
-
-    def feature_is_on_for?(feature_name, properties)
-      variant = @base_client.config_client.get(feature_name, false, properties)
-
-      is_on?(variant)
-    end
-
-    def get(feature_name, properties, default: false)
-      value = _get(feature_name, properties)
-
-      value.nil? ? default : value
-    end
-
-    private
-
-    def _get(feature_name, properties)
-      @base_client.config_client.get(feature_name, nil, properties)
-    end
-
-    def is_on?(variant)
-      return false if variant.nil?
-
-      return variant if variant == !!variant
-
-      variant.bool
-    rescue StandardError
-      @base_client.log.info("is_on? methods only work for boolean feature flags variants. This feature flags variant is '#{variant}'. Returning false")
-      false
-    end
-  end
-end

data/lib/prefab/http_connection.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Prefab
-  class HttpConnection
-    AUTH_USER = 'authuser'
-    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
-      @api_key = api_key
-    end
-
-    def get(path)
-      connection(PROTO_HEADERS).get(path)
-    end
-
-    def post(path, body)
-      connection(PROTO_HEADERS).post(path, body.to_proto)
-    end
-
-    def connection(headers = {})
-      if Faraday::VERSION[0].to_i >= 2
-        Faraday.new(@api_root) do |conn|
-          conn.request :authorization, :basic, AUTH_USER, @api_key
-
-          conn.headers.merge!(headers)
-        end
-      else
-        Faraday.new(@api_root) do |conn|
-          conn.request :basic_auth, AUTH_USER, @api_key
-
-          conn.headers.merge!(headers)
-        end
-      end
-    end
-  end
-end