flipper 1.1.2 → 1.3.0

data/lib/flipper/cli.rb

@@ -0,0 +1,263 @@
+require 'optparse'
+
+module Flipper
+  class CLI < OptionParser
+    def self.run(argv = ARGV)
+      new.run(argv)
+    end
+
+    # Path to the local Rails application's environment configuration.
+    DEFAULT_REQUIRE = "./config/environment"
+
+    attr_accessor :shell
+
+    def initialize(stdout: $stdout, stderr: $stderr, shell: Bundler::Thor::Base.shell.new)
+      super
+
+      # Program is always flipper, no matter how it's invoked
+      @program_name = 'flipper'
+      @require = ENV.fetch("FLIPPER_REQUIRE", DEFAULT_REQUIRE)
+      @commands = {}
+
+      # Extend whatever shell to support output redirection
+      @shell = shell.extend(ShellOutput)
+      shell.redirect(stdout: stdout, stderr: stderr)
+
+      %w[enable disable].each do |action|
+        command action do |c|
+          c.banner = "Usage: #{c.program_name} [options] <feature>"
+          c.description = "#{action.to_s.capitalize} a feature"
+
+          values = []
+
+          c.on('-a id', '--actor=id', "#{action} for an actor") do |id|
+            values << Actor.new(id)
+          end
+          c.on('-g name', '--group=name', "#{action} for a group") do |name|
+            values << Types::Group.new(name)
+          end
+          c.on('-p NUM', '--percentage-of-actors=NUM', Numeric, "#{action} for a percentage of actors") do |num|
+            values << Types::PercentageOfActors.new(num)
+          end
+          c.on('-t NUM', '--percentage-of-time=NUM', Numeric, "#{action} for a percentage of time") do |num|
+            values << Types::PercentageOfTime.new(num)
+          end
+          c.on('-x expressions', '--expression=NUM', "#{action} for the given expression") do |expression|
+            begin
+              values << Flipper::Expression.build(JSON.parse(expression))
+            rescue JSON::ParserError => e
+              ui.error "JSON parse error #{e.message}"
+              ui.trace(e)
+              exit 1
+            rescue ArgumentError => e
+              ui.error "Invalid expression: #{e.message}"
+              ui.trace(e)
+              exit 1
+            end
+          end
+
+          c.action do |feature|
+            f = Flipper.feature(feature)
+
+            if values.empty?
+              f.send(action)
+            else
+              values.each { |value| f.send(action, value) }
+            end
+
+            ui.info feature_details(f)
+          end
+        end
+      end
+
+      command 'list' do |c|
+        c.description = "List defined features"
+        c.action do
+          ui.info feature_summary(Flipper.features)
+        end
+      end
+
+      command 'show' do |c|
+        c.description = "Show a defined feature"
+        c.action do |feature|
+          ui.info feature_details(Flipper.feature(feature))
+        end
+      end
+
+      command 'help' do |c|
+        c.load_environment = false
+        c.action do |command = nil|
+          ui.info command ? @commands[command].help : help
+        end
+      end
+
+      on_tail('-r path', "The path to load your application. Default: #{@require}") do |path|
+        @require = path
+      end
+
+      # Options available on all commands
+      on_tail('-h', '--help', 'Print help message') do
+        ui.info help
+        exit
+      end
+
+      # Set help documentation
+      self.banner = "Usage: #{program_name} [options] <command>"
+      separator ""
+      separator "Commands:"
+
+      pad = @commands.keys.map(&:length).max + 2
+      @commands.each do |name, command|
+        separator "  #{name.to_s.ljust(pad, " ")} #{command.description}" if command.description
+      end
+
+      separator ""
+      separator "Options:"
+    end
+
+    def run(argv)
+      command, *args = order(argv)
+
+      if @commands[command]
+        load_environment! if @commands[command].load_environment
+        @commands[command].run(args)
+      else
+        ui.info help
+
+        if command
+          ui.error "Unknown command: #{command}"
+          exit 1
+        end
+      end
+    rescue OptionParser::InvalidOption => e
+      ui.error e.message
+      exit 1
+    end
+
+    # Helper method to define a new command
+    def command(name, &block)
+      @commands[name] = Command.new(program_name: "#{program_name} #{name}")
+      block.call(@commands[name])
+    end
+
+    def load_environment!
+      ENV["FLIPPER_CLOUD_LOGGING_ENABLED"] ||= "false"
+      require File.expand_path(@require)
+      # Ensure all of flipper gets loaded if it hasn't already.
+      require 'flipper'
+    rescue LoadError => e
+      ui.error e.message
+      exit 1
+    end
+
+    def feature_summary(features)
+      features = Array(features)
+      padding = features.map { |f| f.key.to_s.length }.max
+
+      features.map do |feature|
+        summary = case feature.state
+        when :on
+          colorize("⏺ enabled", [:GREEN])
+        when :off
+          "⦸ disabled"
+        else
+            "#{colorize("◯ enabled", [:YELLOW])} for " + feature.enabled_gates.map do |gate|
+            case gate.name
+            when :actor
+              pluralize feature.actors_value.size, 'actor', 'actors'
+            when :group
+              pluralize feature.groups_value.size, 'group', 'groups'
+            when :percentage_of_actors
+              "#{feature.percentage_of_actors_value}% of actors"
+            when :percentage_of_time
+              "#{feature.percentage_of_time_value}% of time"
+            when :expression
+              "an expression"
+            end
+          end.join(', ')
+        end
+
+        colorize("%-#{padding}s" % feature.key, [:BOLD, :WHITE]) + " is #{summary}"
+      end.join("\n")
+    end
+
+    def feature_details(feature)
+      summary = case feature.state
+      when :on
+        colorize("⏺ enabled", [:GREEN])
+      when :off
+        "⦸ disabled"
+      else
+        lines = feature.enabled_gates.map do |gate|
+          case gate.name
+          when :actor
+            [ pluralize(feature.actors_value.size, 'actor', 'actors') ] +
+            feature.actors_value.map { |actor| "- #{actor}" }
+          when :group
+            [ pluralize(feature.groups_value.size, 'group', 'groups') ] +
+            feature.groups_value.map { |group| "  - #{group}" }
+          when :percentage_of_actors
+            "#{feature.percentage_of_actors_value}% of actors"
+          when :percentage_of_time
+            "#{feature.percentage_of_time_value}% of time"
+          when :expression
+            json = indent(JSON.pretty_generate(feature.expression_value), 2)
+            "the expression: \n#{colorize(json, [:MAGENTA])}"
+          end
+        end
+
+        "#{colorize("◯ conditionally enabled", [:YELLOW])} for:\n" +
+        indent(lines.flatten.join("\n"), 2)
+      end
+
+      "#{colorize(feature.key, [:BOLD, :WHITE])} is #{summary}"
+    end
+
+    def pluralize(count, singular, plural)
+      "#{count} #{count == 1 ? singular : plural}"
+    end
+
+    def colorize(text, colors)
+      ui.add_color(text, *colors)
+    end
+
+    def ui
+      @ui ||= Bundler::UI::Shell.new.tap do |ui|
+        ui.shell = shell
+      end
+    end
+
+    def indent(text, spaces)
+      text.gsub(/^/, " " * spaces)
+    end
+
+    # Redirect the shell's output to the given stdout and stderr streams
+    module ShellOutput
+      attr_reader :stdout, :stderr
+
+      def redirect(stdout: $stdout, stderr: $stderr)
+        @stdout, @stderr = stdout, stderr
+      end
+    end
+
+    class Command < OptionParser
+      attr_accessor :description, :load_environment
+
+      def initialize(program_name: nil)
+        super()
+        @program_name = program_name
+        @load_environment = true
+        @action = lambda { }
+      end
+
+      def run(argv)
+        # Parse argv and call action with arguments
+        @action.call(*permute(argv))
+      end
+
+      def action(&block)
+        @action = block
+      end
+    end
+  end
+end

