sentry-ruby 4.0.1 → 4.1.4

data/lib/sentry/backtrace.rb

@@ -82,16 +82,14 @@ module Sentry
 
     # holder for an Array of Backtrace::Line instances
     attr_reader :lines
-    attr_reader :configuration
 
-    def self.parse(backtrace, configuration:)
+    def self.parse(backtrace, project_root, app_dirs_pattern, &backtrace_cleanup_callback)
       ruby_lines = backtrace.is_a?(Array) ? backtrace : backtrace.split(/\n\s*/)
 
-      ruby_lines = configuration.backtrace_cleanup_callback.call(ruby_lines) if configuration&.backtrace_cleanup_callback
+      ruby_lines = backtrace_cleanup_callback.call(ruby_lines) if backtrace_cleanup_callback
 
       in_app_pattern ||= begin
-        project_root = configuration.project_root&.to_s
-        Regexp.new("^(#{project_root}/)?#{configuration.app_dirs_pattern || APP_DIRS_PATTERN}")
+        Regexp.new("^(#{project_root}/)?#{app_dirs_pattern || APP_DIRS_PATTERN}")
       end
 
       lines = ruby_lines.to_a.map do |unparsed_line|

data/lib/sentry/client.rb

@@ -20,35 +20,51 @@ module Sentry
       end
     end
 
-    def capture_event(event, scope, hint = nil)
+    def capture_event(event, scope, hint = {})
+      return unless configuration.sending_allowed?
+
       scope.apply_to_event(event, hint)
 
-      if configuration.async?
+      if async_block = configuration.async
         begin
           # We have to convert to a JSON-like hash, because background job
           # processors (esp ActiveJob) may not like weird types in the event hash
-          configuration.async.call(event.to_json_compatible)
+          event_hash = event.to_json_compatible
+
+          if async_block.arity == 2
+            async_block.call(event_hash, hint)
+          else
+            async_block.call(event_hash)
+          end
         rescue => e
           configuration.logger.error(LOGGER_PROGNAME) { "async event sending failed: #{e.message}" }
           send_event(event, hint)
         end
       else
-        send_event(event, hint)
+        if hint.fetch(:background, true)
+          Sentry.background_worker.perform do
+            send_event(event, hint)
+          end
+        else
+          send_event(event, hint)
+        end
       end
 
       event
     end
 
-    def event_from_exception(exception)
+    def event_from_exception(exception, hint = {})
+      integration_meta = Sentry.integrations[hint[:integration]]
       return unless @configuration.exception_class_allowed?(exception)
 
-      Event.new(configuration: configuration).tap do |event|
+      Event.new(configuration: configuration, integration_meta: integration_meta).tap do |event|
         event.add_exception_interface(exception)
       end
     end
 
-    def event_from_message(message)
-      Event.new(configuration: configuration, message: message)
+    def event_from_message(message, hint = {})
+      integration_meta = Sentry.integrations[hint[:integration]]
+      Event.new(configuration: configuration, integration_meta: integration_meta, message: message)
     end
 
     def event_from_transaction(transaction)
@@ -64,9 +80,9 @@ module Sentry
     end
 
     def send_event(event, hint = nil)
-      return false unless configuration.sending_allowed?
+      event_type = event.is_a?(Event) ? event.type : event["type"]
+      event = configuration.before_send.call(event, hint) if configuration.before_send && event_type == "event"
 
-      event = configuration.before_send.call(event, hint) if configuration.before_send
       if event.nil?
         configuration.logger.info(LOGGER_PROGNAME) { "Discarded event because before_send returned nil" }
         return

data/lib/sentry/configuration.rb

@@ -1,3 +1,5 @@
+require "concurrent/utility/processor_counter"
+
 require "sentry/utils/exception_cause_chain"
 require "sentry/dsn"
 require "sentry/transport/configuration"
@@ -13,7 +15,15 @@ module Sentry
     # Provide an object that responds to `call` to send events asynchronously.
     # E.g.: lambda { |event| Thread.new { Sentry.send_event(event) } }
     attr_reader :async
