binnacle 0.4.8

data/lib/binnacle/http_logging/adapters/http.rb

@@ -0,0 +1,63 @@
+unless ENV['BINNACLE_RB_ENVIRONMENT'] == 'test'
+  if defined?(::HTTP::Client) and defined?(::HTTP::Connection)
+    require 'uri'
+
+    module ::HTTP
+      class Client
+        alias_method(:orig_make_request, :make_request) unless method_defined?(:orig_make_request)
+
+        def make_request(req, options)
+          log_enabled = Binnacle::HttpLogger.allow?(req.uri)
+
+          bm = Benchmark.realtime do
+            @response = orig_make_request(req, options)
+          end
+
+          if log_enabled
+            headers = @response.headers.to_h
+            content_type = headers['Content-Type']
+            uri = URI(req.uri)
+            url_without_query = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+
+            Binnacle::HttpLogger.signal(url_without_query, req.verb, uri.host, uri.port, uri.path, uri.query, @response.code, bm, headers, @response.body, nil, content_type, req.body)
+          end
+
+          @response
+        end
+      end
+    end
+  end
+end
+
+#
+# Adapt the adapter to allow for testing..
+#
+if ENV['BINNACLE_RB_ENVIRONMENT'] == 'test' #defined?(Webmock) &&
+  require 'webmock'
+  module HTTP
+    class Client
+      alias_method :orig_perform, :perform
+
+      def perform(request, options)
+        return orig_perform(request, options) unless webmock_enabled?
+
+        log_enabled = Binnacle::HttpLogger.allow?(request.uri)
+
+        bm = Benchmark.realtime do
+          @response = WebMockPerform.new(request) { orig_perform(request, options) }.exec
+        end
+
+        if log_enabled
+          headers = @response.headers.to_h
+          uri = URI(request.uri)
+          url_without_query = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+
+          Binnacle::HttpLogger.signal(url_without_query, request.verb, uri.host, uri.port, uri.path, uri.query, @response.code, bm, headers, @response.body, headers['Content-Encoding'], headers['Content-Type'], request.body)
+        end
+
+        @response
+      end
+
+    end
+  end
+end

data/lib/binnacle/http_logging/adapters/httpclient.rb

@@ -0,0 +1,93 @@
+unless ENV['BINNACLE_RB_ENVIRONMENT'] == 'test'
+  if defined?(::HTTPClient)
+    class HTTPClient
+      private
+      alias_method :orig_do_get_block, :do_get_block
+
+      def do_get_block(req, proxy, conn, &block)
+        url = req.header.request_uri
+        log_enabled = Binnacle::HttpLogger.allow?(url)
+
+        uri = URI(url)
+        url_without_query = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+
+        retryable_response = nil
+        bm = Benchmark.realtime do
+          begin
+            orig_do_get_block(req, proxy, conn, &block)
+          rescue RetryableResponse => e
+            retryable_response = e
+          end
+        end
+
+        if log_enabled
+          res = conn.pop
+          headers = res.headers
+
+          Binnacle::HttpLogger.signal(url_without_query, req.header.request_method, @host, @port, uri.path, uri.query, res.status_code, bm, headers, res.body, headers['Content-Encoding'], headers['Content-Type'])
+
+          conn.push(res)
+        end
+
+        raise retryable_response if retryable_response != nil
+      end
+
+      class Session
+        alias_method :orig_create_socket, :create_socket
+
+        if self.instance_method(:create_socket).parameters == [[:req, :host], [:req, :port]]
+          # httpclient-2.7.1 - def create_socket(host, port)
+          def create_socket(host, port)
+            if Binnacle::HttpLogger.allow?("#{host}:#{port}")
+              @host = host
+              @port = port
+            end
+            orig_create_socket(host, port)
+          end
+        else
+          def create_socket(site)
+            if Binnacle::HttpLogger.allow?("#{site.host}:#{site.port}")
+              @host = site.host
+              @port = site.port
+            end
+            orig_create_socket(site)
+          end
+        end
+      end
+    end
+  end
+else # TEST MODE - Adapt the Adapter...
+  if defined?(::HTTPClient)
+    require 'webmock'
+
+    class WebMockHTTPClient
+      alias_method :orig_do_get_block, :do_get_block
+
+      def do_get_block(req, proxy, conn, &block)
+        url = req.header.request_uri
+        log_enabled = Binnacle::HttpLogger.allow?(url)
+        return orig_do_get_block(req, proxy, conn, &block) unless log_enabled
+
+        uri = URI(url)
+        url_without_query = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+
+        retryable_response = nil
+        bm = Benchmark.realtime do
+          begin
+            orig_do_get_block(req, proxy, conn, &block)
+          rescue RetryableResponse => e
+            retryable_response = e
+          end
+        end
+
+        res = conn.pop
+        headers = res.headers
+
+        Binnacle::HttpLogger.signal(url_without_query, req.header.request_method, uri.host, uri.port, uri.path, uri.query, res.status_code, bm, headers, res.body, headers['Content-Encoding'], headers['Content-Type'])
+        conn.push(res)
+
+        raise retryable_response if retryable_response != nil
+      end
+    end
+  end
+end

