songkick-transport 1.2.0 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 363d11105aac72ce511d7f71cf94423173c34ef2
-  data.tar.gz: bb50281d1b1b9c7f621b6421e3683c61ab712fa9
+  metadata.gz: 4b1535085159dedb0d551659b5fafcc840abd490
+  data.tar.gz: 3348c5d75c8a626302f4e1dae864d00edca3b593
 SHA512:
-  metadata.gz: edfc237f243425064e3658e536ebb24194067726d534ba92f79e2334ce61a44da898b68e054aca0c1f0f507786c4447fe7b0bdb1ae6d07be41ff977d74f6768e
-  data.tar.gz: 7861aa8565ba63612cf22ffdd744d5a4ab53bea29af78da05d610cad3d82fc412e58a51fb5c9f82857dab15c8b99afe8be94ee742df9d3ec2038538c0dd75a98
+  metadata.gz: 4134a141cb12aeab651d930938b2fa77361db813fc127c9344477619c748abc57b9ab84deacce2063eafd65cd1cf6e40728cf5af0a50cb0c3770630777fb37ac
+  data.tar.gz: b0f7e3b1acda2080a5bb44aab9890739290c191287480d79b8a3bd08ab54c3df81c2a931ec088bf363b8813d8f8f223a6bf5ac88a7f6db5d5e6f2f895a323e66

data/README.rdoc

@@ -1,7 +1,5 @@
 = Songkick::Transport {<img src="https://secure.travis-ci.org/songkick/transport.png?branch=master" />}[http://travis-ci.org/songkick/transport]
 
-http://songkickontour.appspot.com/lego_tourbus.png
-
 This is a transport layer abstraction for talking to our service APIs. It
 provides an abstract HTTP-like interface while hiding the underlying transport
 and serialization details. It transparently deals with parameter serialization,
@@ -61,7 +59,8 @@ takes a reference to a Rack application, for example:
     
     client = Transport.new(Sinatra::Application,
                            :user_agent => 'Test Agent',
-                           :timeout    => 5)
+                           :timeout    => 5,
+                           :basic_auth => {:username => "foo", :password => "bar"})
 
 All transports expose exactly the same instance methods.
 
@@ -148,6 +147,10 @@ parsers for other content-types like so:
 
 The parser object you register must respond to <tt>parse(string)</tt>.
 
+You can also register a default parser, to handle all content types that don't have a specified parser.
+
+    Songkick::Transport.register_default_parser(DefaultParser)
+
 
 === Nested parameters
 
@@ -173,7 +176,7 @@ Rails and Sinatra will parse this back into the original data structure for you
 on the server side.
 
 
-=== Request headers and timeouts
+=== Request headers, timeouts and basic auth
 
 You can make requests with custom headers using +with_headers+. The return value
 of +with_headers+ works just like a client object, so you can use it for
@@ -191,6 +194,10 @@ Similarly, the request timeout can be adjusted per-request:
 
     client.with_timeout(10).get('/slow_resource')
 
+Likewise basic auth credentials:
+
+    client.with_basic_auth({:username => "foo", :password => "bar"}).get('/')
+
 
 === File uploads
 
@@ -253,8 +260,7 @@ types into an <tt>IO</tt> for you:
 You can then use this to forward uploaded files to another service from your
 Rails or Sinatra application.
 
-
-=== Logging and reporting
+=== Logging, instrumentation and reporting
 
 You can enable basic logging by supplying a logger and switching logging on.
 
@@ -282,15 +288,15 @@ exclude headers used for authentication:
 
 There is also a more advanced reporting system that lets you aggregate request
 statistics. During a request to a web application, many requests to backend
-services may be involved. The repoting system lets you collect information about
-all the backend requests that happened while executing a block. For example you
-can use it to create a logging middleware:
+services may be involved. The reporting system lets you collect information
+about all the backend requests that happened while executing a block. For
+example you can use it to create a logging middleware:
 
     class Reporter
       def initialize(app)
         @app = app
       end
-      
+
       def call(env)
         report = Songkick::Transport.report
         response = report.execute { @app.call(env) }
