airbrake-ruby 4.15.0 → 6.0.2

data/lib/airbrake-ruby/filters/sql_filter.rb

@@ -23,23 +23,23 @@ module Airbrake
 
       # @return [Hash{Symbol=>Regexp}] matchers for certain features of SQL
       ALL_FEATURES = {
-        # rubocop:disable Metrics/LineLength
+        # rubocop:disable Layout/LineLength
         single_quotes: /'(?:[^']|'')*?(?:\\'.*|'(?!'))/,
         double_quotes: /"(?:[^"]|"")*?(?:\\".*|"(?!"))/,
         dollar_quotes: /(\$(?!\d)[^$]*?\$).*?(?:\1|$)/,
-        uuids: /\{?(?:[0-9a-fA-F]\-*){32}\}?/,
+        uuids: /\{?(?:[0-9a-fA-F]-*){32}\}?/,
         numeric_literals: /\b-?(?:[0-9]+\.)?[0-9]+([eE][+-]?[0-9]+)?\b/,
         boolean_literals: /\b(?:true|false|null)\b/i,
         hexadecimal_literals: /0x[0-9a-fA-F]+/,
         comments: /(?:#|--).*?(?=\r|\n|$)/i,
         multi_line_comments: %r{/\*(?:[^/]|/[^*])*?(?:\*/|/\*.*)},
-        oracle_quoted_strings: /q'\[.*?(?:\]'|$)|q'\{.*?(?:\}'|$)|q'\<.*?(?:\>'|$)|q'\(.*?(?:\)'|$)/
-        # rubocop:enable Metrics/LineLength
+        oracle_quoted_strings: /q'\[.*?(?:\]'|$)|q'\{.*?(?:\}'|$)|q'<.*?(?:>'|$)|q'\(.*?(?:\)'|$)/,
+        # rubocop:enable Layout/LineLength
       }.freeze
 
       # @return [Regexp] the regexp that is applied after the feature regexps
       #   were used
-      POST_FILTER = /(?<=[values|in ]\().+(?=\))/i
+      POST_FILTER = /(?<=[values|in ]\().+(?=\))/i.freeze
 
       # @return [Hash{Symbol=>Array<Symbol>}] a set of features that corresponds
       #   to a certain dialect
@@ -108,20 +108,20 @@ module Airbrake
         @regexp = Regexp.union(features)
       end
 
-      # @param [Airbrake::Query] resource
-      def call(resource)
-        return unless resource.respond_to?(:query)
+      # @param [Airbrake::Query] metric
+      def call(metric)
+        return unless metric.respond_to?(:query)
 
-        query = resource.query
+        query = metric.query
         if IGNORED_QUERIES.any? { |q| q =~ query }
-          resource.ignore!
+          metric.ignore!
           return
         end
 
         q = query.gsub(@regexp, FILTERED)
         q.gsub!(POST_FILTER, FILTERED) if q =~ POST_FILTER
         q = ERROR_MSG if UNMATCHED_PAIR[@dialect] =~ q
-        resource.query = q
+        metric.query = q
       end
     end
   end

data/lib/airbrake-ruby/filters/system_exit_filter.rb

@@ -16,6 +16,7 @@ module Airbrake
       # @macro call_filter
       def call(notice)
         return if notice[:errors].none? { |error| error[:type] == SYSTEM_EXIT_TYPE }
+
         notice.ignore!
       end
     end

data/lib/airbrake-ruby/filters/thread_filter.rb

@@ -41,8 +41,7 @@ module Airbrake
           thread_info[:fiber_variables] = vars
         end
 
-        # Present in Ruby 2.3+.
-        if th.respond_to?(:name) && (name = th.name)
+        if (name = th.name)
           thread_info[:name] = name
         end
 
@@ -56,6 +55,7 @@ module Airbrake
       def thread_variables(th)
         th.thread_variables.map.with_object({}) do |var, h|
           next if var.to_s.start_with?(IGNORE_PREFIX)
+
           h[var] = sanitize_value(th.thread_variable_get(var))
         end
       end
@@ -63,6 +63,7 @@ module Airbrake
       def fiber_variables(th)
         th.keys.map.with_object({}) do |key, h|
           next if key.to_s.start_with?(IGNORE_PREFIX)
+
           h[key] = sanitize_value(th[key])
         end
       end
@@ -82,7 +83,7 @@ module Airbrake
         when Array
           value = value.map { |elem| sanitize_value(elem) }
         when Hash
