restful_resource 2.0.2 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 82a879953f0ea77b78d0d10e389f71c52b871478
-  data.tar.gz: 58780ad094d558ac4fcc2a132c3df4405449b252
+  metadata.gz: 78cdc6fe007f825644ca02011bd4331d3d5f2087
+  data.tar.gz: dd4d619d9d2f4a0e020824de651f58a5f339cf84
 SHA512:
-  metadata.gz: 5a7514ee216cd7f0d65844ce0f2e40f545792b61c0272b5249a089b4cb2c8564a01b83fcedb0df47e197ecd7d228957d615477c482921e42c4936ca0c51bfac1
-  data.tar.gz: 2e71dc51a9751ae363e9aa840f513196d704fcda064133a5ba86eac3fc64fcd7b1ce9abe8c968d46fb0a73e5a53ae78e3f8f8ff15dbc5adec5203e25f1adf6ce
+  metadata.gz: 4876da8d8cd7a11501035d975e7511d1481d19c2f40a5423c9c10fbb5331ed963da3607461003677df03f8e138375584a8a9c86a0086a029f3365553f870befe
+  data.tar.gz: eb793fe38f0e1fdddf30f49d695b5bd9cf05e92cc74a7ed16a8651d624655137d75480650b5662cbc01a37d2561f789daebc997b92da8e0b6354afb6a426245e

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+v2.1.0
+---
+
+- Add `open_timeout` and `timeout` options to `Base.configure` and all request methods
+
 v1.6.0
 ---
 - group ServiceUnavailable, Timeout, and ClientError as subclasses of RetryableError

data/lib/restful_resource.rb

@@ -4,6 +4,7 @@ require 'link_header'
 require 'faraday'
 require 'faraday_middleware'
 require 'faraday-http-cache'
+require 'faraday_cdn_metrics'
 require 'faraday/encoding'
 require 'active_support'
 require 'active_support/all'

data/lib/restful_resource/base.rb

@@ -23,44 +23,50 @@ module RestfulResource
     end
 
     def self.find(id, params={})
-      params_without_headers, headers = extract_headers!(params)
+      params_without_options, options = format_params(params)
 
-      response = http.get(member_url(id, params_without_headers), headers: headers)
+      response = http.get(member_url(id, params_without_options), **options)
       self.new(parse_json(response.body))
     end
 
     def self.where(params={})
-      params_without_headers, headers = extract_headers!(params)
+      params_without_options, options = format_params(params)
 
-      url = collection_url(params_without_headers)
-      response = http.get(url, headers: headers)
+      url = collection_url(params_without_options)
+      response = http.get(url, **options)
       self.paginate_response(response)
     end
 
     def self.get(params = {})
-      params_without_headers, headers = extract_headers!(params)
+      params_without_options, options = format_params(params)
 
-      response = http.get(collection_url(params_without_headers), headers: headers)
+      response = http.get(collection_url(params_without_options), **options)
       self.new(parse_json(response.body))
     end
 
     def self.delete(id, **params)
-      headers = params.delete(:headers) || {}
-
-      response = http.delete(member_url(id, params), headers: headers)
+      params_without_options, options = format_params(params)
+      response = http.delete(member_url(id, params_without_options), **options)
       RestfulResource::OpenObject.new(parse_json(response.body))
     end
 
     def self.put(id, data: {}, headers: {}, **params)
-      url = member_url(id, params)
-      response = http.put(url, data: data, headers: headers)
+      params_without_options, options = format_params(params)
+      options.delete(:headers)
+
+      url = member_url(id, params_without_options)
+
+      response = http.put(url, data: data, headers: headers, **options)
       self.new(parse_json(response.body))
     end
 
     def self.post(data: {}, headers: {}, **params)
-      url = collection_url(params)
+      params_without_options, options = format_params(params)
+      options.delete(:headers)
+
+      url = collection_url(params_without_options)
 
-      response = http.post(url, data: data, headers: headers)
+      response = http.post(url, data: data, headers: headers, **options)
 
       self.new(parse_json(response.body))
     end
@@ -113,12 +119,14 @@ module RestfulResource
 
     private
 
-    def self.extract_headers!(params = {})
+    def self.format_params(params = {})
       headers = params.delete(:headers) || {}
 
       headers.merge!(cache_control: 'no-cache') if params.delete(:no_cache)
