songkick-transport 0.2.2 → 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 363d11105aac72ce511d7f71cf94423173c34ef2
+  data.tar.gz: bb50281d1b1b9c7f621b6421e3683c61ab712fa9
+SHA512:
+  metadata.gz: edfc237f243425064e3658e536ebb24194067726d534ba92f79e2334ce61a44da898b68e054aca0c1f0f507786c4447fe7b0bdb1ae6d07be41ff977d74f6768e
+  data.tar.gz: 7861aa8565ba63612cf22ffdd744d5a4ab53bea29af78da05d610cad3d82fc412e58a51fb5c9f82857dab15c8b99afe8be94ee742df9d3ec2038538c0dd75a98

data/README.rdoc

@@ -2,8 +2,6 @@
 
 http://songkickontour.appspot.com/lego_tourbus.png
 
-(Image from {Songkick on Tour}[http://songkickontour.appspot.com])
-
 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,
@@ -131,6 +129,14 @@ If the request raises an exception, it will be of one of the following types:
 * <tt>Songkick::Transport::HttpError</tt> -- we received a response with a
   non-successful status code, e.g. 404 or 500
 
+It is possible to customise the status codes which are treated as UserError
+when initializing the client. Requests responding with any of the provided 
+status codes will then yield a response object with error details, rather than
+raising an exception;
+
+    client = Transport.new('http://localhost:4567',
+                           :user_error_codes => [409, 422])
+
 
 === Registering response parsers
 
@@ -308,6 +314,36 @@ following API:
 The +report+ object itself also responds to +total_duration+, which gives you
 the total time spent calling backend services during the block.
 
+== Writing Service classes
+
++Songkick::Transport::Service+ is a class to make writing service clients more convenient.
+
+Set up config globally (perhaps in a Rails initializer):
+
+    Songkick::Transport::Service.set_endpoints("blah-service" => "of1-dev-services:2347")
+    Songkick::Transport::Service.user_agent "myproject"
+    Songkick::Transport::Service.timeout 60 # optional, default is 10
+
+Subclass to create service clients:
+
+    class BlahService < Songkick::Transport::Service
+      endpoint "blah-service"
+
+      # these global configs can also be set at the class level, in which case they
+      # override the global config
+      user_agent "myproject mainservice class"
+      timeout 10
+
+      def get_data
+        http.get("/stuff", :search => "name")
+      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 
+with:
+
+    transport_layer Songkick::Transport::HttParty
 
 == License
 

data/lib/songkick/transport.rb

@@ -8,6 +8,7 @@ module Songkick
   module Transport
     DEFAULT_TIMEOUT = 5
     DEFAULT_FORMAT  = :json
+    DEFAULT_USER_ERROR_CODES = [409]
     
     HTTP_VERBS    = %w[options head get patch post put delete]
     USE_BODY      = %w[post put]
@@ -26,6 +27,7 @@ module Songkick
     autoload :Request,          ROOT + '/transport/request'
     autoload :Response,         ROOT + '/transport/response'
     autoload :TimeoutDecorator, ROOT + '/transport/timeout_decorator'
+    autoload :Service,          ROOT + '/transport/service'
 
     autoload :UpstreamError,        ROOT + '/transport/upstream_error'
     autoload :HostResolutionError,  ROOT + '/transport/upstream_error'

data/lib/songkick/transport/base.rb

@@ -1,55 +1,60 @@
 module Songkick
   module Transport
-    
+
     class Base
-      attr_accessor :user_agent
-      
+      attr_accessor :user_agent, :user_error_codes
+
       HTTP_VERBS.each do |verb|
         class_eval %{
           def #{verb}(path, params = {}, head = {}, timeout = nil)
-            req = Request.new(endpoint, '#{verb}', path, params, headers.merge(head), timeout)
-            Reporting.log_request(req)
-            
-            req.response = execute_request(req)
-            
-            Reporting.log_response(req)
-            Reporting.record(req)
-            req.response
-            
-          rescue => error
-            req.error = error
-            Reporting.record(req)
-            raise error
+            do_verb("#{verb}", path, params, head, timeout)
           end
         }
       end
-      
+
+      def do_verb(verb, path, params = {}, head = {}, timeout = nil)
+        req = Request.new(endpoint, verb, path, params, headers.merge(head), timeout)
+        Reporting.log_request(req)
+
+        begin
+          req.response = execute_request(req)
+        rescue => error
+          req.error = error
+          Reporting.record(req)
+          raise error
+        end
+
+        Reporting.log_response(req)
+        Reporting.record(req)
+        req.response
+      end
+
       def with_headers(headers = {})
         HeaderDecorator.new(self, headers)
       end
-      
+
       def with_timeout(timeout = DEFAULT_TIMEOUT)
         TimeoutDecorator.new(self, timeout)
       end
-      
-    private
-      
+
+      private
+
       def process(url, status, headers, body)
-        Response.process(url, status, headers, body)
+        Response.process(url, status, headers, body, @user_error_codes)
       end
-      
+
       def headers
         Headers.new(
           'Connection' => 'close',
           'User-Agent' => user_agent
         )
       end
-      
+
       def logger
         Transport.logger
       end
     end
-    
+
   end
 end
 

data/lib/songkick/transport/curb.rb

@@ -19,6 +19,7 @@ module Songkick
         @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
@@ -35,8 +36,9 @@ module Songkick
       def execute_request(req)
         connection.reset
         
-        connection.url = req.url
-        connection.timeout = req.timeout || @timeout
+        connection.url     = req.url
+        timeout            = req.timeout || @timeout
+        connection.timeout = timeout
         connection.headers.update(DEFAULT_HEADERS.merge(req.headers))
         
         response_headers = {}
@@ -67,7 +69,7 @@ module Songkick
         raise Transport::ConnectionFailedError, req
 
       rescue Curl::Err::TimeoutError => error
-        logger.warn "Request timed out after #{@timeout}s : #{req}"
+        logger.warn "Request timed out after #{timeout}s : #{req}"
         raise Transport::TimeoutError, req
 
       rescue Curl::Err::GotNothingError => error

data/lib/songkick/transport/html_report.html.erb

@@ -0,0 +1,140 @@
+<% # don't copy this style, this is just for development mode %>
+<% begin %>
+  <div id="transport-report">
+    <script>
+      function transportReportToggle() {
+        var element = document.getElementById("transport-report").getElementsByClassName("service-metrics")[0];
+        if(element.style.display == "none") {
+          element.style.display = "block";
+        } else {
+          element.style.display = "none";
+        }
+      }
+    </script>
+
+    <style>
+      #transport-report {
+        position: absolute;
+        top: 25px;
+        left: 3px;
+        z-index: 100000;
+        font-size: 11px;
+      }
+
+      #transport-report .switch {
+        color: #333;
+        border: 1px solid #555;
+        background-color: #999;
+        padding: 3px;
+      }
+
+      #transport-report .service-metrics {
+        color: #333;
+        margin-top: 2px;
+        border: 1px solid #aaa;
+        background-color: #eee;
+        padding: 4px;
+        padding-left: 7px;
+        padding-right: 7px;
+      }
+
+      #transport-report .total {
+        color: #333;
+        font-weight: bold;
+        font-size: 0.9em;
+      }
+
+      #transport-report table {
+        width: 100%;
+        font-size: 11px;
+      }
+
+      #transport-report td.data-header {
+        font-weight: bold;
+      }
+
+      #transport-report td.data-footer {
+        font-weight: bold;
+      }
+
+      #transport-report td.data-ms {
+        text-align: right;
+      }
+
+      #transport-report td.data-verb {
+        font-size: 0.8em;
+        width: 40px;
+        vertical-align: top;
+      }
+
+      #transport-report td.data-path {
+        width: 300px;
+      }
+
+      #transport-report .duplicate-request {
+        color: red;
+      }
+
+      #transport-report .params {
+        color: gray;
+      }
+
+      #transport-report div.params {
+        display: none;
+      }
+
+      #transport-report a.request-link:hover + div.params {
+        display: block;
+      }
+    </style>
+
+    <% if report = Songkick::Transport::Reporting.report %>
+      <% services = Hash.new { |hash, key| hash[key] = {:total_duration => 0, :requests => []} }%>
+      <% report.each do |request|
+           service_name = endpoints_to_names[request.endpoint]
+           services[service_name][:total_duration] += request.duration.to_i
+           services[service_name][:requests] << request
+         end %>
+
+      <a class="switch" onclick="transportReportToggle();">SERVICES (<span class="total"><%= services.values.inject(0) {|m,o| m + o[:total_duration]} %> ms</span>)</a>
+
+      <div id="transport-report-data" class="service-metrics" style="display:none;">
+        <% already = {} %>
+        <% services.to_a.sort_by {|_, h| h[:total_duration]}.reverse.each do |service_name, hash| %>
+
+        <table>
+          <tr><td class="data-header" colspan="3"><%= service_name %></td></tr>
+
+          <% hash[:requests].each do |request| %>
+            <tr>
+              <td class="data-verb"><%= request.verb.upcase %></td>
+              <td class="data-path">
+                <% if request.verb == "GET" %>
+                  <% nice_params = (request.params.any? ? "?#{request.params.to_a.sort_by {|x,_| x.to_s}.map {|k,v| "#{k}=#{v}"}.join("&") }": "no params") %>
+                  <% path = request.path + nice_params  %>
+                  <% uri = request.endpoint + path %>
+                  <a class="request-link <%= "duplicate-request" if already[uri] %>" href="http://<%= uri %>">
+                    <%= request.path.split("?").first[0..40] %>
+                  </a>
+                  <div class="params">
+                    <%= nice_params %>
+                  </div>
+                <% else %>
+                  <%= request.path.split("?").first %>
+                <% end %>
+              </td>
+              <td class="data-ms"><%= request.duration.to_i %> ms</td>
+            </tr>
+            <% already[uri] = true %>
+          <% end %>
+          <tr><td></td><td></td><td class="data-footer data-ms"><%= hash[:total_duration] %> ms</td></tr>
+        </table>
+
+        <% end %>
+      </div>
+    <% end %>
+  </div>
+
+<% rescue => e %>
+  <!-- Error generating transport report -->
+<% end %>

data/lib/songkick/transport/httparty.rb

@@ -12,6 +12,8 @@ module Songkick
         
         transport = klass.new
         transport.user_agent = options[:user_agent]
+        transport.user_error_codes =
+          options[:user_error_codes] || DEFAULT_USER_ERROR_CODES
         transport
       end
       

data/lib/songkick/transport/rack_test.rb

@@ -17,6 +17,7 @@ module Songkick
       def initialize(app, options = {})
         @app     = app
         @timeout = options[:timeout] || DEFAULT_TIMEOUT
+        @user_error_codes = options[:user_error_codes] || DEFAULT_USER_ERROR_CODES
       end
       
       HTTP_VERBS.each do |verb|

data/lib/songkick/transport/reporting.rb

@@ -1,21 +1,27 @@
+require 'erb'
+
 module Songkick
   module Transport
-    
+
     module Reporting
+      def self.start
+        Thread.current[:songkick_transport_report] = Report.new
+      end
+
       def self.report
-        Report.new
+        Thread.current[:songkick_transport_report]
       end
-      
+
       def self.record(request)
-        return unless report = Thread.current[:songkick_transport_report]
+        return unless report
         report << request
       end
-      
+
       def self.log_request(request)
         return unless Transport.verbose?
         logger.info(request.to_s)
       end
-      
+
       def self.log_response(request)
         return unless Transport.verbose?
         response = request.response
@@ -23,33 +29,42 @@ module Songkick
         logger.info "Response status: #{response.status}, duration: #{duration.ceil}ms"
         logger.debug "Response data: #{response.data.inspect}"
       end
-      
+
       def self.logger
         Transport.logger
       end
-      
+
       class Report
         include Enumerable
         extend Forwardable
         def_delegators :@requests, :each, :first, :last, :length, :size, :[], :<<
-        
+
         def initialize
           @requests = []
         end
-        
+
         def execute
           Thread.current[:songkick_transport_report] = self
           yield
         ensure
           Thread.current[:songkick_transport_report] = nil
         end
-        
+
         def total_duration
           inject(0) { |s,r| s + r.duration }
         end
+
+        # endpoints_to_names is a hash like:
+        #
+        #   {"dc1-live-service1:9324" => "media-service"}
+        def to_html(endpoints_to_names)
+          source = File.read(File.expand_path("../html_report.html.erb", __FILE__))
+          template = ERB.new(source)
+          template.result(binding)
+        end
       end
     end
-    
+
   end
 end
 

data/lib/songkick/transport/response.rb

@@ -2,14 +2,13 @@ module Songkick
   module Transport
     
     class Response
-      def self.process(request, status, headers, body)
+      def self.process(request, status, headers, body, user_error_codes=409)
         case status.to_i
         when 200 then OK.new(status, headers, body)
         when 201 then Created.new(status, headers, body)
         when 204 then NoContent.new(status, headers, body)
-        when 409 then UserError.new(status, headers, body)
+        when *user_error_codes then UserError.new(status, headers, body)
         else
-          Transport.logger.warn "Received error code: #{status} -- #{request}"
           raise HttpError.new(request, status, headers, body)
         end
       rescue Yajl::ParseError