sentry-ruby-core 4.1.5 → 4.3.0

data/lib/sentry/configuration.rb

@@ -4,6 +4,7 @@ require "sentry/utils/exception_cause_chain"
 require "sentry/dsn"
 require "sentry/transport/configuration"
 require "sentry/linecache"
+require "sentry/interfaces/stacktrace_builder"
 
 module Sentry
   class Configuration
@@ -38,10 +39,19 @@ module Sentry
     #
     attr_accessor :backtrace_cleanup_callback
 
+    # Optional Proc, called before adding the breadcrumb to the current scope
+    # E.g.: lambda { |breadcrumb, hint| breadcrumb }
+    # E.g.: lambda { |breadcrumb, hint| nil }
+    # E.g.: lambda { |breadcrumb, hint|
+    #   breadcrumb.message = 'a'
+    #   breadcrumb
+    # }
+    attr_reader :before_breadcrumb
+
     # Optional Proc, called before sending an event to the server/
-    # E.g.: lambda { |event| event }
-    # E.g.: lambda { |event| nil }
-    # E.g.: lambda { |event|
+    # E.g.: lambda { |event, hint| event }
+    # E.g.: lambda { |event, hint| nil }
+    # E.g.: lambda { |event, hint|
     #   event[:message] = 'a'
     #   event
     # }
@@ -52,6 +62,9 @@ module Sentry
     # - :active_support_logger
     attr_reader :breadcrumbs_logger
 
+    # Max number of breadcrumbs a breadcrumb buffer can hold
+    attr_accessor :max_breadcrumbs
+
     # Number of lines of code context to capture, or nil for none
     attr_accessor :context_lines
 
@@ -109,6 +122,9 @@ module Sentry
     # will not be sent to Sentry.
     attr_accessor :send_default_pii
 
+    # IP ranges for trusted proxies that will be skipped when calculating IP address.
+    attr_accessor :trusted_proxies
+
     attr_accessor :server_name
 
     # Return a Transport::Configuration object for transport-related configurations.
@@ -153,23 +169,29 @@ module Sentry
 
     AVAILABLE_BREADCRUMBS_LOGGERS = [:sentry_logger, :active_support_logger].freeze
 
+    # Post initialization callbacks are called at the end of initialization process
+    # allowing extending the configuration of sentry-ruby by multiple extensions
+    @@post_initialization_callbacks = []
+
     def initialize
       self.background_worker_threads = Concurrent.processor_count
+      self.max_breadcrumbs = BreadcrumbBuffer::DEFAULT_SIZE
       self.breadcrumbs_logger = []
       self.context_lines = 3
       self.environment = environment_from_env
       self.enabled_environments = []
       self.exclude_loggers = []
       self.excluded_exceptions = IGNORE_DEFAULT.dup
-      self.inspect_exception_causes_for_exclusion = false
+      self.inspect_exception_causes_for_exclusion = true
       self.linecache = ::Sentry::LineCache.new
       self.logger = ::Sentry::Logger.new(STDOUT)
-      self.project_root = detect_project_root
+      self.project_root = Dir.pwd
 
       self.release = detect_release
       self.sample_rate = 1.0
       self.send_modules = true
       self.send_default_pii = false
+      self.trusted_proxies = []
       self.dsn = ENV['SENTRY_DSN']
       self.server_name = server_name_from_env
 
@@ -178,7 +200,8 @@ module Sentry
 
       @transport = Transport::Configuration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
-      post_initialization_callback
+
+      run_post_initialization_callbacks
     end
 
     def dsn=(value)
@@ -223,6 +246,14 @@ module Sentry
       @before_send = value
     end
 
+    def before_breadcrumb=(value)
+      unless value.nil? || value.respond_to?(:call)
+        raise ArgumentError, "before_breadcrumb must be callable (or nil to disable)"
+      end
+
+      @before_breadcrumb = value
+    end
+
     def environment=(environment)
       @environment = environment.to_s
     end
@@ -265,16 +296,18 @@ module Sentry
       !!((@traces_sample_rate && @traces_sample_rate > 0.0) || @traces_sampler)
     end
 
-    private
-
-    def detect_project_root
-      if defined? Rails.root # we are in a Rails application
-        Rails.root.to_s
-      else
-        Dir.pwd
-      end
+    def stacktrace_builder
+      @stacktrace_builder ||= StacktraceBuilder.new(
+        project_root: @project_root.to_s,
+        app_dirs_pattern: @app_dirs_pattern,
+        linecache: @linecache,
+        context_lines: @context_lines,
+        backtrace_cleanup_callback: @backtrace_cleanup_callback
+      )
     end
 
+    private
+
     def detect_release
       detect_release_from_env ||
         detect_release_from_git ||
@@ -390,7 +423,21 @@ module Sentry
       end
     end
 
-    # allow extensions to extend the Configuration class
-    def post_initialization_callback; end
+    def run_post_initialization_callbacks
+      self.class.post_initialization_callbacks.each do |hook|
+        instance_eval(&hook)
+      end
+    end
+
+    # allow extensions to add their hooks to the Configuration class
+    def self.add_post_initialization_callback(&block)
+      self.post_initialization_callbacks << block
+    end
+
+    protected
+
+    def self.post_initialization_callbacks
+      @@post_initialization_callbacks
+    end
   end
 end

