growthbook 1.0.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95b90dcba429217cc585f4ea2007e3d7aab0f3489dc93ee41d7fa72b847b7f53
-  data.tar.gz: 363c48f172798a02d899cfdc6ffb692ab1f85b45cf205e0d4c5dc6339c86c83a
+  metadata.gz: cba2938ec675b1626d643fb7493223a54d0faf1ffc37c2bacb5a06637c0a75cd
+  data.tar.gz: bce59918f346b53182450ec2fdd92776767954712334bc5b7c0bd48d952c05ce
 SHA512:
-  metadata.gz: 6b8c950602e92cb66a644e6780827410d3c2e5eb71078adb95b469fbbe1c9b7f9925a6d3cf5917c345b9a5d04feabf21198d0349a57d5c597e7dca92f004bf43
-  data.tar.gz: ded0ea4cc0913bf8d93f8f61a34b622579d7346dfe02f121d011e82b11920e7703c192e8afb6331c2ac0d5245a435473e54707907e6116e46d4b4b01a5a3c394
+  metadata.gz: 0c4ac9f40b23c8719b9cb585d92f089144df5441c787321fd0083ae72ff954f5f8027615cc3d226dcdb7c2bfdc3dc5911ef1abd472904c026a3e24c1dd81230c
+  data.tar.gz: 735bfc1c4b82432a4a9b0664282062f43ab644309933afcddb43c9dc53cd32a278d1cf14221ad9b298a0bbdb0e2a12a8e77c4aa814d8ba3719e7840c62a4d09a

data/lib/growthbook/conditions.rb

@@ -29,7 +29,6 @@ module Growthbook
       when Hash
         return condition.to_h { |k, v| [k.to_s, parse_condition(v)] }
       end
-
       condition
     end
 
@@ -68,6 +67,8 @@ module Growthbook
     end
 
     def self.get_path(attributes, path)
+      path = path.to_s if path.is_a?(Symbol)
+
       parts = path.split('.')
       current = attributes
 

data/lib/growthbook/context.rb

@@ -12,9 +12,12 @@ module Growthbook
     # @return [true, false, nil] If true, random assignment is disabled and only explicitly forced variations are used.
     attr_accessor :qa_mode
 
-    # @return [Listener] An object that responds to some tracking methods that take experiment and result as arguments.
+    # @return [Growthbook::TrackingCallback] An object that responds to `on_experiment_viewed(GrowthBook::InlineExperiment, GrowthBook::InlineExperimentResult)`
     attr_accessor :listener
 
+    # @return [Growthbook::FeatureUsageCallback] An object that responds to `on_feature_usage(String, Growthbook::FeatureResult)`
+    attr_accessor :on_feature_usage
+
     # @return [Hash] Map of user attributes that are used to assign variations
     attr_reader :attributes
 
@@ -24,7 +27,11 @@ module Growthbook
     # @return [Hash] Force specific experiments to always assign a specific variation (used for QA)
     attr_reader :forced_variations
 
-    attr_reader :impressions, :forced_features
+    # @return [Hash[String, Growthbook::InlineExperimentResult]] Tracked impressions
+    attr_reader :impressions
+
+    # @return [Hash[String, Any]] Forced feature values
+    attr_reader :forced_features
 
     def initialize(options = {})
       @features = {}
@@ -34,14 +41,19 @@ module Growthbook
       @enabled = true
       @impressions = {}
 
-      options.each do |key, value|
-        case key.to_sym
+      options.transform_keys(&:to_sym).each do |key, value|
+        case key
         when :enabled
           @enabled = value
         when :attributes
           self.attributes = value
         when :url
           @url = value
+        when :decryption_key
+          nil
+        when :encrypted_features
+          decrypted = decrypted_features_from_options(options)
+          self.features = decrypted unless decrypted.nil?
         when :features
           self.features = value
         when :forced_variations, :forcedVariations
@@ -52,6 +64,8 @@ module Growthbook
           @qa_mode = value
         when :listener
           @listener = value
+        when :on_feature_usage
+          @on_feature_usage = value
         else
           warn("Unknown context option: #{key}")
         end
@@ -61,6 +75,8 @@ module Growthbook
     def features=(features)
       @features = {}
 
+      return if features.nil?
+
       features.each do |k, v|
         # Convert to a Feature object if it's not already
         v = Growthbook::Feature.new(v) unless v.is_a? Growthbook::Feature
