flipper 0.24.1 → 1.3.0

data/spec/flipper/cloud/telemetry/submitter_spec.rb

@@ -0,0 +1,145 @@
+require "stringio"
+require 'flipper/cloud/configuration'
+require 'flipper/cloud/telemetry/submitter'
+
+RSpec.describe Flipper::Cloud::Telemetry::Submitter do
+  let(:cloud_configuration) {
+    Flipper::Cloud::Configuration.new({token: "asdf"})
+  }
+  let(:fake_backoff_policy) { FakeBackoffPolicy.new }
+  let(:subject) { described_class.new(cloud_configuration, backoff_policy: fake_backoff_policy) }
+
+  describe "#initialize" do
+    it "works with cloud_configuration" do
+      submitter = described_class.new(cloud_configuration)
+      expect(submitter.cloud_configuration).to eq(cloud_configuration)
+    end
+  end
+
+  describe "#call" do
+    let(:enabled_metrics) {
+      {
+        Flipper::Cloud::Telemetry::Metric.new(:search, true, 1696793160) => 10,
+        Flipper::Cloud::Telemetry::Metric.new(:search, false, 1696793161) => 15,
+        Flipper::Cloud::Telemetry::Metric.new(:plausible, true, 1696793162) => 25,
+        Flipper::Cloud::Telemetry::Metric.new(:administrator, true, 1696793164) => 1,
+        Flipper::Cloud::Telemetry::Metric.new(:administrator, false, 1696793164) => 24,
+      }
+    }
+
+    it "does not submit blank metrics" do
+      expect(subject.call({})).to be(nil)
+    end
+
+    it "submits present metrics" do
+      expected_body = {
+        "request_id" => subject.request_id,
+        "enabled_metrics" =>[
+          {"key" => "search", "time" => 1696793160, "result" => true, "value" => 10},
+          {"key" => "search", "time" => 1696793160, "result" => false, "value" => 15},
+          {"key" => "plausible", "time" => 1696793160, "result" => true, "value" => 25},
+          {"key" => "administrator", "time" => 1696793160, "result" => true, "value" => 1},
+          {"key" => "administrator", "time" => 1696793160, "result" => false, "value" => 24},
+        ]
+      }
+      expected_headers = {
+        'accept' => 'application/json',
+        'client-engine' => defined?(RUBY_ENGINE) ? RUBY_ENGINE : "",
+        'client-hostname' => Socket.gethostname,
+        'client-language' => 'ruby',
+        'client-language-version' => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+        'client-pid' => Process.pid.to_s,
+        'client-platform' => RUBY_PLATFORM,
+        'client-thread' => Thread.current.object_id.to_s,
+        'content-encoding' => 'gzip',
+        'content-type' => 'application/json',
+        'flipper-cloud-token' => 'asdf',
+        'schema-version' => 'V1',
+        'user-agent' => "Flipper HTTP Adapter v#{Flipper::VERSION}",
+      }
+      stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+        with(headers: expected_headers) { |request|
+          gunzipped = Flipper::Typecast.from_gzip(request.body)
+          body = Flipper::Typecast.from_json(gunzipped)
+          body == expected_body
+        }.to_return(status: 200, body: "{}")
+      subject.call(enabled_metrics)
+    end
+
+    it "defaults backoff_policy" do
+      stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+        to_return(status: 429, body: "{}").
+        to_return(status: 200, body: "{}")
+      instance = described_class.new(cloud_configuration)
+      expect(instance.backoff_policy.min_timeout_ms).to eq(1_000)
+      expect(instance.backoff_policy.max_timeout_ms).to eq(30_000)
+    end
+
+    it "tries 10 times by default" do
+      stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+        to_return(status: 500, body: "{}")
+      subject.call(enabled_metrics)
+      expect(subject.backoff_policy.retries).to eq(9) # 9 retries + 1 initial attempt
+    end
+
+    [
+      EOFError,
+      Errno::ECONNABORTED,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::EHOSTUNREACH,
+      Errno::EINVAL,
+      Errno::ENETUNREACH,
+      Errno::ENOTSOCK,
+      Errno::EPIPE,
+      Errno::ETIMEDOUT,
+      Net::HTTPBadResponse,
+      Net::HTTPHeaderSyntaxError,
+      Net::ProtocolError,
+      Net::ReadTimeout,
+      OpenSSL::SSL::SSLError,
+      SocketError,
+      Timeout::Error,  # Also covers subclasses like Net::OpenTimeout.
+    ].each  do |error_class|
+      it "retries on #{error_class}" do
+        stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+          to_raise(error_class)
+        subject.call(enabled_metrics)
+        expect(subject.backoff_policy.retries).to eq(9)
+      end
+    end
+
+    it "retries on 429" do
+      stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+        to_return(status: 429, body: "{}").
+        to_return(status: 429, body: "{}").
+        to_return(status: 200, body: "{}")
+      subject.call(enabled_metrics)
+      expect(subject.backoff_policy.retries).to eq(2)
+    end
+
+    it "retries on 500" do
+      stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+        to_return(status: 500, body: "{}").
+        to_return(status: 503, body: "{}").
+        to_return(status: 502, body: "{}").
+        to_return(status: 200, body: "{}")
+      subject.call(enabled_metrics)
+      expect(subject.backoff_policy.retries).to eq(3)
+    end
+  end
+
+  def with_telemetry_debug_logging(&block)
+    output = StringIO.new
+    original_logger = cloud_configuration.logger
+
+    begin
+      cloud_configuration.logger = Logger.new(output)
+      block.call
+    ensure
+      cloud_configuration.logger = original_logger
+    end
+
+    output.string
+  end
+end

