airbrake-ruby 1.0.0.rc.1

data/lib/airbrake-ruby/notifier.rb

@@ -0,0 +1,145 @@
+module Airbrake
+  ##
+  # This class is reponsible for sending notices to Airbrake. It supports
+  # synchronous and asynchronous delivery.
+  #
+  # @see Airbrake::Config The list of options
+  # @api private
+  # @since v5.0.0
+  class Notifier
+    ##
+    # Creates a new Airbrake notifier with the given config options.
+    #
+    # @example Configuring with a Hash
+    #   airbrake = Airbrake.new(project_id: 123, project_key: '321')
+    #
+    # @example Configuring with an Airbrake::Config
+    #   config = Airbrake::Config.new
+    #   config.project_id = 123
+    #   config.project_key = '321'
+    #   airbake = Airbrake.new(config)
+    #
+    # @param [Hash, Airbrake::Config] user_config The config that contains
+    #   information about how the notifier should operate
+    # @raise [Airbrake::Error] when either +project_id+ or +project_key+
+    #   is missing (or both)
+    def initialize(user_config)
+      @config = (user_config.is_a?(Config) ? user_config : Config.new(user_config))
+
+      unless [@config.project_id, @config.project_key].all?
+        raise Airbrake::Error, 'both :project_id and :project_key are required'
+      end
+
+      @filter_chain = FilterChain.new(@config)
+      @async_sender = AsyncSender.new(@config)
+      @sync_sender = SyncSender.new(@config)
+    end
+
+    ##
+    # @!macro see_public_api_method
+    #   @see Airbrake.$0
+
+    ##
+    # @macro see_public_api_method
+    def notify(exception, params = {})
+      send_notice(exception, params)
+      nil
+    end
+
+    ##
+    # @macro see_public_api_method
+    def notify_sync(exception, params = {})
+      send_notice(exception, params, @sync_sender)
+    end
+
+    ##
+    # @macro see_public_api_method
+    def add_filter(filter = nil, &block)
+      @filter_chain.add_filter(block_given? ? block : filter)
+    end
+
+    ##
+    # @macro see_public_api_method
+    def whitelist_keys(keys)
+      add_filter(Filters::KeysWhitelist.new(*keys))
+    end
+
+    ##
+    # @macro see_public_api_method
+    def blacklist_keys(keys)
+      add_filter(Filters::KeysBlacklist.new(*keys))
+    end
+
+    ##
+    # @macro see_public_api_method
+    def build_notice(exception, params = {})
+      if @async_sender.closed?
+        raise Airbrake::Error,
+              "attempted to build #{exception} with closed Airbrake instance"
+      end
+
+      if exception.is_a?(Airbrake::Notice)
+        exception
+      else
+        Notice.new(@config, convert_to_exception(exception), params)
+      end
+    end
+
+    ##
+    # @macro see_public_api_method
+    def close
+      @async_sender.close
+    end
+
+    ##
+    # @macro see_public_api_method
+    def create_deploy(deploy_params)
+      deploy_params[:environment] ||= @config.environment
+
+      host = @config.endpoint.to_s.split(@config.endpoint.path).first
+      path = "/api/v4/projects/#{@config.project_id}/deploys?key=#{@config.project_key}"
+
+      @sync_sender.send(deploy_params, URI.join(host, path))
+    end
+
+    private
+
+    def convert_to_exception(ex)
+      if ex.is_a?(Exception) || Backtrace.java_exception?(ex)
+        # Manually created exceptions don't have backtraces, so we create a fake
+        # one, whose first frame points to the place where Airbrake was called
+        # (normally via `notify`).
+        ex.set_backtrace(clean_backtrace) unless ex.backtrace
+        return ex
+      end
+
+      e = RuntimeError.new(ex.to_s)
+      e.set_backtrace(clean_backtrace)
+      e
+    end
+
+    def send_notice(exception, params, sender = default_sender)
+      notice = build_notice(exception, params)
+      @filter_chain.refine(notice)
+      return if notice.ignored?
+
+      sender.send(notice)
+    end
+
+    def default_sender
+      if @async_sender.has_workers?
+        @async_sender
+      else
+        @config.logger.warn(
+          "#{LOG_LABEL} falling back to sync delivery because there are no " \
+          "running async workers"
+        )
+        @sync_sender
+      end
+    end
+
+    def clean_backtrace
+      caller.drop_while { |frame| frame.include?('/lib/airbrake') }
+    end
+  end
+end

