sdk-reforge 1.9.0

data/lib/reforge/javascript_stub.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Reforge
+  class JavaScriptStub
+    LOG = Reforge::InternalLogger.new(self)
+    CAMELS = {}
+
+    def initialize(client = nil)
+      @client = client || Prefab.instance
+    end
+
+    def bootstrap(context)
+      configs, warnings = data(context, :bootstrap)
+      <<~JS
+        window._prefabBootstrap = {
+          evaluations: #{JSON.dump(configs)},
+          context: #{JSON.dump(context)}
+        }
+        #{log_warnings(warnings)}
+      JS
+    end
+
+    def generate_stub(context, callback = nil)
+      configs, warnings = data(context, :stub)
+      <<~JS
+        window.prefab = window.prefab || {};
+        window.prefab.config = #{JSON.dump(configs)};
+        window.prefab.get = function(key) {
+          var value = window.prefab.config[key];
+        #{callback && "  #{callback}(key, value);"}
+          return value;
+        };
+        window.prefab.isEnabled = function(key) {
+          var value = window.prefab.config[key] === true;
+        #{callback && "  #{callback}(key, value);"}
+          return value;
+        };
+        #{log_warnings(warnings)}
+      JS
+    end
+
+    private
+
+    def underlying_value(value)
+      v = Reforge::ConfigValueUnwrapper.new(value, @client.resolver).unwrap(raw_json: true)
+      case v
+      when Google::Protobuf::RepeatedField
+        v.to_a
+      when Reforge::Duration
+        v.as_json
+      else
+        v
+      end
+    end
+
+    def log_warnings(warnings)
+      return '' if warnings.empty?
+
+      <<~JS
+        console.warn('The following keys could not be resolved:', #{JSON.dump(warnings)});
+      JS
+    end
+
+    def data(context, mode)
+      permitted = {}
+      warnings = []
+      resolver_keys = @client.resolver.keys
+
+      resolver_keys.each do |key|
+        begin
+          config = @client.resolver.raw(key)
+
+          if config.config_type == :FEATURE_FLAG || config.send_to_client_sdk || config.config_type == :LOG_LEVEL
+            value = @client.resolver.get(key, context).value
+            if mode == :bootstrap
+              permitted[key] = { value: { to_camel_case(value.type) => underlying_value(value) } }
+            else
+              permitted[key] = underlying_value(value)
+            end
+          end
+        rescue StandardError => e
+          LOG.warn("Could not resolve key #{key}: #{e}")
+
+          warnings << key
+        end
+      end
+
+      [permitted, warnings]
+    end
+
+    def to_camel_case(str)
+      CAMELS[str] ||= begin
+        str.to_s.split('_').map.with_index { |word, index|
+          index == 0 ? word : word.capitalize
+        }.join
+      end
+    end
+  end
+end

data/lib/reforge/local_config_parser.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Reforge
+  class LocalConfigParser
+    class << self
+      def parse(key, value, config, file)
+        if value.instance_of?(Hash)
+          if value['feature_flag']
+            config[key] = feature_flag_config(file, key, value)
+          elsif value['type'] == 'provided'
+            config[key] = provided_config(file, key, value)
+          elsif value['decrypt_with'] || value['confidential']
+            config[key] = complex_string(file, key, value)
+          else
+            value.each do |nest_key, nest_value|
+              nested_key = "#{key}.#{nest_key}"
+              nested_key = key if nest_key == '_'
+              parse(nested_key, nest_value, config, file)
+            end
+          end
+        else
+          config[key] = {
+            source: file,
+            match: 'default',
+            config: PrefabProto::Config.new(
+              config_type: :CONFIG,
+              key: key,
+              rows: [
+                PrefabProto::ConfigRow.new(values: [
+                  PrefabProto::ConditionalValue.new(value: value_from(key, value))
+                ])
+              ]
+            )
+          }
+        end
+
+        config
+      end
+
+      def value_from(key, raw)
+        case raw
+        when String
+          if key.to_s.start_with? 'log-level'
+            prefab_log_level_resolve = PrefabProto::LogLevel.resolve(raw.upcase.to_sym) || PrefabProto::LogLevel::NOT_SET_LOG_LEVEL
+            { log_level: prefab_log_level_resolve }
+          else
+            { string: raw }
+          end
+        when Integer
+          { int: raw }
+        when TrueClass, FalseClass
+          { bool: raw }
+        when Float
+          { double: raw }
+        end
+      end
+
+      def feature_flag_config(file, key, value)
+        criterion = (parse_criterion(value['criterion']) if value['criterion'])
+
+        variant = PrefabProto::ConfigValue.new(value_from(key, value['value']))
+
+        row = PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              criteria: [criterion].compact,
+              value: variant
+            )
+          ]
+        )
+
+        raise Reforge::Error, "Feature flag config `#{key}` #{file} must have a `value`" unless value.key?('value')
+
+        {
+          source: file,
+          match: key,
+          config: PrefabProto::Config.new(
+            config_type: :FEATURE_FLAG,
+            key: key,
+            allowable_values: [variant],
+            rows: [row]
+          )
+        }
+      end
+
+      def provided_config(file, key, value_hash)
+        value = PrefabProto::ConfigValue.new(provided: PrefabProto::Provided.new(
+          source: :ENV_VAR,
+          lookup: value_hash["lookup"],
+        ),
+                                             confidential: value_hash["confidential"],
+        )
+
+        row = PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              value: value
+            )
+          ]
+        )
+
+        {
+          source: file,
+          match: value.provided.lookup,
+          config: PrefabProto::Config.new(
+            config_type: :CONFIG,
+            key: key,
+            rows: [row]
+          )
+        }
+      end
+
+      def complex_string(file, key, value_hash)
+        value = PrefabProto::ConfigValue.new(
+          string: value_hash["value"],
+          confidential: value_hash["confidential"],
+          decrypt_with: value_hash["decrypt_with"],
+        )
+
+        row = PrefabProto::ConfigRow.new(
+          values: [
+            PrefabProto::ConditionalValue.new(
+              value: value
+            )
+          ]
+        )
+
+        {
+          source: file,
+          config: PrefabProto::Config.new(
+            config_type: :CONFIG,
+            key: key,
+            rows: [row]
+          )
+        }
+      end
+
+      def parse_criterion(criterion)
+        PrefabProto::Criterion.new(operator: criterion['operator'],
+                                   property_name: criterion['property'],
+                                   value_to_match: parse_value_to_match(criterion['values']))
+      end
+
+      def parse_value_to_match(values)
+        raise "Can't handle #{values}" unless values.instance_of?(Array)
+
+        PrefabProto::ConfigValue.new(string_list: PrefabProto::StringList.new(values: values))
+      end
+    end
+  end
+end

