prefab-cloud-ruby 1.8.8.pre.1 → 1.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9485b9faf8e79e7e95f3eb69fb0e9f13c8ab4f1cc9c5f3b8d637f5822ed3ba3b
-  data.tar.gz: efb3287eb90d718ee8ddf3f4461b756a228bb619b21ddf9a6224d994a6a180fc
+  metadata.gz: 543a1cb8d31c7ae3efbc8e63f020803a1813e5de5129cf6adb9093bbfad16a7d
+  data.tar.gz: 15b576851d86a6b1c36f0dc1982392eef70fc53ea01da63419e07128ca33ae0a
 SHA512:
-  metadata.gz: 943920075095daaee6f2defc658cea5ac17f77534936d1ba7783bc4993b994cd867515d3dc83ced057ff26ce2cf74ea1acb1b62e0bbe7cad651b9af9c84fe359
-  data.tar.gz: df03d8f2ba7f57f40ccad2e96b5ca73c42a7f4b27f5524506fe6a95a030420a852b62c2e987d70b49d8e441bf092b5fcc37b1fd57183460824979cb6284d5d1e
+  metadata.gz: a9029c5d87c7c2e62c48697d7b40ddcf44d35e12fb211e7a4292f4212e110dcd42492c110b02d7f49df3985a23b4b76692c6367c2587572f9ea7fa177bd808be
+  data.tar.gz: 0f4fdeab62be128860fcd52b0c5de1486e6e3cb88e4494c155bdc7a6b4c65d4a34fb6adcab60c2ac418194b0398797d1441265716bce80d46d193b3cbae0ee14

data/.github/pull_request_template.md

@@ -0,0 +1,8 @@
+## Description
+*(Brief overview of what this PR changes and/or why the changes are needed)*
+
+## Testing & Validation
+*(Outline the steps needed to be taken to verify the changes.)*
+
+## Rollout
+*(Optional section: Provide rollout and rollback procedures, when outside the bounds or requiring additional work beyond standard deployment)*

data/.github/workflows/ruby.yml

@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.7', '3.0', '3.3']
+        ruby-version: ['3.0','3.1','3.2','3.3']
 
     steps:
     - uses: actions/checkout@v4

data/.tool-versions