data/lib/airbrake-ruby/payload_truncator.rb

@@ -0,0 +1,141 @@
+module Airbrake
+  ##
+  # This class is responsible for truncation of too big objects. Mainly, you
+  # should use it for simple objects such as strings, hashes, & arrays.
+  class PayloadTruncator
+    ##
+    # @return [Hash] the options for +String#encode+
+    ENCODING_OPTIONS = { invalid: :replace, undef: :replace }.freeze
+
+    ##
+    # @return [String] the temporary encoding to be used when fixing invalid
+    #   strings with +ENCODING_OPTIONS+
+    TEMP_ENCODING = (RUBY_VERSION == '1.9.2' ? 'iso-8859-1' : 'utf-16')
+
+    ##
+    # @param [Integer] max_size maximum size of hashes, arrays and strings
+    # @param [Logger] logger the logger object
+    def initialize(max_size, logger)
+      @max_size = max_size
+      @logger = logger
+    end
+
+    ##
+    # Truncates errors (not exceptions) to fit the limit.
+    #
+    # @param [Hash] error
+    # @option error [Symbol] :message
+    # @option error [Array<String>] :backtrace
+    # @return [void]
+    def truncate_error(error)
+      if error[:message].length > @max_size
+        error[:message] = truncate_string(error[:message])
+        @logger.info("#{LOG_LABEL} truncated the message of #{error[:type]}")
+      end
+
+      return if (dropped_frames = error[:backtrace].size - @max_size) < 0
+
+      error[:backtrace] = error[:backtrace].slice(0, @max_size)
+      @logger.info("#{LOG_LABEL} dropped #{dropped_frames} frame(s) from #{error[:type]}")
+    end
+
+    ##
+    # Performs deep truncation of arrays, hashes and sets. Uses a
+    # placeholder for recursive objects (`[Circular]`).
+    #
+    # @param [Hash,Array] object The object to truncate
+    # @param [Hash] seen The hash that helps to detect recursion
+    # @return [void]
+    def truncate_object(object, seen = {})
+      return seen[object] if seen[object]
+
+      seen[object] = '[Circular]'.freeze
+      truncated = if object.is_a?(Hash)
+                    truncate_hash(object, seen)
+                  elsif object.is_a?(Array)
+                    truncate_array(object, seen)
+                  elsif object.is_a?(Set)
+                    truncate_set(object, seen)
+                  else
+                    raise Airbrake::Error,
+                          "cannot truncate object: #{object} (#{object.class})"
+                  end
+      seen[object] = truncated
+    end
+
+    ##
+    # Reduces maximum allowed size of the truncated object.
+    # @return [void]
+    def reduce_max_size
+      @max_size /= 2
+    end
+
+    private
+
+    def truncate(val, seen)
+      case val
+      when String
+        truncate_string(val)
+      when Array, Hash, Set
+        truncate_object(val, seen)
+      when Numeric, TrueClass, FalseClass, Symbol, NilClass
+        val
+      else
+        stringified_val = begin
+                            val.to_json
+                          rescue *Notice::JSON_EXCEPTIONS
+                            val.to_s
+                          end
+        truncate_string(stringified_val)
+      end
+    end
+
+    def truncate_string(str)
+      replace_invalid_characters!(str)
+      return str if str.length <= @max_size
+      str.slice(0, @max_size) + '[Truncated]'.freeze
+    end
+
+    ##
+    # Replaces invalid characters in string with arbitrary encoding.
+    #
+    # For Ruby 1.9.2 the method converts encoding of +str+ to +iso-8859-1+ to
+    # avoid a bug when encoding options are no-op, when `#encode` is given the
+    # same encoding as the receiver's encoding.
+    #
+    # For modern Rubies we use UTF-16 as a safe alternative.
+    #
+    # @param [String] str The string to replace characters
+    # @return [void]
+    # @note This method mutates +str+ for speed
+    # @see https://github.com/flori/json/commit/3e158410e81f94dbbc3da6b7b35f4f64983aa4e3
+    def replace_invalid_characters!(str)
+      encoding = str.encoding
+      utf8_string = (encoding == Encoding::UTF_8 || encoding == Encoding::ASCII)
+      return str if utf8_string && str.valid_encoding?
+
+      str.encode!(TEMP_ENCODING, ENCODING_OPTIONS) if utf8_string
+      str.encode!('utf-8', ENCODING_OPTIONS)
+    end
+
+    def truncate_hash(hash, seen)
+      hash.each_with_index do |(key, val), idx|
+        if idx < @max_size
+          hash[key] = truncate(val, seen)
+        else
+          hash.delete(key)
+        end
+      end
+    end
+
+    def truncate_array(array, seen)
+      array.slice(0, @max_size).map! { |val| truncate(val, seen) }
+    end
+
+    def truncate_set(set, seen)
+      set.keep_if.with_index { |_val, idx| idx < @max_size }.map! do |val|
+        truncate(val, seen)
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/response.rb