data/lib/reforge/murmer3.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class Murmur3
+  ## MurmurHash3 was written by Austin Appleby, and is placed in the public
+  ## domain. The author hereby disclaims copyright to this source code.
+
+  MASK32 = 0xffffffff
+
+  def self.murmur3_32_rotl(x, r)
+    ((x << r) | (x >> (32 - r))) & MASK32
+  end
+
+  def self.murmur3_32_fmix(h)
+    h &= MASK32
+    h ^= h >> 16
+    h = (h * 0x85ebca6b) & MASK32
+    h ^= h >> 13
+    h = (h * 0xc2b2ae35) & MASK32
+    h ^ (h >> 16)
+  end
+
+  def self.murmur3_32__mmix(k1)
+    k1 = (k1 * 0xcc9e2d51) & MASK32
+    k1 = murmur3_32_rotl(k1, 15)
+    (k1 * 0x1b873593) & MASK32
+  end
+
+  def self.murmur3_32(str, seed = 0)
+    h1 = seed
+    numbers = str.unpack('V*C*')
+    tailn = str.length % 4
+    tail = numbers.slice!(numbers.size - tailn, tailn)
+    for k1 in numbers
+      h1 ^= murmur3_32__mmix(k1)
+      h1 = murmur3_32_rotl(h1, 13)
+      h1 = (h1 * 5 + 0xe6546b64) & MASK32
+    end
+
+    unless tail.empty?
+      k1 = 0
+      tail.reverse_each do |c1|
+        k1 = (k1 << 8) | c1
+      end
+      h1 ^= murmur3_32__mmix(k1)
+    end
+
+    h1 ^= str.length
+    murmur3_32_fmix(h1)
+  end
+end

