airbrake-ruby 5.2.0-java → 6.0.2-java

data/lib/airbrake-ruby/thread_pool.rb

@@ -6,6 +6,7 @@ module Airbrake
   #   # Initialize a new thread pool with 5 workers and a queue size of 100. Set
   #   # the block to be run concurrently.
   #   thread_pool = ThreadPool.new(
+  #     name: 'performance-notifier',
   #     worker_size: 5,
   #     queue_size: 100,
   #     block: proc { |message| print "ECHO: #{message}..."}
@@ -24,7 +25,8 @@ module Airbrake
     # @note This is exposed for eaiser unit testing
     attr_reader :workers
 
-    def initialize(worker_size:, queue_size:, block:)
+    def initialize(worker_size:, queue_size:, block:, name: nil)
+      @name = name
       @worker_size = worker_size
       @queue_size = queue_size
       @block = block
@@ -46,11 +48,11 @@ module Airbrake
     #   false if the queue is full
     def <<(message)
       if backlog >= @queue_size
-        logger.error(
+        logger.info do
           "#{LOG_LABEL} ThreadPool has reached its capacity of " \
           "#{@queue_size} and the following message will not be " \
-          "processed: #{message.inspect}",
-        )
+          "processed: #{message.inspect}"
+        end
         return false
       end
 
@@ -102,7 +104,7 @@ module Airbrake
 
         unless @queue.empty?
           msg = "#{LOG_LABEL} waiting to process #{@queue.size} task(s)..."
-          logger.debug(msg + ' (Ctrl-C to abort)')
+          logger.debug("#{msg} (Ctrl-C to abort)")
         end
 
         @worker_size.times { @queue << :stop }
@@ -111,7 +113,7 @@ module Airbrake
       end
 
       threads.each(&:join)
-      logger.debug("#{LOG_LABEL} thread pool closed")
+      logger.debug("#{LOG_LABEL} #{@name} thread pool closed")
     end
 
     def closed?

data/lib/airbrake-ruby/time_truncate.rb

@@ -6,10 +6,10 @@ module Airbrake
   module TimeTruncate
     # Truncate +time+ to floor minute and turn it into an RFC3339 timestamp.
     #
-    # @param [Time] time
+    # @param [Time, Integer, Float] time
     # @return [String]
     def self.utc_truncate_minutes(time)
-      tm = time.getutc
+      tm = Time.at(time).getutc
 
       Time.utc(tm.year, tm.month, tm.day, tm.hour, tm.min).to_datetime.rfc3339
     end

data/lib/airbrake-ruby/timed_trace.rb

@@ -50,9 +50,7 @@ module Airbrake
 
     # @return [Hash<String=>Float>]
     def spans
-      @spans.each_with_object({}) do |(label, benchmark), new_spans|
-        new_spans[label] = benchmark.duration
-      end
+      @spans.transform_values(&:duration)
     end
   end
 end

data/lib/airbrake-ruby/version.rb

@@ -3,7 +3,7 @@
 module Airbrake
   # @return [String] the library version
   # @api public
-  AIRBRAKE_RUBY_VERSION = '5.2.0'.freeze
+  AIRBRAKE_RUBY_VERSION = '6.0.2'.freeze
 
   # @return [Hash{Symbol=>String}] the information about the notifier library
   # @since v5.0.0

data/lib/airbrake-ruby.rb

@@ -58,6 +58,7 @@ require 'airbrake-ruby/benchmark'
 require 'airbrake-ruby/monotonic_time'
 require 'airbrake-ruby/timed_trace'
 require 'airbrake-ruby/queue'
+require 'airbrake-ruby/context'
 
 # Airbrake is a thin wrapper around instances of the notifier classes (such as
 # notice, performance & deploy notifiers). It creates a way to access them via a
@@ -273,7 +274,7 @@ module Airbrake
     #   Airbrake.notify('App crashed!') #=> raises Airbrake::Error
     #
     # @return [nil]
-    # rubocop:disable Style/IfUnlessModifier, Metrics/CyclomaticComplexity
+    # rubocop:disable Style/IfUnlessModifier
     def close
       if defined?(@notice_notifier) && @notice_notifier
         @notice_notifier.close
@@ -289,7 +290,7 @@ module Airbrake
 
       nil
     end
-    # rubocop:enable Style/IfUnlessModifier, Metrics/CyclomaticComplexity
+    # rubocop:enable Style/IfUnlessModifier
 
     # Pings the Airbrake Deploy API endpoint about the occurred deploy.
     #