@@ -0,0 +1,53 @@
+module Airbrake
+  ##
+  # Parses responses coming from the Airbrake API. Handles HTTP errors by
+  # logging them.
+  module Response
+    ##
+    # @return [Integer] the limit of the response body
+    TRUNCATE_LIMIT = 100
+
+    ##
+    # Parses HTTP responses from the Airbrake API.
+    #
+    # @param [Net::HTTPResponse] response
+    # @param [Logger] logger
+    # @return [Hash{String=>String}] parsed response
+    def self.parse(response, logger)
+      code = response.code.to_i
+      body = response.body
+
+      begin
+        case code
+        when 201
+          parsed_body = JSON.parse(body)
+          logger.debug("#{LOG_LABEL} #{parsed_body}")
+          parsed_body
+        when 400, 401, 403, 429
+          parsed_body = JSON.parse(body)
+          logger.error("#{LOG_LABEL} #{parsed_body['error']}")
+          parsed_body
+        else
+          body_msg = truncated_body(body)
+          logger.error("#{LOG_LABEL} unexpected code (#{code}). Body: #{body_msg}")
+          { 'error' => body_msg }
+        end
+      rescue => ex
+        body_msg = truncated_body(body)
+        logger.error("#{LOG_LABEL} error while parsing body (#{ex}). Body: #{body_msg}")
+        { 'error' => ex }
+      end
+    end
+
+    def self.truncated_body(body)
+      if body.nil?
+        '[EMPTY_BODY]'.freeze
+      elsif body.length > TRUNCATE_LIMIT
+        body[0..TRUNCATE_LIMIT] << '...'
+      else
+        body
+      end
+    end
+    private_class_method :truncated_body
+  end
+end

data/lib/airbrake-ruby/sync_sender.rb