@@ -314,9 +320,14 @@ following API:
 The +report+ object itself also responds to +total_duration+, which gives you
 the total time spent calling backend services during the block.
 
+To instrument transports using the `ActiveSupport::Notifications` API, pass
+`{:instrumenter => ActiveSupport::Notifications}` in the options. You can also
+override the default event label of `http.songkick_transport` by passing
+`:instrumentation_label`.
+
 == Writing Service classes
 
-+Songkick::Transport::Service+ is a class to make writing service clients more convenient.
+`Songkick::Transport::Service` is a class to make writing service clients more convenient.
 
 Set up config globally (perhaps in a Rails initializer):
 
@@ -339,17 +350,44 @@ Subclass to create service clients:
       end
     end
 
-The default transport layer for clients inheriting from +Songkick::Transport::Service+
-is Curb, if you want to use something else you can override it globally or in a class 
+The default transport layer for clients inheriting from `Songkick::Transport::Service`
+is Curb, if you want to use something else you can override it globally or in a class
 with:
 
     transport_layer Songkick::Transport::HttParty
 
+You can specify extra headers to be sent with every request from a service class and
+from the root class, and they are merged together:
+
+    Songkick::Transport::Service.with_headers "rlah" => "1"
+
+    class BlahService < Songkick::Transport::Service
+      with_headers "blah" => "1"
+    end
+
+    class FlahService < BlahService
+      with_headers "flah" => "1"
+
+      def get_data
+        http.get("/stuff") # will have headers "rlah", "blah" and "flah"
+      end
+    end
+
+To pass extra, perhaps transport-specific, options hashes to the transport
+layer on initialize, specify them with:
+
+    class FooService < Songkick::Transport::Service
+      transport_layer Songkick::Transport::Curb
+      transport_layer_options :no_signal => true
+    end
+
+These are also inheritable, and merge down like extra headers do.
+
 == License
 
 The MIT License
 
-Copyright (c) 2012-2013 Songkick
+Copyright (c) 2012-2015 Songkick
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
@@ -367,4 +405,3 @@ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-

data/lib/songkick/transport/authentication.rb

@@ -0,0 +1,27 @@
+require "base64"
+
+module Songkick
+  module Transport
+    module Authentication
+      
+      extend self
+      
+      def basic_auth_headers(credentials)
+        username = credentials.fetch(:username)
+        password = credentials.fetch(:password)
+        encoded_creds = strict_encode64("#{username}:#{password}")
+        Headers.new({"Authorization" => "Basic #{encoded_creds}"})
+      end
+
+      # Base64.strict_encode64 is not available on Ruby 1.8.7
+      def strict_encode64(str)
+        if Base64.respond_to?(:strict_encode64)
+          Base64.strict_encode64(str)
+        else
+          Base64.encode64(str).gsub("\n", '')
+        end
+      end
+    
+    end
+  end
+end

data/lib/songkick/transport/base.rb

@@ -2,39 +2,102 @@ module Songkick
   module Transport
 
     class Base
+      module API
+        def get(path, params = {}, head = {}, timeout = nil)
+          do_verb("get", path, params, head, timeout)
+        end
+
+        def post(path, params = {}, head = {}, timeout = nil)
+          do_verb("post", path, params, head, timeout)
+        end
+
+        def put(path, params = {}, head = {}, timeout = nil)
+          do_verb("put", path, params, head, timeout)
+        end
+
+        def patch(path, params = {}, head = {}, timeout = nil)
+          do_verb("patch", path, params, head, timeout)
+        end
+
+        def delete(path, params = {}, head = {}, timeout = nil)
+          do_verb("delete", path, params, head, timeout)
+        end
+
+        def options(path, params = {}, head = {}, timeout = nil)
+          do_verb("options", path, params, head, timeout)
+        end
+
+        def head(path, params = {}, head = {}, timeout = nil)
+          do_verb("head", path, params, head, timeout)
+        end
+
+        def with_headers(headers = {})
+          HeaderDecorator.new(self, headers)
+        end
+
+        def with_timeout(timeout)
+          TimeoutDecorator.new(self, timeout)
+        end
+
+        def with_params(params)
+          ParamsDecorator.new(self, params)
+        end
+
+        def with_basic_auth(credentials)
+          BasicAuthDecorator.new(self, credentials)
+        end
+      end
+
+      include API
+
       attr_accessor :user_agent, :user_error_codes