@@ -83,44 +99,49 @@ module Growthbook
 
     def eval_feature(key)
       # Forced in the context
-      return get_feature_result(@forced_features[key.to_s], 'override') if @forced_features.key?(key.to_s)
+      return get_feature_result(key.to_s, @forced_features[key.to_s], 'override', nil, nil) if @forced_features.key?(key.to_s)
 
       # Return if we can't find the feature definition
       feature = get_feature(key)
-      return get_feature_result(nil, 'unknownFeature') unless feature
+      return get_feature_result(key.to_s, nil, 'unknownFeature', nil, nil) unless feature
 
       feature.rules.each do |rule|
         # Targeting condition
-        next if rule.condition && !condition_passes(rule.condition)
+        next if rule.condition && !condition_passes?(rule.condition)
 
         # If there are filters for who is included (e.g. namespaces)
-        next if rule.filters && filtered_out?(rule.filters)
+        next if rule.filters && filtered_out?(rule.filters || [])
 
         # If this is a percentage rollout, skip if not included
         if rule.force?
           seed = rule.seed || key
           hash_attribute = rule.hash_attribute || 'id'
           included_in_rollout = included_in_rollout?(
-            seed: seed, hash_attribute: hash_attribute, range: rule.range,
-            coverage: rule.coverage, hash_version: rule.hash_version
+            seed: seed.to_s,
+            hash_attribute: hash_attribute,
+            range: rule.range,
+            coverage: rule.coverage,
+            hash_version: rule.hash_version
           )
           next unless included_in_rollout
 
-          return get_feature_result(rule.force, 'force')
+          return get_feature_result(key.to_s, rule.force, 'force', nil, nil)
         end
         # Experiment rule
         next unless rule.experiment?
 
         exp = rule.to_experiment(key)
+        next if exp.nil?
+
         result = _run(exp, key)
 
         next unless result.in_experiment && !result.passthrough
 
-        return get_feature_result(result.value, 'experiment', exp, result)
+        return get_feature_result(key.to_s, result.value, 'experiment', exp, result)
       end
 
       # Fallback
-      get_feature_result(feature.default_value || nil, 'defaultValue')
+      get_feature_result(key.to_s, feature.default_value.nil? ? nil : feature.default_value, 'defaultValue', nil, nil)
     end
 
     def run(exp)
@@ -152,8 +173,9 @@ module Growthbook
       return get_experiment_result(exp, -1, hash_used: false, feature_id: feature_id) unless @enabled
 
       # 3. If forced via URL querystring
-      if @url
-        qs_override = Util.get_query_string_override(key, @url, exp.variations.length)
+      override_url = @url
+      unless override_url.nil?
+        qs_override = Util.get_query_string_override(key, override_url, exp.variations.length)
         return get_experiment_result(exp, qs_override, hash_used: false, feature_id: feature_id) unless qs_override.nil?
       end
 
@@ -177,13 +199,13 @@ module Growthbook
 
       # 7. Exclude if user is filtered out (used to be called "namespace")
       if exp.filters
-        return get_experiment_result(exp, -1, hash_used: false, feature_id: feature_id) if filtered_out?(exp.filters)
-      elsif exp.namespace && !Growthbook::Util.in_namespace(hash_value, exp.namespace)
+        return get_experiment_result(exp, -1, hash_used: false, feature_id: feature_id) if filtered_out?(exp.filters || [])
+      elsif exp.namespace && !Growthbook::Util.in_namespace?(hash_value, exp.namespace)
         return get_experiment_result(exp, -1, hash_used: false, feature_id: feature_id)
       end
 
       # 8. Exclude if condition is false
-      if exp.condition && !condition_passes(exp.condition)
+      if exp.condition && !condition_passes?(exp.condition)
         return get_experiment_result(
           exp,
           -1,
@@ -198,7 +220,10 @@ module Growthbook
         exp.coverage,
         exp.weights
       )
-      n = Growthbook::Util.hash(seed: exp.seed || key, value: hash_value, version: exp.hash_version || 1)
+      seed = exp.seed || key || ''
+      n = Growthbook::Util.get_hash(seed: seed, value: hash_value, version: exp.hash_version || 1)
+      return get_experiment_result(exp, -1, hash_used: false, feature_id: feature_id) if n.nil?
+
       assigned = Growthbook::Util.choose_variation(n, ranges)
 
       # 10. Return if not in experiment