@@ -0,0 +1,76 @@
+module Airbrake
+  ##
+  # Responsible for sending notices to Airbrake synchronously. Supports proxies.
+  #
+  # @see AsyncSender
+  class SyncSender
+    ##
+    # @return [String] body for HTTP requests
+    CONTENT_TYPE = 'application/json'.freeze
+
+    ##
+    # @return [Array] the errors to be rescued and logged during an HTTP request
+    HTTP_ERRORS = [
+      Timeout::Error,
+      Net::HTTPBadResponse,
+      Net::HTTPHeaderSyntaxError,
+      Errno::ECONNRESET,
+      Errno::ECONNREFUSED,
+      EOFError,
+      OpenSSL::SSL::SSLError
+    ]
+
+    ##
+    # @param [Airbrake::Config] config
+    def initialize(config)
+      @config = config
+    end
+
+    ##
+    # Sends a POST request to the given +endpoint+ with the +notice+ payload.
+    #
+    # @param [Airbrake::Notice] notice
+    # @param [Airbrake::Notice] endpoint
+    # @return [Hash{String=>String}] the parsed HTTP response
+    def send(notice, endpoint = @config.endpoint)
+      response = nil
+      req = build_post_request(endpoint, notice)
+      https = build_https(endpoint)
+
+      begin
+        response = https.request(req)
+      rescue *HTTP_ERRORS => ex
+        @config.logger.error("#{LOG_LABEL} HTTP error: #{ex}")
+        return
+      end
+
+      Response.parse(response, @config.logger)
+    end
+
+    private
+
+    def build_https(uri)
+      Net::HTTP.new(uri.host, uri.port, *proxy_params).tap do |https|
+        https.use_ssl = uri.is_a?(URI::HTTPS)
+      end
+    end
+
+    def build_post_request(uri, notice)
+      Net::HTTP::Post.new(uri.request_uri).tap do |req|
+        req.body = notice.to_json
+
+        req['Content-Type'] = CONTENT_TYPE
+        req['User-Agent'] =
+          "#{Airbrake::Notice::NOTIFIER[:name]}/#{Airbrake::AIRBRAKE_RUBY_VERSION}" \
+          " Ruby/#{RUBY_VERSION}"
+      end
+    end
+
+    def proxy_params
+      [@config.proxy[:host],
+       @config.proxy[:port],
+       @config.proxy[:user],
+       @config.proxy[:password]]
+    end
+  end
+end

data/lib/airbrake-ruby/version.rb

@@ -0,0 +1,7 @@
+##
+# Defines version.
+module Airbrake
+  ##
+  # @return [String] the library version
+  AIRBRAKE_RUBY_VERSION = '1.0.0.rc.1'.freeze
+end