data/spec/flipper/cloud/telemetry_spec.rb

@@ -0,0 +1,208 @@
+require 'flipper/cloud/telemetry'
+require 'flipper/cloud/configuration'
+
+RSpec.describe Flipper::Cloud::Telemetry do
+  before do
+    # Stub polling for features.
+    stub_request(:get, "https://www.flippercloud.io/adapter/features?exclude_gate_names=true").
+      to_return(status: 200, body: "{}")
+  end
+
+  it "phones home and does not update telemetry interval if missing" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_return(status: 200, body: "{}")
+
+    cloud_configuration = Flipper::Cloud::Configuration.new(token: "test")
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry = described_class.new(cloud_configuration)
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+
+    expect(telemetry.interval).to eq(60)
+    expect(telemetry.timer.execution_interval).to eq(60)
+    expect(stub).to have_been_requested
+  end
+
+  it "phones home and updates telemetry interval if present" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_return(status: 200, body: "{}", headers: {"telemetry-interval" => "120"})
+
+    cloud_configuration = Flipper::Cloud::Configuration.new(token: "test")
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry = described_class.new(cloud_configuration)
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+
+    expect(telemetry.interval).to eq(120)
+    expect(telemetry.timer.execution_interval).to eq(120)
+    expect(stub).to have_been_requested
+  end
+
+  it "phones home and requests shutdown if telemetry-shutdown header is true" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_return(status: 404, body: "{}", headers: {"telemetry-shutdown" => "true"})
+
+    output = StringIO.new
+    cloud_configuration = Flipper::Cloud::Configuration.new(
+      token: "test",
+      logger: Logger.new(output),
+      logging_enabled: true,
+    )
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry = described_class.new(cloud_configuration)
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+    expect(stub).to have_been_requested
+    expect(output.string).to match(/action=telemetry_shutdown message=The server has requested that telemetry be shut down./)
+  end
+
+  it "phones home and does not shutdown if telemetry shutdown header is missing" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_return(status: 404, body: "{}", headers: {})
+
+    output = StringIO.new
+    cloud_configuration = Flipper::Cloud::Configuration.new(
+      token: "test",
+      logger: Logger.new(output),
+      logging_enabled: true,
+    )
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry = described_class.new(cloud_configuration)
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+    expect(stub).to have_been_requested
+    expect(output.string).not_to match(/action=telemetry_shutdown message=The server has requested that telemetry be shut down./)
+  end
+
+  it "can update telemetry interval from error" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_return(status: 500, body: "{}", headers: {"telemetry-interval" => "120"})
+
+    cloud_configuration = Flipper::Cloud::Configuration.new(token: "test")
+    telemetry = described_class.new(cloud_configuration)
+
+    # Override the submitter to use back off policy that doesn't actually
+    # sleep. If we don't then the stop below kills the working thread and the
+    # interval is never updated.
+    telemetry.submitter = ->(drained) {
+      Flipper::Cloud::Telemetry::Submitter.new(
+        cloud_configuration,
+        backoff_policy: FakeBackoffPolicy.new
+      ).call(drained)
+    }
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+
+    # Check the conig interval and the timer interval.
+    expect(telemetry.interval).to eq(120)
+    expect(telemetry.timer.execution_interval).to eq(120)
+    expect(stub).to have_been_requested.times(10)
+  end
+
+  it "doesn't try to update telemetry interval from error if not response error" do
+    stub = stub_request(:post, "https://www.flippercloud.io/adapter/telemetry").
+      to_raise(Net::OpenTimeout)
+
+    cloud_configuration = Flipper::Cloud::Configuration.new(token: "test")
+    telemetry = described_class.new(cloud_configuration)
+
+    # Override the submitter to use back off policy that doesn't actually
+    # sleep. If we don't then the stop below kills the working thread and the
+    # interval is never updated.
+    telemetry.submitter = ->(drained) {
+      Flipper::Cloud::Telemetry::Submitter.new(
+        cloud_configuration,
+        backoff_policy: FakeBackoffPolicy.new
+      ).call(drained)
+    }
+
+    # Record some telemetry and stop the threads so we submit a response.
+    telemetry.record(Flipper::Feature::InstrumentationName, {
+      operation: :enabled?,
+      feature_name: :foo,
+      result: true,
+    })
+    telemetry.stop
+
+    expect(telemetry.interval).to eq(60)
+    expect(telemetry.timer.execution_interval).to eq(60)
+    expect(stub).to have_been_requested.times(10)
+  end
+
+  describe '#record' do
+    it "increments in metric storage" do
+      begin
+        config = Flipper::Cloud::Configuration.new(token: "test")
+        telemetry = described_class.new(config)
+        telemetry.record(Flipper::Feature::InstrumentationName, {
+          operation: :enabled?,
+          feature_name: :foo,
+          result: true,
+        })
+        telemetry.record(Flipper::Feature::InstrumentationName, {
+          operation: :enabled?,
+          feature_name: :foo,
+          result: true,
+        })
+        telemetry.record(Flipper::Feature::InstrumentationName, {
+          operation: :enabled?,
+          feature_name: :bar,
+          result: true,
+        })
+        telemetry.record(Flipper::Feature::InstrumentationName, {
+          operation: :enabled?,
+          feature_name: :baz,
+          result: true,
+        })
+        telemetry.record(Flipper::Feature::InstrumentationName, {
+          operation: :enabled?,
+          feature_name: :foo,
+          result: false,
+        })
+
+        drained = telemetry.metric_storage.drain
+        metrics_by_key = drained.keys.group_by(&:key)
+
+        foo_true, foo_false = metrics_by_key["foo"].partition { |metric| metric.result }
+        foo_true_sum = foo_true.map { |metric| drained[metric] }.sum
+        expect(foo_true_sum).to be(2)
+        foo_false_sum = foo_false.map { |metric| drained[metric] }.sum
+        expect(foo_false_sum).to be(1)
+
+        bar_true_sum = metrics_by_key["bar"].map { |metric| drained[metric] }.sum
+        expect(bar_true_sum).to be(1)
+
+        baz_true_sum = metrics_by_key["baz"].map { |metric| drained[metric] }.sum
+        expect(baz_true_sum).to be(1)
+      ensure
+        telemetry.stop
+      end
+    end
+  end
+end

