http_event_logger 0.1.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d1c6e13a02bf58df078b6db91d89d34e04a3ab46
+  data.tar.gz: 8743f10e8bc7672991d0447cf8dad126d84d7e7f
+SHA512:
+  metadata.gz: 5827ef887a7b2a13a9d9d29a684eb1b75963047ed30c7a4c9717c5346a2268ad94521dd363f8c57b84311306242e52d4e732f091f0aa9882ea0fccfeea9f169c
+  data.tar.gz: 27e747db5d476fbc7fc9db0adf5a759ca1ea5d750c4b70ddf8219a60956b7bf8bea9cdda18aeabbd0c0cc3bc9f1f95f3d0fd8ebc56021954dfcf966512809079

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 Thilo Rusche
+
+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 the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS 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/http_event_logger/adapter/ethon.rb

@@ -0,0 +1,56 @@
+module Ethon
+
+  class Easy
+
+    module Http
+
+      def http_request_with_logging(url, action_name, options={})
+        create_request_event(url, action_name, options)
+        http_request_without_logging(url, action_name, options)
+      end
+
+      alias_method_chain :http_request, :logging
+
+      private
+
+      def create_request_event(url, action_name, options)
+        @request_event = HttpEventLogger::Event::Request.new(
+          method:  action_name,
+          uri:     url,
+          headers: options[:headers],
+          body:    options[:body]
+        )
+      end
+
+    end
+
+    module Operations
+
+      def perform_with_logging
+        result = nil
+        time_taken_in_seconds = ::Benchmark.realtime do
+          result = perform_without_logging
+        end
+        create_response_event(time_taken_in_seconds)
+        result
+      end
+
+      alias_method_chain :perform, :logging
+
+      private
+
+      def create_response_event(time_taken_in_seconds)
+        HttpEventLogger::Event::Response.new(
+          request:               @request_event,
+          time_taken_in_seconds: time_taken_in_seconds,
+          status:                response_code,
+          headers:               response_headers,
+          body:                  response_body
+        )
+      end
+
+    end
+
+  end
+
+end if defined?(Ethon)

data/lib/http_event_logger/adapter/excon.rb

@@ -0,0 +1,64 @@
+module Excon
+
+  class Socket
+
+    def connect_with_logging
+      host = @data[:proxy] ? @data[:proxy][:host] : @data[:host]
+      port = @data[:proxy] ? @data[:proxy][:port] : @data[:port]
+      HttpEventLogger::Event::Connection.new(host, port)
+      connect_without_logging
+    end
+
+    alias_method_chain :connect, :logging
+
+  end
+
+  class Connection
+
+    def request_with_logging(params, &block)
+      request_datum = @data.merge(params)
+      request_datum[:headers] = @data[:headers].merge(request_datum[:headers] || {})
+      request_event = create_request_event(request_datum)
+      result = nil
+      time_taken_in_seconds = ::Benchmark.realtime do
+        result = request_without_logging(params, &block)
+      end
+      response = result.is_a?(Excon::Response) ? result : Excon::Response.new(response(result)[:response])
+      create_response_event(request_event, time_taken_in_seconds, response)
+      result
+    end
+
+    alias_method_chain :request, :logging
+
+    private
+
+    def create_request_event(datum)
+      HttpEventLogger::Event::Request.new(
+        method:  method_from(datum),
+        uri:     absolute_url_from(datum),
+        headers: datum[:headers],
+        body:    datum[:body]
+      )
+    end
+
+    def method_from(datum)
+      datum[:method] ? datum[:method].to_s.upcase : "UNKNOWN"
+    end
+
+    def absolute_url_from(datum)
+      "#{datum[:scheme]}://#{datum[:host]}:#{datum[:port]}#{datum[:path]}#{datum[:query]}"
+    end
+
+    def create_response_event(request_event, time_taken_in_seconds, response)
+      HttpEventLogger::Event::Response.new(
+        request:               request_event,
+        time_taken_in_seconds: time_taken_in_seconds,
+        status:                response.status,
+        headers:               response.headers,
+        body:                  response.body
+      )
+    end
+
+  end
+
+end if defined?(Excon)