data/lib/flipper/cloud/configuration.rb

@@ -163,7 +163,8 @@ module Flipper
           max_retries: 0, # we'll handle retries ourselves
           debug_output: @debug_output,
           headers: {
-            "Flipper-Cloud-Token" => @token,
+            "flipper-cloud-token" => @token,
+            "accept-encoding" => "gzip",
           },
         })
       end
@@ -173,7 +174,7 @@ module Flipper
       end
 
       def setup_log(options)
-        set_option :logging_enabled, options, default: true, typecast: :boolean
+        set_option :logging_enabled, options, default: false, typecast: :boolean
         set_option :logger, options, from_env: false, default: -> {
           if logging_enabled
             Logger.new(STDOUT)
@@ -186,6 +187,11 @@ module Flipper
       def setup_http(options)
         set_option :url, options, default: DEFAULT_URL
         set_option :debug_output, options, from_env: false
+
+        if @debug_output.nil? && Flipper::Typecast.to_boolean(ENV["FLIPPER_CLOUD_DEBUG_OUTPUT_STDOUT"])
+          @debug_output = STDOUT
+        end
+
         set_option :read_timeout, options, default: 5, typecast: :float, minimum: 0.1
         set_option :open_timeout, options, default: 2, typecast: :float, minimum: 0.1
         set_option :write_timeout, options, default: 5, typecast: :float, minimum: 0.1
@@ -208,8 +214,7 @@ module Flipper
           Telemetry.instance_for(self)
         }
 