+      open_timeout = params.delete(:open_timeout)
+      timeout = params.delete(:timeout)
 
-      [params, headers]
+      [params, headers: headers, open_timeout: open_timeout, timeout: timeout]
     end
 
     def self.merge_url_paths(uri, *paths)

data/lib/restful_resource/http_client.rb

@@ -65,15 +65,21 @@ module RestfulResource
                    logger: nil,
                    cache_store: nil,
                    connection: nil,
-                   instrumentation: {})
-
-
-      api_name = instrumentation[:api_name]     ||= 'api'
-      instrumentation[:request_instrument_name] ||= "http.#{api_name}"
-      instrumentation[:cache_instrument_name]   ||= "http_cache.#{api_name}"
+                   instrumentation: {},
+                   open_timeout: 2,
+                   timeout: 10)
+      api_name = instrumentation[:api_name]            ||= 'api'
+      instrumentation[:request_instrument_name]        ||= "http.#{api_name}"
+      instrumentation[:cache_instrument_name]          ||= "http_cache.#{api_name}"
+      instrumentation[:server_cache_instrument_name]   ||= "cdn_metrics.#{api_name}"
 
       if instrumentation[:metric_class]
-        @metrics = Instrumentation.new(instrumentation.slice(:app_name, :api_name, :request_instrument_name, :cache_instrument_name, :metric_class))
+        @metrics = Instrumentation.new(instrumentation.slice(:app_name,
+                                                             :api_name,
+                                                             :request_instrument_name,
+                                                             :cache_instrument_name,
+                                                             :server_cache_instrument_name,
+                                                             :metric_class))
         @metrics.subscribe_to_notifications
       end
 
@@ -82,36 +88,74 @@ module RestfulResource
                                                         cache_store: cache_store,
                                                         instrumenter: ActiveSupport::Notifications,
                                                         request_instrument_name: instrumentation.fetch(:request_instrument_name, nil),
-                                                        cache_instrument_name: instrumentation.fetch(:cache_instrument_name, nil))
+                                                        cache_instrument_name: instrumentation.fetch(:cache_instrument_name, nil),
+                                                        server_cache_instrument_name: instrumentation.fetch(:server_cache_instrument_name, nil))
 
-      if username && password
-        @connection.basic_auth username, password
-      end
+      @connection.basic_auth(username, password) if username && password
+      @default_open_timeout = open_timeout
+      @default_timeout = timeout
     end
 
-    def get(url, headers: {})
-      http_request(Request.new(:get, url, headers: headers))
+    def get(url, headers: {}, open_timeout: nil, timeout: nil)
+      http_request(
+        Request.new(
+          :get,
+          url,
+          headers: headers,
+          open_timeout: open_timeout,
+          timeout: timeout
+        )
+      )
     end
 
-    def delete(url, headers: {})
-      http_request(Request.new(:delete, url, headers: headers))
+    def delete(url, headers: {}, open_timeout: nil, timeout: nil)
+      http_request(
+        Request.new(
+          :delete,
+          url,
+          headers: headers,
+          open_timeout: open_timeout,
+          timeout: timeout
+        )
+      )
     end
 
-    def put(url, data: {}, headers: {})
-      http_request(Request.new(:put, url, body: data, headers: headers))
+    def put(url, data: {}, headers: {}, open_timeout: nil, timeout: nil)
+      http_request(
+        Request.new(
+          :put,
+          url,
+          body: data,
+          headers: headers,
+          open_timeout: open_timeout,
+          timeout: timeout
+        )
+      )
     end
 
-    def post(url, data: {}, headers: {})
-      http_request(Request.new(:post, url, body: data, headers: headers))
+    def post(url, data: {}, headers: {}, open_timeout: nil, timeout: nil)
+      http_request(
+        Request.new(
+          :post,
+          url,
+          body: data,
+          headers: headers,
+          open_timeout: open_timeout,
+          timeout: timeout
+        )
+      )
     end
 
     private
 
+    attr_reader :default_open_timeout, :default_timeout
+
     def initialize_connection(logger: nil,
                               cache_store: nil,
                               instrumenter: nil,
                               request_instrument_name: nil,
-                              cache_instrument_name: nil)
+                              cache_instrument_name: nil,
+                              server_cache_instrument_name: nil)
 
       @connection = Faraday.new do |b|
         b.request :json
@@ -121,6 +165,11 @@ module RestfulResource
           b.response :logger, logger
         end
 