data/lib/reforge/options.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Reforge
+  # This class contains all the options that can be passed to the Prefab client.
+  class Options
+    attr_reader :sdk_key
+    attr_reader :namespace
+    attr_reader :sources
+    attr_reader :sse_sources
+    attr_reader :telemetry_destination
+    attr_reader :config_sources
+    attr_reader :on_no_default
+    attr_reader :initialization_timeout_sec
+    attr_reader :on_init_failure
+    attr_reader :collect_sync_interval
+    attr_reader :use_local_cache
+    attr_reader :datafile
+    attr_reader :global_context
+    attr_accessor :is_fork
+    attr_reader :symbolize_json_names
+
+    module ON_INITIALIZATION_FAILURE
+      RAISE = :raise
+      RETURN = :return
+    end
+
+    module ON_NO_DEFAULT
+      RAISE = :raise
+      RETURN_NIL = :return_nil
+    end
+
+    module DATASOURCES
+      ALL = :all
+      LOCAL_ONLY = :local_only
+    end
+
+    DEFAULT_MAX_PATHS = 1_000
+    DEFAULT_MAX_KEYS = 100_000
+    DEFAULT_MAX_EXAMPLE_CONTEXTS = 100_000
+    DEFAULT_MAX_EVAL_SUMMARIES = 100_000
+
+    DEFAULT_SOURCES = [
+      "https://primary.reforge.com",
+      "https://secondary.reforge.com",
+    ].freeze
+
+    private def init(
+      sources: nil,
+      sdk_key: ENV['SDK_API_KEY'] || ENV['PREFAB_API_KEY'],
+      namespace: '',
+      reforge_api_url: nil,
+      on_no_default: ON_NO_DEFAULT::RAISE, # options :raise, :warn_and_return_nil,
+      initialization_timeout_sec: 10, # how long to wait before on_init_failure
+      on_init_failure: ON_INITIALIZATION_FAILURE::RAISE,
+      prefab_datasources: (ENV['REFORGE_DATASOURCES'] || ENV['PREFAB_DATASOURCES']) == 'LOCAL_ONLY' ? DATASOURCES::LOCAL_ONLY : DATASOURCES::ALL,
+      collect_logger_counts: true,
+      collect_max_paths: DEFAULT_MAX_PATHS,
+      collect_sync_interval: nil,
+      context_upload_mode: :periodic_example, # :periodic_example, :shape_only, :none
+      context_max_size: DEFAULT_MAX_EVAL_SUMMARIES,
+      collect_evaluation_summaries: true,
+      collect_max_evaluation_summaries: DEFAULT_MAX_EVAL_SUMMARIES,
+      allow_telemetry_in_local_mode: false,
+      datafile: ENV['PREFAB_DATAFILE'],
+      x_datafile: nil, # DEPRECATED in favor of `datafile`
+      x_use_local_cache: false,
+      symbolize_json_names: false,
+      global_context: {}
+    )
+      @sdk_key = sdk_key
+      @namespace = namespace
+      @on_no_default = on_no_default
+      @initialization_timeout_sec = initialization_timeout_sec
+      @on_init_failure = on_init_failure
+      @prefab_datasources = prefab_datasources
+
+      @datafile = datafile || x_datafile
+
+      if !x_datafile.nil?
+        warn '[DEPRECATION] x_datafile is deprecated. Please provide `datafile` instead'
+      end
+
+      @collect_logger_counts = collect_logger_counts
+      @collect_max_paths = collect_max_paths
+      @collect_sync_interval = collect_sync_interval
+      @collect_evaluation_summaries = collect_evaluation_summaries
+      @collect_max_evaluation_summaries = collect_max_evaluation_summaries
+      @allow_telemetry_in_local_mode = allow_telemetry_in_local_mode
+      @use_local_cache = x_use_local_cache
+      @is_fork = false
+      @global_context = global_context
+      @symbolize_json_names = symbolize_json_names
+
+      # defaults that may be overridden by context_upload_mode
+      @collect_shapes = false
+      @collect_max_shapes = 0
+      @collect_example_contexts = false
+      @collect_max_example_contexts = 0
+
+      if ENV['PREFAB_API_URL_OVERRIDE'] && ENV['PREFAB_API_URL_OVERRIDE'].length > 0
+        sources = ENV['PREFAB_API_URL_OVERRIDE']
+      end
+
+      @sources = Array(sources || DEFAULT_SOURCES).map {|source| remove_trailing_slash(source) }
+
+      @sse_sources = @sources
+      @config_sources = @sources
+
+      @telemetry_destination = @sources.select do |source|
+        source.start_with?('https://') && (source.include?("primary") || source.include?("secondary") || source.include?("belt") || source.include?("suspenders"))
+      end.map do |source|
+        source.sub(/(primary|secondary)\./, 'telemetry.').sub(/(belt|suspenders)\./, 'telemetry.')
+      end[0]
+
+      if reforge_api_url
+        warn '[DEPRECATION] reforge_api_url is deprecated. Please provide `sources` if you need to override the default sources'
+      end
+
+      case context_upload_mode
+      when :none
+        # do nothing
+      when :periodic_example
+        @collect_example_contexts = true
+        @collect_max_example_contexts = context_max_size
+        @collect_shapes = true
+        @collect_max_shapes = context_max_size
+      when :shape_only
+        @collect_shapes = true
+        @collect_max_shapes = context_max_size
+      else
+        raise "Unknown context_upload_mode #{context_upload_mode}. Please provide :periodic_example, :shape_only, or :none."
+      end
+    end
+
+    def initialize(options = {})
+      init(**options)
+    end
+
+    def local_only?
+      @prefab_datasources == DATASOURCES::LOCAL_ONLY
+    end
+
+    def datafile?
+      !@datafile.nil?
+    end
+
+    def collect_max_paths
+      return 0 unless telemetry_allowed?(@collect_logger_counts)
+
+      @collect_max_paths
+    end
+
+    def collect_max_shapes
+      return 0 unless telemetry_allowed?(@collect_shapes)
+
+      @collect_max_shapes
+    end
+
+    def collect_max_example_contexts
+      return 0 unless telemetry_allowed?(@collect_example_contexts)
+
+      @collect_max_example_contexts
+    end
+
+    def collect_max_evaluation_summaries
+      return 0 unless telemetry_allowed?(@collect_evaluation_summaries)
+
+      @collect_max_evaluation_summaries
+    end
+
+    def sdk_key_id
+      @sdk_key&.split("-")&.first
+    end
+
+    def for_fork
+      clone = self.clone
+      clone.is_fork = true
+      clone
+    end
+
+    private
+
+    def telemetry_allowed?(option)
+      option && (!local_only? || @allow_telemetry_in_local_mode)
+    end
+
+    def remove_trailing_slash(url)
+      url.end_with?('/') ? url[0..-2] : url
+    end
+  end
+end

