airbrake-ruby 4.8.0

data/lib/airbrake-ruby/thread_pool.rb

@@ -0,0 +1,128 @@
+module Airbrake
+  # ThreadPool implements a simple thread pool that can configure the number of
+  # worker threads and the size of the queue to process.
+  #
+  # @example
+  #   # 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(
+  #     worker_size: 5,
+  #     queue_size: 100,
+  #     block: proc { |message| print "ECHO: #{message}..."}
+  #   )
+  #
+  #   # Send work.
+  #   10.times { |i| thread_pool << i }
+  #   #=> ECHO: 0...ECHO: 1...ECHO: 2...
+  #
+  # @api private
+  # @since v4.6.1
+  class ThreadPool
+    include Loggable
+
+    # @return [ThreadGroup] the list of workers
+    # @note This is exposed for eaiser unit testing
+    attr_reader :workers
+
+    def initialize(worker_size:, queue_size:, block:)
+      @worker_size = worker_size
+      @queue_size = queue_size
+      @block = block
+
+      @queue = SizedQueue.new(queue_size)
+      @workers = ThreadGroup.new
+      @mutex = Mutex.new
+      @pid = nil
+      @closed = false
+
+      has_workers?
+    end
+
+    # Adds a new message to the thread pool. Rejects messages if the queue is at
+    # its capacity.
+    #
+    # @param [Object] message The message that gets passed to the block
+    # @return [Boolean] true if the message was successfully sent to the pool,
+    #   false if the queue is full
+    def <<(message)
+      return false if backlog >= @queue_size
+      @queue << message
+      true
+    end
+
+    # @return [Integer] how big the queue is at the moment
+    def backlog
+      @queue.size
+    end
+
+    # Checks if a thread pool has any workers. A thread pool doesn't have any
+    # workers only in two cases: when it was closed or when all workers
+    # crashed. An *active* thread pool doesn't have any workers only when
+    # something went wrong.
+    #
+    # Workers are expected to crash when you +fork+ the process the workers are
+    # living in. In this case we detect a +fork+ and try to revive them here.
+    #
+    # Another possible scenario that crashes workers is when you close the
+    # instance on +at_exit+, but some other +at_exit+ hook prevents the process
+    # from exiting.
+    #
+    # @return [Boolean] true if an instance wasn't closed, but has no workers
+    # @see https://goo.gl/oydz8h Example of at_exit that prevents exit
+    def has_workers?
+      @mutex.synchronize do
+        return false if @closed
+
+        if @pid != Process.pid && @workers.list.empty?
+          @pid = Process.pid
+          spawn_workers
+        end
+
+        !@closed && @workers.list.any?
+      end
+    end
+
+    # Closes the thread pool making it a no-op (it shut downs all worker
+    # threads). Before closing, waits on all unprocessed tasks to be processed.
+    #
+    # @return [void]
+    # @raise [Airbrake::Error] when invoked more than one time
+    def close
+      threads = @mutex.synchronize do
+        raise Airbrake::Error, 'this thread pool is closed already' if @closed
+
+        unless @queue.empty?
+          msg = "#{LOG_LABEL} waiting to process #{@queue.size} task(s)..."
+          logger.debug(msg + ' (Ctrl-C to abort)')
+        end
+
+        @worker_size.times { @queue << :stop }
+        @closed = true
+        @workers.list.dup
+      end
+
+      threads.each(&:join)
+      logger.debug("#{LOG_LABEL} thread pool closed")
+    end
+
+    def closed?
+      @closed
+    end
+
+    def spawn_workers
+      @worker_size.times { @workers.add(spawn_worker) }
+      @workers.enclose
+    end
+
+    private
+
+    def spawn_worker
+      Thread.new do
+        while (message = @queue.pop)
+          break if message == :stop
+          @block.call(message)
+        end
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/time_truncate.rb

@@ -0,0 +1,17 @@
+module Airbrake
+  # TimeTruncate contains methods for truncating time.
+  #
+  # @api private
+  # @since v3.2.0
+  module TimeTruncate
+    # Truncate +time+ to floor minute and turn it into an RFC3339 timestamp.
+    #
+    # @param [Time] time
+    # @return [String]
+    def self.utc_truncate_minutes(time)
+      tm = time.getutc
+
+      Time.utc(tm.year, tm.month, tm.day, tm.hour, tm.min).to_datetime.rfc3339
+    end
+  end
+end

