flipper 0.16.0 → 1.4.0

data/lib/flipper/adapters/http/client.rb

@@ -7,25 +7,57 @@ module Flipper
     class Http
       class Client
         DEFAULT_HEADERS = {
-          'Content-Type' => 'application/json',
-          'Accept' => 'application/json',
-          'User-Agent' => "Flipper HTTP Adapter v#{VERSION}",
+          'content-type' => 'application/json',
+          'accept' => 'application/json',
+          'user-agent' => "Flipper HTTP Adapter v#{VERSION}",
         }.freeze
 
         HTTPS_SCHEME = "https".freeze
 
+        CLIENT_FRAMEWORKS = {
+          rails:    -> { Rails.version if defined?(Rails) },
+          sinatra:  -> { Sinatra::VERSION if defined?(Sinatra) },
+          hanami:   -> { Hanami::VERSION if defined?(Hanami) },
+          sidekiq:  -> { Sidekiq::VERSION if defined?(Sidekiq) },
+          good_job: -> { GoodJob::VERSION if defined?(GoodJob) },
+        }
+
+        attr_reader :uri, :headers
+        attr_reader :basic_auth_username, :basic_auth_password
+        attr_reader :read_timeout, :open_timeout, :write_timeout
+        attr_reader :max_retries, :debug_output
+
         def initialize(options = {})
           @uri = URI(options.fetch(:url))
-          @headers = DEFAULT_HEADERS.merge(options[:headers] || {})
           @basic_auth_username = options[:basic_auth_username]
           @basic_auth_password = options[:basic_auth_password]
           @read_timeout = options[:read_timeout]
           @open_timeout = options[:open_timeout]
+          @write_timeout = options[:write_timeout]
+          @max_retries = options.key?(:max_retries) ? options[:max_retries] : 0
           @debug_output = options[:debug_output]
+
+          @headers = {}
+          DEFAULT_HEADERS.each { |key, value| add_header key, value }
+          if options[:headers]
+            options[:headers].each { |key, value| add_header key, value }
+          end
         end
 
-        def get(path)
-          perform Net::HTTP::Get, path, @headers
+        def add_header(key, value)
+          @headers[normalize_header_key(key)] = value
+        end
+
+        def get(path, options = {})
+          headers = @headers.dup
+
+          if options[:headers]
+            options[:headers].each do |key, value|
+              headers[normalize_header_key(key)] = value
+            end
+          end
+
+          perform Net::HTTP::Get, path, headers
         end
 
         def post(path, body = nil)
@@ -57,6 +89,8 @@ module Flipper
           http = Net::HTTP.new(uri.host, uri.port)
           http.read_timeout = @read_timeout if @read_timeout
           http.open_timeout = @open_timeout if @open_timeout
+          http.max_retries = @max_retries if @max_retries
+          http.write_timeout = @write_timeout if @write_timeout
           http.set_debug_output(@debug_output) if @debug_output
 
           if uri.scheme == HTTPS_SCHEME
@@ -68,9 +102,24 @@ module Flipper
         end
 
         def build_request(http_method, uri, headers, options)
+          request_headers = {
+            'client-language' => "ruby",
+            'client-language-version' => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+            'client-platform' => RUBY_PLATFORM,
+            'client-engine' => defined?(RUBY_ENGINE) ? RUBY_ENGINE : "",
+            'client-pid' => Process.pid.to_s,
+            'client-thread' => Thread.current.object_id.to_s,
+            'client-hostname' => Socket.gethostname,
+          }.merge(headers)
+
           body = options[:body]
           request = http_method.new(uri.request_uri)
-          request.initialize_http_header(headers) if headers
+          request.initialize_http_header(request_headers)
+
+          client_frameworks.each do |framework, version|
+            request.add_field("client-framework", [framework, version].join("="))
+          end
+
           request.body = body if body
 
           if @basic_auth_username && @basic_auth_password
@@ -79,6 +128,14 @@ module Flipper
 
           request
         end
+
+        def client_frameworks
+          CLIENT_FRAMEWORKS.transform_values { |detect| detect.call rescue nil }.compact
+        end
+
+        def normalize_header_key(key)
+          key.to_s.downcase.gsub('_'.freeze, '-'.freeze)
+        end
       end
     end
   end

data/lib/flipper/adapters/http/error.rb

@@ -1,3 +1,5 @@
+require "json"
+
 module Flipper
   module Adapters
     class Http
