Example Cached Circuitbox Faraday Middleware

cached_circuit_middleware.rb

module MyClient
  module Middleware
    class CachedCircuit < Circuitbox::FaradayMiddleware

      attr_reader :cache

      def initialize(app, opts = {})
        @cache = circuit_breaker_options.fetch(:cache)
        exceptions = 
        super app, identifier: 'my_client',
                   circuit_breaker_options: circuit_breaker_options,
                   exceptions: [MyClient::Error] + 
                               Circuitbox::FaradayMiddleware::DEFAULT_EXCEPTIONS
      end

      def call(request_env)
        if circuit(request_env).open?
          response = cached_response(request_env)
          raise MyClient::Error::CachedCircuitEmptyError if response.body.empty?
          return response
        end
        super
      end

      private

      def open_circuit?(response)
        return true unless response
        super.tap do |open|
          cache_write(response.env.url, response.body) unless open
        end
      end

      def circuit_open_value(env, _service_response, exception)
        cache_value = cache_read env[:url]
        if open_circuit?(env.response) && (cache_value.nil? || cache_value.empty?)
          e = exception.respond_to?(:original) ? exception.original : exception
          raise MyClient::Error::CachedCircuitEmptyError.new(e, e.response)
        end
        cached_response(env, cache_value)
      end

      def cache_key(url)
        [url.to_s, "&my_client_version=#{MyClient.version}"].join
      end

      def cache_read(url)
        key = cache_key(url)
        cache[key]
      end

      def cache_write(url, value)
        key = cache_key(url)
        cache[key] = value
      end

      def cached_response(env, cache_value = nil)
        env.status = 200
        env.body = cache_value || cache_read(env[:url])
        env.response = Faraday::Response.new(env)
        env.response
      end

    end
  end
end