data/lib/sentry/event.rb

@@ -20,7 +20,7 @@ module Sentry
     MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
 
     attr_accessor(*ATTRIBUTES)
-    attr_reader :configuration, :request, :exception, :stacktrace
+    attr_reader :configuration, :request, :exception, :threads
 
     def initialize(configuration:, integration_meta: nil, message: nil)
       # this needs to go first because some setters rely on configuration
@@ -52,19 +52,26 @@ module Sentry
     class << self
       def get_log_message(event_hash)
         message = event_hash[:message] || event_hash['message']
-        message = get_message_from_exception(event_hash) if message.nil? || message.empty?
-        message = '<no message value>' if message.nil? || message.empty?
-        message
+
+        return message unless message.nil? || message.empty?
+
+        message = get_message_from_exception(event_hash)
+
+        return message unless message.nil? || message.empty?
+
+        message = event_hash[:transaction] || event_hash["transaction"]
+
+        return message unless message.nil? || message.empty?
+
+        '<no message value>'
       end
 
       def get_message_from_exception(event_hash)
-        (
-          event_hash &&
-          event_hash[:exception] &&
-          event_hash[:exception][:values] &&
-          event_hash[:exception][:values][0] &&
-          "#{event_hash[:exception][:values][0][:type]}: #{event_hash[:exception][:values][0][:value]}"
-        )
+        if exception = event_hash.dig(:exception, :values, 0)
+          "#{exception[:type]}: #{exception[:value]}"
+        elsif exception = event_hash.dig("exception", "values", 0)
+          "#{exception["type"]}: #{exception["value"]}"
+        end
       end
     end
 
@@ -99,9 +106,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[:threads] = threads.to_hash if threads
 
       data
     end
@@ -111,42 +118,23 @@ module Sentry
     end
 
     def add_request_interface(env)
-      @request = Sentry::RequestInterface.from_rack(env)
+      @request = Sentry::RequestInterface.build(env: env)
     end
 
-    def add_exception_interface(exc)
-      if exc.respond_to?(:sentry_context)
-        @extra.merge!(exc.sentry_context)
-      end
+    def add_threads_interface(backtrace: nil, **options)
+      @threads = ThreadsInterface.build(
+        backtrace: backtrace,
+        stacktrace_builder: configuration.stacktrace_builder,
+        **options
+      )
+    end
 
-      @exception = Sentry::ExceptionInterface.new.tap do |exc_int|
-        exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exc).reverse
-        backtraces = Set.new
-        exc_int.values = exceptions.map do |e|
-          SingleExceptionInterface.new.tap do |int|
-            int.type = e.class.to_s
-            int.value = e.message.byteslice(0..MAX_MESSAGE_SIZE_IN_BYTES)
-            int.module = e.class.to_s.split('::')[0...-1].join('::')
-
-            int.stacktrace =
-              if e.backtrace && !backtraces.include?(e.backtrace.object_id)
-                backtraces << e.backtrace.object_id
-                initialize_stacktrace_interface(e.backtrace)
-              end
-          end
-        end
+    def add_exception_interface(exception)
+      if exception.respond_to?(:sentry_context)
+        @extra.merge!(exception.sentry_context)
       end
-    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
-      )
+      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: configuration.stacktrace_builder)
     end
 
     private
@@ -166,7 +154,8 @@ module Sentry
         :remote_addr => env["REMOTE_ADDR"],
         :client_ip => env["HTTP_CLIENT_IP"],
         :real_ip => env["HTTP_X_REAL_IP"],
-        :forwarded_for => env["HTTP_X_FORWARDED_FOR"]
+        :forwarded_for => env["HTTP_X_FORWARDED_FOR"],
+        :trusted_proxies => configuration.trusted_proxies
       ).calculate_ip
     end
   end

data/lib/sentry/exceptions.rb

@@ -0,0 +1,7 @@
+module Sentry
+  class Error < StandardError
+  end
+
+  class ExternalError < StandardError
+  end
+end

data/lib/sentry/hub.rb

@@ -69,9 +69,11 @@ module Sentry
       @stack.pop
     end
 
-    def start_transaction(transaction: nil, **options)
+    def start_transaction(transaction: nil, configuration: Sentry.configuration, **options)
+      return unless configuration.tracing_enabled?
+
       transaction ||= Transaction.new(**options)
-      transaction.set_initial_sample_desicion
+      transaction.set_initial_sample_decision(configuration: current_client.configuration)
       transaction
     end
 
@@ -120,7 +122,13 @@ module Sentry
       event
     end
 
-    def add_breadcrumb(breadcrumb)
+    def add_breadcrumb(breadcrumb, hint: {})
+      if before_breadcrumb = current_client.configuration.before_breadcrumb
+        breadcrumb = before_breadcrumb.call(breadcrumb, hint)
+      end
+
+      return unless breadcrumb
+
       current_scope.add_breadcrumb(breadcrumb)
     end
 