@@ -6,7 +8,23 @@ module Flipper
 
         def initialize(response)
           @response = response
-          super("Failed with status: #{response.code}")
+          message = "Failed with status: #{response.code}"
+
+          begin
+            data = Typecast.from_json(response.body)
+
+            if error_message = data["message"]
+              message << "\n\n#{data["message"]}"
+            end
+
+            if more_info = data["more_info"]
+              message << "\n#{data["more_info"]}"
+            end
+          rescue
+            # welp we tried
+          end
+
+          super(message)
         end
       end
     end

data/lib/flipper/adapters/http.rb

@@ -10,7 +10,7 @@ module Flipper
     class Http
       include Flipper::Adapter
 
-      attr_reader :name
+      attr_reader :client
 
       def initialize(options = {})
         @client = Client.new(url: options.fetch(:url),
@@ -19,14 +19,19 @@ module Flipper
                              basic_auth_password: options[:basic_auth_password],
                              read_timeout: options[:read_timeout],
                              open_timeout: options[:open_timeout],
+                             write_timeout: options[:write_timeout],
+                             max_retries: options[:max_retries],
                              debug_output: options[:debug_output])
-        @name = :http
+        @last_get_all_etag = nil
+        @last_get_all_result = nil
+        @last_get_all_response = nil
+        @get_all_mutex = Mutex.new
       end
 
       def get(feature)
         response = @client.get("/features/#{feature.key}")
         if response.is_a?(Net::HTTPOK)
-          parsed_response = JSON.parse(response.body)
+          parsed_response = Typecast.from_json(response.body)
           result_for_feature(feature, parsed_response.fetch('gates'))
         elsif response.is_a?(Net::HTTPNotFound)
           default_config
@@ -35,18 +40,12 @@ module Flipper
         end
       end
 
-      def add(feature)
-        body = JSON.generate(name: feature.key)
-        response = @client.post('/features', body)
-        response.is_a?(Net::HTTPOK)
-      end
-
       def get_multi(features)
         csv_keys = features.map(&:key).join(',')
-        response = @client.get("/features?keys=#{csv_keys}")
+        response = @client.get("/features?keys=#{csv_keys}&exclude_gate_names=true")
         raise Error, response unless response.is_a?(Net::HTTPOK)
 
-        parsed_response = JSON.parse(response.body)
+        parsed_response = Typecast.from_json(response.body)
         parsed_features = parsed_response.fetch('features')
         gates_by_key = parsed_features.each_with_object({}) do |parsed_feature, hash|
           hash[parsed_feature['key']] = parsed_feature['gates']
@@ -60,78 +59,129 @@ module Flipper
         result
       end
 
-      def get_all
-        response = @client.get("/features")
+      def get_all(cache_bust: false)
+        options = {}
+        path = "/features?exclude_gate_names=true"
+        path += "&_cb=#{Time.now.to_i}" if cache_bust
+        etag = @get_all_mutex.synchronize { @last_get_all_etag }
+
+        if etag
+          options[:headers] = { if_none_match: etag }
+        end
+
+        response = @client.get(path, options)
+        @get_all_mutex.synchronize { @last_get_all_response = response }
+
+        if response.is_a?(Net::HTTPNotModified)
+          cached_result = @get_all_mutex.synchronize { @last_get_all_result }
+
+          if cached_result
+            return cached_result
+          else
+            raise Error, response
+          end
+        end
+
         raise Error, response unless response.is_a?(Net::HTTPOK)
 
-        parsed_response = JSON.parse(response.body)
-        parsed_features = parsed_response.fetch('features')
+        parsed_response = response.body.empty? ? {} : Typecast.from_json(response.body)
+        parsed_features = parsed_response['features'] || []
         gates_by_key = parsed_features.each_with_object({}) do |parsed_feature, hash|
           hash[parsed_feature['key']] = parsed_feature['gates']
           hash
         end
 
         result = {}
-        gates_by_key.keys.each do |key|
+        gates_by_key.each_key do |key|
           feature = Feature.new(key, self)
           result[feature.key] = result_for_feature(feature, gates_by_key[feature.key])
         end
+
+        @get_all_mutex.synchronize do
+          @last_get_all_etag = response['etag'] if response['etag']
+          @last_get_all_result = result
+        end
+
         result
       end
 