-          Hash[value.map { |k, v| [k, sanitize_value(v)] }]
+          value.transform_values { |v| sanitize_value(v) }
         else
           value.to_s
         end

data/lib/airbrake-ruby/grouppable.rb

@@ -2,7 +2,7 @@ module Airbrake
   # Grouppable adds the `#groups` method, so that we don't need to define it in
   # all of performance models every time we add a model without groups.
   #
-  # @since 4.9.0
+  # @since v4.9.0
   # @api private
   module Grouppable
     def groups

data/lib/airbrake-ruby/ignorable.rb

@@ -18,11 +18,9 @@ module Airbrake
     # Checks whether the instance was ignored.
     # @return [Boolean]
     # @see #ignore!
-    # rubocop:disable Style/DoubleNegation
     def ignored?
       !!ignored
     end
-    # rubocop:enable Style/DoubleNegation
 
     # Ignores an instance. Ignored instances must never reach the Airbrake
     # dashboard.
@@ -38,6 +36,7 @@ module Airbrake
     # @raise [Airbrake::Error] when instance is ignored
     def raise_if_ignored
       return unless ignored?
+
       raise Airbrake::Error, "cannot access ignored #{self.class}"
     end
   end

data/lib/airbrake-ruby/mergeable.rb

@@ -2,7 +2,7 @@ module Airbrake
   # Mergeable adds the `#merge` method, so that we don't need to define it in
   # all of performance models every time we add a model.
   #
-  # @since 4.9.0
+  # @since v4.9.0
   # @api private
   module Mergeable
     def merge(_other)

data/lib/airbrake-ruby/monotonic_time.rb

@@ -39,7 +39,7 @@ module Airbrake
 
         def time_in_nanoseconds
           time = Time.now
-          time.to_i * (10**9) + time.nsec
+          (time.to_i * (10**9)) + time.nsec
         end
 
       end

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

@@ -20,14 +20,13 @@ module Airbrake
 
     def initialize
       @config = Airbrake::Config.instance
-      @context = {}
       @filter_chain = FilterChain.new
-      @async_sender = AsyncSender.new
+      @async_sender = AsyncSender.new(:post, self.class.name)
       @sync_sender = SyncSender.new
 
       DEFAULT_FILTERS.each { |filter| add_filter(filter.new) }
 
-      add_filter(Airbrake::Filters::ContextFilter.new(@context))
+      add_filter(Airbrake::Filters::ContextFilter.new)
       add_filter(Airbrake::Filters::ExceptionAttributesFilter.new)
     end
 
@@ -79,7 +78,7 @@ module Airbrake
 
     # @see Airbrake.merge_context
     def merge_context(context)
-      @context.merge!(context)
+      Airbrake::Context.current.merge!(context)
     end
 
     # @return [Boolean]
@@ -135,6 +134,7 @@ module 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

data/lib/airbrake-ruby/performance_breakdown.rb

@@ -12,16 +12,13 @@ module Airbrake
     include Stashable
     include Mergeable
 
-    attr_accessor :method, :route, :response_type, :groups, :start_time,
-                  :end_time, :timing, :time
+    attr_accessor :method, :route, :response_type, :groups, :timing, :time
 
     def initialize(
       method:,
       route:,
       response_type:,
       groups:,
-      start_time: Time.now,
-      end_time: start_time + 1,
       timing: nil,
       time: Time.now
     )
@@ -30,8 +27,6 @@ module Airbrake
       @route = route
       @response_type = response_type
       @groups = groups
-      @start_time = start_time
-      @end_time = end_time
       @timing = timing
       @time = time
     end

data/lib/airbrake-ruby/performance_notifier.rb

@@ -1,6 +1,6 @@
 module Airbrake
-  # QueryNotifier aggregates information about SQL queries and periodically sends
-  # collected data to Airbrake.
+  # PerformanceNotifier aggregates performance data and periodically sends it to
+  # Airbrake.
   #
   # @api public
   # @since v3.2.0
@@ -12,7 +12,7 @@ module Airbrake
     def initialize
       @config = Airbrake::Config.instance
       @flush_period = Airbrake::Config.instance.performance_stats_flush_period
-      @async_sender = AsyncSender.new(:put)
+      @async_sender = AsyncSender.new(:put, self.class.name)
       @sync_sender = SyncSender.new(:put)
       @schedule_flush = nil
       @filter_chain = FilterChain.new
@@ -21,20 +21,20 @@ module Airbrake
       @has_payload = @payload.new_cond
     end
 