@@ -228,7 +253,9 @@ module Growthbook
       new_hash
     end
 
-    def condition_passes(condition)
+    def condition_passes?(condition)
+      return false if condition.nil?
+
       Growthbook::Conditions.eval_condition(@attributes, condition)
     end
 
@@ -244,9 +271,18 @@ module Growthbook
       meta = experiment.meta ? experiment.meta[variation_index] : {}
 
       result = Growthbook::InlineExperimentResult.new(
-        { key: meta['key'] || variation_index, in_experiment: in_experiment, variation_id: variation_index,
-          value: experiment.variations[variation_index], hash_used: hash_used, hash_attribute: hash_attribute,
-          hash_value: hash_value, feature_id: feature_id, bucket: bucket, name: meta['name'] }
+        {
+          key: meta['key'] || variation_index,
+          in_experiment: in_experiment,
+          variation_id: variation_index,
+          value: experiment.variations[variation_index],
+          hash_used: hash_used,
+          hash_attribute: hash_attribute,
+          hash_value: hash_value,
+          feature_id: feature_id,
+          bucket: bucket,
+          name: meta['name']
+        }
       )
 
       result.passthrough = true if meta['passthrough']
@@ -254,8 +290,19 @@ module Growthbook
       result
     end
 
-    def get_feature_result(value, source, experiment = nil, experiment_result = nil)
-      Growthbook::FeatureResult.new(value, source, experiment, experiment_result)
+    def get_feature_result(key, value, source, experiment, experiment_result)
+      res = Growthbook::FeatureResult.new(value, source, experiment, experiment_result)
+
+      track_feature_usage(key, res)
+
+      res
+    end
+
+    def track_feature_usage(key, feature_result)
+      return unless on_feature_usage.respond_to?(:on_feature_usage)
+      return if feature_result.source == 'override'
+
+      on_feature_usage.on_feature_usage(key, feature_result)
     end
 
     def get_feature(key)
@@ -273,8 +320,10 @@ module Growthbook
     end
 
     def track_experiment(experiment, result)
+      return if listener.nil?
+
       @listener.on_experiment_viewed(experiment, result) if @listener.respond_to?(:on_experiment_viewed)
-      @impressions[experiment.key] = result
+      @impressions[experiment.key] = result unless experiment.key.nil?
     end
 
     def included_in_rollout?(seed:, hash_attribute:, hash_version:, range:, coverage:)
@@ -284,7 +333,8 @@ module Growthbook
 
       return false if hash_value.empty?
 
-      n = Growthbook::Util.hash(seed: seed, value: hash_value, version: hash_version || 1)
+      n = Growthbook::Util.get_hash(seed: seed, value: hash_value, version: hash_version || 1)
+      return false if n.nil?
 
       return Growthbook::Util.in_range?(n, range) if range
       return n <= coverage if coverage
@@ -299,11 +349,23 @@ module Growthbook
         if hash_value.empty?
           false
         else
-          n = Growthbook::Util.hash(seed: filter['seed'], value: hash_value, version: filter['hashVersion'] || 2)
+          n = Growthbook::Util.get_hash(seed: filter['seed'] || '', value: hash_value, version: filter['hashVersion'] || 2)
+
+          return true if n.nil?
 
           filter['ranges'].none? { |range| Growthbook::Util.in_range?(n, range) }
         end
       end
     end
+
+    def decrypted_features_from_options(options)
+      decrypted_features = DecryptionUtil.decrypt(options[:encrypted_features], key: options[:decryption_key])
+
+      return nil if decrypted_features.nil?
+
+      JSON.parse(decrypted_features)
+    rescue StandardError
+      nil
+    end
   end
 end

