binnacle 0.4.8

data/lib/binnacle/configuration.rb

@@ -0,0 +1,278 @@
+module Binnacle
+  class Configuration
+
+    DEFAULT_IGNORED_EXCEPTIONS = [
+      'ActiveRecord::RecordNotFound',
+      'ActionController::RoutingError',
+      'ActionController::InvalidAuthenticityToken',
+      'CGI::Session::CookieStore::TamperedWithCookie',
+      'ActionController::UnknownHttpMethod',
+      'ActionController::UnknownAction',
+      'AbstractController::ActionNotFound',
+      'Mongoid::Errors::DocumentNotFound',
+      'ActionController::UnknownFormat',
+      'Sinatra::NotFound'
+    ].map(&:freeze).freeze
+
+    DEFAULT_PORT = '8080'
+
+    DEFAULT_BACKTRACE_FILTERS = [
+      lambda { |line| line.gsub(/^\.\//, "") },
+      lambda { |line|
+        Gem.path.each{ |path| line.sub!(/#{path}/, "[GEM_ROOT]") unless path.to_s.strip.empty? } if defined?(Gem)
+        line
+      },
+      lambda { |line| line if line !~ %r{lib/binnacle} }
+    ].freeze
+
+    # The Binnacle Endpoint (BINNACLE_ENDPOINT) single IP or Array of IPs
+    attr_accessor :endpoint
+
+    # The Binnacle Endpoint PORT (BINNACLE_PORT), defaults to 8080 if not encrypted
+    attr_accessor :port
+
+    # The application logger Binnacle Channel (BINNACLE_APP_LOG_CHANNEL)
+    attr_accessor :logging_channel
+
+    # The application error Binnacle Channel (BINNACLE_APP_ERR_CHANNEL)
+    attr_accessor :error_channel
+
+    # An approved publisher API key for the App (BINNACLE_API_KEY)
+    attr_accessor :api_key
+
+    # The API secret for the given API key (BINNACLE_API_SECRET)
+    attr_accessor :api_secret
+
+    # Whether to redirect rails logging to Binnacle (BINNACLE_RAILS_LOG)
+    attr_accessor :intercept_rails_logging
+
+    # Whether to pipe Rails logs as they are (verbose as shit) or just grab action_controller events and single line them (BINNACLE_RAILS_LOG_VERBOSE)
+    attr_accessor :rails_verbose_logging
+
+    # Whether to report exceptions to Binnacle (BINNACLE_REPORT_EXCEPTIONS)
+    attr_accessor :report_exceptions
+
+    # Exceptions that do not get reported to Binnacle (BINNACLE_IGNORED_EXCEPTIONS)
+    attr_accessor :ignored_exceptions
+
+    # Whether to skip reporting exceptions where the headers['X-Cascade'] is set
+    # to 'pass'. In Rails typically it means route was not found (404 error).
+    attr_accessor :ignore_cascade_pass
+
+    # Whether to make the requests over HTTPS, default is HTTPS
+    attr_reader :encrypted
+
+    # Whether to log asynchronoushly via the Ruby logger
+    attr_accessor :asynch_logging
+
+    # Array of Events to skip, e.g. ['home#index', 'webhooks#test']
+    attr_writer :ignore_actions
+
+    # HTTP outgoing logging options
+    attr_accessor :url_whitelist_patterns
+    attr_accessor :url_blacklist_patterns
+    attr_reader :url_whitelist_pattern
+    attr_reader :url_blacklist_pattern
+
+    attr_accessor :log_binnacle_signals
+
+
+    def initialize
+      if ENV['BINNACLE_ENDPOINT']
+        self.endpoint    ||= ENV['BINNACLE_ENDPOINT'].include?(',') ? ENV['BINNACLE_ENDPOINT'].split(',') : ENV['BINNACLE_ENDPOINT']
+      else
+        if self.endpoint !~ /[^[:space:]]/
+          self.endpoint = (1..6).to_a.sample(3).map { |n| "api#{n}.binnacle-api.io" }
+        end
+      end
+
+      self.logging_channel ||= ENV['BINNACLE_APP_LOG_CHANNEL']
+      self.error_channel   ||= ENV['BINNACLE_APP_ERR_CHANNEL']
+      self.api_key     ||= ENV['BINNACLE_API_KEY']
+      self.api_secret  ||= ENV['BINNACLE_API_SECRET']
+      self.intercept_rails_logging = Configuration.set_boolean_flag_for(ENV['BINNACLE_RAILS_LOG'])
+      self.rails_verbose_logging = Configuration.set_boolean_flag_for(ENV['BINNACLE_RAILS_LOG_VERBOSE'])
+      self.report_exceptions = Configuration.set_boolean_flag_for(ENV['BINNACLE_REPORT_EXCEPTIONS'])
+      self.ignored_exceptions ||= ENV['BINNACLE_IGNORED_EXCEPTIONS'] ? DEFAULT_IGNORED_EXCEPTIONS + ENV['BINNACLE_IGNORED_EXCEPTIONS'].split(',') : DEFAULT_IGNORED_EXCEPTIONS
+      self.ignore_cascade_pass     ||= true
+      self.asynch_logging = Configuration.set_boolean_flag_for(ENV['BINNACLE_RAILS_LOG_ASYNCH'], true)
+      @encrypted = Configuration.set_boolean_flag_for(ENV['BINNACLE_ENCRYPTED'], true)
+
+      self.url_whitelist_patterns ||= ENV['BINNACLE_HTTP_LOGGING_WHITELIST'] ? ENV['BINNACLE_HTTP_LOGGING_WHITELIST'].split(',') : []
+      self.url_blacklist_patterns ||= ENV['BINNACLE_HTTP_LOGGING_BLACKLIST'] ? ENV['BINNACLE_HTTP_LOGGING_BLACKLIST'].split(',') : []
+      @url_whitelist_pattern = /.*/
+      @url_blacklist_pattern = nil
+
+      self.log_binnacle_signals = Configuration.set_boolean_flag_for(ENV['BINNACLE_LOG_SIGNALS'])
+
+      prepare!
+    end
+
+    def prepare!
+      set_default_port
+      set_urls
+      set_blacklist_patterns
+      set_whitelist_patterns
+    end
+
+    def url
+      if @urls
+        @urls.is_a?(Array) ? @urls.sample : @urls
+      end
+    end
+
+    def urls
+      @urls
+    end
+
+    def ready?
+      urls? && self.api_key && self.api_secret
+    end
+
+    def urls?
+      (!@urls.nil? && !@urls.is_a?(Array)) || (@urls.is_a?(Array) && !@urls.empty?)
+    end
+
+    def can_setup_logger?
+      !self.logging_channel.nil?
+    end
+
+    def intercept_rails_logging?
+      self.intercept_rails_logging && !self.logging_channel.nil?
+    end
+
+    def rails_verbose_logging?
+      self.rails_verbose_logging
+    end
+
+    def trap?
+      !self.report_exceptions.nil? && !self.error_channel.nil?
+    end
+
+    def ignore_cascade_pass?
+      self.ignore_cascade_pass
+    end
+
+    def encrypted?
+      self.encrypted
+    end
+
+    def build_url(ip_or_host)
+      ["#{protocol}://#{ip_or_host}", port].compact.join(":")
+    end
+
+    def protocol
+      self.encrypted? ? 'https' : 'http'
+    end
+
+    def set_urls
+      if self.endpoint && (self.endpoint.is_a?(Array) ? !self.endpoint.empty? : (!self.endpoint !~ /[^[:space:]]/))
+        @urls = self.endpoint.is_a?(Array) ? self.endpoint.map { |ep| build_url(ep) } : build_url(endpoint)
+      end
+    end
+
+    def set_blacklist_patterns
+      blacklist_patterns = []
+
+      # don't log binnacle's posts
+      unless self.log_binnacle_signals
+        if @urls.is_a?(Array)
+          @urls.each do |url|
+            blacklist_patterns << /#{url}/ if url
+          end
+        elsif @urls
+          blacklist_patterns << /#{@urls}/
+        end
+      end
+
+      self.url_blacklist_patterns.each do |pattern|
+        blacklist_patterns << pattern
+      end
+
+      unless blacklist_patterns.empty?
+        @url_blacklist_pattern = Regexp.union(blacklist_patterns)
+      end
+    end
+
+    def set_whitelist_patterns
+      whitelist_patterns = []
+
+      self.url_whitelist_patterns.each do |pattern|
+        whitelist_patterns << pattern
+      end
+
+      unless whitelist_patterns.empty?
+        @whitelist_pattern = Regexp.union(whitelist_patterns)
+      end
+    end
+
+    def endpoint=(value)
+      @endpoint = value
+      set_urls
+    end
+
+    def encrypted=(value)
+      @encrypted = value
+      set_default_port
+      set_urls
+    end
+
+    def to_s
+      [ :endpoint,
+        :logging_channel,
+        :error_channel,
+        :api_key,
+        :api_secret,
+        :intercept_rails_logging,
+        :report_exceptions,
+        :ignore_cascade_pass,
+        :encrypted,
+        :asynch_logging
+      ].map { |m| "#{m}: #{self.send(m)}" }.join(', ')
+    end
+
+    def self.set_boolean_flag_for(value, default = false)
+      !value.nil? ? value.downcase == 'true' : default
+    end
+
+    def set_default_port
+      self.port ||= ENV['BINNACLE_PORT'] || (self.encrypted? ? nil : DEFAULT_PORT)
+    end
+
+    # Set conditions for events that should be ignored
+    #
+    # Currently supported formats are:
+    #  - A single string representing a controller action, e.g. 'users#sign_in'
+    #  - An array of strings representing controller actions
+    #  - An object that responds to call with an event argument and returns
+    #    true if the event should be ignored.
+    #
+    # The action ignores are given to 'ignore_actions'. The callable ignores
+    # are given to 'ignore'.  Both methods can be called multiple times, which
+    # just adds more ignore conditions to a list that is checked before logging.
+
+    def ignore_actions(actions)
+      ignore(lamba do |event|
+        params = event.payload[:params]
+        Array(actions).include?("#{params['controller']}##{params['action']}")
+      end)
+    end
+
+    def ignore_tests
+      @ignore_tests ||= []
+    end
+
+    def ignore(test)
+      ignore_tests.push(test) if test
+    end
+
+    def ignore_nothing
+      @ignore_tests = []
+    end
+
+    def ignore?(event)
+      ignore_tests.any? { |ignore_test| ignore_test.call(event) }
+    end
+
+  end
+end

data/lib/binnacle/connection.rb

@@ -0,0 +1,66 @@
+require 'forwardable'
+require 'faraday'
+require 'uri'
+
+module Binnacle
+  class Connection
+    extend Forwardable
+
+    attr_reader :connection
+    attr_reader :active_url
+    attr_reader :contact_url
+
+    def_delegators :@connection, :get, :post, :put, :delete, :head, :patch, :options
+
+    def initialize(api_key = nil, api_secret = nil, url = nil)
+      @contact_url = url || Binnacle.configuration.url
+      @active_url = @contact_url
+      @api_key = api_key || Binnacle.configuration.api_key
+      @api_secret = api_secret || Binnacle.configuration.api_secret
+
+      raise Binnacle::ConfigurationError.new("Binnacle URL not provided, set BINNACLE_URL or provide in the constructor") unless @contact_url
+
+      build_connection
+      randomize_endpoint
+    end
+
+    def endpoints
+      begin
+        response = @connection.get do |req|
+          req.url "/api/endpoints"
+          req.headers['Content-Type'] = 'application/json'
+        end
+
+        if response.status == 401
+          Binnacle.binnacle_logger.error("Error communicating with Binnacle (/api/endpoints): #{response.body}")
+          []
+        else
+          JSON.parse(response.body)
+        end
+      rescue Faraday::Error::ConnectionFailed => cf
+        Binnacle.binnacle_logger.error("Error communicating with Binnacle (/api/endpoints): #{cf.message}")
+        []
+      end
+    end
+
+    def randomize_endpoint
+      fresh_endpoints = endpoints
+      if fresh_endpoints.size > 1
+        Binnacle.configuration.endpoint = fresh_endpoints
+        @active_url = Binnacle.configuration.url
+        build_connection()
+      end
+    end
+
+    def build_connection
+      @connection ||= Faraday.new(:url => @active_url) do |faraday|
+        faraday.request :basic_auth, @api_key, @api_secret
+        faraday.request  :url_encoded             # form-encode POST params
+        #faraday.response :logger                  # log requests to STDOUT TODO set a client log file
+        faraday.adapter :httpclient
+      end
+    end
+
+  end
+
+end

data/lib/binnacle/errors.rb

@@ -0,0 +1,4 @@
+module Binnacle
+  class Error < RuntimeError; end
+  class ConfigurationError < Error; end
+end

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

@@ -0,0 +1,44 @@
+if defined?(Ethon)
+  require 'uri'
+
+  module Ethon
+    class Easy
+      module Http
+        alias_method :orig_http_request, :http_request
+        def http_request(url, action_name, options = {})
+          @binnacle_request_headers = options[:headers]
+          @binnacle_backup_url = url
+
+          @binnacle_action_name = action_name # remember this for compact logging
+          @binnacle_request_headers = options[:headers]
+          @binnacle_request_data = options[:body]
+
+          orig_http_request(url, action_name, options)
+        end
+      end
+
+      module Operations
+        alias_method :orig_perform, :perform
+        def perform
+          _url = _url || @url || @binnacle_backup_url
+          return orig_perform unless Binnacle::HttpLogger.allow?(_url)
+
+          _response_code = nil
+          bm = Benchmark.realtime do
+            _response_code = orig_perform
+          end
+
+          uri = URI(_url)
+          status   = response_headers.scan(/HTTP\/... (\d{3})/).flatten.first
+          encoding = response_headers.scan(/Content-Encoding: (\S+)/).flatten.first
+          content_type = response_headers.scan(/Content-Type: (\S+(; charset=\S+)?)/).flatten.first
+          url_without_query = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+
+          Binnacle::HttpLogger.signal(url_without_query, @binnacle_action_name, uri.host, uri.port, uri.path, uri.query, response_code, bm, @binnacle_request_headers, response_body, encoding, content_type, @binnacle_request_data)
+
+          return_code
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+if defined?(Excon)
+  module Excon
+
+    class Connection
+
+      def _httplog_url(datum)
+        "#{datum[:scheme]}://#{datum[:host]}:#{datum[:port]}#{datum[:path]}#{datum[:query]}"
+      end
+
+      alias_method :orig_request, :request
+      def request(params, &block)
+        datum = @data.merge(params)
+        url = _httplog_url(datum)
+
+        return orig_request(params, &block) unless Binnacle::HttpLogger.allow?(url)
+
+        result = nil
+        @binnacle_bm = Benchmark.realtime do
+          result = orig_request(params, &block)
+        end
+
+        datum[:headers] = @data[:headers].merge(datum[:headers] || {})
+
+        if Binnacle::HttpLogger.allow?(url)
+          @binnacle_method = datum[:method]
+        end
+        result
+      end
+
+      alias_method :orig_request_call, :request_call
+      def request_call(datum)
+        url = _httplog_url(datum)
+
+        if Binnacle::HttpLogger.allow?(url)
+          @binnacle_headers = datum[:headers]
+          @binnacle_data = datum[:body] # if datum[:method] == :post
+          @binnacle_method = datum[:method]
+        end
+        orig_request_call(datum)
+      end
+
+      alias_method :orig_response, :response
+      def response(datum={})
+        url = _httplog_url(datum)
+        return orig_response(datum) unless Binnacle::HttpLogger.allow?(url)
+
+        uri = URI(url)
+        url_without_query = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
+
+        bm = Benchmark.realtime do
+          datum = orig_response(datum)
+        end
+        response = datum[:response]
+        headers = response[:headers] || {}
+
+        Binnacle::HttpLogger.signal(url_without_query, @binnacle_method, datum[:host], datum[:port], uri.path, uri.query, response[:status], @binnacle_bm, @binnacle_headers, response[:body], headers['Content-Encoding'], headers['Content-Type'], @binnacle_data)
+
+        datum
+      end
+    end
+  end
+end