data/spec/flipper/cloud_spec.rb

@@ -0,0 +1,181 @@
+require 'flipper/cloud'
+require 'flipper/adapters/instrumented'
+require 'flipper/instrumenters/memory'
+
+RSpec.describe Flipper::Cloud do
+  before do
+    stub_request(:get, /flippercloud\.io/).to_return(status: 200, body: "{}")
+  end
+
+  context "initialize with token" do
+    let(:token) { 'asdf' }
+
+    before do
+      @instance = described_class.new(token: token)
+    end
+
+    it 'returns Flipper::DSL instance' do
+      expect(@instance).to be_instance_of(Flipper::Cloud::DSL)
+    end
+
+    it 'can read the cloud configuration' do
+      expect(@instance.cloud_configuration).to be_instance_of(Flipper::Cloud::Configuration)
+    end
+
+    it 'configures the correct adapter' do
+      # pardon the nesting...
+      memoized_adapter = @instance.adapter
+      dual_write_adapter = memoized_adapter.adapter
+      expect(dual_write_adapter).to be_instance_of(Flipper::Adapters::DualWrite)
+      poll_adapter = dual_write_adapter.local
+      expect(poll_adapter).to be_instance_of(Flipper::Adapters::Poll)
+
+      http_adapter = dual_write_adapter.remote
+      client = http_adapter.client
+      expect(client.uri.scheme).to eq('https')
+      expect(client.uri.host).to eq('www.flippercloud.io')
+      expect(client.uri.path).to eq('/adapter')
+      expect(client.headers["flipper-cloud-token"]).to eq(token)
+      expect(@instance.instrumenter).to be_a(Flipper::Cloud::Telemetry::Instrumenter)
+      expect(@instance.instrumenter.instrumenter).to be(Flipper::Instrumenters::Noop)
+    end
+  end
+
+  context 'initialize with token and options' do
+    it 'sets correct url' do
+      instance = described_class.new(token: 'asdf', url: 'https://www.fakeflipper.com/sadpanda')
+      # pardon the nesting...
+      memoized = instance.adapter
+      dual_write = memoized.adapter
+      remote = dual_write.remote
+      uri = remote.client.uri
+      expect(uri.scheme).to eq('https')
+      expect(uri.host).to eq('www.fakeflipper.com')
+      expect(uri.path).to eq('/sadpanda')
+    end
+  end
+
+  it 'can initialize with no token explicitly provided' do
+    ENV['FLIPPER_CLOUD_TOKEN'] = 'asdf'
+    expect(described_class.new).to be_instance_of(Flipper::Cloud::DSL)
+  end
+
+  it 'can set instrumenter' do
+    instrumenter = Flipper::Instrumenters::Memory.new
+    instance = described_class.new(token: 'asdf', instrumenter: instrumenter)
+    expect(instance.instrumenter).to be_a(Flipper::Cloud::Telemetry::Instrumenter)
+    expect(instance.instrumenter.instrumenter).to be(instrumenter)
+  end
+
+  it 'allows wrapping adapter with another adapter like the instrumenter' do
+    instance = described_class.new(token: 'asdf') do |config|
+      config.adapter do |adapter|
+        Flipper::Adapters::Instrumented.new(adapter)
+      end
+    end
+    # instance.adapter is memoizable adapter instance
+    expect(instance.adapter.adapter).to be_instance_of(Flipper::Adapters::Instrumented)
+  end
+
+  it 'can set debug_output' do
+    expect(Flipper::Adapters::Http::Client).to receive(:new)
+      .with(hash_including(debug_output: STDOUT)).at_least(:once)
+    described_class.new(token: 'asdf', debug_output: STDOUT)
+  end
+
+  it 'can set read_timeout' do
+    expect(Flipper::Adapters::Http::Client).to receive(:new)
+      .with(hash_including(read_timeout: 1)).at_least(:once)
+    described_class.new(token: 'asdf', read_timeout: 1)
+  end
+
+  it 'can set open_timeout' do
+    expect(Flipper::Adapters::Http::Client).to receive(:new)
+      .with(hash_including(open_timeout: 1)).at_least(:once)
+    described_class.new(token: 'asdf', open_timeout: 1)
+  end
+
+  if RUBY_VERSION >= '2.6.0'
+    it 'can set write_timeout' do
+      expect(Flipper::Adapters::Http::Client).to receive(:new)
+        .with(hash_including(open_timeout: 1)).at_least(:once)
+      described_class.new(token: 'asdf', open_timeout: 1)
+    end
+  end
+
+  it 'can import' do
+    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
+      with(headers: {'flipper-cloud-token'=>'asdf'}).to_return(status: 200, body: "{}", headers: {})
+
+    flipper = Flipper.new(Flipper::Adapters::Memory.new)
+
+    flipper.enable(:test)
+    flipper.enable(:search)
+    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
+    flipper.enable_percentage_of_time(:logging, 5)
+
+    cloud_flipper = Flipper::Cloud.new(token: "asdf")
+
+    get_all = {
+      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: "5"},
+      "search" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "test" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+    }
+
+    expect(flipper.adapter.get_all).to eq(get_all)
+    cloud_flipper.import(flipper)
+    expect(flipper.adapter.get_all).to eq(get_all)
+    expect(cloud_flipper.adapter.get_all).to eq(get_all)
+  end
+
+  it 'raises error for failure while importing' do
+    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
+      with(headers: {'flipper-cloud-token'=>'asdf'}).to_return(status: 500, body: "{}")
+
+    flipper = Flipper.new(Flipper::Adapters::Memory.new)
+
+    flipper.enable(:test)
+    flipper.enable(:search)
+    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
+    flipper.enable_percentage_of_time(:logging, 5)
+
+    cloud_flipper = Flipper::Cloud.new(token: "asdf")
+
+    get_all = {
+      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: "5"},
+      "search" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "test" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+    }
+
+    expect(flipper.adapter.get_all).to eq(get_all)
+    expect { cloud_flipper.import(flipper) }.to raise_error(Flipper::Adapters::Http::Error)
+    expect(flipper.adapter.get_all).to eq(get_all)
+  end
+
+  it 'raises error for timeout while importing' do
+    stub_request(:post, /www\.flippercloud\.io\/adapter\/features.*/).
+      with(headers: {'flipper-cloud-token'=>'asdf'}).to_timeout
+
+    flipper = Flipper.new(Flipper::Adapters::Memory.new)
+
+    flipper.enable(:test)
+    flipper.enable(:search)
+    flipper.enable_actor(:stats, Flipper::Actor.new("jnunemaker"))
+    flipper.enable_percentage_of_time(:logging, 5)
+
+    cloud_flipper = Flipper::Cloud.new(token: "asdf")
+
+    get_all = {
+      "logging" => {actors: Set.new, boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: "5"},
+      "search" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "stats" => {actors: Set["jnunemaker"], boolean: nil, groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+      "test" => {actors: Set.new, boolean: "true", groups: Set.new, expression: nil, percentage_of_actors: nil, percentage_of_time: nil},
+    }
+
+    expect(flipper.adapter.get_all).to eq(get_all)
+    expect { cloud_flipper.import(flipper) }.to raise_error(Net::OpenTimeout)
+    expect(flipper.adapter.get_all).to eq(get_all)
+  end
+end

data/spec/flipper/configuration_spec.rb

@@ -30,4 +30,21 @@ RSpec.describe Flipper::Configuration do
       expect(subject.default).to be(instance)
     end
   end
+
+  describe '#statsd' do
+    let(:statsd) { double(Statsd) }
+
+    after do
+      Flipper::Instrumentation::StatsdSubscriber.client = nil
+    end
+
+    it 'returns nil by default' do
+      expect(subject.statsd).to be_nil
+    end
+
+    it 'can be set' do
+      subject.statsd = statsd
+      expect(subject.statsd).to be(statsd)
+    end
+  end
 end