data/lib/growthbook/decryption_util.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'openssl'
+
+module Growthbook
+  # Utils for working with encrypted feature payloads.
+  class DecryptionUtil
+    # @return [String, nil] The decrypted payload, or nil if it fails to decrypt
+    def self.decrypt(payload, key:)
+      return nil if payload.nil?
+      return nil unless payload.include?('.')
+
+      parts = payload.split('.')
+      return nil if parts.length != 2
+
+      iv = parts[0]
+      decoded_iv = Base64.strict_decode64(iv)
+      decoded_key = Base64.strict_decode64(key)
+
+      cipher_text = parts[1]
+      decoded_cipher_text = Base64.strict_decode64(cipher_text)
+
+      cipher = OpenSSL::Cipher.new('aes-128-cbc')
+
+      cipher.decrypt
+      cipher.key = decoded_key
+      cipher.iv = decoded_iv
+
+      cipher.update(decoded_cipher_text) + cipher.final
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/growthbook/feature_repository.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module Growthbook
+  # Optional class for fetching features from the GrowthBook API
+  class FeatureRepository
+    # [String] The SDK endpoint
+    attr_reader :endpoint
+
+    # [String, nil] Optional key for decrypting an encrypted payload
+    attr_reader :decryption_key
+
+    # Parsed features JSON
+    attr_reader :features_json
+
+    def initialize(endpoint:, decryption_key:)
+      @endpoint = endpoint
+      @decryption_key = decryption_key
+      @features_json = {}
+    end
+
+    def fetch
+      uri = URI(endpoint)
+      res = Net::HTTP.get_response(uri)
+
+      @response = res.is_a?(Net::HTTPSuccess) ? res.body : nil
+
+      return nil if response.nil?
+
+      if use_decryption?
+        parsed_decrypted_response
+      else
+        parsed_plain_text_response
+      end
+    rescue StandardError
+      nil
+    end
+
+    def fetch!
+      fetch
+
+      raise FeatureFetchError if response.nil?
+      raise FeatureParseError if features_json.nil? || features_json.empty?
+
+      features_json
+    end
+
+    private
+
+    attr_reader :response
+
+    def use_decryption?
+      !decryption_key.nil?
+    end
+
+    def parsed_plain_text_response
+      @features_json = parsed_response['features'] unless parsed_response.nil?
+    rescue StandardError
+      nil
+    end
+
+    def parsed_decrypted_response
+      k = decryption_key
+      return nil if k.nil?
+
+      decrypted_str = Growthbook::DecryptionUtil.decrypt(parsed_response['encryptedFeatures'], key: k)
+      @features_json = JSON.parse(decrypted_str) unless decrypted_str.nil?
+    rescue StandardError
+      nil
+    end
+
+    def parsed_response
+      res = response
+      return {} if res.nil?
+
+      JSON.parse(res)
+    rescue StandardError
+      {}
+    end
+
+    class FeatureFetchError < StandardError; end
+
+    class FeatureParseError < StandardError; end
+  end
+end

data/lib/growthbook/feature_rule.rb

@@ -98,7 +98,9 @@ module Growthbook
     end
 
     def experiment?
-      !!@variations
+      return false if @variations.nil?
+
+      !@variations&.empty?
     end
 
     def force?

data/lib/growthbook/feature_usage_callback.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Growthbook
+  # Extendable class that can be used as the feature usage callback
+  class FeatureUsageCallback
+    def on_feature_usage(_feature_key, _result); end
+  end
+end

data/lib/growthbook/fnv.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# FNV
+# {https://github.com/jakedouglas/fnv-ruby Source}
+class FNV
+  INIT32  = 0x811c9dc5
+  INIT64  = 0xcbf29ce484222325
+  PRIME32 = 0x01000193
+  PRIME64 = 0x100000001b3
+  MOD32   = 4_294_967_296
+  MOD64   = 18_446_744_073_709_551_616
+
+  def fnv1a_32(data)
+    hash = INIT32
+
+    data.bytes.each do |byte|
+      hash = hash ^ byte
+      hash = (hash * PRIME32) % MOD32
+    end
+
+    hash
+  end
+end

data/lib/growthbook/inline_experiment.rb

@@ -56,7 +56,7 @@ module Growthbook
       @variations = get_option(options, :variations, [])
       @weights = get_option(options, :weights)
       @active = get_option(options, :active, true)
-      @coverage = get_option(options, :coverage, 1)
+      @coverage = get_option(options, :coverage, 1.0)
       @ranges = get_option(options, :ranges)
       @condition = get_option(options, :condition)
       @namespace = get_option(options, :namespace)

data/lib/growthbook/tracking_callback.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Growthbook
+  # Extendable class that can be used as the tracking callback
+  class TrackingCallback
+    def on_experiment_viewed(_experiment, _result); end
+  end
+end

data/lib/growthbook/util.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'fnv'
+require 'base64'
 require 'bigdecimal'
 require 'bigdecimal/util'
 
@@ -42,15 +42,20 @@ module Growthbook
       end
     end
 