-        # This is alpha. Don't use this unless you are me. And you are not me.
-        set_option :telemetry_enabled, options, default: false, typecast: :boolean
+        set_option :telemetry_enabled, options, default: true, typecast: :boolean
         instrumenter = options.fetch(:instrumenter, Instrumenters::Noop)
         @instrumenter = if telemetry_enabled
           Telemetry::Instrumenter.new(self, instrumenter)

data/lib/flipper/cloud/middleware.rb

@@ -24,7 +24,7 @@ module Flipper
         if request.post? && (request.path_info.match(ROOT_PATH) || request.path_info.match(WEBHOOK_PATH))
           status = 200
           headers = {
-            "content-type" => "application/json",
+            Rack::CONTENT_TYPE => "application/json",
           }
           body = "{}"
           payload = request.body.read
@@ -41,12 +41,12 @@ module Flipper
                 })
               rescue Flipper::Adapters::Http::Error => error
                 status = error.response.code.to_i == 402 ? 402 : 500
-                headers["Flipper-Cloud-Response-Error-Class"] = error.class.name
-                headers["Flipper-Cloud-Response-Error-Message"] = error.message
+                headers["flipper-cloud-response-error-class"] = error.class.name
+                headers["flipper-cloud-response-error-message"] = error.message
               rescue => error
                 status = 500
-                headers["Flipper-Cloud-Response-Error-Class"] = error.class.name
-                headers["Flipper-Cloud-Response-Error-Message"] = error.message
+                headers["flipper-cloud-response-error-class"] = error.class.name
+                headers["flipper-cloud-response-error-message"] = error.message
               end
             end
           rescue MessageVerifier::InvalidSignature

data/lib/flipper/cloud/telemetry/instrumenter.rb

@@ -3,9 +3,11 @@ require "delegate"
 module Flipper
   module Cloud
     class Telemetry
-      class Instrumenter < SimpleDelegator
+      class Instrumenter
+        attr_reader :instrumenter
+
         def initialize(cloud_configuration, instrumenter)
-          super instrumenter
+          @instrumenter = instrumenter
           @cloud_configuration = cloud_configuration
         end
 
@@ -14,12 +16,6 @@ module Flipper
           @cloud_configuration.telemetry.record(name, payload)
           return_value
         end
-
-        private
-
-        def instrumenter
-          __getobj__
-        end
       end
     end
   end

data/lib/flipper/cloud/telemetry/submitter.rb

@@ -78,8 +78,8 @@ module Flipper
 
         def submit(body)
           client = @cloud_configuration.http_client
