sentry-ruby 4.0.0 → 4.1.3

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

@@ -18,9 +18,9 @@ module Sentry
     )
 
     attr_accessor(*ATTRIBUTES)
-    attr_reader :configuration
+    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         = {}
@@ -75,14 +75,15 @@ module Sentry
     end
 
     def rack_env=(env)
-      unless @request || env.empty?
-        @request = Sentry::RequestInterface.new.tap do |int|
-          int.from_rack(env)
-        end
+      unless request || env.empty?
+        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
@@ -96,9 +97,9 @@ module Sentry
     def to_hash
       data = serialize_attributes
       data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
-      data[:stacktrace] = @stacktrace.to_hash if @stacktrace
-      data[:request] = @request.to_hash if @request
-      data[:exception] = @exception.to_hash if @exception
+      data[:stacktrace] = stacktrace.to_hash if stacktrace
+      data[:request] = request.to_hash if request
+      data[:exception] = exception.to_hash if exception
 
       data
     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

@@ -76,12 +76,12 @@ module Sentry
     def capture_exception(exception, **options, &block)
       return unless current_client
 
-      event = current_client.event_from_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 +89,15 @@ 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)
+      hint = options.delete(:hint) || {}
       scope = current_scope.dup
 
       if block
@@ -110,7 +110,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,22 +64,14 @@ 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_/, "")
@@ -84,10 +87,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

data/lib/sentry/interfaces/stacktrace.rb

@@ -1,11 +1,31 @@
 module Sentry
-  class StacktraceInterface < Interface
-    attr_accessor :frames
+  class StacktraceInterface
+    attr_reader :frames
+
+    def initialize(backtrace:, project_root:, app_dirs_pattern:, linecache:, context_lines:, backtrace_cleanup_callback: nil)
+      @project_root = project_root
+      @frames = []
+
+      parsed_backtrace_lines = Backtrace.parse(
+        backtrace, project_root, app_dirs_pattern, &backtrace_cleanup_callback
+      ).lines
+
+      parsed_backtrace_lines.reverse.each_with_object(@frames) do |line, frames|
+        frame = convert_parsed_line_into_frame(line, project_root, linecache, context_lines)
+        frames << frame if frame.filename
+      end
+    end
 
     def to_hash
-      data = super
-      data[:frames] = data[:frames].map(&:to_hash)
-      data
+      { frames: @frames.map(&:to_hash) }
+    end
+
+    private
+
+    def convert_parsed_line_into_frame(line, project_root, linecache, context_lines)
+      frame = StacktraceInterface::Frame.new(@project_root, line)
+      frame.set_context(linecache, context_lines) if context_lines
+      frame
     end
 
     # Not actually an interface, but I want to use the same style
@@ -13,8 +33,14 @@ module Sentry
       attr_accessor :abs_path, :context_line, :function, :in_app,
                     :lineno, :module, :pre_context, :post_context, :vars
 
-      def initialize(project_root)
+      def initialize(project_root, line)
         @project_root = project_root
+
+        @abs_path = line.file if line.file
+        @function = line.method if line.method
+        @lineno = line.number
+        @in_app = line.in_app
+        @module = line.module_name if line.module_name
       end
 
       def filename
@@ -33,6 +59,13 @@ module Sentry
         @filename = prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
       end
 
+      def set_context(linecache, context_lines)
+        return unless abs_path
+
+        self.pre_context, self.context_line, self.post_context = \
+            linecache.get_file_context(abs_path, lineno, context_lines)
+      end
+
       def to_hash(*args)
         data = super(*args)
         data[:filename] = filename

data/lib/sentry/rack.rb

@@ -1,5 +1,4 @@
-require 'time'
 require 'rack'
 
-require 'sentry/rack/capture_exception'
-require 'sentry/rack/tracing'
+require 'sentry/rack/capture_exceptions'
+require 'sentry/rack/deprecations'

data/lib/sentry/rack/capture_exceptions.rb

@@ -0,0 +1,62 @@
+module Sentry
+  module Rack
+    class CaptureExceptions
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless Sentry.initialized?
+
+        # make sure the current thread has a clean hub
+        Sentry.clone_hub_to_current_thread
+
+        Sentry.with_scope do |scope|
+          scope.clear_breadcrumbs
+          scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
+          scope.set_rack_env(env)
+
+          span = Sentry.start_transaction(name: scope.transaction_name, op: transaction_op)
+          scope.set_span(span)
+
+          begin
+            response = @app.call(env)
+          rescue Sentry::Error
+            finish_span(span, 500)
+            raise # Don't capture Sentry errors
+          rescue Exception => e
+            capture_exception(e)
+            finish_span(span, 500)
+            raise
+          end
+
+          exception = collect_exception(env)
+          capture_exception(exception) if exception
+
+          finish_span(span, response[0])
+
+          response
+        end
+      end
+
+      private
+
+      def collect_exception(env)
+        env['rack.exception'] || env['sinatra.error']
+      end
+
+      def transaction_op
+        "rack.request".freeze
+      end
+
+      def capture_exception(exception)
+        Sentry.capture_exception(exception)
+      end
+
+      def finish_span(span, status_code)
+        span.set_http_status(status_code)
+        span.finish
+      end
+    end
+  end
+end