data/lib/sentry/interface.rb

@@ -20,3 +20,4 @@ require "sentry/interfaces/exception"
 require "sentry/interfaces/request"
 require "sentry/interfaces/single_exception"
 require "sentry/interfaces/stacktrace"
+require "sentry/interfaces/threads"

data/lib/sentry/interfaces/exception.rb

@@ -1,11 +1,29 @@
 module Sentry
   class ExceptionInterface < Interface
-    attr_accessor :values
+    def initialize(values:)
+      @values = values
+    end
 
     def to_hash
       data = super
       data[:values] = data[:values].map(&:to_hash) if data[:values]
       data
     end
+
+    def self.build(exception:, stacktrace_builder:)
+      exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exception).reverse
+      processed_backtrace_ids = Set.new
+
+      exceptions = exceptions.map do |e|
+        if e.backtrace && !processed_backtrace_ids.include?(e.backtrace.object_id)
+          processed_backtrace_ids << e.backtrace.object_id
+          SingleExceptionInterface.build_with_stacktrace(exception: e, stacktrace_builder: stacktrace_builder)
+        else
+          SingleExceptionInterface.new(exception: exception)
+        end
+      end
+
+      new(values: exceptions)
+    end
   end
 end

data/lib/sentry/interfaces/request.rb

@@ -17,10 +17,10 @@ module Sentry
 
     attr_accessor :url, :method, :data, :query_string, :cookies, :headers, :env
 
-    def self.from_rack(env)
+    def self.build(env:)
       env = clean_env(env)
-      req = ::Rack::Request.new(env)
-      self.new(req)
+      request = ::Rack::Request.new(env)
+      self.new(request: request)
     end
 
     def self.clean_env(env)
@@ -34,17 +34,17 @@ module Sentry
       env
     end
 
-    def initialize(req)
-      env = req.env
+    def initialize(request:)
+      env = request.env
 
       if Sentry.configuration.send_default_pii
-        self.data = read_data_from(req)
-        self.cookies = req.cookies
+        self.data = read_data_from(request)
+        self.cookies = request.cookies
+        self.query_string = request.query_string
       end
 
-      self.url = req.scheme && req.url.split('?').first
-      self.method = req.request_method
-      self.query_string = req.query_string
+      self.url = request.scheme && request.url.split('?').first
+      self.method = request.request_method
 
       self.headers = filter_and_format_headers(env)
       self.env     = filter_and_format_env(env)

data/lib/sentry/interfaces/single_exception.rb

@@ -1,14 +1,26 @@
 module Sentry
   class SingleExceptionInterface < Interface
-    attr_accessor :type
-    attr_accessor :value
-    attr_accessor :module
-    attr_accessor :stacktrace
+    attr_reader :type, :value, :module, :thread_id, :stacktrace
+
+    def initialize(exception:, stacktrace: nil)
+      @type = exception.class.to_s
+      @value = (exception.message || "").byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES)
+      @module = exception.class.to_s.split('::')[0...-1].join('::')
+      @thread_id = Thread.current.object_id
+      @stacktrace = stacktrace
+    end
 
     def to_hash
       data = super
       data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
       data
     end
+
+    # patch this method if you want to change an exception's stacktrace frames
+    # also see `StacktraceBuilder.build`.
+    def self.build_with_stacktrace(exception:, stacktrace_builder:)
+      stacktrace = stacktrace_builder.build(backtrace: exception.backtrace)
+      new(exception: exception, stacktrace: stacktrace)
+    end
   end
 end

data/lib/sentry/interfaces/stacktrace.rb

@@ -2,18 +2,8 @@ module Sentry
   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
+    def initialize(frames:)
+      @frames = frames
     end
 
     def to_hash
@@ -22,30 +12,24 @@ module Sentry
 
     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
     class Frame < Interface
-      attr_accessor :abs_path, :context_line, :function, :in_app,
-                    :lineno, :module, :pre_context, :post_context, :vars
+      attr_accessor :abs_path, :context_line, :function, :in_app, :filename,
+                  :lineno, :module, :pre_context, :post_context, :vars
 
       def initialize(project_root, line)
         @project_root = project_root
 
-        @abs_path = line.file if line.file
+        @abs_path = line.file
         @function = line.method if line.method
         @lineno = line.number
         @in_app = line.in_app
         @module = line.module_name if line.module_name
+        @filename = compute_filename
       end
 
-      def filename
+      def compute_filename
         return if abs_path.nil?
-        return @filename if instance_variable_defined?(:@filename)
 
         prefix =
           if under_project_root? && in_app
@@ -56,19 +40,18 @@ module Sentry
             longest_load_path
           end
 
-        @filename = prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
+        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 = \
+        @pre_context, @context_line, @post_context = \
             linecache.get_file_context(abs_path, lineno, context_lines)
       end
 
       def to_hash(*args)
         data = super(*args)
-        data[:filename] = filename
         data.delete(:vars) unless vars && !vars.empty?
         data.delete(:pre_context) unless pre_context && !pre_context.empty?
         data.delete(:post_context) unless post_context && !post_context.empty?