data/spec/airbrake_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+RSpec.describe Airbrake do
+  let(:endpoint) do
+    'https://airbrake.io/api/v3/projects/113743/notices?key=fd04e13d806a90f96614ad8e529b2822'
+  end
+
+  before do
+    described_class.configure do |c|
+      c.project_id = 113743
+      c.project_key = 'fd04e13d806a90f96614ad8e529b2822'
+    end
+
+    stub_request(:post, endpoint).to_return(status: 201, body: '{}')
+  end
+
+  after do
+    described_class.instance_variable_set(:@notifiers, {})
+  end
+
+  shared_examples 'error handling' do |method|
+    it "raises error if there is no notifier when using #{method}" do
+      described_class.instance_variable_set(:@notifiers, {})
+
+      expect { described_class.__send__(method, 'bingo') }.
+        to raise_error(Airbrake::Error,
+                       "the 'default' notifier isn't configured")
+    end
+  end
+
+  describe ".notify" do
+    include_examples 'error handling', :notify
+
+    it "sends exceptions asynchronously" do
+      described_class.notify('bingo')
+      sleep 2
+      expect(a_request(:post, endpoint)).to have_been_made.once
+    end
+  end
+
+  describe ".notify_sync" do
+    include_examples 'error handling', :notify_sync
+
+    it "sends exceptions synchronously" do
+      expect(described_class.notify_sync('bingo')).to be_a(Hash)
+      expect(a_request(:post, endpoint)).to have_been_made.once
+    end
+
+    context "given the notifier argument" do
+      it "sends exceptions via that notifier, ignoring other ones" do
+        bingo_string = StringIO.new
+        bango_string = StringIO.new
+
+        described_class.configure(:bingo) do |c|
+          c.project_id = 113743
+          c.project_key = 'fd04e13d806a90f96614ad8e529b2822'
+          c.logger = Logger.new(bingo_string)
+        end
+
+        described_class.configure(:bango) do |c|
+          c.project_id = 113743
+          c.project_key = 'fd04e13d806a90f96614ad8e529b2822'
+          c.logger = Logger.new(bango_string)
+        end
+
+        stub_request(:post, endpoint).to_return(status: 201, body: '{"id":1}')
+
+        described_class.notify_sync('bango', {}, :bango)
+        expect(bingo_string.string).to be_empty
+        expect(bango_string.string).to match(/\*\*Airbrake: {"id"=>1}/)
+      end
+    end
+
+    describe "clean backtrace" do
+      shared_examples 'backtrace building' do |msg, argument|
+        it(msg) do
+          described_class.notify_sync(argument)
+
+          # rubocop:disable Metrics/LineLength
+          expected_body = %r|
+            {"errors":\[{"type":"RuntimeError","message":"bingo","backtrace":\[
+            {"file":"[\w/\-\.]+spec/airbrake_spec.rb","line":\d+,"function":"[\w/\s\(\)<>]+"},
+            {"file":"\[GEM_ROOT\]/gems/rspec-core-.+/.+","line":\d+,"function":"[\w/\s\(\)<>]+"}
+          |x
+          # rubocop:enable Metrics/LineLength
+
+          expect(
+            a_request(:post, endpoint).
+            with(body: expected_body)
+          ).to have_been_made.once
+        end
+      end
+
+      context "given a String" do
+        include_examples(
+          'backtrace building',
+          'converts it to a RuntimeException and builds a fake backtrace',
+          'bingo')
+      end
+
+      context "given an Exception with missing backtrace" do
+        include_examples(
+          'backtrace building',
+          'builds a backtrace for it and sends the notice',
+          RuntimeError.new('bingo'))
+      end
+    end
+
+    context "special params" do
+      it "sends context/component and doesn't contain params/component" do
+        described_class.notify_sync('bingo', component: 'bango')
+
+        expect(
+          a_request(:post, endpoint).
+          with(body: /"context":{.*"component":"bango".+"params":{}/)
+        ).to have_been_made.once
+      end
+
+      it "sends context/action and doesn't contain params/action" do
+        described_class.notify_sync('bingo', action: 'bango')
+
+        expect(
+          a_request(:post, endpoint).
+          with(body: /"context":{.*"action":"bango".+"params":{}/)
+        ).to have_been_made.once
+      end
+    end
+  end
+
+  describe ".configure" do
+    context "given an argument" do
+      it "configures a notifier with the given name" do
+        described_class.configure(:bingo) do |c|
+          c.project_id = 123
+          c.project_key = '321'
+        end
+
+        notifiers = described_class.instance_variable_get(:@notifiers)
+
+        expect(notifiers).to be_a(Hash)
+        expect(notifiers.keys).to eq([:default, :bingo])
+        expect(notifiers.values).to all(satisfy { |v| v.is_a?(Airbrake::Notifier) })
+      end
+
+      it "raises error when a notifier of the given type was already configured" do
+        described_class.configure(:bingo) do |c|
+          c.project_id = 123
+          c.project_key = '321'
+        end
+
+        expect do
+          described_class.configure(:bingo) do |c|
+            c.project_id = 123
+            c.project_key = '321'
+          end
+        end.to raise_error(Airbrake::Error,
+                           "the 'bingo' notifier was already configured")
+      end
+    end
+  end
+
+  describe ".add_filter" do
+    include_examples 'error handling', :add_filter
+  end
+
+  describe ".whitelist_keys" do
+    include_examples 'error handling', :whitelist_keys
+  end
+
+  describe ".blacklist_keys" do
+    include_examples 'error handling', :blacklist_keys
+  end
+
+  describe ".build_notice" do
+    include_examples 'error handling', :build_notice
+  end
+end