hydraulic_brake 0.0.0

data/lib/hydraulic_brake/configuration.rb

@@ -0,0 +1,242 @@
+module HydraulicBrake
+  # Used to set up and modify settings for the notifier.
+  class Configuration
+
+    OPTIONS = [
+      :api_key,
+      :backtrace_filters,
+      :development_environments,
+      :development_lookup,
+      :environment_name,
+      :framework,
+      :host,
+      :http_open_timeout,
+      :http_read_timeout,
+      :notifier_name,
+      :notifier_url,
+      :notifier_version,
+      :params_filters,
+      :port,
+      :project_root,
+      :protocol,
+      :proxy_host,
+      :proxy_pass,
+      :proxy_port,
+      :proxy_user,
+      :rake_environment_filters,
+      :rescue_rake_exceptions,
+      :secure,
+      :use_system_ssl_cert_chain,
+    ].freeze
+
+    # The API key for your project, found on the project edit form.
+    attr_accessor :api_key
+
+    # The host to connect to
+    attr_accessor :host
+
+    # The port on which your Airbrake server runs (defaults to 443 for secure
+    # connections, 80 for insecure connections).
+    attr_accessor :port
+
+    # +true+ for https connections, +false+ for http connections.
+    attr_accessor :secure
+
+    # +true+ to use whatever CAs OpenSSL has installed on your system. +false+
+    # to use the ca-bundle.crt file included in HydraulicBrake itself
+    # (reccomended and default)
+    attr_accessor :use_system_ssl_cert_chain
+
+    # The HTTP open timeout in seconds (defaults to 2).
+    attr_accessor :http_open_timeout
+
+    # The HTTP read timeout in seconds (defaults to 5).
+    attr_accessor :http_read_timeout
+
+    # The hostname of your proxy server (if using a proxy)
+    attr_accessor :proxy_host
+
+    # The port of your proxy server (if using a proxy)
+    attr_accessor :proxy_port
+
+    # The username to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_user
+
+    # The password to use when logging into your proxy server (if using a proxy)
+    attr_accessor :proxy_pass
+
+    # A list of parameters that should be filtered out of what is sent to Airbrake.
+    # By default, all "password" attributes will have their contents replaced.
+    attr_reader :params_filters
+
+    # A list of filters for cleaning and pruning the backtrace. See #filter_backtrace.
+    attr_reader :backtrace_filters
+
+    # A list of environment keys that will be ignored from what is sent to Airbrake server
+    # Empty by default and used only in rake handler
+    attr_reader :rake_environment_filters
+
+    # A list of environments in which notifications should not be sent.
+    attr_accessor :development_environments
+
+    # +true+ if you want to check for production errors matching development errors, +false+ otherwise.
+    attr_accessor :development_lookup
+
+    # The name of the environment the application is running in
+    attr_accessor :environment_name
+
+    # The path to the project in which the error occurred, such as the Rails.root
+    attr_accessor :project_root
+
+    # The name of the notifier library being used to send notifications (such
+    # as "HydraulicBrake Notifier")
+    attr_accessor :notifier_name
+
+    # The version of the notifier library being used to send notifications (such as "1.0.2")
+    attr_accessor :notifier_version
+
+    # The url of the notifier library being used to send notifications
+    attr_accessor :notifier_url
+
+    # The logger used by HydraulicBrake
+    attr_accessor :logger
+
+    # The framework HydraulicBrake is configured to use
+    attr_accessor :framework
+
+    # Should HydraulicBrake catch exceptions from Rake tasks?
+    # (boolean or nil; set to nil to catch exceptions when rake isn't running from a terminal; default is nil)
+    attr_accessor :rescue_rake_exceptions
+
+    # User attributes that are being captured
+    attr_accessor :user_attributes
+
+
+    DEFAULT_PARAMS_FILTERS = %w(password password_confirmation).freeze
+
+    DEFAULT_USER_ATTRIBUTES = %w(id name username email).freeze
+
+    DEFAULT_BACKTRACE_FILTERS = [
+      lambda { |line|
+        if defined?(HydraulicBrake.configuration.project_root) && HydraulicBrake.configuration.project_root.to_s != ''
+          line.sub(/#{HydraulicBrake.configuration.project_root}/, "[PROJECT_ROOT]")
+        else
+          line
+        end
+      },
+      lambda { |line| line.gsub(/^\.\//, "") },
+      lambda { |line|
+        if defined?(Gem)
+          Gem.path.inject(line) do |line, path|
+            line.gsub(/#{path}/, "[GEM_ROOT]")
+          end
+        end
+      },
+      lambda { |line| line if line !~ %r{lib/hydraulic_brake} }
+    ].freeze
+
+    alias_method :secure?, :secure
+    alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
+
+    def initialize
+      @secure                   = false
+      @use_system_ssl_cert_chain= false
+      @host                     = 'api.airbrake.io'
+      @http_open_timeout        = 2
+      @http_read_timeout        = 5
+      @params_filters           = DEFAULT_PARAMS_FILTERS.dup
+      @backtrace_filters        = DEFAULT_BACKTRACE_FILTERS.dup
+      @development_environments = %w(development test cucumber)
+      @development_lookup       = true
+      @notifier_name            = 'HydraulicBrake Notifier'
+      @notifier_version         = VERSION
+      @notifier_url             = 'https://github.com/stevecrozz/hydraulic_brake'
+      @framework                = 'Standalone'
+      @rescue_rake_exceptions   = nil
+      @user_attributes          = DEFAULT_USER_ATTRIBUTES.dup
+      @rake_environment_filters = []
+    end
+
+    # Takes a block and adds it to the list of backtrace filters. When the filters
+    # run, the block will be handed each line of the backtrace and can modify
+    # it as necessary.
+    #
+    # @example
+    #   config.filter_bracktrace do |line|
+    #     line.gsub(/^#{Rails.root}/, "[Rails.root]")
+    #   end
+    #
+    # @param [Proc] block The new backtrace filter.
+    # @yieldparam [String] line A line in the backtrace.
+    def filter_backtrace(&block)
+      self.backtrace_filters << block
+    end
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      send(option)
+    end
+
+    # Returns a hash of all configurable options
+    def to_hash
+      OPTIONS.inject({}) do |hash, option|
+        hash[option.to_sym] = self.send(option)
+        hash
+      end
+    end
+
+    # Returns a hash of all configurable options merged with +hash+
+    #
+    # @param [Hash] hash A set of configuration options that will take precedence over the defaults
+    def merge(hash)
+      to_hash.merge(hash)
+    end
+
+    # Determines if the notifier will send notices.
+    # @return [Boolean] Returns +false+ if in a development environment, +true+ otherwise.
+    def public?
+      !development_environments.include?(environment_name)
+    end
+
+    def port
+      @port || default_port
+    end
+
+    # Determines whether protocol should be "http" or "https".
+    # @return [String] Returns +"http"+ if you've set secure to +false+ in
+    # configuration, and +"https"+ otherwise.
+    def protocol
+      if secure?
+        'https'
+      else
+        'http'
+      end
+    end
+
+    def ca_bundle_path
+      if use_system_ssl_cert_chain? && File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
+        OpenSSL::X509::DEFAULT_CERT_FILE
+      else
+        local_cert_path # ca-bundle.crt built from source, see resources/README.md
+      end
+    end
+
+    def local_cert_path
+      File.expand_path(File.join("..", "..", "..", "resources", "ca-bundle.crt"), __FILE__)
+    end
+
+  private
+    # Determines what port should we use for sending notices.
+    # @return [Fixnum] Returns 443 if you've set secure to true in your
+    # configuration, and 80 otherwise.
+    def default_port
+      if secure?
+        443
+      else
+        80
+      end
+    end
+  end
+end

data/lib/hydraulic_brake/notice.rb

@@ -0,0 +1,321 @@
+require 'builder'
+require 'socket'
+
+module HydraulicBrake
+  class Notice
+
+    class << self
+      def attr_reader_with_tracking(*names)
+        attr_readers.concat(names)
+        attr_reader_without_tracking(*names)
+      end
+
+      alias_method :attr_reader_without_tracking, :attr_reader
+      alias_method :attr_reader, :attr_reader_with_tracking
+
+
+      def attr_readers
+        @attr_readers ||= []
+      end
+    end
+
+    # The exception that caused this notice, if any
+    attr_reader :exception
+
+    # The API key for the project to which this notice should be sent
+    attr_reader :api_key
+
+    # The backtrace from the given exception or hash.
+    attr_reader :backtrace
+
+    # The name of the class of error (such as RuntimeError)
+    attr_reader :error_class
+
+    # The name of the server environment (such as "production")
+    attr_reader :environment_name
+
+    # CGI variables such as HTTP_METHOD
+    attr_reader :cgi_data
+
+    # The message from the exception, or a general description of the error
+    attr_reader :error_message
+
+    # See Configuration#backtrace_filters
+    attr_reader :backtrace_filters
+
+    # See Configuration#params_filters
+    attr_reader :params_filters
+
+    # A hash of parameters from the query string or post body.
+    attr_reader :parameters
+    alias_method :params, :parameters
+
+    # The component (if any) which was used in this request (usually the controller)
+    attr_reader :component
+    alias_method :controller, :component
+
+    # The action (if any) that was called in this request
+    attr_reader :action
+
+    # A hash of session data from the request
+    attr_reader :session_data
+
+    # The path to the project that caused the error (usually Rails.root)
+    attr_reader :project_root
+
+    # The URL at which the error occurred (if any)
+    attr_reader :url
+
+    # The name of the notifier library sending this notice, such as "HydraulicBrake Notifier"
+    attr_reader :notifier_name
+
+    # The version number of the notifier library sending this notice, such as "2.1.3"
+    attr_reader :notifier_version
+
+    # A URL for more information about the notifier library sending this notice
+    attr_reader :notifier_url
+
+    # The host name where this error occurred (if any)
+    attr_reader :hostname
+
+    # Details about the user who experienced the error
+    attr_reader :user
+
+    private
+
+    # Private writers for all the attributes
+    attr_writer :exception, :api_key, :backtrace, :error_class, :error_message,
+      :backtrace_filters, :parameters, :params_filters, :project_root, :url,
+      :notifier_name, :notifier_url, :notifier_version, :component, :action,
+      :cgi_data, :environment_name, :hostname, :user, :session_data
+
+    # Arguments given in the initializer
+    attr_accessor :args
+
+    public
+
+    def initialize(args)
+      self.args         = args
+      self.exception    = args[:exception]
+      self.api_key      = args[:api_key]
+      self.project_root = args[:project_root]
+      self.url          = args[:url]
+
+      self.notifier_name    = args[:notifier_name]
+      self.notifier_version = args[:notifier_version]
+      self.notifier_url     = args[:notifier_url]
+
+      self.backtrace_filters   = args[:backtrace_filters]   || []
+      self.params_filters      = args[:params_filters]      || []
+      self.parameters          = args[:parameters] || {}
+      self.component           = args[:component] || args[:controller] || nil
+      self.action              = args[:action] || nil
+
+      self.environment_name = args[:environment_name]
+      self.cgi_data         = args[:cgi_data] || {}
+      self.backtrace        = Backtrace.parse(exception_attribute(:backtrace, caller), :filters => self.backtrace_filters)
+      self.error_class      = exception_attribute(:error_class) {|exception| exception.class.name }
+      self.error_message    = exception_attribute(:error_message, 'Notification') do |exception|
+        "#{exception.class.name}: #{args[:error_message] || exception.message}"
+      end
+      self.session_data = args[:session_data] || {}
+
+      self.hostname        = local_hostname
+      self.user = args[:user] || {}
+
+      clean_params
+    end
+
+    # Converts the given notice to XML
+    def to_xml
+      builder = Builder::XmlMarkup.new
+      builder.instruct!
+      xml = builder.notice(:version => HydraulicBrake::API_VERSION) do |notice|
+        notice.tag!("api-key", api_key)
+        notice.notifier do |notifier|
+          notifier.name(notifier_name)
+          notifier.version(notifier_version)
+          notifier.url(notifier_url)
+        end
+        notice.error do |error|
+          error.tag!('class', error_class)
+          error.message(error_message)
+          error.backtrace do |backtrace|
+            self.backtrace.lines.each do |line|
+              backtrace.line(:number => line.number,
+                             :file   => line.file,
+                             :method => line.method)
+            end
+          end
+        end
+
+        if request_present?
+          notice.request do |request|
+            request.url(url)
+            request.component(controller)
+            request.action(action)
+            unless parameters.nil? || parameters.empty?
+              request.params do |params|
+                xml_vars_for(params, parameters)
+              end
+            end
+            unless session_data.empty?
+              request.session do |session|
+                xml_vars_for(session, session_data)
+              end
+            end
+            unless cgi_data.nil? || cgi_data.empty?
+              request.tag!("cgi-data") do |cgi_datum|
+                xml_vars_for(cgi_datum, cgi_data)
+              end
+            end
+          end
+        end
+
+        notice.tag!("server-environment") do |env|
+          env.tag!("project-root", project_root)
+          env.tag!("environment-name", environment_name)
+          env.tag!("hostname", hostname)
+        end
+        unless user.empty?
+          notice.tag!("current-user") do |u|
+            u.tag!("id",user[:id])
+            u.tag!("name",user[:name])
+            u.tag!("email",user[:email])
+            u.tag!("username",user[:username])
+          end
+        end
+      end
+      xml.to_s
+    end
+
+    # Allows properties to be accessed using a hash-like syntax
+    #
+    # @example
+    #   notice[:error_message]
+    # @param [String] method The given key for an attribute
+    # @return The attribute value, or self if given +:request+
+    def [](method)
+      case method
+      when :request
+        self
+      else
+        send(method)
+      end
+    end
+
+    private
+
+    def request_present?
+      url ||
+        controller ||
+        action ||
+        !parameters.empty? ||
+        !cgi_data.empty? ||
+        !session_data.empty?
+    end
+
+    # Gets a property named +attribute+ of an exception, either from an actual
+    # exception or a hash.
+    #
+    # If an exception is available, #from_exception will be used. Otherwise,
+    # a key named +attribute+ will be used from the #args.
+    #
+    # If no exception or hash key is available, +default+ will be used.
+    def exception_attribute(attribute, default = nil, &block)
+      (exception && from_exception(attribute, &block)) || args[attribute] || default
+    end
+
+    # Gets a property named +attribute+ from an exception.
+    #
+    # If a block is given, it will be used when getting the property from an
+    # exception. The block should accept and exception and return the value for
+    # the property.
+    #
+    # If no block is given, a method with the same name as +attribute+ will be
+    # invoked for the value.
+    def from_exception(attribute)
+      if block_given?
+        yield(exception)
+      else
+        exception.send(attribute)
+      end
+    end
+
+    # Removes non-serializable data from the given attribute.
+    # See #clean_unserializable_data
+    def clean_unserializable_data_from(attribute)
+      self.send(:"#{attribute}=", clean_unserializable_data(send(attribute)))
+    end
+
+    # Removes non-serializable data. Allowed data types are strings, arrays,
+    # and hashes. All other types are converted to strings.
+    # TODO: move this onto Hash
+    def clean_unserializable_data(data, stack = [])
+      return "[possible infinite recursion halted]" if stack.any?{|item| item == data.object_id }
+
+      if data.respond_to?(:to_hash)
+        data.to_hash.inject({}) do |result, (key, value)|
+          result.merge(key => clean_unserializable_data(value, stack + [data.object_id]))
+        end
+      elsif data.respond_to?(:to_ary)
+        data.to_ary.collect do |value|
+          clean_unserializable_data(value, stack + [data.object_id])
+        end
+      else
+        data.to_s
+      end
+    end
+
+    # Replaces the contents of params that match params_filters.
+    # TODO: extract this to a different class
+    def clean_params
+      clean_unserializable_data_from(:parameters)
+      filter(parameters)
+      if cgi_data
+        clean_unserializable_data_from(:cgi_data)
+        filter(cgi_data)
+      end
+    end
+
+    def filter(hash)
+      if params_filters
+        hash.each do |key, value|
+          if filter_key?(key)
+            hash[key] = "[FILTERED]"
+          elsif value.respond_to?(:to_hash)
+            filter(hash[key])
+          end
+        end
+      end
+    end
+
+    def filter_key?(key)
+      params_filters.any? do |filter|
+        key.to_s.eql?(filter.to_s)
+      end
+    end
+
+    def xml_vars_for(builder, hash)
+      hash.each do |key, value|
+        if value.respond_to?(:to_hash)
+          builder.var(:key => key){|b| xml_vars_for(b, value.to_hash) }
+        else
+          builder.var(value.to_s, :key => key)
+        end
+      end
+    end
+
+    def local_hostname
+      Socket.gethostname
+    end
+
+    def to_s
+      content = []
+      self.class.attr_readers.each do |attr|
+        content << "  #{attr}: #{send(attr)}"
+      end
+      content.join("\n")
+    end
+  end
+end

data/lib/hydraulic_brake/sender.rb

@@ -0,0 +1,128 @@
+module HydraulicBrake
+  # Sends out the notice to Airbrake
+  class Sender
+
+    NOTICES_URI = '/notifier_api/v2/notices/'.freeze
+    HTTP_ERRORS = [Timeout::Error,
+                   Errno::EINVAL,
+                   Errno::ECONNRESET,
+                   EOFError,
+                   Net::HTTPBadResponse,
+                   Net::HTTPHeaderSyntaxError,
+                   Net::ProtocolError,
+                   Errno::ECONNREFUSED].freeze
+
+    def initialize(options = {})
+      [ :proxy_host,
+        :proxy_port,
+        :proxy_user,
+        :proxy_pass,
+        :protocol,
+        :host,
+        :port,
+        :secure,
+        :use_system_ssl_cert_chain,
+        :http_open_timeout,
+        :http_read_timeout
+      ].each do |option|
+        instance_variable_set("@#{option}", options[option])
+      end
+    end
+
+    # Sends the notice data off to Airbrake for processing.
+    #
+    # @param [Notice or String] notice The notice to be sent off
+    def send_to_airbrake(notice)
+      data = notice.respond_to?(:to_xml) ? notice.to_xml : notice
+      http = setup_http_connection
+
+      response = begin
+                   http.post(url.path, data, HEADERS)
+                 rescue *HTTP_ERRORS => e
+                   log :level => :error,
+                       :message => "Unable to contact the Airbrake server. HTTP Error=#{e}"
+                   nil
+                 end
+
+      case response
+      when Net::HTTPSuccess then
+        log :level => :info,
+            :message => "Success: #{response.class}",
+            :response => response
+      else
+        log :level => :error,
+            :message => "Failure: #{response.class}",
+            :response => response,
+            :notice => notice
+      end
+
+      if response && response.respond_to?(:body)
+        error_id = response.body.match(%r{<id[^>]*>(.*?)</id>})
+        error_id[1] if error_id
+      end
+    rescue => e
+      log :level => :error,
+        :message => "[HydraulicBrake::Sender#send_to_airbrake] Cannot send notification. Error: #{e.class}" +
+        " - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
+
+      nil
+    end
+
+    attr_reader :proxy_host,
+                :proxy_port,
+                :proxy_user,
+                :proxy_pass,
+                :protocol,
+                :host,
+                :port,
+                :secure,
+                :use_system_ssl_cert_chain,
+                :http_open_timeout,
+                :http_read_timeout
+
+    alias_method :secure?, :secure
+    alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
+
+  private
+
+    def url
+      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
+    end
+
+    def log(opts = {})
+      opts[:logger].send opts[:level], LOG_PREFIX + opts[:message] if opts[:logger]
+      HydraulicBrake.report_environment_info
+      HydraulicBrake.report_response_body(opts[:response].body) if opts[:response] && opts[:response].respond_to?(:body)
+      HydraulicBrake.report_notice(opts[:notice]) if opts[:notice]
+    end
+
+    def logger
+      HydraulicBrake.logger
+    end
+
+    def setup_http_connection
+      http =
+        Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass).
+        new(url.host, url.port)
+
+      http.read_timeout = http_read_timeout
+      http.open_timeout = http_open_timeout
+
+      if secure?
+        http.use_ssl     = true
+
+        http.ca_file      = HydraulicBrake.configuration.ca_bundle_path
+        http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+      else
+        http.use_ssl     = false
+      end
+
+      http
+    rescue => e
+      log :level => :error,
+          :message => "[HydraulicBrake::Sender#setup_http_connection] Failure initializing the HTTP connection.\n" +
+                      "Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
+      raise e
+    end
+  end
+end

data/lib/hydraulic_brake/version.rb

@@ -0,0 +1,5 @@
+module HydraulicBrake
+
+  VERSION = File.read(File.join(File.dirname(__FILE__), "../../VERSION"))
+
+end