flipper 0.16.0 → 1.4.0

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

@@ -0,0 +1,107 @@
+require 'flipper/cloud/telemetry/backoff_policy'
+
+RSpec.describe Flipper::Cloud::Telemetry::BackoffPolicy do
+  context "#initialize" do
+    it "with no options" do
+      policy = described_class.new
+      expect(policy.min_timeout_ms).to eq(30_000)
+      expect(policy.max_timeout_ms).to eq(120_000)
+      expect(policy.multiplier).to eq(1.5)
+      expect(policy.randomization_factor).to eq(0.5)
+    end
+
+    it "with options" do
+      policy = described_class.new({
+        min_timeout_ms: 1234,
+        max_timeout_ms: 5678,
+        multiplier: 24,
+        randomization_factor: 0.4,
+      })
+      expect(policy.min_timeout_ms).to eq(1234)
+      expect(policy.max_timeout_ms).to eq(5678)
+      expect(policy.multiplier).to eq(24)
+      expect(policy.randomization_factor).to eq(0.4)
+    end
+
+    it "with min higher than max" do
+      expect {
+        described_class.new({
+          min_timeout_ms: 2,
+          max_timeout_ms: 1,
+        })
+      }.to raise_error(ArgumentError, ":min_timeout_ms (2) must be <= :max_timeout_ms (1)")
+    end
+
+    it "with invalid min_timeout_ms" do
+      expect {
+        described_class.new({
+          min_timeout_ms: -1,
+        })
+      }.to raise_error(ArgumentError, ":min_timeout_ms must be >= 0 but was -1")
+    end
+
+    it "with invalid max_timeout_ms" do
+      expect {
+        described_class.new({
+          max_timeout_ms: -1,
+        })
+      }.to raise_error(ArgumentError, ":max_timeout_ms must be >= 0 but was -1")
+    end
+
+    it "from env" do
+      ENV.update(
+        "FLIPPER_BACKOFF_MIN_TIMEOUT_MS" => "1000",
+        "FLIPPER_BACKOFF_MAX_TIMEOUT_MS" => "2000",
+        "FLIPPER_BACKOFF_MULTIPLIER" => "1.9",
+        "FLIPPER_BACKOFF_RANDOMIZATION_FACTOR" => "0.1",
+      )
+
+      policy = described_class.new
+      expect(policy.min_timeout_ms).to eq(1000)
+      expect(policy.max_timeout_ms).to eq(2000)
+      expect(policy.multiplier).to eq(1.9)
+      expect(policy.randomization_factor).to eq(0.1)
+    end
+  end
+
+  context "#next_interval" do
+    it "works" do
+      policy = described_class.new({
+        min_timeout_ms: 1_000,
+        max_timeout_ms: 10_000,
+        multiplier: 2,
+        randomization_factor: 0.5,
+      })
+
+      expect(policy.next_interval).to be_within(500).of(1000)
+      expect(policy.next_interval).to be_within(1000).of(2000)
+      expect(policy.next_interval).to be_within(2000).of(4000)
+      expect(policy.next_interval).to be_within(4000).of(8000)
+    end
+
+    it "caps maximum duration at max_timeout_secs" do
+      policy = described_class.new({
+        min_timeout_ms: 1_000,
+        max_timeout_ms: 10_000,
+        multiplier: 2,
+        randomization_factor: 0.5,
+      })
+      10.times { policy.next_interval }
+      expect(policy.next_interval).to be_within(10_000*0.1).of(10_000)
+    end
+  end
+
+  it "can reset" do
+    policy = described_class.new({
+      min_timeout_ms: 1_000,
+      max_timeout_ms: 10_000,
+      multiplier: 2,
+      randomization_factor: 0.5,
+    })
+    10.times { policy.next_interval }
+
+    expect(policy.attempts).to eq(10)
+    policy.reset
+    expect(policy.attempts).to eq(0)
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'flipper/cloud/telemetry/metric'
+
+RSpec.describe Flipper::Cloud::Telemetry::Metric do
+  it 'has key, result and time' do
+    metric = described_class.new(:search, true, 1696793160)
+    expect(metric.key).to eq(:search)
+    expect(metric.result).to eq(true)
+    expect(metric.time).to eq(1696793160)
+  end
+
+  it "clamps time to minute" do
+    metric = described_class.new(:search, true, 1696793204)
+    expect(metric.time).to eq(1696793160)
+  end
+
+  describe "#eql?" do
+    it "returns true when key, time and result are the same" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = described_class.new(:search, true, 1696793204)
+      expect(metric.eql?(other)).to be(true)
+    end
+
+    it "returns false for other class" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = Object.new
+      expect(metric.eql?(other)).to be(false)
+    end
+
+    it "returns false for sub class" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = Class.new(described_class).new(:search, true, 1696793204)
+      expect(metric.eql?(other)).to be(false)
+    end
+
+    it "returns false if key is different" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = described_class.new(:other, true, 1696793204)
+      expect(metric.eql?(other)).to be(false)
+    end
+
+    it "returns false if time is different" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = described_class.new(:search, true, 1696793204 - 60 - 60)
+      expect(metric.eql?(other)).to be(false)
+    end
+
+    it "returns true with different times if times are in same minute" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = described_class.new(:search, true, 1696793206)
+      expect(metric.eql?(other)).to be(true)
+    end
+
+    it "returns false if result is different" do
+      metric = described_class.new(:search, true, 1696793204)
+      other = described_class.new(:search, false, 1696793204)
+      expect(metric.eql?(other)).to be(false)
+    end
+  end
+
+  describe "#hash" do
+    it "returns hash based on class, key, time and result" do
+      metric = described_class.new(:search, true, 1696793204)
+      expect(metric.hash).to eq([described_class, metric.key, metric.time, metric.result].hash)
+    end
+  end
+
+  describe "#as_json" do
+    it "returns key time and result" do
+      metric = described_class.new(:search, true, 1696793160)
+      expect(metric.as_json).to eq({
+        "key" => "search",
+        "result" => true,
+        "time" => 1696793160,
+      })
+    end
+
+    it "can include other hashes" do
+      metric = described_class.new(:search, true, 1696793160)
+      expect(metric.as_json(with: {"value" => 2})).to eq({
+        "key" => "search",
+        "result" => true,
+        "time" => 1696793160,
+        "value" => 2,
+      })
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require 'flipper/cloud/telemetry/metric_storage'
+require 'flipper/cloud/telemetry/metric'
+
+RSpec.describe Flipper::Cloud::Telemetry::MetricStorage do
+  describe "#increment" do
+    it "increments the counter for the metric" do
+      metric_storage = described_class.new
+      storage = metric_storage.instance_variable_get(:@storage)
+      metric = Flipper::Cloud::Telemetry::Metric.new(:search, true, 1696793160)
+      other = Flipper::Cloud::Telemetry::Metric.new(:search, false, 1696793160)
+
+      metric_storage.increment(metric)
+      expect(storage[metric].value).to be(1)
+
+      5.times { metric_storage.increment(metric) }
+      expect(storage[metric].value).to be(6)
+
+      metric_storage.increment(other)
+      expect(storage[other].value).to be(1)
+    end
+  end
+
+  describe "#drain" do
+    it "returns clears metrics and return hash" do
+      metric_storage = described_class.new
+      storage = metric_storage.instance_variable_get(:@storage)
+      storage[Flipper::Cloud::Telemetry::Metric.new(:search, true, 1696793160)] = Concurrent::AtomicFixnum.new(10)
+      storage[Flipper::Cloud::Telemetry::Metric.new(:search, false, 1696793161)] = Concurrent::AtomicFixnum.new(15)
+      storage[Flipper::Cloud::Telemetry::Metric.new(:plausible, true, 1696793162)] = Concurrent::AtomicFixnum.new(25)
+      storage[Flipper::Cloud::Telemetry::Metric.new(:administrator, true, 1696793164)] = Concurrent::AtomicFixnum.new(1)
+      storage[Flipper::Cloud::Telemetry::Metric.new(:administrator, false, 1696793164)] = Concurrent::AtomicFixnum.new(24)
+
+      drained = metric_storage.drain
+      expect(drained).to be_frozen
+      expect(drained).to eq({
+        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,
+      })
+      expect(storage.keys).to eq([])
+    end
+  end
+
+  describe "#empty?" do
+    it "returns true if empty" do
+      metric_storage = described_class.new
+      expect(metric_storage).to be_empty
+    end
+
+    it "returns false if not empty" do
+      metric_storage = described_class.new
+      metric_storage.increment Flipper::Cloud::Telemetry::Metric.new(:search, true, 1696793160)
+      expect(metric_storage).not_to be_empty
+    end
+  end
+end

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(30_000)
+      expect(instance.backoff_policy.max_timeout_ms).to eq(120_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(4) # 4 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(4)
+      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.at_least_once
+  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.at_least_once
+  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.at_least_once
+    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.at_least_once
+    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.at_least_times(5)
+  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(5)
+  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