flipper 0.24.1 → 1.3.0

data/benchmark/enabled_multiple_actors_ips.rb

@@ -0,0 +1,20 @@
+require 'bundler/setup'
+require 'flipper'
+require 'benchmark/ips'
+
+actor1 = Flipper::Actor.new("User;1")
+actor2 = Flipper::Actor.new("User;2")
+actor3 = Flipper::Actor.new("User;3")
+actor4 = Flipper::Actor.new("User;4")
+actor5 = Flipper::Actor.new("User;5")
+actor6 = Flipper::Actor.new("User;6")
+actor7 = Flipper::Actor.new("User;7")
+actor8 = Flipper::Actor.new("User;8")
+
+actors = [actor1, actor2, actor3, actor4, actor5, actor6, actor7, actor8]
+
+Benchmark.ips do |x|
+  x.report("with array of actors") { Flipper.enabled?(:foo, actors) }
+  x.report("with multiple enabled? checks") { actors.each { |actor| Flipper.enabled?(:foo, actor) } }
+  x.compare!
+end

data/benchmark/enabled_profile.rb

@@ -0,0 +1,20 @@
+require 'bundler/setup'
+require 'flipper'
+require 'stackprof'
+require 'benchmark/ips'
+
+flipper = Flipper.new(Flipper::Adapters::Memory.new)
+feature = flipper.feature(:foo)
+actor = Flipper::Actor.new("User;1")
+
+profile = StackProf.run(mode: :wall, interval: 1_000) do
+  2_000_000.times do
+    feature.enabled?(actor)
+  end
+end
+
+result = StackProf::Report.new(profile)
+puts
+result.print_text
+puts "\n\n\n"
+result.print_method(/Flipper::Feature#enabled?/)

data/benchmark/instrumentation_ips.rb

@@ -0,0 +1,21 @@
+require 'bundler/setup'
+require 'flipper'
+require 'active_support/notifications'
+require 'active_support/isolated_execution_state'
+require 'benchmark/ips'
+
+class FlipperSubscriber
+  def call(name, start, finish, id, payload)
+  end
+
+  ActiveSupport::Notifications.subscribe(/flipper/, new)
+end
+
+actor = Flipper::Actor.new("User;1")
+bare = Flipper.new(Flipper::Adapters::Memory.new)
+instrumented = Flipper.new(Flipper::Adapters::Memory.new, instrumenter: ActiveSupport::Notifications)
+
+Benchmark.ips do |x|
+  x.report("with instrumentation") { instrumented.enabled?(:foo, actor) }
+  x.report("without instrumentation") { bare.enabled?(:foo, actor) }
+end

data/benchmark/typecast_ips.rb

@@ -0,0 +1,27 @@
+require 'bundler/setup'
+require 'flipper'
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.report("Typecast.to_boolean true") { Flipper::Typecast.to_boolean(true) }
+  x.report("Typecast.to_boolean 1") { Flipper::Typecast.to_boolean(1) }
+  x.report("Typecast.to_boolean 'true'") { Flipper::Typecast.to_boolean('true'.freeze) }
+  x.report("Typecast.to_boolean '1'") { Flipper::Typecast.to_boolean('1'.freeze) }
+  x.report("Typecast.to_boolean false") { Flipper::Typecast.to_boolean(false) }
+
+  x.report("Typecast.to_integer 1") { Flipper::Typecast.to_integer(1) }
+  x.report("Typecast.to_integer '1'") { Flipper::Typecast.to_integer('1') }
+
+  x.report("Typecast.to_float 1") { Flipper::Typecast.to_float(1) }
+  x.report("Typecast.to_float '1'") { Flipper::Typecast.to_float('1'.freeze) }
+  x.report("Typecast.to_float 1.01") { Flipper::Typecast.to_float(1) }
+  x.report("Typecast.to_float '1.01'") { Flipper::Typecast.to_float('1'.freeze) }
+
+  x.report("Typecast.to_number 1") { Flipper::Typecast.to_number(1) }
+  x.report("Typecast.to_number 1.1") { Flipper::Typecast.to_number(1.1) }
+  x.report("Typecast.to_number '1'") { Flipper::Typecast.to_number('1'.freeze) }
+  x.report("Typecast.to_number '1.1'") { Flipper::Typecast.to_number('1.1'.freeze) }
+  x.report("Typecast.to_number nil") { Flipper::Typecast.to_number(nil) }
+  time = Time.now
+  x.report("Typecast.to_number Time.now") { Flipper::Typecast.to_number(time) }
+end

data/examples/api/basic.ru

@@ -1,19 +1,18 @@
 #
 # Usage:
-#   # if you want it to not reload and be really fast
 #   bin/rackup examples/api/basic.ru -p 9999
 #
-#   # if you want reloading
-#   bin/shotgun examples/api/basic.ru -p 9999
-#
 #   http://localhost:9999/
 #
 
 require 'bundler/setup'
+require 'rack/reloader'
 require "flipper/api"
 require "flipper/adapters/pstore"
 
 # You can uncomment this to get some default data:
 # Flipper.enable :logging
 
+use Rack::Reloader
+
 run Flipper::Api.app

data/examples/api/custom_memoized.ru

@@ -1,15 +1,12 @@
 #
 # Usage:
-#   # if you want it to not reload and be really fast
 #   bin/rackup examples/api/custom_memoized.ru -p 9999
 #
-#   # if you want reloading
-#   bin/shotgun examples/api/custom_memoized.ru -p 9999
-#
 #   http://localhost:9999/
 #
 
 require 'bundler/setup'
+require 'rack/reloader'
 require "active_support/notifications"
 require "flipper/api"
 require "flipper/adapters/pstore"
@@ -31,6 +28,8 @@ ActiveSupport::Notifications.subscribe(/.*/, ->(*args) {
 # You can uncomment this to get some default data:
 # flipper[:logging].enable_percentage_of_time 5
 
+use Rack::Reloader
+
 run Flipper::Api.app(flipper) { |builder|
   builder.use Flipper::Middleware::SetupEnv, flipper
   builder.use Flipper::Middleware::Memoizer, preload: true

data/examples/api/memoized.ru

@@ -1,15 +1,12 @@
 #
 # Usage:
-#   # if you want it to not reload and be really fast
 #   bin/rackup examples/api/memoized.ru -p 9999
 #
-#   # if you want reloading
-#   bin/shotgun examples/api/memoized.ru -p 9999
-#
 #   http://localhost:9999/
 #
 
 require 'bundler/setup'
+require 'rack/reloader'
 require "active_support/notifications"
 require "flipper/api"
 require "flipper/adapters/pstore"
@@ -38,6 +35,8 @@ Flipper.register(:admins) { |actor|
 # You can uncomment this to get some default data:
 # Flipper.enable :logging
 
+use Rack::Reloader
+
 run Flipper::Api.app { |builder|
   builder.use Flipper::Middleware::Memoizer, preload: true
 }

data/examples/cloud/app.ru

@@ -0,0 +1,12 @@
+# Usage (from the repo root):
+#   env FLIPPER_CLOUD_TOKEN=<token> FLIPPER_CLOUD_SYNC_SECRET=<secret> bundle exec rackup examples/cloud/app.ru -p 9999
+#   http://localhost:9999/
+
+require 'bundler/setup'
+require 'flipper/cloud'
+
+Flipper.configure do |config|
+  config.default { Flipper::Cloud.new }
+end
+
+run Flipper::Cloud.app

data/examples/cloud/backoff_policy.rb

@@ -0,0 +1,13 @@
+# Just a simple example that shows how the backoff policy works.
+require 'bundler/setup'
+require 'flipper/cloud/telemetry/backoff_policy'
+
+intervals = []
+policy = Flipper::Cloud::Telemetry::BackoffPolicy.new
+
+10.times do |n|
+  intervals << policy.next_interval
+end
+
+pp intervals.map { |i| i.round(2) }
+puts "Total: #{intervals.sum.round(2)}ms (#{(intervals.sum/1_000.0).round(2)} sec)"

data/examples/cloud/basic.rb

@@ -0,0 +1,22 @@
+# Usage (from the repo root):
+# env FLIPPER_CLOUD_TOKEN=<token> bundle exec ruby examples/cloud/basic.rb
+
+require_relative "./cloud_setup"
+require 'bundler/setup'
+require 'flipper/cloud'
+
+Flipper[:stats].enable
+
+if Flipper[:stats].enabled?
+  puts 'Enabled!'
+else
+  puts 'Disabled!'
+end
+
+Flipper[:stats].disable
+
+if Flipper[:stats].enabled?
+  puts 'Enabled!'
+else
+  puts 'Disabled!'
+end

data/examples/cloud/cloud_setup.rb

@@ -0,0 +1,20 @@
+if ENV["FLIPPER_CLOUD_TOKEN"].nil? || ENV["FLIPPER_CLOUD_TOKEN"].empty?
+  warn "FLIPPER_CLOUD_TOKEN missing so skipping cloud example."
+  exit
+end
+
+matrix_key = if ENV["CI"]
+  suffix_rails = ENV["RAILS_VERSION"].split(".").take(2).join
+  suffix_ruby = RUBY_VERSION.split(".").take(2).join
+  "FLIPPER_CLOUD_TOKEN_#{suffix_ruby}_#{suffix_rails}"
+else
+  "FLIPPER_CLOUD_TOKEN"
+end
+
+if matrix_token = ENV[matrix_key]
+  puts "Using #{matrix_key} for FLIPPER_CLOUD_TOKEN"
+  ENV["FLIPPER_CLOUD_TOKEN"] = matrix_token
+else
+  warn "Missing #{matrix_key}. Go create an environment in flipper cloud and set #{matrix_key} to the adapter token for that environment in github actions secrets."
+  exit 1
+end

data/examples/cloud/forked.rb

@@ -0,0 +1,36 @@
+# Usage (from the repo root):
+# env FLIPPER_CLOUD_TOKEN=<token> bundle exec ruby examples/cloud/threaded.rb
+
+require_relative "./cloud_setup"
+require 'bundler/setup'
+require 'flipper/cloud'
+
+puts Process.pid
+
+# Make a call in the parent process so we can detect forking.
+Flipper.enabled?(:stats)
+
+pids = 2.times.map do |n|
+  fork {
+    # Check every second to see if the feature is enabled
+    threads = []
+    2.times do
+      threads << Thread.new do
+        loop do
+          sleep rand
+
+          if Flipper[:stats].enabled?
+            puts "#{Process.pid} #{Time.now.to_i} Enabled!"
+          else
+            puts "#{Process.pid} #{Time.now.to_i} Disabled!"
+          end
+        end
+      end
+    end
+    threads.map(&:join)
+  }
+end
+
+pids.each do |pid|
+  Process.waitpid pid, 0
+end

data/examples/cloud/import.rb

@@ -0,0 +1,17 @@
+# Usage (from the repo root):
+#   env FLIPPER_CLOUD_TOKEN=<token> bundle exec ruby examples/cloud/import.rb
+
+require_relative "./cloud_setup"
+require 'bundler/setup'
+require 'flipper'
+require 'flipper/cloud'
+
+Flipper.enable(:test)
+Flipper.enable(:search)
+Flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
+Flipper.enable_percentage_of_time(:logging, 5)
+
+cloud = Flipper::Cloud.new
+
+# makes cloud identical to memory flipper
+cloud.import(Flipper)

data/examples/cloud/threaded.rb

@@ -0,0 +1,33 @@
+# Usage (from the repo root):
+# env FLIPPER_CLOUD_TOKEN=<token> bundle exec ruby examples/cloud/threaded.rb
+
+require_relative "./cloud_setup"
+require 'bundler/setup'
+require 'flipper/cloud'
+
+puts Process.pid
+
+Flipper.configure do |config|
+  config.default {
+    Flipper::Cloud.new(
+      local_adapter: config.adapter,
+      debug_output: STDOUT,
+    )
+  }
+end
+
+# You might want to do this at some point to see different results:
+# Flipper.enable(:search)
+# Flipper.disable(:stats)
+
+# Check every second to see if the feature is enabled
+5.times.map { |i|
+  Thread.new {
+    loop do
+      sleep rand
+
+      Flipper.enabled?(:stats)
+      Flipper.enabled?(:search)
+    end
+  }
+}.each(&:join)

data/examples/dsl.rb

@@ -1,7 +1,7 @@
 require 'bundler/setup'
 require 'flipper'
 
-# create a thing with an identifier
+# create an actor with an identifier
 class Person < Struct.new(:id)
   include Flipper::Identifier
 end
@@ -47,20 +47,6 @@ puts "stats.enabled?: #{stats.enabled?}"
 puts "stats.enabled? person: #{stats.enabled? person}"
 puts
 
-# get an instance of the percentage of time type set to 5
-puts Flipper.time(5).inspect
-
-# get an instance of the percentage of actors type set to 15
-puts Flipper.actors(15).inspect
-
-# get an instance of an actor using an object that responds to flipper_id
-responds_to_flipper_id = Struct.new(:flipper_id).new(10)
-puts Flipper.actor(responds_to_flipper_id).inspect
-
-# get an instance of an actor using an object
-thing = Struct.new(:flipper_id).new(22)
-puts Flipper.actor(thing).inspect
-
 # register a top level group
 admins = Flipper.register(:admins) { |actor|
   actor.respond_to?(:admin?) && actor.admin?

data/examples/enabled_for_actor.rb

@@ -31,5 +31,7 @@ Flipper.enable_percentage_of_actors :pro_stats, 50
 Flipper.enable_group :tweets, :admins
 Flipper.enable_actor :posts, user2
 
-pp Flipper.features.select { |feature| feature.enabled?(user1) }.map(&:name)
-pp Flipper.features.select { |feature| feature.enabled?(user2) }.map(&:name)
+pp Flipper.features.select { |feature| feature.enabled?(user1) }.map(&:name).sort
+pp Flipper.features.select { |feature| feature.enabled?(user2) }.map(&:name).sort
+pp Flipper.features.select { |feature| feature.enabled?(user1, user2) }.map(&:name).sort
+pp Flipper.features.select { |feature| feature.enabled?([user2, user1]) }.map(&:name).sort

data/examples/expressions.rb

@@ -0,0 +1,213 @@
+require 'bundler/setup'
+require 'flipper'
+
+def assert(value)
+  if value
+    p value
+  else
+    puts "Expected true but was #{value}. Please correct."
+    exit 1
+  end
+end
+
+def refute(value)
+  if value
+    puts "Expected false but was #{value}. Please correct."
+    exit 1
+  else
+    p value
+  end
+end
+
+def reset
+  Flipper.disable_expression :something
+end
+
+class User < Struct.new(:id, :flipper_properties)
+  include Flipper::Identifier
+end
+
+class Org < Struct.new(:id, :flipper_properties)
+  include Flipper::Identifier
+end
+
+NOW = Time.now.to_i
+DAY = 60 * 60 * 24
+
+org = Org.new(1, {
+  "type" => "Org",
+  "id" => 1,
+  "now" => NOW,
+})
+
+user = User.new(1, {
+  "type" => "User",
+  "id" => 1,
+  "plan" => "basic",
+  "age" => 39,
+  "team_user" => true,
+  "now" => NOW,
+})
+
+admin_user = User.new(2, {
+  "type" => "User",
+  "id" => 2,
+  "admin" => true,
+  "team_user" => true,
+  "now" => NOW,
+})
+
+other_user = User.new(3, {
+  "type" => "User",
+  "id" => 3,
+  "plan" => "plus",
+  "age" => 18,
+  "org_admin" => true,
+  "now" => NOW - DAY,
+})
+
+age_expression = Flipper.property(:age).gte(21)
+plan_expression = Flipper.property(:plan).eq("basic")
+admin_expression = Flipper.property(:admin).eq(true)
+
+puts "Single Expression"
+refute Flipper.enabled?(:something, user)
+
+puts "Enabling single expression"
+Flipper.enable :something, plan_expression
+assert Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "Disabling single expression"
+reset
+refute Flipper.enabled?(:something, user)
+
+puts "\n\nAny Expression"
+any_expression = Flipper.any(plan_expression, age_expression)
+refute Flipper.enabled?(:something, user)
+
+puts "Enabling any expression"
+Flipper.enable :something, any_expression
+assert Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "Disabling any expression"
+reset
+refute Flipper.enabled?(:something, user)
+
+puts "\n\nAll Expression"
+all_expression = Flipper.all(plan_expression, age_expression)
+refute Flipper.enabled?(:something, user)
+
+puts "Enabling all expression"
+Flipper.enable :something, all_expression
+assert Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "Disabling all expression"
+reset
+refute Flipper.enabled?(:something, user)
+
+puts "\n\nNested Expression"
+nested_expression = Flipper.any(admin_expression, all_expression)
+refute Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "Enabling nested expression"
+Flipper.enable :something, nested_expression
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "Disabling nested expression"
+reset
+refute Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "\n\nBoolean Expression"
+boolean_expression = Flipper.boolean(true)
+Flipper.enable :something, boolean_expression
+assert Flipper.enabled?(:something)
+assert Flipper.enabled?(:something, user)
+reset
+
+puts "\n\nSet of Actors Expression"
+set_of_actors_expression = Flipper.any(
+  Flipper.property(:flipper_id).eq("User;1"),
+  Flipper.property(:flipper_id).eq("User;3"),
+)
+Flipper.enable :something, set_of_actors_expression
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, other_user)
+refute Flipper.enabled?(:something, admin_user)
+reset
+
+puts "\n\n% of Actors Expression"
+percentage_of_actors = Flipper.property(:flipper_id).percentage_of_actors(30)
+Flipper.enable :something, percentage_of_actors
+refute Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, other_user)
+assert Flipper.enabled?(:something, admin_user)
+reset
+
+puts "\n\n% of Actors Per Type Expression"
+percentage_of_actors_per_type = Flipper.any(
+  Flipper.all(
+    Flipper.property(:type).eq("User"),
+    Flipper.property(:flipper_id).percentage_of_actors(40),
+  ),
+  Flipper.all(
+    Flipper.property(:type).eq("Org"),
+    Flipper.property(:flipper_id).percentage_of_actors(10),
+  )
+)
+Flipper.enable :something, percentage_of_actors_per_type
+refute Flipper.enabled?(:something, user) # not in the 40% enabled for Users
+assert Flipper.enabled?(:something, other_user)
+assert Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, org) # not in the 10% of enabled for Orgs
+reset
+
+puts "\n\nPercentage of Time Expression"
+percentage_of_time_expression = Flipper.random(100).lt(50)
+Flipper.enable :something, percentage_of_time_expression
+results = (1..10000).map { |n| Flipper.enabled?(:something, user) }
+enabled, disabled = results.partition { |r| r }
+p enabled: enabled.size
+p disabled: disabled.size
+assert (4_700..5_200).include?(enabled.size)
+assert (4_700..5_200).include?(disabled.size)
+reset
+
+puts "\n\nChanging single expression to all expression"
+Flipper.enable :something, plan_expression
+Flipper.enable :something, Flipper.expression(:something).all.add(age_expression)
+assert Flipper.enabled?(:something, user)
+refute Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "\n\nChanging single expression to any expression"
+Flipper.enable :something, plan_expression
+Flipper.enable :something, Flipper.expression(:something).any.add(age_expression, admin_expression)
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "\n\nChanging single expression to any expression by adding to condition"
+Flipper.enable :something, plan_expression
+Flipper.enable :something, Flipper.expression(:something).add(admin_expression)
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)
+
+puts "\n\nEnabling based on time"
+scheduled_time_expression = Flipper.property(:now).gte(NOW)
+Flipper.enable :something, scheduled_time_expression
+assert Flipper.enabled?(:something, user)
+assert Flipper.enabled?(:something, admin_user)
+refute Flipper.enabled?(:something, other_user)

data/examples/instrumentation.rb

@@ -1,5 +1,6 @@
 require 'bundler/setup'
 require 'securerandom'
+require 'active_support/isolated_execution_state'
 require 'active_support/notifications'
 
 class FlipperSubscriber

data/examples/instrumentation_last_accessed_at.rb

@@ -1,6 +1,7 @@
 # Quick example of how to keep track of when a feature was last checked.
 require 'bundler/setup'
 require 'securerandom'
+require 'active_support/isolated_execution_state'
 require 'active_support/notifications'
 require 'flipper'
 

data/examples/mirroring.rb

@@ -0,0 +1,59 @@
+require 'bundler/setup'
+require_relative 'active_record/ar_setup'
+require 'flipper'
+require 'flipper/adapters/redis'
+require 'flipper/adapters/active_record'
+
+# Say you have production...
+production_adapter = Flipper::Adapters::Memory.new
+production = Flipper.new(production_adapter)
+
+# And production has some stuff enabled...
+production.enable(:search)
+production.enable_percentage_of_time(:verbose_logging, 5)
+production.enable_percentage_of_actors(:new_feature, 5)
+production.enable_actor(:issues, Flipper::Actor.new('1'))
+production.enable_actor(:issues, Flipper::Actor.new('2'))
+production.enable_group(:request_tracing, :staff)
+
+# And you would like to mirror production to staging...
+staging_adapter = Flipper::Adapters::Memory.new
+staging = Flipper.new(staging_adapter)
+staging_export = staging.export
+
+puts "Here is the state of the world for staging and production..."
+puts "Staging"
+staging.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end
+puts "Production"
+production.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end
+
+# NOTE: This wipes active record clean and copies features/gates from redis into active record.
+puts "Mirroring production to staging..."
+staging.import(production.export)
+puts "Staging is now identical to Production."
+
+puts "Staging"
+staging.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end
+puts "Production"
+production.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end
+
+puts "Restoring staging to original state..."
+staging.import(staging_export)
+puts "Staging restored."
+
+puts "Staging"
+staging.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end
+puts "Production"
+production.features.each do |feature|
+  pp feature: feature.key, values: feature.gate_values
+end