data/lib/binnacle/http_logging/adapters/net_http.rb

@@ -0,0 +1,54 @@
+unless ENV['BINNACLE_RB_ENVIRONMENT'] == 'test'
+  module Net
+    class HTTP
+      alias_method(:orig_request, :request) unless method_defined?(:orig_request)
+
+      def request(req, body = nil, &block)
+        url = "http://#{@address}:#{@port}#{req.path}"
+        uri = URI(url)
+        url_without_query = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+
+        bm = Benchmark.realtime do
+          @response = orig_request(req, body, &block)
+        end
+
+        if Binnacle::HttpLogger.allow?(url) && started?
+          data = req.body.nil? || req.body.size == 0 ? body : req.body
+          Binnacle::HttpLogger.signal(url_without_query, req.method, @address, @port, uri.path, uri.query, @response.code, bm, @response.each_header.collect.to_h, @response.body, @response['Content-Encoding'], @response['Content-Type'], data)
+        end
+
+        @response
+      end
+    end
+  end
+end
+
+#
+# Adapt the adapter to allow for testing..
+#
+if ENV['BINNACLE_RB_ENVIRONMENT'] == 'test' #defined?(Webmock) &&
+  require 'webmock'
+  web_mock_adapter = WebMock::HttpLibAdapters::NetHttpAdapter.instance_variable_get("@webMockNetHTTP")
+  web_mock_adapter.send(:alias_method, :orig_request, :request) unless web_mock_adapter.method_defined?(:orig_request)
+  web_mock_adapter.send(:define_method, :request, lambda do |req, body = nil, &block|
+    url = "http://#{@address}:#{@port}#{req.path}"
+
+    return orig_request(req, body, &block) unless Binnacle::HttpLogger.allow?(url)
+
+    uri = URI(url)
+    url_without_query = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+
+    bm = Benchmark.realtime do
+      @response = orig_request(req, body, &block)
+    end
+
+    if Binnacle::HttpLogger.allow?(url)
+      data = req.body.nil? || req.body.size == 0 ? body : req.body
+      headers = @response.each_header.collect.to_h
+      Binnacle::HttpLogger.signal(url_without_query, req.method, @address, @port, uri.path, uri.query, @response.code, bm, headers, @response.body, @response['Content-Encoding'], @response['Content-Type'], data)
+    end
+
+    @response
+  end
+  )
+end

data/lib/binnacle/http_logging/adapters/patron.rb

@@ -0,0 +1,24 @@
+if defined?(Patron)
+  require 'uri'
+
+  module Patron
+    class Session
+      alias_method :orig_request, :request
+      def request(action_name, url, headers, options = {})
+        log_enabled = Binnacle::HttpLogger.allow?(url)
+
+        bm = Benchmark.realtime do
+          @response = orig_request(action_name, url, headers, options)
+        end
+
+        if log_enabled
+          headers = @response.headers
+          uri = URI(url)
+          url_without_query = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+
+          Binnacle::HttpLogger.signal(url_without_query, action_name, uri.host, uri.port, uri.path, uri.query, @response.status, bm, headers, @response.body, headers['Content-Encoding'], headers['Content-Type'], options[:data])
+        end
+      end
+    end
+  end
+end

data/lib/binnacle/http_logging/adapters/typhoeus.rb

@@ -0,0 +1,20 @@
+if defined?(Typhoeus)
+  require 'uri'
+
+  on_complete = Proc.new do |response|
+    request = response.request
+    action = request.options[:method] || :get
+
+    uri = URI(request.url)
+
+    content_type = response.headers['Content-Type']
+    request_body = request.options[:body]
+    encoding = nil
+
+    Binnacle::HttpLogger.signal(request.base_url, action, uri.host, uri.port, uri.path, uri.query, response.response_code, response.total_time, request.options[:params], response.response_body, encoding, content_type, request_body)
+  end
+
+  unless Typhoeus.on_complete.include?(on_complete)
+    Typhoeus.on_complete << on_complete
+  end
+end

data/lib/binnacle/http_logging/http_logger.rb