data/lib/http_event_logger/adapter/httpclient.rb

@@ -0,0 +1,60 @@
+class HTTPClient
+
+  private
+
+  class Session
+
+    def create_socket_with_logging(site)
+      HttpEventLogger::Event::Connection.new(site.host, site.port)
+      create_socket_without_logging(site)
+    end
+
+    alias_method_chain :create_socket, :logging
+
+  end
+
+  def do_get_block_with_logging(req, proxy, conn, &block)
+    request_event = create_request_event(req)
+    retryable_response_error = nil
+    time_taken_in_seconds = ::Benchmark.realtime do
+      begin
+        do_get_block_without_logging(req, proxy, conn, &block)
+      rescue RetryableResponse => exc
+        retryable_response_error = exc
+      end
+    end
+    res = conn.pop
+    create_response_event(request_event, res, time_taken_in_seconds)
+    conn.push(res)
+    raise retryable_response_error unless retryable_response_error.nil?
+  end
+
+  alias_method_chain :do_get_block, :logging
+
+  def create_request_event(req)
+    HttpEventLogger::Event::Request.new(
+      method:  req.header.request_method,
+      uri:     req.header.request_uri,
+      headers: req.headers,
+      body:    req.body
+    )
+  end
+
+  def create_response_event(request_event, res, time_taken_in_seconds)
+    HttpEventLogger::Event::Response.new(
+      request:               request_event,
+      time_taken_in_seconds: time_taken_in_seconds,
+      status:                res.status_code,
+      headers:               response_headers_from(res),
+      body:                  res.body
+    )
+  end
+
+  def response_headers_from(res)
+    res.header.all.reduce({}) do |result, header|
+      result[header[0]] = header[1]
+      result
+    end
+  end
+
+end if defined?(::HTTPClient)

data/lib/http_event_logger/adapter/net_http.rb

@@ -0,0 +1,65 @@
+module Net
+
+  class HTTP
+
+    private
+
+    HIDDEN_PORTS = [ 80, 443 ].freeze
+
+    public
+
+    def connect_with_logging
+      HttpEventLogger::Event::Connection.new(@address, @port) unless started?
+      connect_without_logging
+    end
+
+    alias_method_chain :connect, :logging
+
+    def request_with_logging(req, body = nil, &block)
+      create_request_event(req, body) if started?
+      response = nil
+      time_taken_in_seconds = ::Benchmark.realtime do
+        response = request_without_logging(req, body, &block)
+      end
+      create_response_event(time_taken_in_seconds, response) if started?
+      response
+    end
+
+    alias_method_chain :request, :logging
+
+    private
+
+    def create_request_event(req, body)
+      @request_event = HttpEventLogger::Event::Request.new(
+        method:  req.method,
+        uri:     absolute_url_from(req),
+        headers: req.each_header.collect,
+        body:    request_body_from(req, body)
+      )
+    end
+
+    def absolute_url_from(req)
+      protocol       = @use_ssl ? "https" : "http"
+      port_indicator = HIDDEN_PORTS.include?(@port) ? "" : ":#{@port}"
+      hostname       = "#{@address}#{port_indicator}"
+      "#{protocol}://#{hostname}#{req.path}"
+    end
+
+    # A bit convoluted because post_form uses form_data= to assign the data, so in that case req.body will be empty
+    def request_body_from(req, body)
+      req.body.nil? || req.body.size == 0 ? body : req.body
+    end
+
+    def create_response_event(time_taken_in_seconds, response)
+      HttpEventLogger::Event::Response.new(
+        request:               @request_event,
+        time_taken_in_seconds: time_taken_in_seconds,
+        status:                response.code,
+        headers:               response.each_header.collect,
+        body:                  response.body
+      )
+    end
+
+  end
+
+end

