sdk-reforge 1.9.0

data/lib/reforge/rate_limit_cache.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Reforge
+  # A key-based rate limiter that considers a key to be fresh if it has been
+  # seen within the last `duration` seconds.
+  #
+  # This is used to rate limit the number of times we send a given context
+  # to the server.
+  #
+  # Because expected usage is to immediately `set` on a `fresh?` miss, we do
+  # not prune the data structure on `fresh?` calls. Instead, we manually invoke
+  # `prune` periodically from the cache consumer.
+  class RateLimitCache
+    attr_reader :data
+
+    def initialize(duration)
+      @data = Concurrent::Map.new
+      @duration = duration
+    end
+
+    def fresh?(key)
+      timestamp = @data[key]
+
+      return false unless timestamp
+      return false if Time.now.utc.to_i - timestamp > @duration
+
+      true
+    end
+
+    def set(key)
+      @data[key] = Time.now.utc.to_i
+    end
+
+    def prune
+      now = Time.now.utc.to_i
+      @data.each_pair do |key, (timestamp, _)|
+        @data.delete(key) if now - timestamp > @duration
+      end
+    end
+  end
+end

data/lib/reforge/resolved_config_presenter.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Reforge
+  class ResolvedConfigPresenter
+    class ConfigRow
+      include Comparable
+
+      attr_reader :key, :value, :match, :source
+
+      def initialize(key, value, match, source)
+        @key = key
+        @value = value
+        @match = match
+        @source = source
+      end
+
+      def <=>(other)
+        inspect <=> other.inspect
+      end
+
+      def inspect
+        [@key, @value, @match, @source].inspect
+      end
+    end
+
+    def initialize(resolver, lock, local_store)
+      @resolver = resolver
+      @lock = lock
+      @local_store = local_store
+    end
+
+    def each(&block)
+      to_h.each(&block)
+    end
+
+    def to_h
+      hash = {}
+
+      Reforge::Context.with_context({}) do
+        @lock.with_read_lock do
+          @local_store.keys.sort.each do |k|
+            v = @local_store[k]
+
+            if v.nil?
+              hash[k] = ConfigRow.new(k, nil, nil, nil)
+            else
+              value = @resolver.evaluate(v[:config])&.reportable_value
+              hash[k] = ConfigRow.new(k, value, v[:match], v[:source])
+            end
+          end
+        end
+      end
+
+      hash
+    end
+
+    def to_s
+      str = "\n"
+
+      Reforge::Context.with_context({}) do
+        @lock.with_read_lock do
+          @local_store.keys.sort.each do |k|
+            v = @local_store[k]
+            elements = [k.slice(0..49).ljust(50)]
+            if v.nil?
+              elements << 'tombstone'
+            else
+              value = begin
+                @resolver.evaluate(v[:config])&.reportable_value
+              rescue StandardError => e
+                "ERROR EVALUATING: #{e.class} #{e.message}"
+              end
+              elements << value.to_s.slice(0..34).ljust(35)
+              elements << value.class.to_s.slice(0..6).ljust(7)
+              elements << "Match: #{v[:match]}".slice(0..29).ljust(30)
+              elements << "Source: #{v[:source]}"
+            end
+            str += elements.join(' | ') << "\n"
+          end
+        end
+      end
+
+      str
+    end
+  end
+end