@@ -363,23 +364,14 @@ module Airbrake
     #     method: 'POST',
     #     route: '/thing/:id/create',
     #     status_code: 200,
-    #     func: 'do_stuff',
-    #     file: 'app/models/foo.rb',
-    #     line: 452,
     #     timing: 123.45 # ms
     #   )
     #
     # @param [Hash{Symbol=>Object}] request_info
     # @option request_info [String] :method The HTTP method that was invoked
     # @option request_info [String] :route The route that was invoked
-    # @option request_info [Integer] :status_code The respose code that the
+    # @option request_info [Integer] :status_code The response code that the
     #   route returned
-    # @option request_info [String] :func The function that called the query
-    #   (optional)
-    # @option request_info [String] :file The file that has the function that
-    #   called the query (optional)
-    # @option request_info [Integer] :line The line that executes the query
-    #   (optional)
     # @option request_info [Float] :timing  How much time it took to process the
     #   request (in ms)
     # @param [Hash] stash What needs to be appeneded to the stash, so it's
@@ -414,6 +406,9 @@ module Airbrake
     #     method: 'GET',
     #     route: '/things',
     #     query: 'SELECT * FROM things',
+    #     func: 'do_stuff',
+    #     file: 'app/models/foo.rb',
+    #     line: 452,
     #     timing: 123.45 # ms
     #   )
     #
@@ -423,6 +418,12 @@ module Airbrake
     # @option query_info [String] :route The route that triggered this SQL
     #    query (optional)
     # @option query_info [String] :query The query that was executed
+    # @option request_info [String] :func The function that called the query
+    #   (optional)
+    # @option request_info [String] :file The file that has the function that
+    #   called the query (optional)
+    # @option request_info [Integer] :line The line that executes the query
+    #   (optional)
     # @option query_info [Float] :timing How much time it took to process the
     #   query (in ms)
     # @param [Hash] stash What needs to be appeneded to the stash, so it's
@@ -450,7 +451,7 @@ module Airbrake
     # Increments performance breakdown statistics of a certain route.
     #
     # @example
-    #   Airbrake.notify_request(
+    #   Airbrake.notify_performance_breakdown(
     #     method: 'POST',
     #     route: '/thing/:id/create',
     #     response_type: 'json',
@@ -522,24 +523,24 @@ module Airbrake
       performance_notifier.notify_sync(queue)
     end
 
-    # Runs a callback before {.notify_request} or {.notify_query} kicks in. This
-    # is useful if you want to ignore specific resources or filter the data the
-    # resource contains.
+    # Runs a callback before {.notify_request}, {.notify_query}, {.notify_queue}
+    # or {.notify_performance_breakdown} kicks in. This is useful if you want to
+    # ignore specific metrics or filter the data the metric contains.
     #
-    # @example Ignore all resources
+    # @example Ignore all metrics
     #   Airbrake.add_performance_filter(&:ignore!)
     # @example Filter sensitive data
-    #   Airbrake.add_performance_filter do |resource|
-    #     case resource
+    #   Airbrake.add_performance_filter do |metric|
+    #     case metric
     #     when Airbrake::Query
-    #       resource.route = '[Filtered]'
+    #       metric.route = '[Filtered]'
     #     when Airbrake::Request
-    #       resource.query = '[Filtered]'
+    #       metric.query = '[Filtered]'
     #     end
     #   end
     # @example Filter with help of a class
     #   class MyFilter
-    #     def call(resource)
+    #     def call(metric)
     #       # ...
     #     end
     #   end
@@ -547,7 +548,7 @@ module Airbrake
     #   Airbrake.add_performance_filter(MyFilter.new)
     #
     # @param [#call] filter The filter object
-    # @yield [resource] The resource to filter
+    # @yield [metric] The metric to filter
     # @yieldparam [Airbrake::Query, Airbrake::Request]
     # @yieldreturn [void]
     # @return [void]

data/spec/airbrake_spec.rb

@@ -30,11 +30,9 @@ RSpec.describe Airbrake do
 
     it "yields the config" do
       expect do |b|
-        begin
-          described_class.configure(&b)
-        rescue Airbrake::Error
-          nil
-        end
+        described_class.configure(&b)
+      rescue Airbrake::Error
+        nil
       end.to yield_with_args(Airbrake::Config)
     end
 
@@ -62,26 +60,26 @@ RSpec.describe Airbrake do
 
     context "when called multiple times" do
       it "doesn't overwrite performance notifier" do
-        described_class.configure {}
+        described_class.configure { anything }
         performance_notifier = described_class.performance_notifier
 
