airbrake-ruby 4.13.4 → 5.0.0.rc.2

data/lib/airbrake-ruby/notice.rb

@@ -4,19 +4,12 @@ module Airbrake
   #
   # @since v1.0.0
   class Notice
-    # @return [Hash{Symbol=>String}] the information about the notifier library
-    NOTIFIER = {
-      name: 'airbrake-ruby'.freeze,
-      version: Airbrake::AIRBRAKE_RUBY_VERSION,
-      url: 'https://github.com/airbrake/airbrake-ruby'.freeze,
-    }.freeze
-
     # @return [Hash{Symbol=>String,Hash}] the information to be displayed in the
     #   Context tab in the dashboard
     CONTEXT = {
       os: RUBY_PLATFORM,
       language: "#{RUBY_ENGINE}/#{RUBY_VERSION}".freeze,
-      notifier: NOTIFIER,
+      notifier: Airbrake::NOTIFIER_INFO,
     }.freeze
 
     # @return [Integer] the maxium size of the JSON payload in bytes

data/lib/airbrake-ruby/notice_notifier.rb

@@ -82,6 +82,12 @@ module Airbrake
       @context.merge!(context)
     end
 
+    # @return [Boolean]
+    # @since v4.14.0
+    def has_filter?(filter_class) # rubocop:disable Naming/PredicateName
+      @filter_chain.includes?(filter_class)
+    end
+
     private
 
     def convert_to_exception(ex)

data/lib/airbrake-ruby/performance_notifier.rb

@@ -144,7 +144,7 @@ module Airbrake
 
       with_grouped_payload(payload) do |resource_hash, destination|
         url = URI.join(
-          @config.host,
+          @config.apm_host,
           "api/v5/projects/#{@config.project_id}/#{destination}",
         )
 

data/lib/airbrake-ruby/remote_settings.rb