data/lib/airbrake-ruby/timed_trace.rb

@@ -0,0 +1,58 @@
+module Airbrake
+  # TimedTrace represents a chunk of code performance of which was measured and
+  # stored under a label. The chunk is called a "span".
+  #
+  # @example
+  #   timed_trace = TimedTrace.new
+  #   timed_trace.span('http request') do
+  #     http.get('example.com')
+  #   end
+  #   timed_trace.spans #=> { 'http request' => 0.123 }
+  #
+  # @api public
+  # @since v4.3.0
+  class TimedTrace
+    # @param [String] label
+    # @return [Airbrake::TimedTrace]
+    def self.span(label, &block)
+      new.tap { |timed_trace| timed_trace.span(label, &block) }
+    end
+
+    def initialize
+      @spans = {}
+    end
+
+    # @param [String] label
+    # @return [Boolean]
+    def span(label)
+      start_span(label)
+      yield
+      stop_span(label)
+    end
+
+    # @param [String] label
+    # @return [Boolean]
+    def start_span(label)
+      return false if @spans.key?(label)
+
+      @spans[label] = Airbrake::Benchmark.new
+      true
+    end
+
+    # @param [String] label
+    # @return [Boolean]
+    def stop_span(label)
+      return false unless @spans.key?(label)
+
+      @spans[label].stop
+      true
+    end
+
+    # @return [Hash<String=>Float>]
+    def spans
+      @spans.each_with_object({}) do |(label, benchmark), new_spans|
+        new_spans[label] = benchmark.duration
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/truncator.rb

@@ -0,0 +1,115 @@
+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.
+  #
+  # @api private
+  # @since v1.0.0
+  class Truncator
+    # @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 = 'utf-16'.freeze
+
+    # @return [String] what to append when something is a circular reference
+    CIRCULAR = '[Circular]'.freeze
+
+    # @return [String] what to append when something is truncated
+    TRUNCATED = '[Truncated]'.freeze
+
+    # @return [Array<Class>] The types that can contain references to itself
+    CIRCULAR_TYPES = [Array, Hash, Set].freeze
+
+    # @param [Integer] max_size maximum size of hashes, arrays and strings
+    def initialize(max_size)
+      @max_size = max_size
+    end
+
+    # Performs deep truncation of arrays, hashes, sets & strings. Uses a
+    # placeholder for recursive objects (`[Circular]`).
+    #
+    # @param [Object] object The object to truncate
+    # @param [Set] seen The cache that helps to detect recursion
+    # @return [Object] truncated object
+    def truncate(object, seen = Set.new)
+      if seen.include?(object.object_id)
+        return CIRCULAR if CIRCULAR_TYPES.any? { |t| object.is_a?(t) }
+        return object
+      end
+      truncate_object(object, seen << object.object_id)
+    end
+
+    # Reduces maximum allowed size of hashes, arrays, sets & strings by half.
+    # @return [Integer] current +max_size+ value
+    def reduce_max_size
+      @max_size /= 2
+    end
+
+    private
+
+    def truncate_object(object, seen)
+      case object
+      when Hash then truncate_hash(object, seen)
+      when Array then truncate_array(object, seen)
+      when Set then truncate_set(object, seen)
+      when String then truncate_string(object)
+      when Numeric, TrueClass, FalseClass, Symbol, NilClass then object
+      else
+        truncate_string(stringify_object(object))
+      end
+    end
+
+    def truncate_string(str)
+      fixed_str = replace_invalid_characters(str)
+      return fixed_str if fixed_str.length <= @max_size
+      (fixed_str.slice(0, @max_size) + TRUNCATED).freeze
+    end
+
+    def stringify_object(object)
+      object.to_json
+    rescue *Notice::JSON_EXCEPTIONS
+      object.to_s
+    end
+
+    def truncate_hash(hash, seen)
+      truncated_hash = {}
+      hash.each_with_index do |(key, val), idx|
+        break if idx + 1 > @max_size
+        truncated_hash[key] = truncate(val, seen)
+      end
+
+      truncated_hash.freeze
+    end
+
+    def truncate_array(array, seen)
+      array.slice(0, @max_size).map! { |elem| truncate(elem, seen) }.freeze
+    end
+
+    def truncate_set(set, seen)
+      truncated_set = Set.new
+
+      set.each do |elem|
+        truncated_set << truncate(elem, seen)
+        break if truncated_set.size >= @max_size
+      end
+
+      truncated_set.freeze
+    end
+
+    # Replaces invalid characters in a string with arbitrary encoding.
+    #
+    # @param [String] str The string to replace characters
+    # @return [String] a UTF-8 encoded string
+    # @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?
+
+      temp_str = str.dup
+      temp_str.encode!(TEMP_ENCODING, ENCODING_OPTIONS) if utf8_string
+      temp_str.encode!('utf-8', ENCODING_OPTIONS)
+    end
+  end
+end

data/lib/airbrake-ruby/version.rb

@@ -0,0 +1,6 @@
+# We use Semantic Versioning v2.0.0
+# More information: http://semver.org/
+module Airbrake
+  # @return [String] the library version
+  AIRBRAKE_RUBY_VERSION = '4.8.0'.freeze
+end

data/spec/airbrake_spec.rb

@@ -0,0 +1,324 @@
+RSpec.describe Airbrake do
+  it "gets initialized with a performance notifier" do
+    expect(described_class.performance_notifier).not_to be_nil
+  end
+
+  it "gets initialized with a notice notifier" do
+    expect(described_class.notice_notifier).not_to be_nil
+  end
+
+  it "gets initialized with a deploy notifier" do
+    expect(described_class.deploy_notifier).not_to be_nil
+  end
+
+  describe ".configure" do
+    before do
+      Airbrake::Config.instance = Airbrake::Config.new
+      described_class.reset
+    end
+
+    after { described_class.reset }
+
+    it "yields the config" do
+      expect do |b|
+        begin
+          described_class.configure(&b)
+        rescue Airbrake::Error
+          nil
+        end
+      end.to yield_with_args(Airbrake::Config)
+    end
+
+    it "sets logger to Airbrake::Loggable" do
+      logger = Logger.new(File::NULL)
+      described_class.configure do |c|
+        c.project_id = 1
+        c.project_key = '123'
+        c.logger = logger
+      end
+
+      expect(Airbrake::Loggable.instance).to eql(logger)
+    end
+
+    it "makes Airbrake configured" do
+      expect(described_class).not_to be_configured
+
+      described_class.configure do |c|
+        c.project_id = 1
+        c.project_key = '2'
+      end
+
+      expect(described_class).to be_configured
+    end
+
+    context "when a notifier was configured" do
+      before do
+        expect(described_class).to receive(:configured?).and_return(true)
+      end
+
+      it "closes previously configured notice notifier" do
+        expect(described_class).to receive(:close)
+        described_class.configure {}
+      end
+    end
+
+    context "when a notifier wasn't configured" do
+      before do
+        expect(described_class).to receive(:configured?).and_return(false)
+      end
+
+      it "doesn't close previously configured notice notifier" do
+        expect(described_class).not_to receive(:close)
+        described_class.configure {}
+      end
+    end
+
+    context "when called multiple times" do
+      it "doesn't overwrite performance notifier" do
+        described_class.configure {}
+        performance_notifier = described_class.performance_notifier
+
+        described_class.configure {}
+        expect(described_class.performance_notifier).to eql(performance_notifier)
+      end
+
+      it "doesn't overwrite notice notifier" do
+        described_class.configure {}
+        notice_notifier = described_class.notice_notifier
+
+        described_class.configure {}
+        expect(described_class.notice_notifier).to eql(notice_notifier)
+      end
+
+      it "doesn't overwrite deploy notifier" do
+        described_class.configure {}
+        deploy_notifier = described_class.deploy_notifier
+
+        described_class.configure {}
+        expect(described_class.deploy_notifier).to eql(deploy_notifier)
+      end
+    end
+
+    context "when blacklist_keys gets configured" do
+      before { allow(Airbrake.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] }
+      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] }
+      end
+    end
+
+    context "when whitelist_keys gets configured" do
+      before { allow(Airbrake.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] }
+      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] }
+      end
+    end
+
+    context "when root_directory gets configured" do
+      before { allow(Airbrake.notice_notifier).to receive(:add_filter) }
+
+      it "adds root directory filter" do
+        expect(Airbrake.notice_notifier).to receive(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::RootDirectoryFilter))
+        described_class.configure { |c| c.root_directory = '/my/path' }
+      end
+
+      it "initializes root directory filter with specified path" do
+        expect(Airbrake::Filters::RootDirectoryFilter)
+          .to receive(:new).with('/my/path')
+        described_class.configure { |c| c.root_directory = '/my/path' }
+      end
+
+      it "adds git revision filter" do
+        expect(Airbrake.notice_notifier).to receive(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitRevisionFilter))
+        described_class.configure { |c| c.root_directory = '/my/path' }
+      end
+
+      it "initializes git revision filter with correct root directory" do
+        expect(Airbrake::Filters::GitRevisionFilter)
+          .to receive(:new).with('/my/path')
+        described_class.configure { |c| c.root_directory = '/my/path' }
+      end
+
+      it "adds git repository filter" do
+        expect(Airbrake.notice_notifier).to receive(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitRepositoryFilter))
+        described_class.configure { |c| c.root_directory = '/my/path' }
+      end
+
+      it "initializes git repository filter with correct root directory" do
+        expect(Airbrake::Filters::GitRepositoryFilter)
+          .to receive(:new).with('/my/path')
+        described_class.configure { |c| c.root_directory = '/my/path' }
+      end
+
+      it "adds git last checkout filter" do
+        expect(Airbrake.notice_notifier).to receive(:add_filter)
+          .with(an_instance_of(Airbrake::Filters::GitLastCheckoutFilter))
+        described_class.configure { |c| c.root_directory = '/my/path' }
+      end
+
+      it "initializes git last checkout filter with correct root directory" do
+        expect(Airbrake::Filters::GitLastCheckoutFilter)
+          .to receive(:new).with('/my/path')
+        described_class.configure { |c| c.root_directory = '/my/path' }
+      end
+    end
+  end
+
+  describe "#reset" do
+    context "when Airbrake was previously configured" do
+      before do
+        expect(described_class).to receive(:configured?).and_return(true)
+      end
+
+      it "closes notice notifier" do
+        expect(described_class).to receive(:close)
+        subject.reset
+      end
+    end
+  end
+
+  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|
+          expect(request.stash).to be_empty
+        end
+
+        described_class.notify_request(
+          method: 'GET',
+          route: '/',
+          status_code: 200,
+          start_time: Time.now
+        )
+      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',
+            route: '/',
+            status_code: 200,
+            start_time: Time.now
+          },
+          request_id: 1
+        )
+      end
+    end
+  end
+
+  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|
+          expect(query.stash).to be_empty
+        end
+
+        described_class.notify_query(
+          method: 'GET',
+          route: '/',
+          query: '',
+          start_time: Time.now
+        )
+      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',
+            route: '/',
+            query: '',
+            start_time: Time.now
+          },
+          request_id: 1
+        )
+      end
+    end
+  end
+
+  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|
+          expect(query.stash).to be_empty
+        end
+
+        described_class.notify_query(
+          method: 'GET',
+          route: '/',
+          query: '',
+          start_time: Time.now
+        )
+      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)
+        end
+
+        described_class.notify_performance_breakdown(
+          {
+            method: 'GET',
+            route: '/',
+            response_type: :html,
+            groups: {},
+            start_time: Time.now
+          },
+          request_id: 1
+        )
+      end
+    end
+  end
+
+  describe ".performance_notifier" do
+    it "returns a performance notifier" do
+      expect(described_class.performance_notifier)
+        .to be_an(Airbrake::PerformanceNotifier)
+    end
+  end
+
+  describe ".notice_notifier" do
+    it "returns a notice notifier" do
+      expect(described_class.notice_notifier).to be_an(Airbrake::NoticeNotifier)
+    end
+  end
+
+  describe ".deploy_notifier" do
+    it "returns a deploy notifier" do
+      expect(described_class.deploy_notifier).to be_an(Airbrake::DeployNotifier)
+    end
+  end
+end