-    # @param [Hash] resource
+    # @param [Hash] metric
     # @see Airbrake.notify_query
     # @see Airbrake.notify_request
-    def notify(resource)
+    def notify(metric)
       @payload.synchronize do
-        send_resource(resource, sync: false)
+        send_metric(metric, sync: false)
       end
     end
 
-    # @param [Hash] resource
+    # @param [Hash] metric
     # @since v4.10.0
     # @see Airbrake.notify_queue_sync
-    def notify_sync(resource)
-      send_resource(resource, sync: true).value
+    def notify_sync(metric)
+      send_metric(metric, sync: true).value
     end
 
     # @see Airbrake.add_performance_filter
@@ -51,7 +51,6 @@ module Airbrake
       @payload.synchronize do
         @schedule_flush.kill if @schedule_flush
         @async_sender.close
-        logger.debug("#{LOG_LABEL} performance notifier closed")
       end
     end
 
@@ -79,16 +78,16 @@ module Airbrake
       end
     end
 
-    def send_resource(resource, sync:)
-      promise = check_configuration(resource)
+    def send_metric(metric, sync:)
+      promise = check_configuration(metric)
       return promise if promise.rejected?
 
-      @filter_chain.refine(resource)
-      if resource.ignored?
-        return Promise.new.reject("#{resource.class} was ignored by a filter")
+      @filter_chain.refine(metric)
+      if metric.ignored?
+        return Promise.new.reject("#{metric.class} was ignored by a filter")
       end
 
-      update_payload(resource)
+      update_payload(metric)
       if sync || @flush_period == 0
         send(@sync_sender, @payload, promise)
       else
@@ -97,42 +96,29 @@ module Airbrake
       end
     end
 
-    def update_payload(resource)
-      if (total_stat = @payload[resource])
-        @payload.key(total_stat).merge(resource)
+    def update_payload(metric)
+      if (total_stat = @payload[metric])
+        @payload.key(total_stat).merge(metric)
       else
-        @payload[resource] = { total: Airbrake::Stat.new }
+        @payload[metric] = { total: Airbrake::Stat.new }
       end
 
-      update_total(resource, @payload[resource][:total])
+      @payload[metric][:total].increment_ms(metric.timing)
 
-      resource.groups.each do |name, ms|
-        @payload[resource][name] ||= Airbrake::Stat.new
-        @payload[resource][name].increment_ms(ms)
+      metric.groups.each do |name, ms|
+        @payload[metric][name] ||= Airbrake::Stat.new
+        @payload[metric][name].increment_ms(ms)
       end
     end
 
-    def update_total(resource, total)
-      if resource.timing
-        total.increment_ms(resource.timing)
-      else
-        loc = caller_locations(6..6).first
-        Kernel.warn(
-          "#{loc.path}:#{loc.lineno}: warning: :start_time and :end_time are " \
-          "deprecated. Use :timing & :time instead",
-        )
-        total.increment(resource.start_time, resource.end_time)
-      end
-    end
-
-    def check_configuration(resource)
+    def check_configuration(metric)
       promise = @config.check_configuration
       return promise if promise.rejected?
 
-      promise = @config.check_performance_options(resource)
+      promise = @config.check_performance_options(metric)
       return promise if promise.rejected?
 
-      if resource.timing && resource.timing == 0
+      if metric.timing && metric.timing == 0
         return Promise.new.reject(':timing cannot be zero')
       end
 
@@ -142,47 +128,47 @@ module Airbrake
     def send(sender, payload, promise)
       raise "payload cannot be empty. Race?" if payload.none?
 
-      with_grouped_payload(payload) do |resource_hash, destination|
+      with_grouped_payload(payload) do |metric_hash, destination|
         url = URI.join(
-          @config.host,
+          @config.apm_host,
           "api/v5/projects/#{@config.project_id}/#{destination}",
         )
 
         logger.debug do
-          "#{LOG_LABEL} #{self.class.name}##{__method__}: #{resource_hash}"
+          "#{LOG_LABEL} #{self.class.name}##{__method__}: #{metric_hash}"
         end
-        sender.send(resource_hash, promise, url)
+        sender.send(metric_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]
+      grouped_payload = raw_payload.group_by do |metric, _stats|
+        [metric.cargo, metric.destination]
       end
 
-      grouped_payload.each do |(cargo, destination), resources|
+      grouped_payload.each do |(cargo, destination), metrics|
         payload = {}
-        payload[cargo] = serialize_resources(resources)
+        payload[cargo] = serialize_metrics(metrics)
         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)