data/lib/reforge/semver.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+class SemanticVersion
+  include Comparable
+
+  SEMVER_PATTERN = /
+    ^
+    (?<major>0|[1-9]\d*)
+    \.
+    (?<minor>0|[1-9]\d*)
+    \.
+    (?<patch>0|[1-9]\d*)
+    (?:-(?<prerelease>
+      (?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)
+      (?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*
+    ))?
+    (?:\+(?<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?
+    $
+  /x
+
+  attr_reader :major, :minor, :patch, :prerelease, :build_metadata
+
+  def self.parse(version_string)
+    raise ArgumentError, "version string cannot be nil" if version_string.nil?
+    raise ArgumentError, "version string cannot be empty" if version_string.empty?
+
+    match = SEMVER_PATTERN.match(version_string)
+    raise ArgumentError, "invalid semantic version format: #{version_string}" unless match
+
+    new(
+      major: match[:major].to_i,
+      minor: match[:minor].to_i,
+      patch: match[:patch].to_i,
+      prerelease: match[:prerelease],
+      build_metadata: match[:buildmetadata]
+    )
+  end
+
+  def self.parse_quietly(version_string)
+    parse(version_string)
+  rescue ArgumentError
+    nil
+  end
+
+  def initialize(major:, minor:, patch:, prerelease: nil, build_metadata: nil)
+    @major = major
+    @minor = minor
+    @patch = patch
+    @prerelease = prerelease
+    @build_metadata = build_metadata
+  end
+
+  def <=>(other)
+    return nil unless other.is_a?(SemanticVersion)
+
+    # Compare major.minor.patch
+    return major <=> other.major if major != other.major
+    return minor <=> other.minor if minor != other.minor
+    return patch <=> other.patch if patch != other.patch
+
+    # Compare pre-release versions
+    compare_prerelease(prerelease, other.prerelease)
+  end
+
+  def ==(other)
+    return false unless other.is_a?(SemanticVersion)
+
+    major == other.major &&
+      minor == other.minor &&
+      patch == other.patch &&
+      prerelease == other.prerelease
+    # Build metadata is ignored in equality checks
+  end
+
+  def eql?(other)
+    self == other
+  end
+
+  def hash
+    [major, minor, patch, prerelease].hash
+  end
+
+  def to_s
+    result = "#{major}.#{minor}.#{patch}"
+    result += "-#{prerelease}" if prerelease
+    result += "+#{build_metadata}" if build_metadata
+    result
+  end
+
+  private
+
+  def self.numeric?(str)
+    str.to_i.to_s == str
+  end
+
+  def compare_prerelease(pre1, pre2)
+    # If both are empty, they're equal
+    return 0 if pre1.nil? && pre2.nil?
+
+    # A version without prerelease has higher precedence
+    return 1 if pre1.nil?
+    return -1 if pre2.nil?
+
+    # Split into identifiers
+    ids1 = pre1.split('.')
+    ids2 = pre2.split('.')
+
+    # Compare each identifier until we find a difference
+    [ids1.length, ids2.length].min.times do |i|
+      cmp = compare_prerelease_identifiers(ids1[i], ids2[i])
+      return cmp if cmp != 0
+    end
+
+    # If all identifiers match up to the length of the shorter one,
+    # the longer one has higher precedence
+    ids1.length <=> ids2.length
+  end
+
+  def compare_prerelease_identifiers(id1, id2)
+    # If both are numeric, compare numerically
+    if self.class.numeric?(id1) && self.class.numeric?(id2)
+      return id1.to_i <=> id2.to_i
+    end
+
+    # If only one is numeric, numeric ones have lower precedence
+    return -1 if self.class.numeric?(id1)
+    return 1 if self.class.numeric?(id2)
+
+    # Neither is numeric, compare as strings
+    id1 <=> id2
+  end
+end

data/lib/reforge/sse_config_client.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Reforge
+  class SSEConfigClient
+    class Options
+      attr_reader :sse_read_timeout, :seconds_between_new_connection,
+                  :sse_default_reconnect_time, :sleep_delay_for_new_connection_check,
+                  :errors_to_close_connection
+
+      def initialize(sse_read_timeout: 300,
+                     seconds_between_new_connection: 5,
+                     sleep_delay_for_new_connection_check: 1,
+                     sse_default_reconnect_time: SSE::Client::DEFAULT_RECONNECT_TIME,
+                     errors_to_close_connection: [HTTP::ConnectionError])
+        @sse_read_timeout = sse_read_timeout
+        @seconds_between_new_connection = seconds_between_new_connection
+        @sse_default_reconnect_time = sse_default_reconnect_time
+        @sleep_delay_for_new_connection_check = sleep_delay_for_new_connection_check
+        @errors_to_close_connection = errors_to_close_connection
+      end
+    end
+
+    AUTH_USER = 'authuser'
+    LOG = Reforge::InternalLogger.new(self)
+
+    def initialize(prefab_options, config_loader, options = nil, logger = nil)
+      @prefab_options = prefab_options
+      @options = options || Options.new
+      @config_loader = config_loader
+      @connected = false
+      @logger = logger || LOG
+    end
+
+    def close
+      @retry_thread&.kill
+      @client&.close
+    end
+
+    def start(&load_configs)
+      if @prefab_options.sse_sources.empty?
+        @logger.debug 'No SSE sources configured'
+        return
+      end
+
+      @client = connect(&load_configs)
+
+      closed_count = 0
+
+      @retry_thread = Thread.new do
+        loop do
+          sleep @options.sleep_delay_for_new_connection_check
+
+          if @client.closed?
+            closed_count += @options.sleep_delay_for_new_connection_check
+
+            if closed_count > @options.seconds_between_new_connection
+              closed_count = 0
+              @logger.debug 'Reconnecting SSE client'
+              @client = connect(&load_configs)
+            end
+          end
+        end
+      end
+    end
+
+    def connect(&load_configs)
+      url = "#{source}/api/v2/sse/config"
+      @logger.debug "SSE Streaming Connect to #{url} start_at #{@config_loader.highwater_mark}"
+
+      SSE::Client.new(url,
+                      headers: headers,
+                      read_timeout: @options.sse_read_timeout,
+                      reconnect_time: @options.sse_default_reconnect_time,
+                      logger: Reforge::InternalLogger.new(SSE::Client)) do |client|
+        client.on_event do |event|
+          configs = PrefabProto::Configs.decode(Base64.decode64(event.data))
+          load_configs.call(configs, event, :sse)
+        end
+
+        client.on_error do |error|
+          @logger.error "SSE Streaming Error: #{error.inspect} for url #{url}"
+
+          if @options.errors_to_close_connection.any? { |klass| error.is_a?(klass) }
+            @logger.debug "Closing SSE connection for url #{url}"
+            client.close
+          end
+        end
+      end
+    end
+
+    def headers
+      auth = "#{AUTH_USER}:#{@prefab_options.sdk_key}"
+      auth_string = Base64.strict_encode64(auth)
+      return {
+        'Last-Event-ID' => @config_loader.highwater_mark,
+        'Authorization' => "Basic #{auth_string}",
+        'Accept' => 'text/event-stream',
+        'X-Reforge-SDK-Version' => "sdk-ruby-#{Reforge::VERSION}"
+      }
+    end
+
+    def source
+      @source_index = @source_index.nil? ? 0 : @source_index + 1
+
+      if @source_index >= @prefab_options.sse_sources.size
+        @source_index = 0
+      end
+
+      return @prefab_options.sse_sources[@source_index].sub(/(primary|secondary)\./, 'stream.').sub(/(belt|suspenders)\./, 'stream.')
+    end
+  end
+end

data/lib/reforge/time_helpers.rb

@@ -0,0 +1,7 @@
+module Reforge
+  module TimeHelpers
+    def self.now_in_ms
+      ::Time.now.utc.to_i * 1000
+    end
+  end
+end

data/lib/reforge/weighted_value_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Reforge
+  class WeightedValueResolver
+    MAX_32_FLOAT = 4_294_967_294.0
+
+    def initialize(weights, config_key, context_hash_value)
+      @weights = weights
+      @config_key = config_key
+      @context_hash_value = context_hash_value
+    end
+
+    def resolve
+      percent = @context_hash_value ? user_percent : rand
+
+      index = variant_index(percent)
+
+      [@weights[index], index]
+    end
+
+    def user_percent
+      to_hash = "#{@config_key}#{@context_hash_value}"
+      int_value = Murmur3.murmur3_32(to_hash)
+      int_value / MAX_32_FLOAT
+    end
+
+    def variant_index(percent_through_distribution)
+      distribution_space = @weights.inject(0) { |sum, v| sum + v.weight }
+      bucket = distribution_space * percent_through_distribution
+
+      sum = 0
+      @weights.each_with_index do |variant_weight, index|
+        return index if bucket < sum + variant_weight.weight
+
+        sum += variant_weight.weight
+      end
+
+      # In the event that all weights are zero, return the last variant
+      @weights.size - 1
+    end
+  end
+end

data/lib/reforge/yaml_config_parser.rb

@@ -0,0 +1,34 @@
+require 'yaml'
+
+module Reforge
+  class YAMLConfigParser
+    LOG = Reforge::InternalLogger.new(self)
+
+    def initialize(file, client)
+      @file = file
+      @client = client
+    end
+
+    def merge(config)
+      yaml = load
+
+      yaml.each do |k, v|
+        config = Reforge::LocalConfigParser.parse(k, v, config, @file)
+      end
+
+      config
+    end
+
+    private
+
+    def load
+      if File.exist?(@file)
+        LOG.info "Load #{@file}"
+        YAML.load_file(@file)
+      else
+        LOG.info "No file #{@file}"
+        {}
+      end
+    end
+  end
+end

data/lib/reforge-sdk.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Reforge
+  NO_DEFAULT_PROVIDED = :no_default_provided
+  VERSION = File.read(File.dirname(__FILE__) + '/../VERSION').strip
+end
+
+require 'semantic_logger'
+require 'reforge/internal_logger'
+require 'concurrent/atomics'
+require 'concurrent'
+require 'faraday'
+require 'openssl'
+require 'ld-eventsource'
+require 'prefab_pb'
+require 'reforge/time_helpers'
+require 'reforge/error'
+require 'reforge/duration'
+require 'reforge/evaluation'
+require 'reforge/encryption'
+require 'reforge/exponential_backoff'
+require 'reforge/errors/initialization_timeout_error'
+require 'reforge/errors/invalid_sdk_key_error'
+require 'reforge/errors/missing_default_error'
+require 'reforge/errors/env_var_parse_error'
+require 'reforge/errors/missing_env_var_error'
+require 'reforge/errors/uninitialized_error'
+require 'reforge/options'
+require 'reforge/rate_limit_cache'
+require 'reforge/context_shape_aggregator'
+require 'reforge/example_contexts_aggregator'
+require 'reforge/evaluation_summary_aggregator'
+require 'reforge/weighted_value_resolver'
+require 'reforge/config_value_wrapper'
+require 'reforge/config_value_unwrapper'
+require 'reforge/criteria_evaluator'
+require 'reforge/config_loader'
+require 'reforge/context_shape'
+require 'reforge/local_config_parser'
+require 'reforge/yaml_config_parser'
+require 'reforge/resolved_config_presenter'
+require 'reforge/config_resolver'
+require 'reforge/http_connection'
+require 'reforge/context'
+require 'active_support/deprecation'
+require 'active_support'
+require 'reforge/sse_config_client'
+require 'reforge/client'
+require 'reforge/config_client_presenter'
+require 'reforge/config_client'
+require 'reforge/feature_flag_client'
+require 'reforge/prefab'
+require 'reforge/murmer3'
+require 'reforge/javascript_stub'
+require 'reforge/semver'
+require 'reforge/fixed_size_hash'
+require 'reforge/caching_http_connection'

data/test/fixtures/datafile.json

@@ -0,0 +1,87 @@
+{
+  "configs": [
+    {
+      "id": "16825372746571694",
+      "projectId": "202",
+      "key": "log-level",
+      "changedBy": {
+        "email": "jeffrey.chupp@prefab.cloud"
+      },
+      "configType": "DELETED"
+    },
+    {
+      "id": "17271108409487302",
+      "projectId": "202",
+      "key": "flag.list.environments",
+      "changedBy": {
+        "email": "jeffrey.chupp@prefab.cloud"
+      },
+      "rows": [
+        {
+          "projectEnvId": "308",
+          "values": [
+            {
+              "criteria": [
+                {
+                  "propertyName": "user.key",
+                  "operator": "PROP_IS_ONE_OF",
+                  "valueToMatch": {
+                    "stringList": {
+                      "values": [
+                        "5905ecd1-9bbf-4711-a663-4f713628a78c"
+                      ]
+                    }
+                  }
+                }
+              ],
+              "value": {
+                "bool": true
+              }
+            },
+            {
+              "value": {
+                "bool": true
+              }
+            }
+          ]
+        }
+      ],
+      "allowableValues": [
+        {
+          "bool": false
+        },
+        {
+          "bool": true
+        }
+      ],
+      "configType": "FEATURE_FLAG",
+      "valueType": "BOOL"
+    },
+    {
+      "id": "17271831941669987",
+      "projectId": "202",
+      "key": "my.test.string",
+      "changedBy": {
+        "userId": "3",
+        "apiKeyId": "481"
+      },
+      "rows": [
+        {
+          "values": [
+            {
+              "value": {
+                "string": "hello world"
+              }
+            }
+          ]
+        }
+      ],
+      "configType": "CONFIG",
+      "valueType": "STRING"
+    }
+  ],
+  "configServicePointer": {
+    "projectId": "202",
+    "projectEnvId": "308"
+  }
+}