@@ -0,0 +1,143 @@
+module Airbrake
+  # RemoteSettings polls the remote config of the passed project at fixed
+  # intervals. The fetched config is yielded as a callback parameter so that the
+  # invoker can define read config values.
+  #
+  # @example Disable/enable error notifications based on the remote value
+  #   RemoteSettings.poll do |data|
+  #     config.error_notifications = data.error_notifications?
+  #   end
+  #
+  # When {#poll} is called, it will try to load remote settings from disk, so
+  # that it doesn't wait on the result from the API call.
+  #
+  # When {#stop_polling} is called, the current config will be dumped to disk.
+  #
+  # @since ?.?.?
+  # @api private
+  class RemoteSettings
+    include Airbrake::Loggable
+
+    # @return [String] the path to the persistent config
+    CONFIG_DUMP_PATH = File.join(
+      File.expand_path(__dir__),
+      '../../config/config.json',
+    ).freeze
+
+    # @return [Hash{Symbol=>String}] metadata to be attached to every GET
+    #   request
+    QUERY_PARAMS = URI.encode_www_form(
+      notifier_name: Airbrake::NOTIFIER_INFO[:name],
+      notifier_version: Airbrake::NOTIFIER_INFO[:version],
+      os: RUBY_PLATFORM,
+      language: "#{RUBY_ENGINE}/#{RUBY_VERSION}".freeze,
+    ).freeze
+
+    # Polls remote config of the given project.
+    #
+    # @param [Integer] project_id
+    # @yield [data]
+    # @yieldparam data [Airbrake::RemoteSettings::SettingsData]
+    # @return [Airbrake::RemoteSettings]
+    def self.poll(project_id, &block)
+      new(project_id, &block).poll
+    end
+
+    # @param [Integer] project_id
+    # @yield [data]
+    # @yieldparam data [Airbrake::RemoteSettings::SettingsData]
+    def initialize(project_id, &block)
+      @data = SettingsData.new(project_id, {})
+      @block = block
+      @poll = nil
+    end
+
+    # Polls remote config of the given project in background. Loads local config
+    # first (if exists).
+    #
+    # @return [self]
+    def poll
+      @poll ||= Thread.new do
+        begin
+          load_config
+        rescue StandardError => ex
+          logger.error("#{LOG_LABEL} config loading failed: #{ex}")
+        end
+
+        @block.call(@data)
+
+        loop do
+          @block.call(@data.merge!(fetch_config))
+          sleep(@data.interval)
+        end
+      end
+
+      self
+    end
+
+    # Stops the background poller thread. Dumps current config to disk.
+    #
+    # @return [void]
+    def stop_polling
+      @poll.kill if @poll
+
+      begin
+        dump_config
+      rescue StandardError => ex
+        logger.error("#{LOG_LABEL} config dumping failed: #{ex}")
+      end
+    end
+
+    private
+
+    def fetch_config
+      response = nil
+      begin
+        response = Net::HTTP.get(build_config_uri)
+      rescue StandardError => ex
+        logger.error(ex)
+        return {}
+      end
+
+      # AWS S3 API returns XML when request is not valid. In this case we just
+      # print the returned body and exit the method.
+      if response.start_with?('<?xml ')
+        logger.error(response)
+        return {}
+      end
+
+      json = nil
+      begin
+        json = JSON.parse(response)
+      rescue JSON::ParserError => ex
+        logger.error(ex)
+        return {}
+      end
+
+      json
+    end
+
+    def build_config_uri
+      uri = URI(@data.config_route)
+      uri.query = QUERY_PARAMS
+      uri
+    end
+
+    def load_config
+      config_dir = File.dirname(CONFIG_DUMP_PATH)
+      Dir.mkdir(config_dir) unless File.directory?(config_dir)
+
+      return unless File.exist?(CONFIG_DUMP_PATH)
+
+      config = File.read(CONFIG_DUMP_PATH)
+      @data.merge!(JSON.parse(config))
+    end
+
+    def dump_config
+      config_dir = File.dirname(CONFIG_DUMP_PATH)
+      Dir.mkdir(config_dir) unless File.directory?(config_dir)
+
+      File.write(CONFIG_DUMP_PATH, JSON.dump(@data.to_h))
+    end
+  end
+end

data/lib/airbrake-ruby/remote_settings/settings_data.rb

