sentry-ruby 4.1.2 → 4.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbe0af63148c410c71208f7bac743d24e224b5265102d645831a9538262961dc
-  data.tar.gz: 9933997d430fc94d400f97b9e2319ab14ccfe1bd2ff42635eda5b13bd4e11621
+  metadata.gz: 823d9f50e4335e2c08fa6a6afedac78e2c6243ea94a104db560870f0021c51c7
+  data.tar.gz: 385143cfb2e2218afb9fca2bebe07a26bca02565cd525b32a1abdde38bcd53e0
 SHA512:
-  metadata.gz: a813b4fad61840a850b6dd82451d689272800b5d4e405ab50f80f99cfe69a371f770c1a8151491ccd2f10400822e0e4a98bc8c2ca1265b562139bd7ffc1cdd02
-  data.tar.gz: 1331331801ea39234c96e50e9fc469713efd48ee316e5620ae2c200f97a4a4d88810f942d707fb77dab7b458284ee11cad4b6153632cde4aa6014e2df5a89820
+  metadata.gz: 143855b2a274c65d17b72a60adbe8ff72b2d71ad316796d7899803d3bf28f4645cba7afa1518aabae592b0093ba51f5f3c41d755ce9674cd65b3da3363a5bb72
+  data.tar.gz: a4b8fc9795553867da3b5d6c0eebd6f2d4198805c21f19a936149653ddac882b4db5cba46678f016982f3529314a95d5a23e9770173f53dbeb33ff7ba6a4b6c7

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 4.1.3
+
+- rm reference to old constant (from Rails v2.2) [#1184](https://github.com/getsentry/sentry-ruby/pull/1184)
+- Use copied env in events [#1186](https://github.com/getsentry/sentry-ruby/pull/1186)
+  - Fixes [#1183](https://github.com/getsentry/sentry-ruby/issues/1183)
+- Refactor RequestInterface [#1187](https://github.com/getsentry/sentry-ruby/pull/1187)
+- Supply event hint to async callback when possible [#1189](https://github.com/getsentry/sentry-ruby/pull/1189)
+  - Fixes [#1188](https://github.com/getsentry/sentry-ruby/issues/1188)
+- Refactor stacktrace parsing and increase test coverage [#1190](https://github.com/getsentry/sentry-ruby/pull/1190)
+- Sentry.send_event should also take a hint [#1192](https://github.com/getsentry/sentry-ruby/pull/1192)
+
 ## 4.1.2
 
 - before_send callback shouldn't be applied to transaction events [#1167](https://github.com/getsentry/sentry-ruby/pull/1167)

data/README.md

@@ -94,7 +94,7 @@ Sentry.init do |config|
 end
 ```
 
-To lean more about performance monitoring, please visit the [official documentation](https://docs.sentry.io/platforms/ruby/performance).
+To learn more about performance monitoring, please visit the [official documentation](https://docs.sentry.io/platforms/ruby/performance).
 
 ### Usage
 
@@ -144,8 +144,8 @@ You're all set - but there's a few more settings you may want to know about too!
 **Before version 4.1.0**, `sentry-ruby` sends every event immediately. But it can be configured to send asynchronously:
 
 ```ruby
-config.async = lambda { |event|
-  Thread.new { Sentry.send_event(event) }
+config.async = lambda { |event, hint|
+  Thread.new { Sentry.send_event(event, hint) }
 }
 ```
 
@@ -154,13 +154,13 @@ Using a thread to send events will be adequate for truly parallel Ruby platforms
 Note that the naive example implementation has a major drawback - it can create an infinite number of threads. We recommend creating a background job, using your background job processor, that will send Sentry notifications in the background.
 
 ```ruby
-config.async = lambda { |event| SentryJob.perform_later(event) }
+config.async = lambda { |event, hint| SentryJob.perform_later(event, hint) }
 
 class SentryJob < ActiveJob::Base
   queue_as :default
 
-  def perform(event)
-    Sentry.send_event(event)
+  def perform(event, hint)
+    Sentry.send_event(event, hint)
   end
 end
 ```

data/lib/sentry-ruby.rb

@@ -54,6 +54,7 @@ module Sentry
   class << self
     extend Forwardable
 
+    def_delegators :get_current_client, :configuration, :send_event
     def_delegators :get_current_scope, :set_tags, :set_extras, :set_user
 
     attr_accessor :background_worker
@@ -85,10 +86,6 @@ module Sentry
       get_current_scope.breadcrumbs.record(breadcrumb, &block)
     end
 
-    def configuration
-      get_current_client.configuration
-    end
-
     def get_current_client
       get_current_hub&.current_client
     end
@@ -118,10 +115,6 @@ module Sentry
       get_current_hub&.configure_scope(&block)
     end
 
-    def send_event(event)
-      get_current_client.send_event(event)
-    end
-
     def capture_event(event)
       get_current_hub&.capture_event(event)
     end

data/lib/sentry/background_worker.rb

@@ -10,7 +10,7 @@ module Sentry
       @number_of_threads = configuration.background_worker_threads
 
       @executor =
-        if configuration.async?
+        if configuration.async
           configuration.logger.debug(LOGGER_PROGNAME) { "config.async is set, BackgroundWorker is disabled" }
           Concurrent::ImmediateExecutor.new
         elsif @number_of_threads == 0

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

@@ -25,11 +25,17 @@ module Sentry
 
       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)

data/lib/sentry/configuration.rb

@@ -15,7 +15,6 @@ 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
@@ -134,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',
@@ -156,7 +154,6 @@ 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
@@ -194,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

@@ -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/interfaces/request.rb

@@ -1,6 +1,9 @@
+# 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",
@@ -8,23 +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 initialize(req)
+      env = req.env
+
+      if Sentry.configuration.send_default_pii
+        self.data = read_data_from(req)
+        self.cookies = req.cookies
+      end
+
+      self.url = req.scheme && req.url.split('?').first
+      self.method = req.request_method
+      self.query_string = req.query_string
+
+      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
@@ -32,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_/, "")
@@ -63,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 'rack'
 
 require 'sentry/rack/capture_exceptions'
-require 'sentry/rack/interface'
 require 'sentry/rack/deprecations'

data/lib/sentry/utils/request_id.rb

@@ -4,9 +4,9 @@ module Sentry
       REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
 
       # Request ID based on ActionDispatch::RequestId
-      def self.read_from(env_hash)
+      def self.read_from(env)
         REQUEST_ID_HEADERS.each do |key|
-          request_id = env_hash[key]
+          request_id = env[key]
           return request_id if request_id
         end
         nil

data/lib/sentry/version.rb

@@ -1,3 +1,3 @@
 module Sentry
-  VERSION = "4.1.2"
+  VERSION = "4.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 4.1.2
+  version: 4.1.3
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-30 00:00:00.000000000 Z
+date: 2021-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -89,7 +89,6 @@ files:
 - lib/sentry/rack.rb
 - lib/sentry/rack/capture_exceptions.rb
 - lib/sentry/rack/deprecations.rb
-- lib/sentry/rack/interface.rb
 - lib/sentry/rake.rb
 - lib/sentry/scope.rb
 - lib/sentry/span.rb

data/lib/sentry/rack/interface.rb

@@ -1,22 +0,0 @@
-module Sentry
-  class RequestInterface
-    def from_rack(env_hash)
-      req = ::Rack::Request.new(env_hash)
-
-      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)
-    end
-  end
-end