+        if server_cache_instrument_name
+          b.use :cdn_metrics, instrumenter: instrumenter,
+                              instrument_name: server_cache_instrument_name
+        end
+
         if cache_store
           b.use :http_cache, store: cache_store,
                              logger: logger,
@@ -141,8 +190,8 @@ module RestfulResource
 
     def http_request(request)
       response = @connection.send(request.method) do |req|
-        req.options.open_timeout = 2 # seconds
-        req.options.timeout = 10 # seconds
+        req.options.open_timeout = request.open_timeout || default_open_timeout # seconds
+        req.options.timeout = request.timeout || default_timeout # seconds
 
         req.body = request.body unless request.body.nil?
         req.url request.url

data/lib/restful_resource/instrumentation.rb

@@ -3,15 +3,17 @@ require 'active_support/notifications'
 module RestfulResource
   class Instrumentation
 
-    def initialize(app_name:, api_name:, request_instrument_name:, cache_instrument_name:, metric_class:)
+    def initialize(app_name:, api_name:, request_instrument_name:, cache_instrument_name:, server_cache_instrument_name:, metric_class:)
       @app_name = app_name
       @api_name = api_name
       @request_instrument_name = request_instrument_name
       @cache_instrument_name = cache_instrument_name
+      @server_cache_instrument_name = server_cache_instrument_name
       @metric_class = metric_class
     end
 
-    attr_reader :app_name, :api_name, :request_instrument_name, :cache_instrument_name, :metric_class
+    attr_reader :app_name, :api_name, :request_instrument_name, :cache_instrument_name,
+      :server_cache_instrument_name, :metric_class
 
     def subscribe_to_notifications
       validate_metric_class!
@@ -62,6 +64,39 @@ module RestfulResource
             metric_class.count cache_notifier_namespace(metric: 'cache_bypass', event: event), 1
         end
       end
+
+      # Subscribes to events from Faraday::Cdn::Metrics
+      ActiveSupport::Notifications.subscribe server_cache_instrument_name do |*args|
+        event = ActiveSupport::Notifications::Event.new(*args)
+        client_cache_status = event.payload.fetch(:client_cache_status, nil)
+        server_cache_status = event.payload.fetch(:server_cache_status, nil)
+
+        if client_cache_status.nil? || !client_cache_status.in?([:fresh, :valid])
+          # Outputs log lines like:
+          # count#quotes_site.research_site_api.server_cache_hit=1
+          # count#quotes_site.research_site_api.api_v2_cap_derivatives.server_cache_hit=1
+          case server_cache_status
+          when :fresh
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_hit'), 1
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_hit', event: event), 1
+          when :valid
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_hit_while_revalidate'), 1
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_hit_while_revalidate', event: event), 1
+          when :invalid, :miss
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_miss'), 1
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_miss', event: event), 1
+          when :unacceptable
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_not_cacheable'), 1
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_not_cacheable', event: event), 1
+          when :bypass
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_bypass'), 1
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_bypass', event: event), 1
+          when :unknown
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_unknown'), 1
+            metric_class.count cache_notifier_namespace(metric: 'server_cache_unknown', event: event), 1
+          end
+        end
+      end
     end
 
     def validate_metric_class!
@@ -75,9 +110,9 @@ module RestfulResource
       [app_name, api_name, base_request_path(event), metric].compact.join('.')
     end
 
-    # Converts a path like "/api/v2/cap_derivatives/75423" to "api_v2_cap_derivatives"
+    # Converts a path like "/api/v2/cap_derivatives/75423/with_colours" to "api_v2_cap_derivatives_with_colours"
     def base_request_path(event)
-      path_from_event(event).split('/').drop(1).take(3).join('_') if event
+      path_from_event(event).split('/').drop(1).select {|a| a.match(/\d+/).nil? }.join('_') if event
     end
 
     def path_from_event(event)
@@ -93,4 +128,3 @@ module RestfulResource
     end
   end
 end
-

data/lib/restful_resource/rails_validations.rb

@@ -1,48 +1,41 @@
 module RestfulResource
   module RailsValidations
     module ClassMethods