+      attr_reader :host, :timeout, :instrumenter, :basic_auth
+      alias_method :endpoint, :host
+      DEFAULT_INSTRUMENTATION_LABEL = 'http.songkick_transport'
 
-      HTTP_VERBS.each do |verb|
-        class_eval %{
-          def #{verb}(path, params = {}, head = {}, timeout = nil)
-            do_verb("#{verb}", path, params, head, timeout)
-          end
-        }
+      def initialize(host, options = {})
+        @host       = host
+        @timeout    = options[:timeout] || DEFAULT_TIMEOUT
+        @user_agent = options[:user_agent]
+        @user_error_codes = options[:user_error_codes] || DEFAULT_USER_ERROR_CODES
+        @instrumenter ||= options[:instrumenter]
+        @instrumentation_label = options[:instrumentation_label] || DEFAULT_INSTRUMENTATION_LABEL
+        @basic_auth = options[:basic_auth]
       end
 
       def do_verb(verb, path, params = {}, head = {}, timeout = nil)
-        req = Request.new(endpoint, verb, path, params, headers.merge(head), timeout)
+        auth_headers = basic_auth ? Authentication.basic_auth_headers(basic_auth) : {}
+        req = Request.new(endpoint, verb, path, params, headers.merge(auth_headers).merge(head), timeout)
         Reporting.log_request(req)
 
-        begin
-          req.response = execute_request(req)
-        rescue => error
-          req.error = error
-          Reporting.record(req)
-          raise error
+        instrument(req) do |payload|
+          begin
+            req.response = execute_request(req)
+            payload.merge!({ :status => req.response.status,
+                             :response_headers => req.response.headers.to_hash }) if req.response
+          rescue => error
+            req.error = error
+            payload.merge!({ :status => error.status,
+                             :response_headers => error.headers.to_hash }) if error.is_a?(HttpError)
+            Reporting.record(req)
+            raise error
+          ensure
+            payload.merge!(self.instrumentation_payload_extras)
+          end
         end
 
         Reporting.log_response(req)
         Reporting.record(req)
+
         req.response
       end
 
-      def with_headers(headers = {})
-        HeaderDecorator.new(self, headers)
+      def instrumentation_payload_extras
+        Thread.current[:transport_base_payload_extras] ||= {}
       end
 
-      def with_timeout(timeout = DEFAULT_TIMEOUT)
-        TimeoutDecorator.new(self, timeout)
+      def instrumentation_payload_extras=(extras)
+        Thread.current[:transport_base_payload_extras] = {}
       end
 
       private
@@ -43,6 +106,23 @@ module Songkick
         Response.process(url, status, headers, body, @user_error_codes)
       end
 