-        described_class.configure {}
+        described_class.configure { anything }
         expect(described_class.performance_notifier).to eql(performance_notifier)
       end
 
       it "doesn't overwrite notice notifier" do
-        described_class.configure {}
+        described_class.configure { anything }
         notice_notifier = described_class.notice_notifier
 
-        described_class.configure {}
+        described_class.configure { anything }
         expect(described_class.notice_notifier).to eql(notice_notifier)
       end
 
       it "doesn't overwrite deploy notifier" do
-        described_class.configure {}
+        described_class.configure { anything }
         deploy_notifier = described_class.deploy_notifier
 
-        described_class.configure {}
+        described_class.configure { anything }
         expect(described_class.deploy_notifier).to eql(deploy_notifier)
       end
 
@@ -91,20 +89,24 @@ RSpec.describe Airbrake do
           c.project_key = '2'
         end
 
-        expect(described_class.notice_notifier).not_to receive(:add_filter)
-        10.times { described_class.configure {} }
+        allow(described_class.notice_notifier).to receive(:add_filter)
+
+        10.times { described_class.configure { anything } }
+
+        expect(described_class.notice_notifier).not_to have_received(:add_filter)
       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
+
+        expect(described_class.notice_notifier).to have_received(:add_filter).with(
+          an_instance_of(Airbrake::Filters::RootDirectoryFilter),
+        )
       end
     end
 
@@ -112,14 +114,21 @@ RSpec.describe Airbrake do
       before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds blocklist filter" do
-        expect(described_class.notice_notifier).to receive(:add_filter)
-          .with(an_instance_of(Airbrake::Filters::KeysBlocklist))
+        allow(described_class.notice_notifier).to receive(:add_filter)
+
         described_class.configure { |c| c.blocklist_keys = %w[password] }
+
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::KeysBlocklist))
       end
 
       it "initializes blocklist with specified parameters" do
-        expect(Airbrake::Filters::KeysBlocklist).to receive(:new).with(%w[password])
+        allow(Airbrake::Filters::KeysBlocklist).to receive(:new)
+
         described_class.configure { |c| c.blocklist_keys = %w[password] }
+
+        expect(Airbrake::Filters::KeysBlocklist)
+          .to have_received(:new).with(%w[password])
       end
     end
 
@@ -127,14 +136,17 @@ RSpec.describe Airbrake do
       before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       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] }
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::KeysAllowlist))
       end
 
       it "initializes allowlist with specified parameters" do
-        expect(Airbrake::Filters::KeysAllowlist).to receive(:new).with(%w[banana])
+        allow(Airbrake::Filters::KeysAllowlist).to receive(:new)
+
         described_class.configure { |c| c.allowlist_keys = %w[banana] }
+        expect(Airbrake::Filters::KeysAllowlist)
+          .to have_received(:new).with(%w[banana])
       end
     end
 
@@ -142,77 +154,90 @@ RSpec.describe Airbrake do
       before { allow(described_class.notice_notifier).to receive(:add_filter) }
 
       it "adds root directory filter" do
-        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' }
+
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::RootDirectoryFilter))
       end
 
       it "initializes root directory filter with specified path" do
-        expect(Airbrake::Filters::RootDirectoryFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::RootDirectoryFilter).to receive(:new)
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::RootDirectoryFilter)
+          .to have_received(:new).with('/my/path')
       end
 
       it "adds git revision filter" do
-        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' }
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitRevisionFilter))
       end
 
       it "initializes git revision filter with correct root directory" do
-        expect(Airbrake::Filters::GitRevisionFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::GitRevisionFilter).to receive(:new)
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::GitRevisionFilter)
+          .to have_received(:new).with('/my/path')
       end
 
       it "adds git repository filter" do
-        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' }
+
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitRepositoryFilter))
       end
 
       it "initializes git repository filter with correct root directory" do
-        expect(Airbrake::Filters::GitRepositoryFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::GitRepositoryFilter).to receive(:new)
+
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::GitRepositoryFilter)
+          .to have_received(:new).with('/my/path')
       end
 
       it "adds git last checkout filter" do
-        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' }
+        expect(described_class.notice_notifier).to have_received(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitLastCheckoutFilter))
       end
 
       it "initializes git last checkout filter with correct root directory" do
-        expect(Airbrake::Filters::GitLastCheckoutFilter)
-          .to receive(:new).with('/my/path')
+        allow(Airbrake::Filters::GitLastCheckoutFilter).to receive(:new)
         described_class.configure { |c| c.root_directory = '/my/path' }