-      def put(id, data: {}, headers: {}, **params)
-        begin
-          super(id, data: data, headers: {}, **params)
-        rescue HttpClient::UnprocessableEntity => e
-          errors = parse_json(e.response.body)
-          result = nil
-          if errors.is_a?(Hash) && errors.has_key?('errors')
-            result = data.merge(errors)
-          else
-            result = data.merge(errors: errors)
-          end
-          result = result.merge(id: id)
-          self.new(result)
+      def put(id, data: {}, **)
+        super
+      rescue HttpClient::UnprocessableEntity => e
+        errors = parse_json(e.response.body)
+        result = nil
+        if errors.is_a?(Hash) && errors.has_key?('errors')
+          result = data.merge(errors)
+        else
+          result = data.merge(errors: errors)
         end
+        result = result.merge(id: id)
+        self.new(result)
       end
 
-      def post(data: {}, headers: {}, **params)
-        with_validations(data: data) do
-          super(data: data, headers: {}, **params)
-        end
+      def post(data: {}, **)
+        with_validations(data: data) { super }
       end
 
-      def get(params = {})
-        with_validations do
-          super(params)
-        end
+      def get(*)
+        with_validations { super }
       end
 
       private
-      def with_validations(data: {}, &block)
-        begin
-          block.call
-        rescue HttpClient::UnprocessableEntity => e
-          errors = parse_json(e.response.body)
-          result = nil
-          if errors.is_a?(Hash) && errors.has_key?('errors')
-            result = data.merge(errors)
-          else
-            result = data.merge(errors: errors)
-          end
-          self.new(result)
+
+      def with_validations(data: {})
+        yield
+      rescue HttpClient::UnprocessableEntity => e
+        errors = parse_json(e.response.body)
+        result = nil
+        if errors.is_a?(Hash) && errors.has_key?('errors')
+          result = data.merge(errors)
+        else
+          result = data.merge(errors: errors)
         end
+        self.new(result)
       end
     end
 

data/lib/restful_resource/redirections.rb

@@ -8,10 +8,10 @@ module RestfulResource
   module Redirections
     def self.included(base)
       base.instance_eval do
-        def post(data: {}, delay: 1.0, max_attempts: 10, headers: {}, **params)
+        def post(data: {}, delay: 1.0, max_attempts: 10, headers: {}, open_timeout: nil, timeout: nil, **params)
           url = collection_url(params)
 
-          response = self.accept_redirected_result(response: http.post(url, data: data, headers: headers), delay: delay, max_attempts: max_attempts)
+          response = self.accept_redirected_result(response: http.post(url, data: data, headers: headers, open_timeout: nil, timeout: nil), delay: delay, max_attempts: max_attempts)
 
           self.new(parse_json(response.body))
         end
@@ -24,12 +24,12 @@ module RestfulResource
             resource_location = response.headers[:location]
 
             RestfulResource::Redirections.wait(delay)
-            new_response = http.get(resource_location, headers: {})
+            new_response = http.get(resource_location, headers: {}, open_timeout: nil, timeout: nil)
 
             while (new_response.status == 202) && (attempts < max_attempts)
               attempts += 1
               RestfulResource::Redirections.wait(delay)
-              new_response = http.get(resource_location, headers: {})
+              new_response = http.get(resource_location, headers: {}, open_timeout: nil, timeout: nil)
             end
 
             if attempts == max_attempts

data/lib/restful_resource/request.rb

@@ -1,9 +1,14 @@
 module RestfulResource
   class Request
-    attr_reader :body, :method, :url
+    attr_reader :body, :method, :url, :open_timeout, :timeout
 
-    def initialize(method, url, headers: {}, body: nil)
-      @method, @url, @headers, @body = method, url, headers, body
+    def initialize(method, url, headers: {}, body: nil, open_timeout: nil, timeout: nil)
+      @method = method
+      @url = url
+      @headers = headers
+      @body = body
+      @open_timeout = open_timeout
+      @timeout = timeout
     end
 
     def headers
@@ -14,9 +19,8 @@ module RestfulResource
 
     # Formats all keys in Word-Word format
     def format_headers
-      @headers.stringify_keys.inject({}) do |h, key_with_value|
-        h[format_key key_with_value.first] = key_with_value.last
-        h
+      @headers.stringify_keys.each_with_object({}) do |key_with_value, headers|
+        headers[format_key(key_with_value.first)] = key_with_value.last
       end
     end
 

data/lib/restful_resource/version.rb

@@ -1,3 +1,3 @@
 module RestfulResource
-  VERSION = '2.0.2'
+  VERSION = '2.2.0'
 end