+      def last_get_all_response
+        @get_all_mutex.synchronize { @last_get_all_response }
+      end
+
       def features
-        response = @client.get('/features')
+        response = @client.get('/features?exclude_gate_names=true')
         raise Error, response unless response.is_a?(Net::HTTPOK)
 
-        parsed_response = JSON.parse(response.body)
+        parsed_response = Typecast.from_json(response.body)
         parsed_response['features'].map { |feature| feature['key'] }.to_set
       end
 
+      def add(feature)
+        body = JSON.generate(name: feature.key)
+        response = @client.post('/features', body)
+        raise Error, response unless response.is_a?(Net::HTTPOK)
+        true
+      end
+
       def remove(feature)
         response = @client.delete("/features/#{feature.key}")
-        response.is_a?(Net::HTTPNoContent)
+        raise Error, response unless response.is_a?(Net::HTTPNoContent)
+        true
       end
 
       def enable(feature, gate, thing)
-        body = request_body_for_gate(gate, thing.value.to_s)
+        body = request_body_for_gate(gate, thing.value)
         query_string = gate.key == :groups ? "?allow_unregistered_groups=true" : ""
         response = @client.post("/features/#{feature.key}/#{gate.key}#{query_string}", body)
-        response.is_a?(Net::HTTPOK)
+        raise Error, response unless response.is_a?(Net::HTTPOK)
+        true
       end
 
       def disable(feature, gate, thing)
-        body = request_body_for_gate(gate, thing.value.to_s)
+        body = request_body_for_gate(gate, thing.value)
         query_string = gate.key == :groups ? "?allow_unregistered_groups=true" : ""
-        response =
-          case gate.key
-          when :percentage_of_actors, :percentage_of_time
-            @client.post("/features/#{feature.key}/#{gate.key}#{query_string}", body)
-          else
-            @client.delete("/features/#{feature.key}/#{gate.key}#{query_string}", body)
-          end
-        response.is_a?(Net::HTTPOK)
+        response = case gate.key
+        when :percentage_of_actors, :percentage_of_time
+          @client.post("/features/#{feature.key}/#{gate.key}#{query_string}", body)
+        else
+          @client.delete("/features/#{feature.key}/#{gate.key}#{query_string}", body)
+        end
+        raise Error, response unless response.is_a?(Net::HTTPOK)
+        true
       end
 
       def clear(feature)
         response = @client.delete("/features/#{feature.key}/clear")
-        response.is_a?(Net::HTTPNoContent)
+        raise Error, response unless response.is_a?(Net::HTTPNoContent)
+        true
+      end
+
+      def import(source)
+        adapter = self.class.from(source)
+        export = adapter.export(format: :json, version: 1)
+        response = @client.post("/import", export.contents)
+        raise Error, response unless response.is_a?(Net::HTTPNoContent)
+        true
       end
 
       private
 
       def request_body_for_gate(gate, value)
         data = case gate.key
-               when :boolean
-                 {}
-               when :groups
-                 { name: value }
-               when :actors
-                 { flipper_id: value }
-               when :percentage_of_actors, :percentage_of_time
-                 { percentage: value }
-               else
-                 raise "#{gate.key} is not a valid flipper gate key"
-               end
+        when :boolean
+          {}
+        when :groups
+          { name: value.to_s }
+        when :actors
+          { flipper_id: value.to_s }
+        when :percentage_of_actors, :percentage_of_time
+          { percentage: value.to_s }
+        when :expression
+          value
+        else
+          raise "#{gate.key} is not a valid flipper gate key"
+        end
         JSON.generate(data)
       end
 
@@ -152,13 +202,17 @@ module Flipper
         case gate.data_type
         when :boolean, :integer
           value ? value.to_s : value
+        when :json
+          value
         when :set
           value ? value.to_set : Set.new
         else
-          unsupported_data_type(gate.data_type)
+          unsupported_data_type gate.data_type
         end
       end
 
+      private
+
       def unsupported_data_type(data_type)
         raise "#{data_type} is not supported by this adapter"
       end

data/lib/flipper/adapters/instrumented.rb

@@ -4,7 +4,7 @@ module Flipper
   module Adapters
     # Internal: Adapter that wraps another adapter and instruments all adapter
     # operations.
-    class Instrumented < SimpleDelegator
+    class Instrumented
       include ::Flipper::Adapter
 
       # Private: The name of instrumentation events.
