Ruby

gem install growthbook

require 'growthbook'

# Fetch features from a GrowthBook instance
# You should cache this in Redis or similar in production
features_repository = Growthbook::FeatureRepository.new(
  endpoint: 'https://cdn.growthbook.io/api/features/MY_API_KEY',
  decryption_key: nil
)
features = features_repository.fetch

# Create a context for the current user/request
gb = Growthbook::Context.new(
  features: features,
  # User attributes for targeting / variation assignment
  attributes: {
    id: '123',
    country: 'US'
  }
)

# Use a boolean feature flag
if gb.on? :my_feature_key
  puts 'My feature is on!'
end

# Get the value of a multivariate feature with a fallback
btn_color = gb.feature_value(:signup_btn_color, 'pink')

gb.impressions.each do |key, result|
  puts "Assigned variation #{result.variation_id} in experiment #{key}"
end

class MyImpressionListener
  def on_experiment_viewed(experiment, result)
    puts "Assigned variation #{result.variation_id} in experiment #{experiment.key}"
  end
end

gb.listener = MyImpressionListener.new

class MyFeatureUsageCallback < FeatureUsageCallback
  def on_feature_usage(feature_key, feature_result)
    puts "on_feature_usage_called with key: #{feature_key} and result #{feature_result}"
  end
end

on_feature_usage = MyFeatureUsageCallback.new

# you can pass it into the context
gb = Growthbook::Context.new({
  attributes: {
    id: 'user-abc123'
  },
  features: feature_repository.fetch || {},
  on_feature_usage: on_feature_usage,
})

# or assign it afterwards
gb.on_feature_usage = on_feature_usage

require 'growthbook'

module GrowthbookSdk
  def growthbook
    @growthbook ||= Growthbook::Context.new(
      features: growthbook_features_json,
      attributes: {},
    )
  end

  # use this as a before_action on your controller
  def init_feature_flags
    return if current_user.nil?

    # TODO: Change this to get your user attributes as a hash in a way that works for your app
    growthbook.attributes = current_user.as_json
  end

  private

  def growthbook_features_json
    Rails.cache.fetch("growthbook_features", expires_in: 1.hour) do
      puts "🌎 Fetching GrowthBook features from the network"

      repo = Growthbook::FeatureRepository.new(
        endpoint: 'https://cdn.growthbook.io/api/features/java_NsrWldWd5bxQJZftGsWKl7R2yD2LtAK8C8EUYh9L8',
        decryption_key: nil,
      )

      repo.fetch || {}
    end
  end
end

class ApplicationController < ActionController::API
  include Authentication # your own auth strategy
  include GrowthbookSdk # the controller concern code above

  before_action :authenticate!
  before_action :init_feature_flags # call this once you have a user from which to get attributes
end

# These take precedence over everything else when determining a feature's value
gb.forced_features = {
  my_feature: true,
  other_feature: "new value"
}

# Will always be true
gb.is_on?(:my_feature)

# Will always be "new value"
gb.feature_value(:other_feature)

gb.enabled = false

require 'growthbook'

class MyStickyBucketService < Growthbook::StickyBucketService
  def get_assignments(attribute_name, attribute_value)
    db.find({
      attributeName: attribute_name,
      attributeValue: attribute_value
    })
  end

  def save_assignments(doc)
    # Insert new record if not exists, otherwise update
    db.upsert({
        attributeName: doc["attributeName"],
        attributeValue: doc["attributeValue"]
    }, {
      "$set": {
        assignments: doc["assignments"]
      }
    })
  end
end

# Pass in an instance of this service to your GrowthBook constructor
gb = Growthbook::Context.new(
  sticky_bucket_service: MyStickyBucketService.new
)

# Simple 50/50 experiment
result = gb.run(Growthbook::InlineExperiment.new(
  key: "my-experiment-key",
  variations: ["red", "green"]
))

# Whether or not the user was included in the experiment (either true or false)
puts(result.in_experiment ? 'included' : 'excluded')

# The value of the assigned variation (either "red" or "green")
puts(result.value)

# The variation index (either 0 or 1)
puts(result.variation_id)

gb.run(Growthbook::InlineExperiment.new(
  key: "my-experiment-key",
  variations: ["red", "green"],
  # Filter by context attributes
  condition: {
    country: {
      "$in": ["US", "CA"]
    }
  },
  # Adjust variation weights from the default 50/50 split
  weights: [0.8, 0.2],
  # Run for a subset of traffic (0 to 1, default = 1)
  coverage: 0.5,
  # Use a different context attribute for assigning a variation (default = "id")
  hash_attribute: "device_id",
  # Use a namespace to run mutually exclusive experiments
  namespace: ["pricing-page", 0, 0.25]
))

# TODO: Replace these values with your own:
Growthbook::Context.new(
  encrypted_features: 'm5ylFM6ndyOJA2OPadubkw==.Uu7ViqgKEt/dWvCyhI46q088PkAEJbnXKf3KPZjf9IEQQ+A8fojNoxw4wIbPX3aj',
  decryption_key: 'Zvwv/+uhpFDznZ6SX28Yjg==',
  attributes: {
    id: '456',
    country: 'CA'
  }
)

uri = URI('https://cdn.growthbook.io/api/features/MY_API_KEY')
res = Net::HTTP.get_response(uri)
encrypted_features = res.is_a?(Net::HTTPSuccess) ? JSON.parse(res.body)['encryptedFeatures'] : nil

Growthbook::Context.new(
  encrypted_features: encrypted_features,
  decryption_key: '<key-for-decrypting>',
  attributes: {
    id: '456',
    country: 'CA'
  }
)