@@ -0,0 +1,83 @@
+require "net/http"
+require "benchmark"
+require 'binnacle'
+
+module Binnacle
+  module HttpLogger
+
+    def self.signal(url, method, host, port, path, query, status, duration, headers = {}, body = nil, encoding = nil, content_type = nil, data = nil)
+      return if !self.allow?(url)
+
+      bm = duration ? (duration * 1000) : 0.0
+
+      signal_data = {
+        direction: :out,
+        url: url,
+        method: method.to_s.upcase,
+        host: host,
+        port: port,
+        path: path,
+        query: query,
+        format: content_type,
+        time: Time.now,
+        status: status,
+        duration: bm,
+        headers: headers,
+        body: extract_body_data(body, encoding, content_type),
+        data: extract_data(data),
+        message: "#{method.to_s.upcase} #{url} AS #{content_type} (duration: #{bm}ms)"
+      }
+
+      Binnacle.client.log_http_event(signal_data) if Binnacle.client
+    end
+
+    def self.allow?(url)
+      unless Binnacle.configuration.url_blacklist_pattern.nil?
+        return false if url.to_s.match(Binnacle.configuration.url_blacklist_pattern)
+      end
+
+      !url.to_s.match(Binnacle.configuration.url_whitelist_pattern).nil?
+    end
+
+    def self.extract_body_data(body, encoding = nil, content_type=nil)
+      return unless text_based?(content_type)
+
+      # open-uri wraps the response in a Net::ReadAdapter that defers reading
+      # the content, so the reponse body is not available here.
+      return if body.is_a?(Net::ReadAdapter)
+
+      if encoding =~ /gzip/
+        begin
+          sio = StringIO.new( body.to_s )
+          gz = Zlib::GzipReader.new( sio )
+          body = gz.read
+        rescue
+          # nothing to see here, move along!
+        end
+      end
+
+      utf_encoded(body.to_s, content_type)
+    end
+
+    def self.extract_data(data)
+      utf_encoded(data.to_s)
+    end
+
+    private
+
+    def self.utf_encoded(data, content_type=nil)
+      charset = content_type.to_s.scan(/; charset=(\S+)/).flatten.first || 'UTF-8'
+      data.force_encoding(charset) rescue data.force_encoding('UTF-8')
+      data.encode('UTF-8', :invalid => :replace, :undef => :replace)
+    end
+
+    def self.text_based?(content_type)
+      # This is a very naive way of determining if the content type is text-based; but
+      # it will allow application/json and the like without having to resort to more
+      # heavy-handed checks.
+      content_type =~ /^text/ ||
+      content_type =~ /^application/ && content_type != 'application/octet-stream'
+    end
+
+  end
+end

data/lib/binnacle/logging/formatter.rb

@@ -0,0 +1,62 @@
+require 'binnacle/resources/event'
+
+module Binnacle
+  module Logging
+    class Formatter
+      def initialize(client)
+        @client = client
+      end
+
+      def call(severity, datetime, progname, msg)
+        unless assets_log_prefix && msg.start_with?(assets_log_prefix)
+          session_id, client_id = @client.session_and_client_ids
+
+          event = Binnacle::Event.new()
+
+          logging_tags = current_tags.dup
+
+          if progname
+            event.configure_from_logging_progname(progname, @client.logging_channel_id, client_id, session_id, severity, datetime, [], { message: msg })
+          elsif defined?(ActiveSupport::TaggedLogging) && logging_tags && !logging_tags.empty? && logging_tags.size > 2
+            logging_tags.shift(2)
+            event_name = logging_tags.shift
+            event.configure_from_logging_progname(event_name, @client.logging_channel_id, client_id, session_id, severity, datetime, logging_tags, { message: msg })
+          else
+            event.configure(@client.logging_channel_id, 'log', client_id, session_id, severity, datetime, [], { message: msg })
+          end
+
+          event
+        end
+      end
+
+      def tagged(*tags)
+        new_tags = push_tags(*tags)
+        yield self
+      ensure
+        pop_tags(new_tags.size)
+      end
+
+      def push_tags(*tags)
+        tags.flatten.reject(&:blank?).tap do |new_tags|
+          current_tags.concat new_tags
+        end
+      end
+
+      def pop_tags(size = 1)
+        current_tags.pop size
+      end
+
+      def clear_tags!
+        current_tags.clear
+      end
+
+      def current_tags
+        Thread.current[:activesupport_tagged_logging_tags] ||= []
+      end
+
+      def assets_log_prefix
+        @assets_log_prefix ||= "Started GET \"#{Rails.application.config.assets.prefix}" if defined?(Rails)
+      end
+    end
+  end
+end

data/lib/binnacle/logging/logging.rb

@@ -0,0 +1,36 @@
+require 'logger'
+
+module Binnacle
+  module Logging
+
+    attr_writer :asynch
+
+    def self.new(client, logging_channel_id, params = {})
+      client.logging_channel_id = logging_channel_id || Binnacle.configuration.logging_channel
+      client.client_id = params[:client_id] || ''
+      client.session_id = params[:session_id] || ''
+
+      if defined?(ActiveSupport::TaggedLogging)
+        logger = ActiveSupport::TaggedLogging.new(Logger.new(client))
+        logger.formatter = client.formatter
+      elsif defined?(ActiveSupport::Logger)
+        logger = ActiveSupport::Logger.new(client)
+        logger.formatter = client.formatter
+      else
+        logger = Logger.new(client)
+        logger.formatter = client.formatter
+      end
+      logger
+    end
+
+    def self.build(api_key = nil, api_secret = nil, endpoint = nil, logging_channel_id = nil, params = {})
+      client = Binnacle::Client.new(api_key, api_secret, endpoint, logging_channel_id)
+      self.new(client, logging_channel_id, params)
+    end
+
+    def asynch
+      @asynch.nil? ? true : @asynch
+    end
+
+  end
+end