@@ -0,0 +1,116 @@
+module Airbrake
+  class RemoteSettings
+    # SettingsData is a container, which wraps JSON payload returned by the
+    # remote settings API. It exposes the payload via convenient methods and
+    # also ensures that in case some data from the payload is missing, a default
+    # value would be returned instead.
+    #
+    # @example
+    #   # Create the object and pass initial data (empty hash).
+    #   settings_data = SettingsData.new({})
+    #
+    #   settings_data.interval #=> 600
+    #
+    # @since ?.?.?
+    # @api private
+    class SettingsData
+      # @return [Integer] how frequently we should poll the config API
+      DEFAULT_INTERVAL = 600
+
+      # @return [String] API version of the S3 API to poll
+      API_VER = '2020-06-18'.freeze
+
+      # @return [String] what URL to poll
+      CONFIG_ROUTE_PATTERN =
+        'https://v1-%<bucket>s.s3.amazonaws.com/' \
+        "#{API_VER}/config/%<project_id>s/config.json".freeze
+
+      # @return [Hash{Symbol=>String}] the hash of all supported settings where
+      #   the value is the name of the setting returned by the API
+      SETTINGS = {
+        errors: 'errors',
+        apm: 'apm',
+      }.freeze
+
+      # @param [Integer] project_id
+      # @param [Hash{String=>Object}] data
+      def initialize(project_id, data)
+        @project_id = project_id
+        @data = data
+      end
+
+      # Merges the given +hash+ with internal data.
+      #
+      # @param [Hash{String=>Object}] hash
+      # @return [self]
+      def merge!(hash)
+        @data.merge!(hash)
+
+        self
+      end
+
+      # @return [Integer] how frequently we should poll for the config
+      def interval
+        return DEFAULT_INTERVAL if !@data.key?('poll_sec') || !@data['poll_sec']
+
+        @data['poll_sec'] > 0 ? @data['poll_sec'] : DEFAULT_INTERVAL
+      end
+
+      # @return [String] where the config is stored on S3.
+      def config_route
+        if !@data.key?('config_route') || !@data['config_route']
+          return format(
+            CONFIG_ROUTE_PATTERN,
+            bucket: 'staging-notifier-configs',
+            project_id: @project_id,
+          )
+        end
+
+        @data['config_route']
+      end
+
+      # @return [Boolean] whether error notifications are enabled
+      def error_notifications?
+        return true unless (s = find_setting(SETTINGS[:errors]))
+
+        s['enabled']
+      end
+
+      # @return [Boolean] whether APM is enabled
+      def performance_stats?
+        return true unless (s = find_setting(SETTINGS[:apm]))
+
+        s['enabled']
+      end
+
+      # @return [String, nil] the host, which provides the API endpoint to which
+      #   exceptions should be sent
+      def error_host
+        return unless (s = find_setting(SETTINGS[:errors]))
+
+        s['endpoint']
+      end
+
+      # @return [String, nil] the host, which provides the API endpoint to which
+      #   APM data should be sent
+      def apm_host
+        return unless (s = find_setting(SETTINGS[:apm]))
+
+        s['endpoint']
+      end
+
+      # @return [Hash{String=>Object}] raw representation of JSON payload
+      def to_h
+        @data.dup
+      end
+
+      private
+
+      def find_setting(name)
+        return unless @data.key?('settings')
+
+        @data['settings'].find { |s| s['name'] == name }
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/sync_sender.rb

@@ -23,7 +23,7 @@ module Airbrake
     # @param [#to_json] data
     # @param [URI::HTTPS] endpoint
     # @return [Hash{String=>String}] the parsed HTTP response
-    def send(data, promise, endpoint = @config.endpoint)
+    def send(data, promise, endpoint = @config.error_endpoint)
       return promise if rate_limited_ip?(promise)
 
       response = nil
@@ -79,7 +79,7 @@ module Airbrake
       req['Authorization'] = "Bearer #{@config.project_key}"
       req['Content-Type'] = CONTENT_TYPE
       req['User-Agent'] =
-        "#{Airbrake::Notice::NOTIFIER[:name]}/#{Airbrake::AIRBRAKE_RUBY_VERSION}" \
+        "#{Airbrake::NOTIFIER_INFO[:name]}/#{Airbrake::AIRBRAKE_RUBY_VERSION}" \
         " Ruby/#{RUBY_VERSION}"
 
       req

data/lib/airbrake-ruby/thread_pool.rb

@@ -83,6 +83,7 @@ module Airbrake
 
         if @pid != Process.pid && @workers.list.empty?
           @pid = Process.pid
+          @workers = ThreadGroup.new
           spawn_workers
         end
 

data/lib/airbrake-ruby/version.rb

@@ -2,5 +2,15 @@
 # More information: http://semver.org/
 module Airbrake
   # @return [String] the library version
-  AIRBRAKE_RUBY_VERSION = '4.13.4'.freeze
+  # @api public
+  AIRBRAKE_RUBY_VERSION = '5.0.0.rc.2'.freeze
+
+  # @return [Hash{Symbol=>String}] the information about the notifier library
+  # @since ?.?.?
+  # @api public
+  NOTIFIER_INFO = {
+    name: 'airbrake-ruby'.freeze,
+    version: Airbrake::AIRBRAKE_RUBY_VERSION,
+    url: 'https://github.com/airbrake/airbrake-ruby'.freeze,
+  }.freeze
 end

data/spec/airbrake_spec.rb

@@ -1,4 +1,13 @@
 RSpec.describe Airbrake do
