sdk-reforge 1.9.0

data/lib/reforge/duration.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Reforge
+  class Duration
+    PATTERN = /P(?:(?<days>\d+(?:\.\d+)?)D)?(?:T(?:(?<hours>\d+(?:\.\d+)?)H)?(?:(?<minutes>\d+(?:\.\d+)?)M)?(?:(?<seconds>\d+(?:\.\d+)?)S)?)?/
+    MINUTES_IN_SECONDS = 60
+    HOURS_IN_SECONDS = 60 * MINUTES_IN_SECONDS
+    DAYS_IN_SECONDS = 24 * HOURS_IN_SECONDS
+
+    def initialize(definition)
+      @seconds = self.class.parse(definition)
+    end
+
+    def self.parse(definition)
+      match = PATTERN.match(definition)
+      return 0 unless match
+
+      days = match[:days]&.to_f || 0
+      hours = match[:hours]&.to_f || 0
+      minutes = match[:minutes]&.to_f || 0
+      seconds = match[:seconds]&.to_f || 0
+
+      (days * DAYS_IN_SECONDS + hours * HOURS_IN_SECONDS + minutes * MINUTES_IN_SECONDS + seconds)
+    end
+
+    def in_seconds
+      @seconds
+    end
+
+    def in_minutes
+      in_seconds / 60.0
+    end
+
+    def in_hours
+      in_minutes / 60.0
+    end
+
+    def in_days
+      in_hours / 24.0
+    end
+
+    def in_weeks
+      in_days / 7.0
+    end
+
+    def to_i
+      in_seconds.to_i
+    end
+
+    def to_f
+      in_seconds.to_f
+    end
+
+    def as_json
+      { ms:  in_seconds * 1000, seconds: in_seconds }
+    end
+  end
+end

data/lib/reforge/encryption.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Reforge
+  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/reforge/error.rb

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

data/lib/reforge/errors/env_var_parse_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Reforge
+  module Errors
+    class EnvVarParseError < Reforge::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/reforge/errors/initialization_timeout_error.rb

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

data/lib/reforge/errors/invalid_sdk_key_error.rb

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

data/lib/reforge/errors/missing_default_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Reforge
+  module Errors
+    class MissingDefaultError < Reforge::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 Reforge::Options."
+
+        super(message)
+      end
+    end
+  end
+end

data/lib/reforge/errors/missing_env_var_error.rb

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

data/lib/reforge/errors/uninitialized_error.rb

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

data/lib/reforge/evaluation.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Reforge
+  # Records the result of evaluating a config's criteria and forensics for reporting
+  class Evaluation
+    attr_reader :value, :context
+
+    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 ||= Reforge::ConfigValueUnwrapper.deepest_value(@value, @config, @context, @resolver)
+    end
+  end
+end

data/lib/reforge/evaluation_summary_aggregator.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'periodic_sync'
+
+module Reforge
+  # 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 Reforge::PeriodicSync
+    LOG = Reforge::InternalLogger.new(self)
+
+    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: Reforge::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/reforge/example_contexts_aggregator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'periodic_sync'
+
+module Reforge
+  # 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 Reforge::PeriodicSync
+    LOG = Reforge::InternalLogger.new(self)
+
+    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 = Reforge::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/reforge/exponential_backoff.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Reforge
+  # 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/reforge/feature_flag_client.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Reforge
+  class FeatureFlagClient
+    LOG = Reforge::InternalLogger.new(self)
+    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
+      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/reforge/fixed_size_hash.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Reforge
+  class FixedSizeHash < Hash
+    def initialize(max_size)
+      @max_size = max_size
+      super()
+    end
+
+    def []=(key, value)
+      shift if size >= @max_size && !key?(key) # Only evict if adding a new key
+      super
+    end
+  end
+end

data/lib/reforge/http_connection.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Reforge
+  class HttpConnection
+    AUTH_USER = 'authuser'
+    PROTO_HEADERS = {
+      'Content-Type' => 'application/x-protobuf',
+      'Accept' => 'application/x-protobuf',
+      'X-Reforge-SDK-Version' => "sdk-ruby-#{Reforge::VERSION}"
+    }.freeze
+
+    def initialize(uri, sdk_key)
+      @uri = uri
+      @sdk_key = sdk_key
+    end
+
+    def uri
+      @uri
+    end
+
+    def get(path, headers = {})
+      connection(PROTO_HEADERS.merge(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(@uri) do |conn|
+          conn.request :authorization, :basic, AUTH_USER, @sdk_key
+
+          conn.headers.merge!(headers)
+        end
+      else
+        Faraday.new(@uri) do |conn|
+          conn.request :basic_auth, AUTH_USER, @sdk_key
+
+          conn.headers.merge!(headers)
+        end
+      end
+    end
+  end
+end

data/lib/reforge/internal_logger.rb

@@ -0,0 +1,43 @@
+module Reforge
+  class InternalLogger < SemanticLogger::Logger
+
+    def initialize(klass)
+      default_level = ENV['REFORGE_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'] ? ENV['REFORGE_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'].downcase.to_sym : :warn
+      super(klass, default_level)
+      instances << self
+    end
+
+    def log(log, message = nil, progname = nil, &block)
+      return if recurse_check[local_log_id]
+      recurse_check[local_log_id] = true
+      begin
+        super(log, message, progname, &block)
+      ensure
+        recurse_check[local_log_id] = false
+      end
+    end
+
+    def local_log_id
+      Thread.current.__id__
+    end
+
+    # Our client outputs debug logging,
+    # but if you aren't using Reforge logging this could be too chatty.
+    # If you aren't using reforge log filter, only log warn level and above
+    def self.using_reforge_log_filter!
+      @@instances.each do |l|
+        l.level = :trace
+      end
+    end
+
+    private
+
+    def instances
+      @@instances ||= []
+    end
+
+    def recurse_check
+      @recurse_check ||=Concurrent::Map.new(initial_capacity: 2)
+    end
+  end
+end