data/lib/http_event_logger/adapter/patron.rb

@@ -0,0 +1,40 @@
+module Patron
+
+  class Session
+
+    def request_with_logging(action_name, url, headers, options={})
+      create_request_event(action_name, headers, options, url)
+      response = nil
+      time_taken_in_seconds = ::Benchmark.realtime do
+        response = request_without_logging(action_name, url, headers, options)
+      end
+      create_response_event(response, time_taken_in_seconds)
+      response
+    end
+
+    alias_method_chain :request, :logging
+
+    private
+
+    def create_response_event(response, time_taken_in_seconds)
+      HttpEventLogger::Event::Response.new(
+        request:               @request_event,
+        time_taken_in_seconds: time_taken_in_seconds,
+        status:                response.status,
+        headers:               response.headers,
+        body:                  response.body
+      )
+    end
+
+    def create_request_event(action_name, headers, options, url)
+      @request_event = HttpEventLogger::Event::Request.new(
+        method:  action_name,
+        uri:     url,
+        headers: headers,
+        body:    options[:data]
+      )
+    end
+
+  end
+
+end if defined?(Patron)

data/lib/http_event_logger/configuration.rb

@@ -0,0 +1,9 @@
+module HttpEventLogger
+
+  class Configuration
+
+    attr_accessor :logger
+
+  end
+
+end

data/lib/http_event_logger/event/connection.rb

@@ -0,0 +1,21 @@
+module HttpEventLogger
+  module Event
+
+    class Connection
+
+      attr_reader :host, :port
+
+      def initialize(host, port)
+        @host = host
+        @port = port ? port.to_s : nil
+        HttpEventLogger::Event::Observer.observe(:connected, self)
+      end
+
+      def uri
+        @port.present? ? "#{@host}:#{@port}" : @host
+      end
+
+    end
+
+  end
+end

data/lib/http_event_logger/event/headers.rb

@@ -0,0 +1,21 @@
+module HttpEventLogger
+  module Event
+
+    class Headers
+
+      def initialize(headers)
+        @headers = headers || ""
+      end
+
+      def [](name)
+        @headers.is_a?(Hash) ? @headers[name] : nil
+      end
+
+      def to_s
+        @headers.is_a?(String) ? @headers : @headers.map { |key, value| "#{key}: #{value}" }.join(", ")
+      end
+
+    end
+
+  end
+end

data/lib/http_event_logger/event/observer.rb

@@ -0,0 +1,13 @@
+module HttpEventLogger
+  module Event
+
+    class Observer
+
+      def self.observe(event_name, event_object)
+        HttpEventLogger.logger.send(event_name, event_object) if HttpEventLogger.logger.logs?(event_object.uri)
+      end
+
+    end
+
+  end
+end

data/lib/http_event_logger/event/request.rb

@@ -0,0 +1,24 @@
+module HttpEventLogger
+  module Event
+
+    class Request
+
+      attr_reader :method, :uri, :headers, :body
+
+      def initialize(args)
+        @method  = args[:method].to_s.upcase
+        @uri     = args[:uri].to_s
+        @headers = HttpEventLogger::Event::Headers.new(args[:headers])
+        @body    = args[:body]
+        HttpEventLogger::Event::Observer.observe(:sent, self)
+      end
+
+      def base_uri
+        matcher = @uri.match(/\/\/([^\/\?]*)/)
+        matcher ? matcher[1] : ""
+      end
+
+    end
+
+  end
+end

data/lib/http_event_logger/event/response.rb