+  let(:remote_settings) { instance_double(Airbrake::RemoteSettings) }
+
+  before do
+    allow(Airbrake::RemoteSettings).to receive(:poll).and_return(remote_settings)
+    allow(remote_settings).to receive(:stop_polling)
+  end
+
+  after { described_class.instance_variable_set(:@remote_settings, nil) }
+
   it "gets initialized with a performance notifier" do
     expect(described_class.performance_notifier).not_to be_nil
   end
@@ -85,43 +94,55 @@ RSpec.describe Airbrake do
         expect(described_class.notice_notifier).not_to receive(:add_filter)
         10.times { described_class.configure {} }
       end
+
+      it "appends some default filters" do
+        allow(described_class.notice_notifier).to receive(:add_filter)
+        expect(described_class.notice_notifier).to receive(:add_filter).with(
+          an_instance_of(Airbrake::Filters::RootDirectoryFilter),
+        )
+
+        described_class.configure do |c|
+          c.project_id = 1
+          c.project_key = '2'
+        end
+      end
     end
 
-    context "when blacklist_keys gets configured" do
-      before { allow(Airbrake.notice_notifier).to receive(:add_filter) }
+    context "when blocklist_keys gets configured" do
+      before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
-      it "adds blacklist filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::KeysBlacklist))
-        described_class.configure { |c| c.blacklist_keys = %w[password] }
+      it "adds blocklist filter" do
+        expect(described_class.notice_notifier).to receive(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::KeysBlocklist))
+        described_class.configure { |c| c.blocklist_keys = %w[password] }
       end
 
-      it "initializes blacklist with specified parameters" do
-        expect(Airbrake::Filters::KeysBlacklist).to receive(:new).with(%w[password])
-        described_class.configure { |c| c.blacklist_keys = %w[password] }
+      it "initializes blocklist with specified parameters" do
+        expect(Airbrake::Filters::KeysBlocklist).to receive(:new).with(%w[password])
+        described_class.configure { |c| c.blocklist_keys = %w[password] }
       end
     end
 
-    context "when whitelist_keys gets configured" do
-      before { allow(Airbrake.notice_notifier).to receive(:add_filter) }
+    context "when allowlist_keys gets configured" do
+      before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
-      it "adds whitelist filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::KeysWhitelist))
-        described_class.configure { |c| c.whitelist_keys = %w[banana] }
+      it "adds allowlist filter" do
+        expect(described_class.notice_notifier).to receive(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::KeysAllowlist))
+        described_class.configure { |c| c.allowlist_keys = %w[banana] }
       end
 
-      it "initializes whitelist with specified parameters" do
-        expect(Airbrake::Filters::KeysWhitelist).to receive(:new).with(%w[banana])
-        described_class.configure { |c| c.whitelist_keys = %w[banana] }
+      it "initializes allowlist with specified parameters" do
+        expect(Airbrake::Filters::KeysAllowlist).to receive(:new).with(%w[banana])
+        described_class.configure { |c| c.allowlist_keys = %w[banana] }
       end
     end
 
     context "when root_directory gets configured" do