-    alias async? async
+
+    # to send events in a non-blocking way, sentry-ruby has its own background worker
+    # by default, the worker holds a thread pool that has [the number of processors] threads
+    # but you can configure it with this configuration option
+    # E.g.: config.background_worker_threads = 5
+    #
+    # if you want to send events synchronously, set the value to 0
+    # E.g.: config.background_worker_threads = 0
+    attr_accessor :background_worker_threads
 
     # a proc/lambda that takes an array of stack traces
     # it'll be used to silence (reduce) backtrace of the exception
@@ -123,7 +133,6 @@ module Sentry
     # Most of these errors generate 4XX responses. In general, Sentry clients
     # only automatically report 5xx responses.
     IGNORE_DEFAULT = [
-      'CGI::Session::CookieStore::TamperedWithCookie',
       'Mongoid::Errors::DocumentNotFound',
       'Rack::QueryParser::InvalidParameterError',
       'Rack::QueryParser::ParameterTypeError',
@@ -145,7 +154,7 @@ module Sentry
     AVAILABLE_BREADCRUMBS_LOGGERS = [:sentry_logger, :active_support_logger].freeze
 
     def initialize
-      self.async = false
+      self.background_worker_threads = Concurrent.processor_count
       self.breadcrumbs_logger = []
       self.context_lines = 3
       self.environment = environment_from_env
@@ -182,8 +191,8 @@ module Sentry
 
 
     def async=(value)
-      unless value == false || value.respond_to?(:call)
-        raise(ArgumentError, "async must be callable (or false to disable)")
+      if value && !value.respond_to?(:call)
+        raise(ArgumentError, "async must be callable")
       end
 
       @async = value

data/lib/sentry/event.rb

@@ -20,7 +20,7 @@ module Sentry
     attr_accessor(*ATTRIBUTES)
     attr_reader :configuration, :request, :exception, :stacktrace
 
-    def initialize(configuration:, message: nil)
+    def initialize(configuration:, integration_meta: nil, message: nil)
       # this needs to go first because some setters rely on configuration
       @configuration = configuration
 
@@ -28,7 +28,7 @@ module Sentry
       @event_id      = SecureRandom.uuid.delete("-")
       @timestamp     = Sentry.utc_now.iso8601
       @platform      = :ruby
-      @sdk           = Sentry.sdk_meta
+      @sdk           = integration_meta || Sentry.sdk_meta
 
       @user          = {}
       @extra         = {}
@@ -76,13 +76,14 @@ module Sentry
 
     def rack_env=(env)
       unless request || env.empty?
-        @request = Sentry::RequestInterface.new.tap do |int|
-          int.from_rack(env)
-        end
+        env = env.dup
+
+        add_request_interface(env)
 
-        if configuration.send_default_pii && ip = calculate_real_ip_from_rack(env.dup)
-          user[:ip_address] = ip
+        if configuration.send_default_pii
+          user[:ip_address] = calculate_real_ip_from_rack(env)
         end
+
         if request_id = Utils::RequestId.read_from(env)
           tags[:request_id] = request_id
         end
@@ -107,6 +108,10 @@ module Sentry
       JSON.parse(JSON.generate(to_hash))
     end
 
+    def add_request_interface(env)
+      @request = Sentry::RequestInterface.from_rack(env)
+    end
+
     def add_exception_interface(exc)
       if exc.respond_to?(:sentry_context)
         @extra.merge!(exc.sentry_context)
@@ -124,33 +129,22 @@ module Sentry
             int.stacktrace =
               if e.backtrace && !backtraces.include?(e.backtrace.object_id)
                 backtraces << e.backtrace.object_id
-                StacktraceInterface.new.tap do |stacktrace|
-                  stacktrace.frames = stacktrace_interface_from(e.backtrace)
-                end
+                initialize_stacktrace_interface(e.backtrace)
               end
           end
         end
       end
     end
 
-    def stacktrace_interface_from(backtrace)
-      project_root = configuration.project_root.to_s
-
-      Backtrace.parse(backtrace, configuration: configuration).lines.reverse.each_with_object([]) do |line, memo|
-        frame = StacktraceInterface::Frame.new(project_root)
-        frame.abs_path = line.file if line.file
-        frame.function = line.method if line.method
-        frame.lineno = line.number
-        frame.in_app = line.in_app
-        frame.module = line.module_name if line.module_name
-
-        if configuration.context_lines && frame.abs_path
-          frame.pre_context, frame.context_line, frame.post_context = \
-            configuration.linecache.get_file_context(frame.abs_path, frame.lineno, configuration.context_lines)
-        end
-
-        memo << frame if frame.filename
-      end
+    def initialize_stacktrace_interface(backtrace)
+      StacktraceInterface.new(
+        backtrace: backtrace,
+        project_root: configuration.project_root.to_s,
+        app_dirs_pattern: configuration.app_dirs_pattern,
+        linecache: configuration.linecache,
+        context_lines: configuration.context_lines,
+        backtrace_cleanup_callback: configuration.backtrace_cleanup_callback
+      )
     end
 
     private

data/lib/sentry/hub.rb

@@ -3,6 +3,8 @@ require "sentry/client"
 
 module Sentry
   class Hub
+    include ArgumentCheckingHelper
+
     attr_reader :last_event_id
 
     def initialize(client, scope)
@@ -76,12 +78,14 @@ module Sentry
     def capture_exception(exception, **options, &block)
       return unless current_client
 
-      event = current_client.event_from_exception(exception)
+      check_argument_type!(exception, ::Exception)
+
+      options[:hint] ||= {}
+      options[:hint][:exception] = exception
+      event = current_client.event_from_exception(exception, options[:hint])
 
       return unless event
 
-      options[:hint] ||= {}
-      options[:hint] = options[:hint].merge(exception: exception)
       capture_event(event, **options, &block)
     end
 
@@ -89,15 +93,17 @@ module Sentry
       return unless current_client
 
       options[:hint] ||= {}
-      options[:hint] = options[:hint].merge(message: message)
-      event = current_client.event_from_message(message)
+      options[:hint][:message] = message
+      event = current_client.event_from_message(message, options[:hint])
       capture_event(event, **options, &block)
     end
 
     def capture_event(event, **options, &block)
       return unless current_client
 
-      hint = options.delete(:hint)
+      check_argument_type!(event, Sentry::Event)
+
+      hint = options.delete(:hint) || {}
       scope = current_scope.dup
 
       if block
@@ -110,7 +116,7 @@ module Sentry
 
       event = current_client.capture_event(event, scope, hint)
 
-      @last_event_id = event.event_id
+      @last_event_id = event&.event_id
       event
     end
 

data/lib/sentry/integrable.rb

@@ -0,0 +1,24 @@
+module Sentry
+  module Integrable
+    def register_integration(name:, version:)
+      Sentry.register_integration(name, version)
+      @integration_name = name
+    end
+
+    def integration_name
+      @integration_name
+    end
+
+    def capture_exception(exception, **options, &block)
+      options[:hint] ||= {}
+      options[:hint][:integration] = integration_name
+      Sentry.capture_exception(exception, **options, &block)
+    end
+
+    def capture_message(message, **options, &block)
+      options[:hint] ||= {}
+      options[:hint][:integration] = integration_name
+      Sentry.capture_message(message, **options, &block)
+    end
+  end
+end

data/lib/sentry/interfaces/request.rb

@@ -1,8 +1,9 @@
-require 'rack'
+# frozen_string_literal: true
 
 module Sentry
   class RequestInterface < Interface
     REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
+    CONTENT_HEADERS = %w(CONTENT_TYPE CONTENT_LENGTH).freeze
     IP_HEADERS = [
       "REMOTE_ADDR",
       "HTTP_CLIENT_IP",
@@ -10,42 +11,52 @@ module Sentry
       "HTTP_X_FORWARDED_FOR"
     ].freeze
 
+    # See Sentry server default limits at
+    # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
+    MAX_BODY_LIMIT = 4096 * 4
+
     attr_accessor :url, :method, :data, :query_string, :cookies, :headers, :env
 
-    def initialize
-      self.headers = {}
-      self.env = {}
-      self.cookies = nil
+    def self.from_rack(env)
+      env = clean_env(env)
+      req = ::Rack::Request.new(env)
+      self.new(req)
+    end
+
+    def self.clean_env(env)
+      unless Sentry.configuration.send_default_pii
+        # need to completely wipe out ip addresses
+        RequestInterface::IP_HEADERS.each do |header|
+          env.delete(header)
+        end
+      end
+
+      env
     end
 
-    def from_rack(env_hash)
-      req = ::Rack::Request.new(env_hash)
+    def initialize(req)
+      env = req.env
 
       if Sentry.configuration.send_default_pii
         self.data = read_data_from(req)
         self.cookies = req.cookies
-      else
-        # need to completely wipe out ip addresses
-        IP_HEADERS.each { |h| env_hash.delete(h) }
       end
 
       self.url = req.scheme && req.url.split('?').first
       self.method = req.request_method
       self.query_string = req.query_string
 
-      self.headers = format_headers_for_sentry(env_hash)
-      self.env     = format_env_for_sentry(env_hash)
+      self.headers = filter_and_format_headers(env)
+      self.env     = filter_and_format_env(env)
     end
 
     private
 
-    # See Sentry server default limits at
-    # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
     def read_data_from(request)
       if request.form_data?
         request.POST
       elsif request.body # JSON requests, etc
-        data = request.body.read(4096 * 4) # Sentry server limit
+        data = request.body.read(MAX_BODY_LIMIT)
         request.body.rewind
         data
       end
@@ -53,27 +64,18 @@ module Sentry
       e.message
     end
 
-    def format_headers_for_sentry(env_hash)
-      env_hash.each_with_object({}) do |(key, value), memo|
+    def filter_and_format_headers(env)
+      env.each_with_object({}) do |(key, value), memo|
         begin
           key = key.to_s # rack env can contain symbols
-          value = value.to_s
-          next memo['X-Request-Id'] ||= Utils::RequestId.read_from(env_hash) if Utils::RequestId::REQUEST_ID_HEADERS.include?(key)
-          next unless key.upcase == key # Non-upper case stuff isn't either
-
-          # Rack adds in an incorrect HTTP_VERSION key, which causes downstream
-          # to think this is a Version header. Instead, this is mapped to
-          # env['SERVER_PROTOCOL']. But we don't want to ignore a valid header
-          # if the request has legitimately sent a Version header themselves.
-          # See: https://github.com/rack/rack/blob/028438f/lib/rack/handler/cgi.rb#L29
-          next if key == 'HTTP_VERSION' && value == env_hash['SERVER_PROTOCOL']
-          next if key == 'HTTP_COOKIE' # Cookies don't go here, they go somewhere else
-          next unless key.start_with?('HTTP_') || %w(CONTENT_TYPE CONTENT_LENGTH).include?(key)
+          next memo['X-Request-Id'] ||= Utils::RequestId.read_from(env) if Utils::RequestId::REQUEST_ID_HEADERS.include?(key)
+          next if is_server_protocol?(key, value, env["SERVER_PROTOCOL"])
+          next if is_skippable_header?(key)
 
           # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
           key = key.sub(/^HTTP_/, "")
           key = key.split('_').map(&:capitalize).join('-')
-          memo[key] = value
+          memo[key] = value.to_s
         rescue StandardError => e
           # Rails adds objects to the Rack env that can sometimes raise exceptions
           # when `to_s` is called.
@@ -84,10 +86,26 @@ module Sentry
       end
     end
 
-    def format_env_for_sentry(env_hash)
-      return env_hash if Sentry.configuration.rack_env_whitelist.empty?
+    def is_skippable_header?(key)
+      key.upcase != key || # lower-case envs aren't real http headers
+        key == "HTTP_COOKIE" || # Cookies don't go here, they go somewhere else
+        !(key.start_with?('HTTP_') || CONTENT_HEADERS.include?(key))
+    end
+
+    # Rack adds in an incorrect HTTP_VERSION key, which causes downstream
+    # to think this is a Version header. Instead, this is mapped to
+    # env['SERVER_PROTOCOL']. But we don't want to ignore a valid header
+    # if the request has legitimately sent a Version header themselves.
+    # See: https://github.com/rack/rack/blob/028438f/lib/rack/handler/cgi.rb#L29
+    # NOTE: This will be removed in version 3.0+
+    def is_server_protocol?(key, value, protocol_version)
+      key == 'HTTP_VERSION' && value == protocol_version
+    end
+
+    def filter_and_format_env(env)
+      return env if Sentry.configuration.rack_env_whitelist.empty?
 
-      env_hash.select do |k, _v|
+      env.select do |k, _v|
         Sentry.configuration.rack_env_whitelist.include? k.to_s
       end
     end