+      def instrument(request)
+        if self.instrumenter
+          payload = { :adapter => self.class.name,
+                      :endpoint => request.endpoint,
+                      :verb => request.verb,
+                      :path => request.path,
+                      :params => request.params,
+                      :request_headers => request.headers.to_hash }
+
+          self.instrumenter.instrument(@instrumentation_label, payload) do
+            yield(payload)
+          end
+        else
+          yield({})
+        end
+      end
+
       def headers
         Headers.new(
           'Connection' => 'close',
@@ -53,8 +133,55 @@ module Songkick
       def logger
         Transport.logger
       end
-    end
 
+      class HeaderDecorator < Struct.new(:client, :headers)
+        include API
+
+        def do_verb(verb, path, params = {}, new_headers = {}, timeout = nil)
+          client.do_verb(verb, path, params, Headers.new(headers).merge(new_headers), timeout)
+        end
+
+        def method_missing(*args, &block)
+          client.__send__(*args, &block)
+        end
+      end
+
+      class TimeoutDecorator < Struct.new(:client, :timeout)
+        include API
+
+        def do_verb(verb, path, params = {}, headers = {}, new_timeout = nil)
+          client.do_verb(verb, path, params, headers, new_timeout || timeout)
+        end
+
+        def method_missing(*args, &block)
+          client.__send__(*args, &block)
+        end
+      end
+
+      class ParamsDecorator < Struct.new(:client, :params)
+        include API
+
+        def do_verb(verb, path, new_params = {}, headers = {}, timeout = nil)
+          client.do_verb(verb, path, params.merge(new_params), headers, timeout)
+        end
+
+        def method_missing(*args, &block)
+          client.__send__(*args, &block)
+        end
+      end
+
+      class BasicAuthDecorator < Struct.new(:client, :credentials)
+        include API
+
+        def do_verb(verb, path, params = {}, headers = {}, timeout = nil)
+          auth_headers = Authentication.basic_auth_headers(credentials)
+          client.do_verb(verb, path, params, auth_headers.merge(headers), timeout)
+        end
+
+        def method_missing(*args, &block)
+          client.__send__(*args, &block)
+        end
+      end
+    end
   end
 end
-

data/lib/songkick/transport/curb.rb

@@ -12,37 +12,40 @@ module Songkick
       DEFAULT_HEADERS = {"Expect" => ""}
 
       def self.clear_thread_connection
-         Thread.current[:transport_curb_easy] = nil
+        Thread.current[:transport_curb_easy] = nil
       end
-      
+
       def initialize(host, options = {})
-        @host       = host
-        @timeout    = options[:timeout] || DEFAULT_TIMEOUT
-        @user_agent = options[:user_agent]
-        @user_error_codes = options[:user_error_codes] || DEFAULT_USER_ERROR_CODES
-        if c = options[:connection]
-          Thread.current[:transport_curb_easy] = c
-        end
+        super(host, options)
+        @no_signal  = !!options[:no_signal]
+        Thread.current[:transport_curb_easy] ||= options[:connection]
       end
-      
+
       def connection
         Thread.current[:transport_curb_easy] ||= Curl::Easy.new
       end
-      
-      def endpoint
-        @host
+
+      def instrumentation_payload_extras
+        Thread.current[:transport_curb_payload_extras] ||= {}
       end
-      
+
+      def instrumentation_payload_extras=(extras)
+        Thread.current[:transport_curb_payload_extras] = {}
+      end
+
       def execute_request(req)
+        self.instrumentation_payload_extras = {} if self.instrumenter
         connection.reset
-        
+
         connection.url     = req.url
         timeout            = req.timeout || @timeout
         connection.timeout = timeout
+        connection.encoding = ''
         connection.headers.update(DEFAULT_HEADERS.merge(req.headers))
-        
+        connection.nosignal = true if @no_signal
+
         response_headers = {}
-        
+
         connection.on_header do |header_line|
           line = header_line.sub(/\r\n$/, '')
           parts = line.split(/:\s*/)
@@ -51,13 +54,18 @@ module Songkick
           end
           header_line.bytesize
         end
-        
+
         if req.use_body?
           connection.__send__("http_#{req.verb}", req.body)
         else
           connection.http(req.verb.upcase)
         end
 
+        if self.instrumenter
+          self.instrumentation_payload_extras[:connect_time] = connection.connect_time
+          self.instrumentation_payload_extras[:name_lookup_time] = connection.name_lookup_time
+        end
+
         process(req, connection.response_code, response_headers, connection.body_str)
 
       rescue Curl::Err::HostResolutionError => error
@@ -75,9 +83,13 @@ module Songkick
       rescue Curl::Err::GotNothingError => error
         logger.warn "Got nothing: #{req}"
         raise Transport::UpstreamError, req
+
+      rescue Curl::Err::RecvError => error
+        logger.warn "Failure receiving network data: #{error.message} : #{req}"
+        raise Transport::UpstreamError, req
+
       end
     end
 
   end
 end
-