-      before { allow(Airbrake.notice_notifier).to receive(:add_filter) }
+      before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds root directory filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
+        expect(described_class.notice_notifier).to receive(:add_filter)
           .with(an_instance_of(Airbrake::Filters::RootDirectoryFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
       end
@@ -133,7 +154,7 @@ RSpec.describe Airbrake do
       end
 
       it "adds git revision filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
+        expect(described_class.notice_notifier).to receive(:add_filter)
           .with(an_instance_of(Airbrake::Filters::GitRevisionFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
       end
@@ -145,7 +166,7 @@ RSpec.describe Airbrake do
       end
 
       it "adds git repository filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
+        expect(described_class.notice_notifier).to receive(:add_filter)
           .with(an_instance_of(Airbrake::Filters::GitRepositoryFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
       end
@@ -157,7 +178,7 @@ RSpec.describe Airbrake do
       end
 
       it "adds git last checkout filter" do
-        expect(Airbrake.notice_notifier).to receive(:add_filter)
+        expect(described_class.notice_notifier).to receive(:add_filter)
           .with(an_instance_of(Airbrake::Filters::GitLastCheckoutFilter))
         described_class.configure { |c| c.root_directory = '/my/path' }
       end
@@ -170,7 +191,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_request" do
+  describe ".notify_request" do
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the request" do
         expect(described_class.performance_notifier).to receive(:notify) do |request|
@@ -205,7 +226,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_request_sync" do
+  describe ".notify_request_sync" do
     it "notifies request synchronously" do
       expect(described_class.performance_notifier).to receive(:notify_sync)
 
@@ -221,7 +242,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_query" do
+  describe ".notify_query" do
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the query" do
         expect(described_class.performance_notifier).to receive(:notify) do |query|
@@ -256,7 +277,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_query_sync" do
+  describe ".notify_query_sync" do
     it "notifies query synchronously" do
       expect(described_class.performance_notifier).to receive(:notify_sync)
 
@@ -272,7 +293,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_performance_breakdown" do
+  describe ".notify_performance_breakdown" do
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the performance breakdown" do
         expect(described_class.performance_notifier).to receive(:notify) do |query|
@@ -310,7 +331,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_performance_breakdown_sync" do
+  describe ".notify_performance_breakdown_sync" do
     it "notifies performance breakdown synchronously" do
       expect(described_class.performance_notifier).to receive(:notify_sync)
 
@@ -327,7 +348,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_queue" do
+  describe ".notify_queue" do
     context "when :stash key is not provided" do
       it "doesn't add anything to the stash of the queue" do
         expect(described_class.performance_notifier).to receive(:notify) do |queue|
@@ -358,7 +379,7 @@ RSpec.describe Airbrake do
     end
   end
 
-  describe "#notify_queue_sync" do
+  describe ".notify_queue_sync" do
     it "notifies queue synchronously" do
       expect(described_class.performance_notifier).to receive(:notify_sync)
 
@@ -392,33 +413,47 @@ RSpec.describe Airbrake do
   end
 
   describe ".close" do
-    after { Airbrake.reset }
+    after { described_class.reset }
 
     context "when notice_notifier is defined" do
       it "gets closed" do
-        expect(Airbrake.notice_notifier).to receive(:close)
+        expect(described_class.notice_notifier).to receive(:close)
       end
     end
 
     context "when notice_notifier is undefined" do
       it "doesn't get closed (because it wasn't initialized)" do
-        Airbrake.instance_variable_set(:@notice_notifier, nil)
+        described_class.instance_variable_set(:@notice_notifier, nil)
         expect_any_instance_of(Airbrake::NoticeNotifier).not_to receive(:close)
       end
     end
 
     context "when performance_notifier is defined" do
       it "gets closed" do
-        expect(Airbrake.performance_notifier).to receive(:close)
+        expect(described_class.performance_notifier).to receive(:close)
       end
     end
 
     context "when perforance_notifier is undefined" do
       it "doesn't get closed (because it wasn't initialized)" do
-        Airbrake.instance_variable_set(:@performance_notifier, nil)
+        described_class.instance_variable_set(:@performance_notifier, nil)
         expect_any_instance_of(Airbrake::PerformanceNotifier)
           .not_to receive(:close)
       end
     end
+
+    context "when remote settings are defined" do
+      it "stops polling" do
+        described_class.instance_variable_set(:@remote_settings, remote_settings)
+        expect(remote_settings).to receive(:stop_polling)
+      end
+    end
+
+    context "when remote settings are undefined" do
+      it "doesn't stop polling (because they weren't initialized)" do
+        described_class.instance_variable_set(:@remote_settings, nil)
+        expect(remote_settings).not_to receive(:stop_polling)
+      end
+    end
   end
 end