@@ -0,0 +1,47 @@
+module HttpEventLogger
+  module Event
+
+    class Response
+
+      attr_reader :request, :time_taken_in_seconds, :status, :headers
+
+      delegate :base_uri, :uri, to: :request
+
+      def initialize(args)
+        @request               = args[:request]
+        @time_taken_in_seconds = args[:time_taken_in_seconds]
+        @status                = args[:status].to_s
+        @headers               = HttpEventLogger::Event::Headers.new(args[:headers])
+        @raw_body              = args[:body]
+        HttpEventLogger::Event::Observer.observe(:received, self)
+      end
+
+      def body_with_formatting
+        body.include?("\n") ? "\n#{body}" : body
+      end
+
+      private
+
+      def body
+        if body_read_deferred?
+          "[not available]"
+        elsif body_gzip_encoded?
+          Zlib::GzipReader.new(StringIO.new(@raw_body.to_s)).read
+        else
+          @raw_body.to_s
+        end
+      end
+
+      # open-uri wraps the response in a Net::ReadAdapter, so the response body is not available yet
+      def body_read_deferred?
+        @raw_body.is_a?(Net::ReadAdapter)
+      end
+
+      def body_gzip_encoded?
+        @headers["Content-Encoding"] =~ /gzip/
+      end
+
+    end
+
+  end
+end

data/lib/http_event_logger/logger.rb

@@ -0,0 +1,47 @@
+module HttpEventLogger
+
+  class Logger
+
+    private
+
+    DEFAULT_LOGGER   = ::Logger.new($stdout).freeze
+    DEFAULT_SEVERITY = ::Logger::Severity::DEBUG.freeze
+
+    public
+
+    def initialize(options={})
+      @logger            = options[:logger]            || DEFAULT_LOGGER
+      @severity          = options[:severity]          || DEFAULT_SEVERITY
+      @blacklist_pattern = options[:blacklist_pattern] || nil
+    end
+
+    def logs?(uri)
+      @blacklist_pattern.nil? || @blacklist_pattern !~ uri
+    end
+
+    def connected(connection)
+      log "[#{connection.uri}] Connected"
+    end
+
+    def sent(request)
+      log "[#{request.base_uri}] Sent - #{request.method} #{request.uri}"
+      log "[#{request.base_uri}] Sent - Headers: #{request.headers}"
+      log "[#{request.base_uri}] Sent - Body: #{request.body}" if request.body.present?
+    end
+
+    def received(response)
+      log "[#{response.base_uri}] Benchmark: #{response.time_taken_in_seconds} seconds"
+      log "[#{response.base_uri}] Received - Status: #{response.status}"
+      log "[#{response.base_uri}] Received - Headers: #{response.headers}"
+      log "[#{response.base_uri}] Received - Body:#{response.body_with_formatting}"
+    end
+
+    private
+
+    def log(message)
+      @logger.add(@severity) { message }
+    end
+
+  end
+
+end

data/lib/http_event_logger/version.rb

@@ -0,0 +1,3 @@
+module HttpEventLogger
+  VERSION = "0.1.0.rc1".freeze
+end

data/lib/http_event_logger.rb

@@ -0,0 +1,43 @@
+require 'net/http'
+require 'logger'
+require 'benchmark'
+
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/string/inflections'
+
+require_relative 'http_event_logger/configuration'
+require_relative 'http_event_logger/event/connection'
+require_relative 'http_event_logger/event/headers'
+require_relative 'http_event_logger/event/request'
+require_relative 'http_event_logger/event/response'
+require_relative 'http_event_logger/logger'
+require_relative 'http_event_logger/event/observer'
+require_relative 'http_event_logger/adapter/net_http'
+require_relative 'http_event_logger/adapter/httpclient'
+require_relative 'http_event_logger/adapter/excon'
+require_relative 'http_event_logger/adapter/ethon'
+require_relative 'http_event_logger/adapter/patron'
+
+module HttpEventLogger
+
+  class << self
+
+    attr_reader :configuration
+
+    def configure(&block)
+      @configuration = HttpEventLogger::Configuration.new
+      block.call @configuration
+    end
+
+    def logger
+      @configuration.logger
+    end
+
+  end
+
+end
+
+# Establish default configuration
+HttpEventLogger.configure { |config| config.logger = HttpEventLogger::Logger.new }