data/lib/reforge/periodic_sync.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Reforge
+  module PeriodicSync
+    LOG = Reforge::InternalLogger.new(self)
+
+    def sync
+      return if @data.size.zero?
+
+      LOG.debug "Syncing #{@data.size} items"
+
+      start_at_was = @start_at
+      @start_at = Reforge::TimeHelpers.now_in_ms
+
+      flush(prepare_data, start_at_was)
+    end
+
+    def prepare_data
+      to_ship = @data.dup
+      @data.clear
+
+      on_prepare_data
+
+      to_ship
+    end
+
+    def on_prepare_data
+      # noop -- override as you wish
+    end
+
+    def post(url, data)
+      @client.post(url, data)
+    end
+
+    def instance_hash
+      @client.instance_hash
+    end
+
+    def start_periodic_sync(sync_interval)
+      @start_at = Reforge::TimeHelpers.now_in_ms
+
+      @sync_interval = calculate_sync_interval(sync_interval)
+
+      Thread.new do
+        LOG.debug "Initialized #{@name} instance_hash=#{@client.instance_hash}"
+
+        loop do
+          sleep @sync_interval.call
+          sync
+        end
+      end
+    end
+
+    def pool
+      @pool ||= Concurrent::ThreadPoolExecutor.new(
+        fallback_policy: :discard,
+        max_queue: 5,
+        max_threads: 4,
+        min_threads: 1,
+        name: @name
+      )
+    end
+
+    private
+
+    def calculate_sync_interval(sync_interval)
+      if sync_interval.is_a?(Numeric)
+        proc { sync_interval }
+      else
+        sync_interval || ExponentialBackoff.new(initial_delay: 8, max_delay: 60 * 5)
+      end
+    end
+  end
+end