+    def serialize_metrics(metrics)
+      metrics.map do |metric, stats|
+        metric_hash = metric.to_h.merge!(stats[:total].to_h)
 
-        if resource.groups.any?
+        if metric.groups.any?
           group_stats = stats.reject { |name, _stat| name == :total }
-          resource_hash['groups'] = group_stats.merge(group_stats) do |_name, stat|
+          metric_hash['groups'] = group_stats.merge(group_stats) do |_name, stat|
             stat.to_h
           end
         end
 
-        resource_hash
+        metric_hash
       end
     end
   end

data/lib/airbrake-ruby/promise.rb

@@ -103,6 +103,7 @@ module Airbrake
     #   needed for compatibility but it shouldn't exist in the future
     def value
       return @value['ok'] if resolved?
+
       @value
     end
   end

data/lib/airbrake-ruby/query.rb

@@ -12,8 +12,7 @@ module Airbrake
     include Mergeable
     include Grouppable
 
-    attr_accessor :method, :route, :query, :func, :file, :line, :start_time,
-                  :end_time, :timing, :time
+    attr_accessor :method, :route, :query, :func, :file, :line, :timing, :time
 
     def initialize(
       method:,
@@ -22,8 +21,6 @@ module Airbrake
       func: nil,
       file: nil,
       line: nil,
-      start_time: Time.now,
-      end_time: start_time + 1,
       timing: nil,
       time: Time.now
     )
@@ -34,8 +31,6 @@ module Airbrake
       @func = func
       @file = file
       @line = line
-      @start_time = start_time
-      @end_time = end_time
       @timing = timing
       @time = time
     end

data/lib/airbrake-ruby/queue.rb

@@ -4,21 +4,17 @@ module Airbrake
   # @see Airbrake.notify_queue
   # @api public
   # @since v4.9.0
-  # rubocop:disable Metrics/ParameterLists
   class Queue
     include HashKeyable
     include Ignorable
     include Stashable
 
-    attr_accessor :queue, :error_count, :groups, :start_time, :end_time,
-                  :timing, :time
+    attr_accessor :queue, :error_count, :groups, :timing, :time
 
     def initialize(
       queue:,
       error_count:,
       groups: {},
-      start_time: Time.now,
-      end_time: start_time + 1,
       timing: nil,
       time: Time.now
     )
@@ -26,8 +22,6 @@ module Airbrake
       @queue = queue
       @error_count = error_count
       @groups = groups
-      @start_time = start_time
-      @end_time = end_time
       @timing = timing
       @time = time
     end
@@ -68,5 +62,4 @@ module Airbrake
       ''
     end
   end
-  # rubocop:enable Metrics/ParameterLists
 end

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

@@ -0,0 +1,44 @@
+module Airbrake
+  class RemoteSettings
+    # Callback is a class that provides a callback for the config poller, which
+    # updates the local config according to the data.
+    #
+    # @api private
+    # @since v5.0.2
+    class Callback
+      def initialize(config)
+        @config = config
+        @orig_error_notifications = config.error_notifications
+        @orig_performance_stats = config.performance_stats
+      end
+
+      # @param [Airbrake::RemoteSettings::SettingsData] data
+      # @return [void]
+      def call(data)
+        @config.logger.debug do
+          "#{LOG_LABEL} applying remote settings: #{data.to_h}"
+        end
+
+        @config.error_host = data.error_host if data.error_host
+        @config.apm_host = data.apm_host if data.apm_host
+
+        process_error_notifications(data)
+        process_performance_stats(data)
+      end
+
+      private
+
+      def process_error_notifications(data)
+        return unless @orig_error_notifications
+
+        @config.error_notifications = data.error_notifications?
+      end
+
+      def process_performance_stats(data)
+        return unless @orig_performance_stats
+
+        @config.performance_stats = data.performance_stats?
+      end
+    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 v5.0.0
+    # @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 path to poll
+      CONFIG_ROUTE_PATTERN =
+        "%<host>s/#{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'.freeze,
+        apm: 'apm'.freeze,
+      }.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
+
+      # @param [String] remote_config_host
+      # @return [String] where the config is stored on S3.
+      def config_route(remote_config_host)
+        if @data['config_route'] && !@data['config_route'].empty?
+          return "#{remote_config_host.chomp('/')}/#{@data['config_route']}"
+        end
+
+        format(
+          CONFIG_ROUTE_PATTERN,
+          host: remote_config_host.chomp('/'),
+          project_id: @project_id,
+        )
+      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