-          client.add_header :schema_version, SCHEMA_VERSION
-          client.add_header :content_encoding, GZIP_ENCODING
+          client.add_header "schema-version", SCHEMA_VERSION
+          client.add_header "content-encoding", GZIP_ENCODING
 
           response = client.post PATH, body
           code = response.code.to_i

data/lib/flipper/cloud/telemetry.rb

@@ -160,8 +160,16 @@ module Flipper
         # thus may have a telemetry-interval header for us to respect.
         response ||= error.response if error && error.respond_to?(:response)
 
-        if response && interval = response["telemetry-interval"]
-          self.interval = interval.to_f
+        if response
+          if Flipper::Typecast.to_boolean(response["telemetry-shutdown"])
+            debug "action=telemetry_shutdown message=The server has requested that telemetry be shut down."
+            stop
+            return
+          end
+
+          if interval = response["telemetry-interval"]
+            self.interval = interval.to_f
+          end
         end
       rescue => error
         error "action=post_to_cloud error=#{error.inspect}"

data/lib/flipper/cloud.rb

@@ -24,7 +24,7 @@ module Flipper
       env_key = options.fetch(:env_key, 'flipper')
       memoizer_options = options.fetch(:memoizer_options, {})
 
-      app = ->(_) { [404, { 'content-type'.freeze => 'application/json'.freeze }, ['{}'.freeze]] }
+      app = ->(_) { [404, { Rack::CONTENT_TYPE => 'application/json'.freeze }, ['{}'.freeze]] }
       builder = Rack::Builder.new
       yield builder if block_given?
       builder.use Flipper::Middleware::SetupEnv, flipper, env_key: env_key

data/lib/flipper/engine.rb

@@ -1,5 +1,19 @@
 module Flipper
   class Engine < Rails::Engine
+    def self.default_strict_value
+      value = ENV["FLIPPER_STRICT"]
+      if value.in?(["warn", "raise", "noop"])
+        value.to_sym
+      elsif value
+        Typecast.to_boolean(value) ? :raise : false
+      elsif Rails.env.production?
+        false
+      else
+        # Warn in development for now. Future versions may default to :raise in development and test
+        Rails.env.development? && :warn
+      end
+    end
+
     paths["config/routes.rb"] = ["lib/flipper/cloud/routes.rb"]
 
     config.before_configuration do
@@ -10,7 +24,9 @@ module Flipper
         instrumenter: ENV.fetch('FLIPPER_INSTRUMENTER', 'ActiveSupport::Notifications').constantize,
         log: ENV.fetch('FLIPPER_LOG', 'true').casecmp('true').zero?,
         cloud_path: "_flipper",
-        strict: default_strict_value
+        strict: default_strict_value,
+        actor_limit: ENV["FLIPPER_ACTOR_LIMIT"]&.to_i || 100,
+        test_help: Flipper::Typecast.to_boolean(ENV["FLIPPER_TEST_HELP"] || Rails.env.test?),
       )
     end
 
@@ -29,10 +45,6 @@ module Flipper
       require 'flipper/cloud' if cloud?
 
       Flipper.configure do |config|