data/lib/reforge/prefab.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Reforge
+  LOG = Reforge::InternalLogger.new(self)
+  @@lock = Concurrent::ReadWriteLock.new
+  @config_has_loaded = false
+
+  def self.init(options = Reforge::Options.new)
+    unless @singleton.nil?
+      LOG.warn 'Prefab already initialized.'
+      return @singleton
+    end
+
+    @@lock.with_write_lock {
+      @singleton = Reforge::Client.new(options)
+    }
+  end
+
+  def self.fork
+    ensure_initialized
+    @@lock.with_write_lock {
+      @singleton = @singleton.fork
+    }
+  end
+
+  def self.set_rails_loggers
+    ensure_initialized
+    @singleton.set_rails_loggers
+  end
+
+  def self.get(key, default = NO_DEFAULT_PROVIDED, jit_context = NO_DEFAULT_PROVIDED)
+    ensure_initialized key
+    @singleton.get(key, default, jit_context)
+  end
+
+  def self.enabled?(feature_name, jit_context = NO_DEFAULT_PROVIDED)
+    ensure_initialized feature_name
+    @singleton.enabled?(feature_name, jit_context)
+  end
+
+  def self.with_context(properties, &block)
+    ensure_initialized
+    @singleton.with_context(properties, &block)
+  end
+
+  def self.instance
+    ensure_initialized
+    @singleton
+  end
+
+  def self.log_filter
+    InternalLogger.using_reforge_log_filter!
+    return Proc.new do |log|
+      bootstrap_log_level(log)
+    end
+  end
+
+  def self.finish_init!
+    @config_has_loaded = true
+  end
+
+  def self.bootstrap_log_level(log)
+    level = ENV['REFORGE_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'] ? ENV['REFORGE_LOG_CLIENT_BOOTSTRAP_LOG_LEVEL'].downcase.to_sym : :warn
+    SemanticLogger::Levels.index(level) <= SemanticLogger::Levels.index(log.level)
+  end
+
+  def self.defined?(key)
+    ensure_initialized key
+    @singleton.defined?(key)
+  end
+
+  def self.is_ff?(key)
+    ensure_initialized key
+    @singleton.is_ff?(key)
+  end
+
+  # Generate the JavaScript snippet to bootstrap the client SDK. This will
+  # include the configuration values that are permitted to be sent to the
+  # client SDK.
+  #
+  # If the context provided to the client SDK is not the same as the context
+  # used to generate the configuration values, the client SDK will still
+  # generate a fetch to get the correct values for the context.
+  #
+  # Any keys that could not be resolved will be logged as a warning to the
+  # console.
+  def self.bootstrap_javascript(context)
+    ensure_initialized
+    Reforge::JavaScriptStub.new(@singleton).bootstrap(context)
+  end
+
+  # Generate the JavaScript snippet to *replace* the client SDK. Use this to
+  # get `prefab.get` and `prefab.isEnabled` functions on the window object.
+  #
+  # Only use this if you are not using the client SDK and do not need
+  # client-side context.
+  #
+  # Any keys that could not be resolved will be logged as a warning to the
+  # console.
+  #
+  # You can pass an optional callback function to be called with the key and
+  # value of each configuration value. This can be useful for logging,
+  # tracking experiment exposure, etc.
+  #
+  # e.g.
+  # - `Prefab.generate_javascript_stub(context, "reportExperimentExposure")`
+  # - `Prefab.generate_javascript_stub(context, "(key,value)=>{console.log({eval: 'eval', key,value})}")`
+  def self.generate_javascript_stub(context, callback = nil)
+    ensure_initialized
+    Reforge::JavaScriptStub.new(@singleton).generate_stub(context, callback)
+  end
+
+  private
+
+  def self.ensure_initialized(key = nil)
+    if not defined? @singleton or @singleton.nil?
+      raise Reforge::Errors::UninitializedError.new(key)
+    end
+  end
+end