data/restful_resource.gemspec

@@ -32,4 +32,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "activesupport"
   spec.add_dependency "rack"
   spec.add_dependency "typhoeus"
+  spec.add_dependency "faraday-cdn-metrics"
 end

data/spec/restful_resource/http_client_configuration_spec.rb

@@ -85,6 +85,7 @@ describe RestfulResource::HttpClient do
                                                      api_name: 'api',
                                                      request_instrument_name: 'http.api',
                                                      cache_instrument_name: 'http_cache.api',
+                                                     server_cache_instrument_name: 'cdn_metrics.api',
                                                      metric_class: FakeMetrics)
           end
 

data/spec/spec_helper.rb

@@ -9,39 +9,47 @@ RSpec.configure do |config|
 end
 
 
-def expect_get(url, response, headers: {})
-  expect(@mock_http).to receive(:get).with(url, headers: headers).and_return(response)
+def expect_get(url, response, headers: {}, open_timeout: nil, timeout: nil)
+  expect(@mock_http).to receive(:get)
+    .with(url, headers: headers, open_timeout: open_timeout, timeout: timeout)
+    .and_return(response)
 end
 
-def expect_delete(url, response, headers: {})
-  expect(@mock_http).to receive(:delete).with(url, headers: headers).and_return(response)
+def expect_delete(url, response, headers: {}, open_timeout: nil, timeout: nil)
+  expect(@mock_http).to receive(:delete)
+    .with(url, headers: headers, open_timeout: open_timeout, timeout: timeout)
+    .and_return(response)
 end
 
-def expect_put(url, response, data: {}, headers: {})
-  expect(@mock_http).to receive(:put).with(url, data: data, headers: headers).and_return(response)
+def expect_put(url, response, data: {}, headers: {}, open_timeout: nil, timeout: nil)
+  expect(@mock_http).to receive(:put)
+    .with(url, data: data, headers: headers, open_timeout: open_timeout, timeout: timeout)
+    .and_return(response)
 end
 
-def expect_post(url, response, data: {}, headers: {})
-  expect(@mock_http).to receive(:post).with(url, data: data, headers: headers).and_return(response)
+def expect_post(url, response, data: {}, headers: {}, open_timeout: nil, timeout: nil)
+  expect(@mock_http).to receive(:post)
+    .with(url, data: data, headers: headers, open_timeout: open_timeout, timeout: timeout)
+    .and_return(response)
 end
 
 def expect_get_with_unprocessable_entity(url, response)
   request = RestfulResource::Request.new(:get, url)
   rest_client_response = OpenStruct.new({body: response.body, headers: response.headers, code: response.status})
   exception = RestfulResource::HttpClient::UnprocessableEntity.new(request, rest_client_response)
-  expect(@mock_http).to receive(:get).with(url, headers: {}).and_raise(exception)
+  expect(@mock_http).to receive(:get).with(url, headers: {}, open_timeout: nil, timeout: nil).and_raise(exception)
 end
 
 def expect_put_with_unprocessable_entity(url, response, data: {})
   request = RestfulResource::Request.new(:put, url, body: data)
   rest_client_response = OpenStruct.new({body: response.body, headers: response.headers, code: response.status})
   exception = RestfulResource::HttpClient::UnprocessableEntity.new(request, rest_client_response)
-  expect(@mock_http).to receive(:put).with(url, data: data, headers: {}).and_raise(exception)
+  expect(@mock_http).to receive(:put).with(url, data: data, headers: {}, open_timeout: nil, timeout: nil).and_raise(exception)
 end
 
 def expect_post_with_unprocessable_entity(url, response, data: {})
   request = RestfulResource::Request.new(:put, url, body: data)
   rest_client_response = OpenStruct.new({body: response.body, headers: response.headers, code: response.status})
   exception = RestfulResource::HttpClient::UnprocessableEntity.new(request, rest_client_response)
-  expect(@mock_http).to receive(:post).with(url, data: data, headers: {}).and_raise(exception)
+  expect(@mock_http).to receive(:post).with(url, data: data, headers: {}, open_timeout: nil, timeout: nil).and_raise(exception)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: restful_resource
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.2.0
 platform: ruby
 authors:
 - David Santoro
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-13 00:00:00.000000000 Z
+date: 2017-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -179,6 +179,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday-cdn-metrics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A simple activerecord inspired rest resource base class implemented using
   rest-client
 email: