airbrake-ruby 4.7.0

data/lib/airbrake-ruby/notice_notifier.rb

@@ -0,0 +1,134 @@
+module Airbrake
+  # NoticeNotifier is reponsible for sending notices to Airbrake. It supports
+  # synchronous and asynchronous delivery.
+  #
+  # @see Airbrake::Config The list of options
+  # @since v1.0.0
+  # @api public
+  class NoticeNotifier
+    # @return [Array<Class>] filters to be executed first
+    DEFAULT_FILTERS = [
+      Airbrake::Filters::SystemExitFilter,
+      Airbrake::Filters::GemRootFilter
+
+      # Optional filters (must be included by users):
+      # Airbrake::Filters::ThreadFilter
+    ].freeze
+
+    include Inspectable
+    include Loggable
+
+    def initialize
+      @config = Airbrake::Config.instance
+      @context = {}
+      @filter_chain = FilterChain.new
+      @async_sender = AsyncSender.new
+      @sync_sender = SyncSender.new
+
+      DEFAULT_FILTERS.each { |filter| add_filter(filter.new) }
+
+      add_filter(Airbrake::Filters::ContextFilter.new(@context))
+      add_filter(Airbrake::Filters::ExceptionAttributesFilter.new)
+    end
+
+    # @see Airbrake.notify
+    def notify(exception, params = {}, &block)
+      send_notice(exception, params, default_sender, &block)
+    end
+
+    # @see Airbrake.notify_sync
+    def notify_sync(exception, params = {}, &block)
+      send_notice(exception, params, @sync_sender, &block).value
+    end
+
+    # @see Airbrake.add_filte
+    def add_filter(filter = nil, &block)
+      @filter_chain.add_filter(block_given? ? block : filter)
+    end
+
+    # @see Airbrake.delete_filter
+    def delete_filter(filter_class)
+      @filter_chain.delete_filter(filter_class)
+    end
+
+    # @see Airbrake.build_notice
+    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[:params].merge!(params)
+        exception
+      else
+        Notice.new(convert_to_exception(exception), params.dup)
+      end
+    end
+
+    # @see Airbrake.close
+    def close
+      @async_sender.close
+    end
+
+    # @see Airbrake.configured?
+    def configured?
+      @config.valid?
+    end
+
+    # @see Airbrake.merge_context
+    def merge_context(context)
+      @context.merge!(context)
+    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)
+      promise = @config.check_configuration
+      return promise if promise.rejected?
+
+      notice = build_notice(exception, params)
+      yield notice if block_given?
+      @filter_chain.refine(notice)
+
+      promise = Airbrake::Promise.new
+      return promise.reject("#{notice} was marked as ignored") if notice.ignored?
+
+      sender.send(notice, promise)
+    end
+
+    def default_sender
+      return @async_sender if @async_sender.has_workers?
+
+      logger.warn(
+        "#{LOG_LABEL} falling back to sync delivery because there are no " \
+        "running async workers"
+      )
+      @sync_sender
+    end
+
+    def clean_backtrace
+      caller_copy = Kernel.caller
+      clean_bt = caller_copy.drop_while { |frame| frame.include?('/lib/airbrake') }
+
+      # If true, then it's likely an internal library error. In this case return
+      # at least some backtrace to simplify debugging.
+      return caller_copy if clean_bt.empty?
+      clean_bt
+    end
+  end
+end

data/lib/airbrake-ruby/performance_breakdown.rb

@@ -0,0 +1,46 @@
+module Airbrake
+  # PerformanceBreakdown holds data that shows how much time a request spent
+  # doing certaing subtasks such as (DB querying, view rendering, etc).
+  #
+  # @see Airbrake.notify_breakdown
+  # @api public
+  # @since v4.2.0
+  # rubocop:disable Metrics/BlockLength, Metrics/ParameterLists
+  PerformanceBreakdown = Struct.new(
+    :method, :route, :response_type, :groups, :start_time, :end_time
+  ) do
+    include HashKeyable
+    include Ignorable
+    include Stashable
+
+    def initialize(
+      method:,
+      route:,
+      response_type:,
+      groups:,
+      start_time:,
+      end_time: Time.now
+    )
+      @start_time_utc = TimeTruncate.utc_truncate_minutes(start_time)
+      super(method, route, response_type, groups, start_time, end_time)
+    end
+
+    def destination
+      'routes-breakdowns'
+    end
+
+    def cargo
+      'routes'
+    end
+
+    def to_h
+      {
+        'method' => method,
+        'route' => route,
+        'responseType' => response_type,
+        'time' => @start_time_utc
+      }.delete_if { |_key, val| val.nil? }
+    end
+  end
+  # rubocop:enable Metrics/BlockLength, Metrics/ParameterLists
+end

data/lib/airbrake-ruby/performance_notifier.rb

@@ -0,0 +1,155 @@
+module Airbrake
+  # QueryNotifier aggregates information about SQL queries and periodically sends
+  # collected data to Airbrake.
+  #
+  # @api public
+  # @since v3.2.0
+  class PerformanceNotifier
+    include Inspectable
+    include Loggable
+
+    def initialize
+      @config = Airbrake::Config.instance
+      @flush_period = Airbrake::Config.instance.performance_stats_flush_period
+      @sender = AsyncSender.new(:put)
+      @payload = {}
+      @schedule_flush = nil
+      @mutex = Mutex.new
+      @filter_chain = FilterChain.new
+      @waiting = false
+    end
+
+    # @param [Hash] resource
+    # @see Airbrake.notify_query
+    # @see Airbrake.notify_request
+    def notify(resource)
+      promise = @config.check_configuration
+      return promise if promise.rejected?
+
+      promise = @config.check_performance_options(resource)
+      return promise if promise.rejected?
+
+      @filter_chain.refine(resource)
+      return if resource.ignored?
+
+      @mutex.synchronize do
+        update_payload(resource)
+        @flush_period > 0 ? schedule_flush : send(@payload, promise)
+      end
+
+      promise.resolve(:success)
+    end
+
+    # @see Airbrake.add_performance_filter
+    def add_filter(filter = nil, &block)
+      @filter_chain.add_filter(block_given? ? block : filter)
+    end
+
+    # @see Airbrake.delete_performance_filter
+    def delete_filter(filter_class)
+      @filter_chain.delete_filter(filter_class)
+    end
+
+    def close
+      @mutex.synchronize do
+        @schedule_flush.kill if @schedule_flush
+        @sender.close
+        logger.debug("#{LOG_LABEL} performance notifier closed")
+      end
+    end
+
+    private
+
+    def update_payload(resource)
+      @payload[resource] ||= { total: Airbrake::Stat.new }
+      @payload[resource][:total].increment(resource.start_time, resource.end_time)
+
+      resource.groups.each do |name, ms|
+        @payload[resource][name] ||= Airbrake::Stat.new
+        @payload[resource][name].increment_ms(ms)
+      end
+    end
+
+    def schedule_flush
+      return if @payload.empty?
+
+      if @schedule_flush && @schedule_flush.status == 'sleep' && @waiting
+        begin
+          @schedule_flush.run
+        rescue ThreadError => exception
+          logger.error("#{LOG_LABEL}: error occurred while flushing: #{exception}")
+        end
+      end
+
+      @schedule_flush ||= spawn_timer
+    end
+
+    def spawn_timer
+      Thread.new do
+        loop do
+          if @payload.none?
+            @waiting = true
+            Thread.stop
+            @waiting = false
+          end
+
+          sleep(@flush_period)
+
+          payload = nil
+          @mutex.synchronize do
+            payload = @payload
+            @payload = {}
+          end
+
+          send(payload, Airbrake::Promise.new)
+        end
+      end
+    end
+
+    def send(payload, promise)
+      signature = "#{self.class.name}##{__method__}"
+      raise "#{signature}: payload (#{payload}) cannot be empty. Race?" if payload.none?
+
+      logger.debug { "#{LOG_LABEL} #{signature}: #{payload}" }
+
+      with_grouped_payload(payload) do |resource_hash, destination|
+        url = URI.join(
+          @config.host,
+          "api/v5/projects/#{@config.project_id}/#{destination}"
+        )
+        @sender.send(resource_hash, promise, url)
+      end
+
+      promise
+    end
+
+    def with_grouped_payload(raw_payload)
+      grouped_payload = raw_payload.group_by do |resource, _stats|
+        [resource.cargo, resource.destination]
+      end
+
+      grouped_payload.each do |(cargo, destination), resources|
+        payload = {}
+        payload[cargo] = serialize_resources(resources)
+        payload['environment'] = @config.environment if @config.environment
+
+        yield(payload, destination)
+      end
+    end
+
+    def serialize_resources(resources)
+      resources.map do |resource, stats|
+        resource_hash = resource.to_h.merge!(stats[:total].to_h)
+
+        if resource.groups.any?
+          group_stats = stats.reject { |name, _stat| name == :total }
+          resource_hash['groups'] = group_stats.merge(group_stats) do |_name, stat|
+            stat.to_h
+          end
+        end
+
+        resource_hash
+      end
+    end
+  end
+end

data/lib/airbrake-ruby/promise.rb

@@ -0,0 +1,109 @@
+module Airbrake
+  # Represents a simplified promise object (similar to promises found in
+  # JavaScript), which allows chaining callbacks that are executed when the
+  # promise is either resolved or rejected.
+  #
+  # @see https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise
+  # @see https://github.com/ruby-concurrency/concurrent-ruby/blob/master/lib/concurrent/promise.rb
+  # @since v1.7.0
+  class Promise
+    def initialize
+      @on_resolved = []
+      @on_rejected = []
+      @value = {}
+      @mutex = Mutex.new
+    end
+
+    # Attaches a callback to be executed when the promise is resolved.
+    #
+    # @example
+    #   Airbrake::Promise.new.then { |response| puts response }
+    #   #=> {"id"=>"00054415-8201-e9c6-65d6-fc4d231d2871",
+    #   #    "url"=>"http://localhost/locate/00054415-8201-e9c6-65d6-fc4d231d2871"}
+    #
+    # @yield [response]
+    # @yieldparam response [Hash<String,String>] Contains the `id` & `url` keys
+    # @return [self]
+    def then(&block)
+      @mutex.synchronize do
+        if @value.key?('ok')
+          yield(@value['ok'])
+          return self
+        end
+
+        @on_resolved << block
+      end
+
+      self
+    end
+
+    # Attaches a callback to be executed when the promise is rejected.
+    #
+    # @example
+    #   Airbrake::Promise.new.rescue { |error| raise error }
+    #
+    # @yield [error] The error message from the API
+    # @yieldparam error [String]
+    # @return [self]
+    def rescue(&block)
+      @mutex.synchronize do
+        if @value.key?('error')
+          yield(@value['error'])
+          return self
+        end
+
+        @on_rejected << block
+      end
+
+      self
+    end
+
+    # @example
+    #   Airbrake::Promise.new.resolve('id' => '123')
+    #
+    # @param reason [Object]
+    # @return [self]
+    def resolve(reason = 'resolved')
+      @mutex.synchronize do
+        @value['ok'] = reason
+        @on_resolved.each { |callback| callback.call(reason) }
+      end
+
+      self
+    end
+
+    # @example
+    #   Airbrake::Promise.new.reject('Something went wrong')
+    #
+    # @param reason [String]
+    # @return [self]
+    def reject(reason = 'rejected')
+      @mutex.synchronize do
+        @value['error'] = reason
+        @on_rejected.each { |callback| callback.call(reason) }
+      end
+
+      self
+    end
+
+    # @return [Boolean]
+    def rejected?
+      @value.key?('error')
+    end
+
+    # @return [Boolean]
+    def resolved?
+      @value.key?('ok')
+    end
+
+    # @return [Hash<String,String>] either successful response containing the
+    #   +id+ key or unsuccessful response containing the +error+ key
+    # @note This is a non-blocking call!
+    # @todo Get rid of this method and use an accessor. The resolved guard is
+    #   needed for compatibility but it shouldn't exist in the future
+    def value
+      return @value['ok'] if resolved?
+      @value
+    end
+  end
+end

data/lib/airbrake-ruby/query.rb

@@ -0,0 +1,54 @@
+module Airbrake
+  # Query holds SQL query data that powers SQL query collection.
+  #
+  # @see Airbrake.notify_query
+  # @api public
+  # @since v3.2.0
+  # rubocop:disable Metrics/ParameterLists, Metrics/BlockLength
+  Query = Struct.new(
+    :method, :route, :query, :func, :file, :line, :start_time, :end_time
+  ) do
+    include HashKeyable
+    include Ignorable
+    include Stashable
+
+    def initialize(
+      method:,
+      route:,
+      query:,
+      func: nil,
+      file: nil,
+      line: nil,
+      start_time:,
+      end_time: Time.now
+    )
+      @start_time_utc = TimeTruncate.utc_truncate_minutes(start_time)
+      super(method, route, query, func, file, line, start_time, end_time)
+    end
+
+    def destination
+      'queries-stats'
+    end
+
+    def cargo
+      'queries'
+    end
+
+    def groups
+      {}
+    end
+
+    def to_h
+      {
+        'method' => method,
+        'route' => route,
+        'query' => query,
+        'time' => @start_time_utc,
+        'function' => func,
+        'file' => file,
+        'line' => line
+      }.delete_if { |_key, val| val.nil? }
+    end
+    # rubocop:enable Metrics/ParameterLists, Metrics/BlockLength
+  end
+end