@@ -1 +1 @@
-ruby 3.0.3
+ruby 3.2.7

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+
+## 1.8.8 - 2025-02-28
+
+- Add conditional fetch support for configurations (#226)
+- Operator support for string starts with, contains (#212)
+- Operator support for regex, semver (protobuf update) (#215)
+- Operator support for date comparison (before/after) (#221)
+- Operator support for numeric comparisons (#220)
+
+
 ## 1.8.7 - 2024-10-25
 
 - Add option symbolize_json_names (#211)

data/VERSION

@@ -1 +1 @@
-1.8.8.pre.1
+1.8.8

data/lib/prefab/caching_http_connection.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Prefab
+  class CachingHttpConnection
+    CACHE_SIZE = 2.freeze
+    CacheEntry = Struct.new(:data, :etag, :expires_at)
+
+    class << self
+      def cache
+        @cache ||= FixedSizeHash.new(CACHE_SIZE)
+      end
+
+      def reset_cache!
+        @cache = FixedSizeHash.new(CACHE_SIZE)
+      end
+    end
+
+    def initialize(uri, api_key)
+      @connection = HttpConnection.new(uri, api_key)
+    end
+
+    def get(path)
+      now = Time.now.to_i
+      cache_key = "#{@connection.uri}#{path}"
+      cached = self.class.cache[cache_key]
+
+      # Check if we have a valid cached response
+      if cached&.data && cached.expires_at && now < cached.expires_at
+        return Faraday::Response.new(
+          status: 200,
+          body: cached.data,
+          response_headers: {
+            'ETag' => cached.etag,
+            'X-Cache' => 'HIT',
+            'X-Cache-Expires-At' => cached.expires_at.to_s
+          }
+        )
+      end
+
+      # Make request with conditional GET if we have an ETag
+      response = if cached&.etag
+                   @connection.get(path, { 'If-None-Match' => cached.etag })
+                 else
+                   @connection.get(path)
+                 end
+
+      # Handle 304 Not Modified
+      if response.status == 304 && cached&.data
+        return Faraday::Response.new(
+          status: 200,
+          body: cached.data,
+          response_headers: {
+            'ETag' => cached.etag,
+            'X-Cache' => 'HIT',
+            'X-Cache-Expires-At' => cached.expires_at.to_s
+          }
+        )
+      end
+
+      # Parse caching headers
+      cache_control = response.headers['Cache-Control'].to_s
+      etag = response.headers['ETag']
+
+      # Always add X-Cache header
+      response.headers['X-Cache'] = 'MISS'
+
+      # Don't cache if no-store is present
+      return response if cache_control.include?('no-store')
+
+      # Calculate expiration
+      max_age = cache_control.match(/max-age=(\d+)/)&.captures&.first&.to_i
+      expires_at = max_age ? now + max_age : nil
+
+      # Cache the response if we have caching headers
+      if etag || expires_at
+        self.class.cache[cache_key] = CacheEntry.new(
+          response.body,
+          etag,
+          expires_at
+        )
+      end
+
+      response
+    end
+
+    # Delegate other methods to the underlying connection
+    def post(path, body)
+      @connection.post(path, body)
+    end
+
+    def uri
+      @connection.uri
+    end
+  end
+end

data/lib/prefab/config_client.rb

@@ -118,7 +118,7 @@ module Prefab
     end
 
     def load_checkpoint
-      success = load_source_checkpoint
+      success = load_source_checkpoint(:start_at_id => @config_loader.highwater_mark)
       return if success
 
       success = load_cache
@@ -127,11 +127,10 @@ module Prefab
       LOG.warn 'No success loading checkpoints'
     end
 
-    def load_source_checkpoint
+    def load_source_checkpoint(start_at_id: 0)
       @options.config_sources.each do |source|
-        conn = Prefab::HttpConnection.new("#{source}/api/v1/configs/0", @base_client.api_key)
+        conn = Prefab::CachingHttpConnection.new("#{source}/api/v1/configs/#{start_at_id}", @base_client.api_key)
         result = load_url(conn, :remote_api)
-
         return true if result
       end
 
@@ -146,18 +145,18 @@ module Prefab
         cache_configs(configs)
         true
       else
-        LOG.info "Checkpoint #{source} failed to load. Response #{resp.status}"
+        LOG.info "Checkpoint #{source} [#{conn.uri}] failed to load. Response #{resp.status}"
         false
       end
     rescue Faraday::ConnectionFailed => e
       if !initialized?
-        LOG.warn "Connection Fail loading #{source} checkpoint."
+        LOG.warn "Connection Fail loading #{source} [#{conn.uri}] checkpoint."
       else
-        LOG.debug "Connection Fail loading #{source} checkpoint."
+        LOG.debug "Connection Fail loading #{source} [#{conn.uri}] checkpoint."
       end
       false
     rescue StandardError => e
-      LOG.warn "Unexpected #{source} problem loading checkpoint #{e} #{conn}"
+      LOG.warn "Unexpected #{source} [#{conn.uri}] problem loading checkpoint #{e} #{conn}"
       LOG.debug e.backtrace
       false
     end

data/lib/prefab/criteria_evaluator.rb

@@ -21,7 +21,7 @@ module Prefab
 
     def evaluate(properties)
       rtn = evaluate_for_env(@project_env_id, properties) ||
-            evaluate_for_env(0, properties)
+        evaluate_for_env(0, properties)
       LOG.trace {
         "Eval Key #{@config.key} Result #{rtn&.reportable_value} with #{properties.to_h}"
       } unless @config.config_type == :LOG_LEVEL
@@ -95,12 +95,129 @@ module Prefab
       value && value >= criterion.value_to_match.int_range.start && value < criterion.value_to_match.int_range.end
     end
 
+    def PROP_MATCHES(criterion, properties)
+      result = check_regex_match(criterion, properties)
+      if result.error
+        false
+      else
+        result.matched
+      end
+    end
+
+    def PROP_DOES_NOT_MATCH(criterion, properties)
+      result = check_regex_match(criterion, properties)
+      if result.error
+        false
+      else
+        !result.matched
+      end
+    end
+
+    def PROP_LESS_THAN(criterion, properties)
+      evaluate_number_comparison(criterion, properties, COMPARE_TO_OPERATORS[:less_than]).matched
+    end
+
+    def PROP_LESS_THAN_OR_EQUAL(criterion, properties)
+      evaluate_number_comparison(criterion, properties, COMPARE_TO_OPERATORS[:less_than_or_equal]).matched
+    end
+
+    def PROP_GREATER_THAN(criterion, properties)
+      evaluate_number_comparison(criterion, properties, COMPARE_TO_OPERATORS[:greater_than]).matched
+    end
+
+    def PROP_GREATER_THAN_OR_EQUAL(criterion, properties)
+      evaluate_number_comparison(criterion, properties,COMPARE_TO_OPERATORS[:greater_than_or_equal]) .matched
+    end
+
+    def PROP_BEFORE(criterion, properties)
+      evaluate_date_comparison(criterion, properties, COMPARE_TO_OPERATORS[:less_than]).matched
+    end
+
+    def PROP_AFTER(criterion, properties)
+      evaluate_date_comparison(criterion, properties, COMPARE_TO_OPERATORS[:greater_than]).matched
+    end
+
+    def PROP_SEMVER_LESS_THAN(criterion, properties)
+      evaluate_semver_comparison(criterion, properties, COMPARE_TO_OPERATORS[:less_than]).matched
+    end
+
+    def PROP_SEMVER_EQUAL(criterion, properties)
+      evaluate_semver_comparison(criterion, properties, COMPARE_TO_OPERATORS[:equal_to]).matched
+    end
+
+    def PROP_SEMVER_GREATER_THAN(criterion, properties)
+      evaluate_semver_comparison(criterion, properties, COMPARE_TO_OPERATORS[:greater_than]).matched
+    end
+
     def value_from_properties(criterion, properties)
       criterion.property_name == NAMESPACE_KEY ? @namespace : properties.get(criterion.property_name)
     end
 
+    COMPARE_TO_OPERATORS = {
+      less_than_or_equal: -> cmp {  cmp <= 0 },
+      less_than: -> cmp {  cmp < 0 },
+      equal_to: -> cmp {  cmp == 0 },
+      greater_than: -> cmp {  cmp > 0 },
+      greater_than_or_equal: -> cmp {  cmp >= 0 },
+    }
+
     private
 
+    def evaluate_semver_comparison(criterion, properties, predicate)
+      context_version = value_from_properties(criterion, properties)&.then { |v| SemanticVersion.parse_quietly(v) }
+      config_version = criterion.value_to_match&.string&.then {|v| SemanticVersion.parse_quietly(criterion.value_to_match.string) }
+
+      unless context_version && config_version
+        return MatchResult.error
+      end
+      predicate.call(context_version <=> config_version) ? MatchResult.matched : MatchResult.not_matched
+    end
+
+    def evaluate_date_comparison(criterion, properties, predicate)
+      context_millis = as_millis(value_from_properties(criterion, properties))
+      config_millis = as_millis(Prefab::ConfigValueUnwrapper.deepest_value(criterion.value_to_match, @config,
+                                                                           properties, @resolver).unwrap)
+
+      unless config_millis && context_millis
+        return MatchResult.error
+      end
+
+      predicate.call(context_millis <=> config_millis) ? MatchResult.matched : MatchResult.not_matched
+    end
+
+    def evaluate_number_comparison(criterion, properties, predicate)
+      context_value = value_from_properties(criterion, properties)
+      value_to_match = extract_numeric_value(criterion.value_to_match)
+
+      return MatchResult.error if value_to_match.nil?
+      return MatchResult.error unless context_value.is_a?(Numeric)
+
+      # Compare the values and apply the predicate method
+      comparison_result = context_value <=> value_to_match
+      return MatchResult.error if comparison_result.nil?
+
+      predicate.call(comparison_result) ? MatchResult.matched : MatchResult.not_matched
+    end
+
+    def extract_numeric_value(config_value)
+      case config_value.type
+      when :int
+        config_value.int
+      when :double
+        config_value.double
+      end
+    end
+
+    def as_millis(obj)
+      if obj.is_a?(Numeric)
+        return obj.to_int if obj.respond_to?(:to_int)
+      end
+      if obj.is_a?(String)
+        Time.iso8601(obj).utc.to_i * 1000 rescue nil
+      end
+    end
+
+
     def evaluate_for_env(env_id, properties)
       @config.rows.each_with_index do |row, index|
         next unless row.project_env_id == env_id
@@ -131,7 +248,7 @@ module Prefab
     end
 
     def matches?(criterion, value, properties)
-      criterion_value_or_values = Prefab::ConfigValueUnwrapper.deepest_value(criterion.value_to_match, @config.key,
+      criterion_value_or_values = Prefab::ConfigValueUnwrapper.deepest_value(criterion.value_to_match, @config,
                                                                              properties, @resolver).unwrap
 
       case criterion_value_or_values
@@ -167,6 +284,60 @@ module Prefab
         value.include?(substring)
       end
     end
+
+    def check_regex_match(criterion, properties)
+      begin
+        regex_definition = Prefab::ConfigValueUnwrapper.deepest_value(criterion.value_to_match, @config.key,
+                                                                      properties, @resolver).unwrap
+
+        return MatchResult.error unless regex_definition.is_a?(String)
+
+        value = value_from_properties(criterion, properties)
+
+        regex = compile_regex_safely(ensure_anchored_regex(regex_definition))
+        return MatchResult.error unless regex
+
+        matches = regex.match?(value.to_s)
+        matches ? MatchResult.matched : MatchResult.not_matched
+      rescue RegexpError
+        MatchResult.error
+      end
+    end
+
+    def compile_regex_safely(pattern)
+      begin
+        Regexp.new(pattern)
+      rescue RegexpError
+        nil
+      end
+    end
+
+    def ensure_anchored_regex(pattern)
+      return pattern if pattern.start_with?("^") && pattern.end_with?("$")
+
+      "^#{pattern}$"
+    end
+
+    class MatchResult
+      attr_reader :matched, :error
+
+      def self.matched
+        new(matched: true)
+      end
+
+      def self.not_matched
+        new(matched: false)
+      end
+
+      def self.error
+        new(matched: false, error: true)
+      end
+
+      def initialize(matched:, error: false)
+        @matched = matched
+        @error = error
+      end
+    end
   end
 end
 # rubocop:enable Naming/MethodName

data/lib/prefab/fixed_size_hash.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Prefab
+  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/prefab/http_connection.rb

@@ -9,13 +9,17 @@ module Prefab
       'X-PrefabCloud-Client-Version' => "prefab-cloud-ruby-#{Prefab::VERSION}"
     }.freeze
 
-    def initialize(api_root, api_key)
-      @api_root = api_root
+    def initialize(uri, api_key)
+      @uri = uri
       @api_key = api_key
     end
 
-    def get(path)
-      connection(PROTO_HEADERS).get(path)
+    def uri
+      @uri
+    end
+
+    def get(path, headers = {})
+      connection(PROTO_HEADERS.merge(headers)).get(path)
     end
 
     def post(path, body)
@@ -24,13 +28,13 @@ module Prefab
 
     def connection(headers = {})
       if Faraday::VERSION[0].to_i >= 2
-        Faraday.new(@api_root) do |conn|
+        Faraday.new(@uri) do |conn|
           conn.request :authorization, :basic, AUTH_USER, @api_key
 
           conn.headers.merge!(headers)
         end
       else
-        Faraday.new(@api_root) do |conn|
+        Faraday.new(@uri) do |conn|
           conn.request :basic_auth, AUTH_USER, @api_key
 
           conn.headers.merge!(headers)

data/lib/prefab/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/prefab-cloud-ruby.rb

@@ -54,3 +54,6 @@ require 'prefab/feature_flag_client'
 require 'prefab/prefab'
 require 'prefab/murmer3'
 require 'prefab/javascript_stub'
+require 'prefab/semver'
+require 'prefab/fixed_size_hash'
+require 'prefab/caching_http_connection'