+
+        expect(Airbrake::Filters::GitLastCheckoutFilter)
+          .to have_received(:new).with('/my/path')
       end
     end
   end
 
   describe ".notify_request" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     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|
-          expect(request.stash).to be_empty
-        end
-
         described_class.notify_request(
           method: 'GET',
           route: '/',
           status_code: 200,
           timing: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |request|
+          expect(request.stash).to be_empty
+        end
       end
     end
 
     context "when :stash key is provided" do
       it "adds the value as the stash of the request" do
-        expect(described_class.performance_notifier).to receive(:notify) do |request|
-          expect(request.stash).to eq(request_id: 1)
-        end
-
         described_class.notify_request(
           {
             method: 'GET',
@@ -222,13 +247,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |request|
+          expect(request.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
   describe ".notify_request_sync" do
     it "notifies request synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_request_sync(
         {
@@ -239,31 +270,35 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
   describe ".notify_query" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     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|
-          expect(query.stash).to be_empty
-        end
-
         described_class.notify_query(
           method: 'GET',
           route: '/',
           query: '',
           timing: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |query|
+          expect(query.stash).to be_empty
+        end
       end
     end
 
     context "when :stash key is provided" do
       it "adds the value as the stash of the query" do
-        expect(described_class.performance_notifier).to receive(:notify) do |query|
-          expect(query.stash).to eq(request_id: 1)
-        end
-
         described_class.notify_query(
           {
             method: 'GET',
@@ -273,13 +308,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |query|
+          expect(query.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
   describe ".notify_query_sync" do
     it "notifies query synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_query_sync(
         {
@@ -290,33 +331,35 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
   describe ".notify_performance_breakdown" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     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|
-          expect(query.stash).to be_empty
-        end
-
         described_class.notify_query(
           method: 'GET',
           route: '/',
           query: '',
           timing: 1,
         )
-      end
-    end
 
-    context "when :stash key is provided" do
-      it "adds the value as the stash of the performance breakdown" do
         expect(
           described_class.performance_notifier,
-        ).to receive(:notify) do |performance_breakdown|
-          expect(performance_breakdown.stash).to eq(request_id: 1)
+        ).to have_received(:notify) do |query|
+          expect(query.stash).to be_empty
         end
+      end
+    end
 
+    context "when :stash key is provided" do
+      it "adds the value as the stash of the performance breakdown" do
         described_class.notify_performance_breakdown(
           {
             method: 'GET',
@@ -327,13 +370,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |performance_breakdown|
+          expect(performance_breakdown.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
   describe ".notify_performance_breakdown_sync" do
     it "notifies performance breakdown synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_performance_breakdown_sync(
         {
@@ -345,29 +394,33 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
   describe ".notify_queue" do
+    before do
+      allow(described_class.performance_notifier).to receive(:notify)
+    end
+
     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|
-          expect(queue.stash).to be_empty
-        end
-
         described_class.notify_queue(
           queue: 'bananas',
           error_count: 10,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |queue|
+          expect(queue.stash).to be_empty
+        end
       end
     end
 
     context "when :stash key is provided" do
       it "adds the value as the stash of the queue" do
-        expect(described_class.performance_notifier).to receive(:notify) do |queue|
-          expect(queue.stash).to eq(request_id: 1)
-        end
-
         described_class.notify_queue(
           {
             queue: 'bananas',
@@ -375,13 +428,19 @@ RSpec.describe Airbrake do
           },
           request_id: 1,
         )
+
+        expect(
+          described_class.performance_notifier,
+        ).to have_received(:notify) do |queue|
+          expect(queue.stash).to eq(request_id: 1)
+        end
       end
     end
   end
 
   describe ".notify_queue_sync" do
     it "notifies queue synchronously" do
-      expect(described_class.performance_notifier).to receive(:notify_sync)
+      allow(described_class.performance_notifier).to receive(:notify_sync)
 
       described_class.notify_queue_sync(
         {
@@ -390,6 +449,8 @@ RSpec.describe Airbrake do
         },
         request_id: 1,
       )
+
+      expect(described_class.performance_notifier).to have_received(:notify_sync)
     end
   end
 
@@ -412,6 +473,7 @@ RSpec.describe Airbrake do
     end
   end
 
+  # rubocop:disable RSpec/MessageSpies
   describe ".close" do
     after { described_class.reset }
 
@@ -456,4 +518,5 @@ RSpec.describe Airbrake do
       end
     end
   end
+  # rubocop:enable RSpec/MessageSpies
 end