@@ -13,9 +13,6 @@ module Flipper
       # Private: What is used to instrument all the things.
       attr_reader :instrumenter
 
-      # Public: The name of the adapter.
-      attr_reader :name
-
       # Internal: Initializes a new adapter instance.
       #
       # adapter - Vanilla adapter instance to wrap.
@@ -24,126 +21,150 @@ module Flipper
       #           :instrumenter - What to use to instrument all the things.
       #
       def initialize(adapter, options = {})
-        super(adapter)
         @adapter = adapter
-        @name = :instrumented
         @instrumenter = options.fetch(:instrumenter, Instrumenters::Noop)
       end
 
       # Public
       def features
-        payload = {
+        default_payload = {
           operation: :features,
           adapter_name: @adapter.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) do |payload|
+        @instrumenter.instrument(InstrumentationName, default_payload) do |payload|
           payload[:result] = @adapter.features
         end
       end
 
       # Public
       def add(feature)
-        payload = {
+        default_payload = {
           operation: :add,
           adapter_name: @adapter.name,
           feature_name: feature.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) do |payload|
+        @instrumenter.instrument(InstrumentationName, default_payload) do |payload|
           payload[:result] = @adapter.add(feature)
         end
       end
 
       # Public
       def remove(feature)
-        payload = {
+        default_payload = {
           operation: :remove,
           adapter_name: @adapter.name,
           feature_name: feature.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) do |payload|
+        @instrumenter.instrument(InstrumentationName, default_payload) do |payload|
           payload[:result] = @adapter.remove(feature)
         end
       end
 
       # Public
       def clear(feature)
-        payload = {
+        default_payload = {
           operation: :clear,
           adapter_name: @adapter.name,
           feature_name: feature.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) do |payload|
+        @instrumenter.instrument(InstrumentationName, default_payload) do |payload|
           payload[:result] = @adapter.clear(feature)
         end
       end
 
       # Public
       def get(feature)
-        payload = {
+        default_payload = {
           operation: :get,
           adapter_name: @adapter.name,
           feature_name: feature.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) do |payload|
+        @instrumenter.instrument(InstrumentationName, default_payload) do |payload|
           payload[:result] = @adapter.get(feature)
         end
       end
 
       def get_multi(features)
-        payload = {
+        default_payload = {
           operation: :get_multi,
           adapter_name: @adapter.name,
           feature_names: features.map(&:name),
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) do |payload|
+        @instrumenter.instrument(InstrumentationName, default_payload) do |payload|
           payload[:result] = @adapter.get_multi(features)
         end
       end
 
-      def get_all
-        payload = {
+      def get_all(**kwargs)
+        default_payload = {
           operation: :get_all,
           adapter_name: @adapter.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) do |payload|
-          payload[:result] = @adapter.get_all
+        @instrumenter.instrument(InstrumentationName, default_payload) do |payload|
+          payload[:result] = @adapter.get_all(**kwargs)
         end
       end
 
       # Public
       def enable(feature, gate, thing)
-        payload = {
+        default_payload = {
           operation: :enable,
           adapter_name: @adapter.name,
           feature_name: feature.name,
           gate_name: gate.name,
+          thing_value: thing.value,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) do |payload|
+        @instrumenter.instrument(InstrumentationName, default_payload) do |payload|
           payload[:result] = @adapter.enable(feature, gate, thing)
         end
       end
 
       # Public
       def disable(feature, gate, thing)
-        payload = {
+        default_payload = {
           operation: :disable,
           adapter_name: @adapter.name,
           feature_name: feature.name,
           gate_name: gate.name,
+          thing_value: thing.value,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) do |payload|
+        @instrumenter.instrument(InstrumentationName, default_payload) do |payload|
           payload[:result] = @adapter.disable(feature, gate, thing)
         end
       end
+
+      def import(source)
+        default_payload = {
+          operation: :import,
+          adapter_name: @adapter.name,
+        }
+
+        @instrumenter.instrument(InstrumentationName, default_payload) do |payload|
+          payload[:result] = @adapter.import(source)
+        end
+      end
+
+      def export(format: :json, version: 1)
+        default_payload = {
+          operation: :export,
+          adapter_name: @adapter.name,
+          format: format,
+          version: version,
+        }
+
+        @instrumenter.instrument(InstrumentationName, default_payload) do |payload|
+          payload[:result] = @adapter.export(format: format, version: version)
+        end
+      end
     end
   end
 end