-    def self.hash(seed:, value:, version:)
+    # @return [Float, nil] Hash, or nil if the hash version is invalid
+    def self.get_hash(seed:, value:, version:)
       return (FNV.new.fnv1a_32(value + seed) % 1000) / 1000.0 if version == 1
       return (FNV.new.fnv1a_32(FNV.new.fnv1a_32(seed + value).to_s) % 10_000) / 10_000.0 if version == 2
 
-      -1
+      nil
     end
 
-    def self.in_namespace(hash_value, namespace)
-      n = hash(seed: "__#{namespace[0]}", value: hash_value, version: 1)
+    def self.in_namespace?(hash_value, namespace)
+      return false if namespace.nil?
+
+      n = get_hash(seed: "__#{namespace[0]}", value: hash_value, version: 1)
+      return false if n.nil?
+
       n >= namespace[1] && n < namespace[2]
     end
 
@@ -65,11 +70,11 @@ module Growthbook
     end
 
     # Determine bucket ranges for experiment variations
-    def self.get_bucket_ranges(num_variations, coverage = 1, weights = [])
+    def self.get_bucket_ranges(num_variations, coverage, weights)
       # Make sure coverage is within bounds
-      coverage = 1 if coverage.nil?
-      coverage = 0 if coverage.negative?
-      coverage = 1 if coverage > 1
+      coverage = 1.0 if coverage.nil?
+      coverage = 0.0 if coverage.negative?
+      coverage = 1.0 if coverage > 1
 
       # Default to equal weights
       weights = get_equal_weights(num_variations) if !weights || weights.length != num_variations
@@ -79,7 +84,7 @@ module Growthbook
       weights = get_equal_weights(num_variations) if total < 0.99 || total > 1.01
 
       # Convert weights to ranges
-      cumulative = 0
+      cumulative = 0.0
       ranges = []
       weights.each do |w|
         start = cumulative
@@ -102,13 +107,14 @@ module Growthbook
     # e.g. http://localhost?my-test=1 will return `1` for id `my-test`
     def self.get_query_string_override(id, url, num_variations)
       # Skip if url is empty
-      return nil if url == ''
+      return nil if url == '' || id.nil?
 
       # Parse out the query string
       parsed = URI(url)
-      return nil unless parsed.query
+      parsed_query = parsed.query
+      return nil if parsed_query.nil?
 
-      qs = URI.decode_www_form(parsed.query)
+      qs = URI.decode_www_form(parsed_query)
 
       # Look for `id` in the querystring and get the value
       vals = qs.assoc(id)

data/lib/growthbook.rb

@@ -6,9 +6,14 @@ end
 
 require 'growthbook/conditions'
 require 'growthbook/context'
+require 'growthbook/decryption_util'
 require 'growthbook/feature'
+require 'growthbook/feature_repository'
 require 'growthbook/feature_result'
 require 'growthbook/feature_rule'
+require 'growthbook/fnv'
 require 'growthbook/inline_experiment'
 require 'growthbook/inline_experiment_result'
+require 'growthbook/tracking_callback'
 require 'growthbook/util'
+require 'growthbook/feature_usage_callback'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: growthbook
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.1
 platform: ruby
 authors:
 - GrowthBook
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-20 00:00:00.000000000 Z
+date: 2023-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -53,19 +67,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.1.0
 - !ruby/object:Gem::Dependency
-  name: fnv
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.0
-  type: :runtime
+        version: '3.18'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.0
+        version: '3.18'
 description: Official GrowthBook SDK for Ruby
 email: jeremy@growthbook.io
 executables: []
@@ -75,11 +89,16 @@ files:
 - lib/growthbook.rb
 - lib/growthbook/conditions.rb
 - lib/growthbook/context.rb
+- lib/growthbook/decryption_util.rb
 - lib/growthbook/feature.rb
+- lib/growthbook/feature_repository.rb
 - lib/growthbook/feature_result.rb
 - lib/growthbook/feature_rule.rb
+- lib/growthbook/feature_usage_callback.rb
+- lib/growthbook/fnv.rb
 - lib/growthbook/inline_experiment.rb
 - lib/growthbook/inline_experiment_result.rb
+- lib/growthbook/tracking_callback.rb
 - lib/growthbook/util.rb
 homepage: https://github.com/growthbook/growthbook-ruby
 licenses:
@@ -101,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: GrowthBook SDK for Ruby