-        if app.config.flipper.strict
-          config.use Flipper::Adapters::Strict, app.config.flipper.strict
-        end
-
         config.default do
           if cloud?
             Flipper::Cloud.new(
@@ -54,6 +66,15 @@ module Flipper
       end
     end
 
+    initializer "flipper.adapters", after: :load_config_initializers do |app|
+      flipper = app.config.flipper
+
+      Flipper.configure do |config|
+        config.use Flipper::Adapters::Strict, flipper.strict if flipper.strict
+        config.use Flipper::Adapters::ActorLimit, flipper.actor_limit if flipper.actor_limit
+      end
+    end
+
     initializer "flipper.memoizer", after: :load_config_initializers do |app|
       flipper = app.config.flipper
 
@@ -66,22 +87,16 @@ module Flipper
       end
     end
 
+    initializer "flipper.test" do |app|
+      require "flipper/test_help" if app.config.flipper.test_help
+    end
+
     def cloud?
       !!ENV["FLIPPER_CLOUD_TOKEN"]
     end
 
-    def self.default_strict_value
-      value = ENV["FLIPPER_STRICT"]
-      if value.in?(["warn", "raise", "noop"])
-        value.to_sym
-      elsif value
-        Typecast.to_boolean(value) ? :raise : false
-      elsif Rails.env.production?
-        false
-      else
-        # Warn for now. Future versions will default to :raise in development and test
-        :warn
-      end
+    def self.deprecated_rails_version?
+      Gem::Version.new(Rails.version) < Gem::Version.new(Flipper::NEXT_REQUIRED_RAILS_VERSION)
     end
   end
 end

data/lib/flipper/instrumentation/log_subscriber.rb

@@ -1,4 +1,5 @@
 require 'securerandom'
+require 'active_support/gem_version'
 require 'active_support/notifications'
 require 'active_support/log_subscriber'
 
@@ -71,11 +72,19 @@ module Flipper
         self.class.logger
       end
 
+      def self.attach
+        attach_to InstrumentationNamespace
+      end
+
+      def self.detach
+        # Rails 5.2 doesn't support this, that's fine
+        detach_from InstrumentationNamespace if respond_to?(:detach_from)
+      end
+
       private
 
       # Rails 7.1 changed the signature of this function.
-      # Checking if > 7.0.99 rather than >= 7.1 so that 7.1 pre-release versions are included.
-      COLOR_OPTIONS = if Rails.gem_version > Gem::Version.new('7.0.99')
+      COLOR_OPTIONS = if Gem::Requirement.new(">=7.1").satisfied_by?(ActiveSupport.gem_version)
         { bold: true }.freeze
       else
         true
@@ -88,5 +97,5 @@ module Flipper
     end
   end
 
-  Instrumentation::LogSubscriber.attach_to InstrumentationNamespace
+  Instrumentation::LogSubscriber.attach
 end

data/lib/flipper/metadata.rb

@@ -1,9 +1,11 @@
+require_relative './version'
+
 module Flipper
   METADATA = {
     "documentation_uri" => "https://www.flippercloud.io/docs",
     "homepage_uri"      => "https://www.flippercloud.io",
     "source_code_uri"   => "https://github.com/flippercloud/flipper",
     "bug_tracker_uri"   => "https://github.com/flippercloud/flipper/issues",
-    "changelog_uri"     => "https://github.com/flippercloud/flipper/blob/main/Changelog.md",
+    "changelog_uri"     => "https://github.com/flippercloud/flipper/releases/tag/v#{Flipper::VERSION}",
   }.freeze
 end

data/lib/flipper/poller.rb

@@ -20,6 +20,8 @@ module Flipper
       instances.each {|_, instance| instance.stop }.clear
     end
 
+    MINIMUM_POLL_INTERVAL = 10
+
     def initialize(options = {})
       @thread = nil
       @pid = Process.pid
@@ -30,9 +32,9 @@ module Flipper
       @last_synced_at = Concurrent::AtomicFixnum.new(0)
       @adapter = Adapters::Memory.new(nil, threadsafe: true)
 
-      if @interval < 1
-        warn "Flipper::Cloud poll interval must be greater than or equal to 1 but was #{@interval}. Setting @interval to 1."
-        @interval = 1
+      if @interval < MINIMUM_POLL_INTERVAL
+        warn "Flipper::Cloud poll interval must be greater than or equal to #{MINIMUM_POLL_INTERVAL} but was #{@interval}. Setting @interval to #{MINIMUM_POLL_INTERVAL}."
+        @interval = MINIMUM_POLL_INTERVAL
       end
 
       @start_automatically = options.fetch(:start_automatically, true)
@@ -64,8 +66,7 @@ module Flipper
           # you can instrument these using poller.flipper
         end
 
-        sleep_interval = interval - (Concurrent.monotonic_time - start)
-        sleep sleep_interval if sleep_interval.positive?
+        sleep interval
       end
     end
 

data/lib/flipper/serializers/gzip.rb

@@ -3,10 +3,8 @@ require "stringio"
 
 module Flipper
   module Serializers
-    module Gzip
-      module_function
-
-      def serialize(source)
+    class Gzip
+      def self.serialize(source)
         return if source.nil?
         output = StringIO.new
         gz = Zlib::GzipWriter.new(output)
@@ -15,7 +13,7 @@ module Flipper
         output.string
       end
 
-      def deserialize(source)
+      def self.deserialize(source)
         return if source.nil?
         Zlib::GzipReader.wrap(StringIO.new(source), &:read)
       end

data/lib/flipper/serializers/json.rb

@@ -2,15 +2,13 @@ require "json"
 
 module Flipper
   module Serializers
-    module Json
-      module_function
-
-      def serialize(source)
+    class Json
+      def self.serialize(source)
         return if source.nil?
         JSON.generate(source)
       end
 
-      def deserialize(source)
+      def self.deserialize(source)
         return if source.nil?
         JSON.parse(source)
       end

data/lib/flipper/spec/shared_adapter_specs.rb

@@ -108,19 +108,19 @@ RSpec.shared_examples_for 'a flipper adapter' do
     actor22 = Flipper::Actor.new('22')
     actor_asdf = Flipper::Actor.new('asdf')
 
-    expect(subject.enable(feature, actor_gate, Flipper::Types::Actor.new(actor22))).to eq(true)
-    expect(subject.enable(feature, actor_gate, Flipper::Types::Actor.new(actor_asdf))).to eq(true)
+    expect(feature.enable(actor22)).to be(true)
+    expect(feature.enable(actor_asdf)).to be(true)
 
-    result = subject.get(feature)
-    expect(result[:actors]).to eq(Set['22', 'asdf'])
+    expect(feature).to be_enabled(actor22)
+    expect(feature).to be_enabled(actor_asdf)
 
-    expect(subject.disable(feature, actor_gate, Flipper::Types::Actor.new(actor22))).to eq(true)
-    result = subject.get(feature)
-    expect(result[:actors]).to eq(Set['asdf'])
+    expect(feature.disable(actor22)).to be(true)
+    expect(feature).not_to be_enabled(actor22)
+    expect(feature).to be_enabled(actor_asdf)
 
-    expect(subject.disable(feature, actor_gate, Flipper::Types::Actor.new(actor_asdf))).to eq(true)
-    result = subject.get(feature)
-    expect(result[:actors]).to eq(Set.new)
+    expect(feature.disable(actor_asdf)).to eq(true)
+    expect(feature).not_to be_enabled(actor22)
+    expect(feature).not_to be_enabled(actor_asdf)
   end
 
   it 'can enable, disable and get value for percentage of actors gate' do
@@ -182,9 +182,10 @@ RSpec.shared_examples_for 'a flipper adapter' do
   end
 
   it 'converts the actor value to a string' do
-    expect(subject.enable(feature, actor_gate, Flipper::Types::Actor.new(Flipper::Actor.new(22)))).to eq(true)
-    result = subject.get(feature)
-    expect(result[:actors]).to eq(Set['22'])
+    actor = Flipper::Actor.new(22)
+    expect(feature).not_to be_enabled(actor)
+    feature.enable_actor actor
+    expect(feature).to be_enabled(actor)
   end
 
   it 'converts group value to a string' do
@@ -295,9 +296,9 @@ RSpec.shared_examples_for 'a flipper adapter' do
 
   it 'can double enable an actor without error' do
     actor = Flipper::Actor.new('Flipper::Actor;22')
-    expect(subject.enable(feature, actor_gate, Flipper::Types::Actor.new(actor))).to eq(true)
-    expect(subject.enable(feature, actor_gate, Flipper::Types::Actor.new(actor))).to eq(true)
-    expect(subject.get(feature).fetch(:actors)).to eq(Set['Flipper::Actor;22'])
+    expect(feature.enable(actor)).to be(true)
+    expect(feature.enable(actor)).to be(true)
+    expect(feature).to be_enabled(actor)
   end
 
   it 'can double enable a group without error' do