sentry-ruby-core 4.8.1 → 5.1.0

data/lib/sentry/event.rb

@@ -10,31 +10,40 @@ require 'sentry/utils/custom_inspection'
 
 module Sentry
   class Event
+    # These are readable attributes.
     SERIALIZEABLE_ATTRIBUTES = %i(
       event_id level timestamp
       release environment server_name modules
       message user tags contexts extra
-      fingerprint breadcrumbs backtrace transaction
+      fingerprint breadcrumbs transaction
       platform sdk type
     )
 
+    # These are writable attributes.
     WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i(type timestamp level)
 
     MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
 
-    SKIP_INSPECTION_ATTRIBUTES = [:@configuration, :@modules, :@backtrace]
+    SKIP_INSPECTION_ATTRIBUTES = [:@modules, :@stacktrace_builder, :@send_default_pii, :@trusted_proxies, :@rack_env_whitelist]
 
     include CustomInspection
 
     attr_writer(*WRITER_ATTRIBUTES)
     attr_reader(*SERIALIZEABLE_ATTRIBUTES)
 
-    attr_reader :configuration, :request, :exception, :threads
+    # @return [RequestInterface]
+    attr_reader :request
 
-    def initialize(configuration:, integration_meta: nil, message: nil)
-      # this needs to go first because some setters rely on configuration
-      @configuration = configuration
+    # @return [ExceptionInterface]
+    attr_reader :exception
+
+    # @return [ThreadsInterface]
+    attr_reader :threads
 
+    # @param configuration [Configuration]
+    # @param integration_meta [Hash, nil]
+    # @param message [String, nil]
+    def initialize(configuration:, integration_meta: nil, message: nil)
       # Set some simple default values
       @event_id      = SecureRandom.uuid.delete("-")
       @timestamp     = Sentry.utc_now.iso8601
@@ -48,17 +57,25 @@ module Sentry
 
       @fingerprint = []
 
+      # configuration data that's directly used by events
       @server_name = configuration.server_name
       @environment = configuration.environment
       @release = configuration.release
       @modules = configuration.gem_specs if configuration.send_modules
 
+      # configuration options to help events process data
+      @send_default_pii = configuration.send_default_pii
+      @trusted_proxies = configuration.trusted_proxies
+      @stacktrace_builder = configuration.stacktrace_builder
+      @rack_env_whitelist = configuration.rack_env_whitelist
+
       @message = (message || "").byteslice(0..MAX_MESSAGE_SIZE_IN_BYTES)
 
       self.level = :error
     end
 
     class << self
+      # @!visibility private
       def get_log_message(event_hash)
         message = event_hash[:message] || event_hash['message']
 
@@ -75,6 +92,7 @@ module Sentry
         '<no message value>'
       end
 
+      # @!visibility private
       def get_message_from_exception(event_hash)
         if exception = event_hash.dig(:exception, :values, 0)
           "#{exception[:type]}: #{exception[:value]}"
@@ -84,21 +102,35 @@ module Sentry
       end
     end
 
+    # @deprecated This method will be removed in v5.0.0. Please just use Sentry.configuration
+    # @return [Configuration]
+    def configuration
+      Sentry.configuration
+    end
+
+    # Sets the event's timestamp.
+    # @param time [Time, Float]
+    # @return [void]
     def timestamp=(time)
       @timestamp = time.is_a?(Time) ? time.to_f : time
     end
 
-    def level=(new_level) # needed to meet the Sentry spec
-      @level = new_level.to_s == "warn" ? :warning : new_level
+    # Sets the event's level.
+    # @param level [String, Symbol]
+    # @return [void]
+    def level=(level) # needed to meet the Sentry spec
+      @level = level.to_s == "warn" ? :warning : level
     end
 
+    # Sets the event's request environment data with RequestInterface.
+    # @see RequestInterface
+    # @param env [Hash]
+    # @return [void]
     def rack_env=(env)
       unless request || env.empty?
-        env = env.dup
-
         add_request_interface(env)
 
-        if configuration.send_default_pii
+        if @send_default_pii
           user[:ip_address] = calculate_real_ip_from_rack(env)
         end
 
@@ -108,6 +140,7 @@ module Sentry
       end
     end
 
+    # @return [Hash]
     def to_hash
       data = serialize_attributes
       data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
@@ -118,32 +151,35 @@ module Sentry
       data
     end
 
+    # @return [Hash]
     def to_json_compatible
       JSON.parse(JSON.generate(to_hash))
     end
 
-    def add_request_interface(env)
-      @request = Sentry::RequestInterface.build(env: env)
-    end
-
+    # @!visibility private
     def add_threads_interface(backtrace: nil, **options)
       @threads = ThreadsInterface.build(
         backtrace: backtrace,
-        stacktrace_builder: configuration.stacktrace_builder,
+        stacktrace_builder: @stacktrace_builder,
         **options
       )
     end
 
+    # @!visibility private
     def add_exception_interface(exception)
       if exception.respond_to?(:sentry_context)
         @extra.merge!(exception.sentry_context)
       end
 
-      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: configuration.stacktrace_builder)
+      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: @stacktrace_builder)
     end
 
     private
 
+    def add_request_interface(env)
+      @request = Sentry::RequestInterface.new(env: env, send_default_pii: @send_default_pii, rack_env_whitelist: @rack_env_whitelist)
+    end
+
     def serialize_attributes
       self.class::SERIALIZEABLE_ATTRIBUTES.each_with_object({}) do |att, memo|
         if value = public_send(att)
@@ -160,7 +196,7 @@ module Sentry
         :client_ip => env["HTTP_CLIENT_IP"],
         :real_ip => env["HTTP_X_REAL_IP"],
         :forwarded_for => env["HTTP_X_FORWARDED_FOR"],
-        :trusted_proxies => configuration.trusted_proxies
+        :trusted_proxies => @trusted_proxies
       ).calculate_ip
     end
   end

data/lib/sentry/hub.rb

@@ -102,7 +102,10 @@ module Sentry
 
       return unless event
 
-      capture_event(event, **options, &block)
+      capture_event(event, **options, &block).tap do
+        # mark the exception as captured so we can use this information to avoid duplicated capturing
+        exception.instance_variable_set(:@__sentry_captured, true)
+      end
     end
 
     def capture_message(message, **options, &block)
@@ -114,6 +117,9 @@ module Sentry
       options[:hint][:message] = message
       backtrace = options.delete(:backtrace)
       event = current_client.event_from_message(message, options[:hint], backtrace: backtrace)
+
+      return unless event
+
       capture_event(event, **options, &block)
     end
 

data/lib/sentry/interface.rb

@@ -2,16 +2,7 @@
 
 module Sentry
   class Interface
-    def self.inherited(klass)
-      name = klass.name.split("::").last.downcase.gsub("interface", "")
-      registered[name.to_sym] = klass
-      super
-    end
-
-    def self.registered
-      @@registered ||= {} # rubocop:disable Style/ClassVars
-    end
-
+    # @return [Hash]
     def to_hash
       Hash[instance_variables.map { |name| [name[1..-1].to_sym, instance_variable_get(name)] }]
     end

data/lib/sentry/interfaces/exception.rb

@@ -2,16 +2,24 @@
 
 module Sentry
   class ExceptionInterface < Interface
-    def initialize(values:)
-      @values = values
+    # @param exceptions [Array<SingleExceptionInterface>]
+    def initialize(exceptions:)
+      @values = exceptions
     end
 
+    # @return [Hash]
     def to_hash
       data = super
       data[:values] = data[:values].map(&:to_hash) if data[:values]
       data
     end
 
+    # Builds ExceptionInterface with given exception and stacktrace_builder.
+    # @param exception [Exception]
+    # @param stacktrace_builder [StacktraceBuilder]
+    # @see SingleExceptionInterface#build_with_stacktrace
+    # @see SingleExceptionInterface#initialize
+    # @return [ExceptionInterface]
     def self.build(exception:, stacktrace_builder:)
       exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exception).reverse
       processed_backtrace_ids = Set.new
@@ -25,7 +33,7 @@ module Sentry
         end
       end
 
-      new(values: exceptions)
+      new(exceptions: exceptions)
     end
   end
 end

data/lib/sentry/interfaces/request.rb

@@ -15,29 +15,45 @@ module Sentry
     # 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
+    # @return [String]
+    attr_accessor :url
 
-    def self.build(env:)
-      env = clean_env(env)
-      request = ::Rack::Request.new(env)
-      self.new(request: request)
-    end
+    # @return [String]
+    attr_accessor :method
+
+    # @return [Hash]
+    attr_accessor :data
+
+    # @return [String]
+    attr_accessor :query_string
+
+    # @return [String]
+    attr_accessor :cookies
+
+    # @return [Hash]
+    attr_accessor :headers
 
-    def self.clean_env(env)
-      unless Sentry.configuration.send_default_pii
+    # @return [Hash]
+    attr_accessor :env
+
+    # @param env [Hash]
+    # @param send_default_pii [Boolean]
+    # @param rack_env_whitelist [Array]
+    # @see Configuration#send_default_pii
+    # @see Configuration#rack_env_whitelist
+    def initialize(env:, send_default_pii:, rack_env_whitelist:)
+      env = env.dup
+
+      unless 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(request:)
-      env = request.env
+      request = ::Rack::Request.new(env)
 
-      if Sentry.configuration.send_default_pii
+      if send_default_pii
         self.data = read_data_from(request)
         self.cookies = request.cookies
         self.query_string = request.query_string
@@ -46,8 +62,8 @@ module Sentry
       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)
+      self.headers = filter_and_format_headers(env, send_default_pii)
+      self.env     = filter_and_format_env(env, rack_env_whitelist)
     end
 
     private
@@ -65,13 +81,14 @@ module Sentry
       e.message
     end
 
-    def filter_and_format_headers(env)
+    def filter_and_format_headers(env, send_default_pii)
       env.each_with_object({}) do |(key, value), memo|
         begin
           key = key.to_s # rack env can contain symbols
           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)
+          next if key == "HTTP_AUTHORIZATION" && !send_default_pii
 
           # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
           key = key.sub(/^HTTP_/, "")
@@ -116,11 +133,11 @@ module Sentry
       key == 'HTTP_VERSION' && value == protocol_version
     end
 
-    def filter_and_format_env(env)
-      return env if Sentry.configuration.rack_env_whitelist.empty?
+    def filter_and_format_env(env, rack_env_whitelist)
+      return env if rack_env_whitelist.empty?
 
       env.select do |k, _v|
-        Sentry.configuration.rack_env_whitelist.include? k.to_s
+        rack_env_whitelist.include? k.to_s
       end
     end
   end

data/lib/sentry/interfaces/stacktrace.rb

@@ -2,16 +2,20 @@
 
 module Sentry
   class StacktraceInterface
+    # @return [<Array[Frame]>]
     attr_reader :frames
 
+    # @param frames [<Array[Frame]>]
     def initialize(frames:)
       @frames = frames
     end
 
+    # @return [Hash]
     def to_hash
       { frames: @frames.map(&:to_hash) }
     end
 
+    # @return [String]
     def inspect
       @frames.map(&:to_s)
     end

data/lib/sentry/interfaces/stacktrace_builder.rb

@@ -2,8 +2,31 @@
 
 module Sentry
   class StacktraceBuilder
-    attr_reader :project_root, :app_dirs_pattern, :linecache, :context_lines, :backtrace_cleanup_callback
+    # @return [String]
+    attr_reader :project_root
 
+    # @return [Regexp, nil]
+    attr_reader :app_dirs_pattern
+
+    # @return [LineCache]
+    attr_reader :linecache
+
+    # @return [Integer, nil]
+    attr_reader :context_lines
+
+    # @return [Proc, nil]
+    attr_reader :backtrace_cleanup_callback
+
+    # @param project_root [String]
+    # @param app_dirs_pattern [Regexp, nil]
+    # @param linecache [LineCache]
+    # @param context_lines [Integer, nil]
+    # @param backtrace_cleanup_callback [Proc, nil]
+    # @see Configuration#project_root
+    # @see Configuration#app_dirs_pattern
+    # @see Configuration#linecache
+    # @see Configuration#context_lines
+    # @see Configuration#backtrace_cleanup_callback
     def initialize(project_root:, app_dirs_pattern:, linecache:, context_lines:, backtrace_cleanup_callback: nil)
       @project_root = project_root
       @app_dirs_pattern = app_dirs_pattern
@@ -12,17 +35,21 @@ module Sentry
       @backtrace_cleanup_callback = backtrace_cleanup_callback
     end
 
-    # you can pass a block to customize/exclude frames:
+    # Generates a StacktraceInterface with the given backtrace.
+    # You can pass a block to customize/exclude frames:
     #
-    # ```ruby
-    # builder.build(backtrace) do |frame|
-    #   if frame.module.match?(/a_gem/)
-    #     nil
-    #   else
-    #     frame
+    # @example
+    #   builder.build(backtrace) do |frame|
+    #     if frame.module.match?(/a_gem/)
+    #       nil
+    #     else
+    #       frame
+    #     end
     #   end
-    # end
-    # ```
+    # @param backtrace [Array<String>]
+    # @param frame_callback [Proc]
+    # @yieldparam frame [StacktraceInterface::Frame]
+    # @return [StacktraceInterface]
     def build(backtrace:, &frame_callback)
       parsed_lines = parse_backtrace_lines(backtrace).select(&:file)
 

data/lib/sentry/interfaces/threads.rb

@@ -2,6 +2,8 @@
 
 module Sentry
   class ThreadsInterface
+    # @param crashed [Boolean]
+    # @param stacktrace [Array]
     def initialize(crashed: false, stacktrace: nil)
       @id = Thread.current.object_id
       @name = Thread.current.name
@@ -10,6 +12,7 @@ module Sentry
       @stacktrace = stacktrace
     end
 
+    # @return [Hash]
     def to_hash
       {
         values: [
@@ -24,8 +27,13 @@ module Sentry
       }
     end
 
-    # patch this method if you want to change a threads interface's stacktrace frames
-    # also see `StacktraceBuilder.build`.
+    # Builds the ThreadsInterface with given backtrace and stacktrace_builder.
+    # Patch this method if you want to change a threads interface's stacktrace frames.
+    # @see StacktraceBuilder.build
+    # @param backtrace [Array]
+    # @param stacktrace_builder [StacktraceBuilder]
+    # @param crashed [Hash]
+    # @return [ThreadsInterface]
     def self.build(backtrace:, stacktrace_builder:, **options)
       stacktrace = stacktrace_builder.build(backtrace: backtrace) if backtrace
       new(**options, stacktrace: stacktrace)

data/lib/sentry/linecache.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Sentry
+  # @api private
   class LineCache
     def initialize
       @cache = {}

data/lib/sentry/net/http.rb

@@ -3,9 +3,11 @@
 require "net/http"
 
 module Sentry
+  # @api private
   module Net
     module HTTP
-      OP_NAME = "net.http"
+      OP_NAME = "http.client"
+      BREADCRUMB_CATEGORY = "net.http"
 
       # To explain how the entire thing works, we need to know how the original Net::HTTP#request works
       # Here's part of its definition. As you can see, it usually calls itself inside a #start block
@@ -22,90 +24,67 @@ module Sentry
       # end
       # ```
       #
-      # So when the entire flow looks like this:
-      #
-      # 1. #request is called.
-      #   - But because the request hasn't started yet, it calls #start (which then calls #do_start)
-      #   - At this moment @sentry_span is still nil, so #set_sentry_trace_header returns early
-      # 2. #do_start then creates a new Span and assigns it to @sentry_span
-      # 3. #request is called for the second time.
-      #   - This time @sentry_span should present. So #set_sentry_trace_header will set the sentry-trace header on the request object
-      # 4. Once the request finished, it
-      #   - Records a breadcrumb if http_logger is set
-      #   - Finishes the Span inside @sentry_span and clears the instance variable
-      #
+      # So we're only instrumenting request when `Net::HTTP` is already started
       def request(req, body = nil, &block)
-        set_sentry_trace_header(req)
+        return super unless started?
+
+        sentry_span = start_sentry_span
+        set_sentry_trace_header(req, sentry_span)
 
         super.tap do |res|
           record_sentry_breadcrumb(req, res)
-          record_sentry_span(req, res)
-        end
-      end
-
-      def do_start
-        super.tap do
-          start_sentry_span
-        end
-      end
-
-      def do_finish
-        super.tap do
-          finish_sentry_span
+          record_sentry_span(req, res, sentry_span)
         end
       end
 
       private
 
-      def set_sentry_trace_header(req)
-        return unless @sentry_span
+      def set_sentry_trace_header(req, sentry_span)
+        return unless sentry_span
 
-        trace = Sentry.get_current_client.generate_sentry_trace(@sentry_span)
+        trace = Sentry.get_current_client.generate_sentry_trace(sentry_span)
         req[SENTRY_TRACE_HEADER_NAME] = trace if trace
       end
 
       def record_sentry_breadcrumb(req, res)
-        if Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
-          return if from_sentry_sdk?
-
-          request_info = extract_request_info(req)
-          crumb = Sentry::Breadcrumb.new(
-            level: :info,
-            category: OP_NAME,
-            type: :info,
-            data: {
-              method: request_info[:method],
-              url: request_info[:url],
-              status: res.code.to_i
-            }
-          )
-          Sentry.add_breadcrumb(crumb)
-        end
+        return unless Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
+        return if from_sentry_sdk?
+
+        request_info = extract_request_info(req)
+
+        crumb = Sentry::Breadcrumb.new(
+          level: :info,
+          category: BREADCRUMB_CATEGORY,
+          type: :info,
+          data: {
+            status: res.code.to_i,
+            **request_info
+          }
+        )
+        Sentry.add_breadcrumb(crumb)
       end
 
-      def record_sentry_span(req, res)
-        if Sentry.initialized? && @sentry_span
-          request_info = extract_request_info(req)
-          @sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
-          @sentry_span.set_data(:status, res.code.to_i)
-        end
+      def record_sentry_span(req, res, sentry_span)
+        return unless Sentry.initialized? && sentry_span
+
+        request_info = extract_request_info(req)
+        sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
+        sentry_span.set_data(:status, res.code.to_i)
+        finish_sentry_span(sentry_span)
       end
 
       def start_sentry_span
-        if Sentry.initialized? && transaction = Sentry.get_current_scope.get_transaction
-          return if from_sentry_sdk?
-          return if transaction.sampled == false
+        return unless Sentry.initialized? && transaction = Sentry.get_current_scope.get_transaction
+        return if from_sentry_sdk?
+        return if transaction.sampled == false
 
-          child_span = transaction.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
-          @sentry_span = child_span
-        end
+        transaction.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
       end
 
-      def finish_sentry_span
-        if Sentry.initialized? && @sentry_span
-          @sentry_span.set_timestamp(Sentry.utc_now.to_f)
-          @sentry_span = nil
-        end
+      def finish_sentry_span(sentry_span)
+        return unless Sentry.initialized? && sentry_span
+
+        sentry_span.set_timestamp(Sentry.utc_now.to_f)
       end
 
       def from_sentry_sdk?
@@ -114,9 +93,17 @@ module Sentry
       end
 
       def extract_request_info(req)
-        uri = req.uri
+        uri = req.uri || URI.parse("#{use_ssl? ? 'https' : 'http'}://#{address}#{req.path}")
         url = "#{uri.scheme}://#{uri.host}#{uri.path}" rescue uri.to_s
-        { method: req.method, url: url }
+
+        result = { method: req.method, url: url }
+
+        if Sentry.configuration.send_default_pii
+          result[:url] = result[:url] + "?#{uri.query}"
+          result[:body] = req.body
+        end
+
+        result
       end
     end
   end

data/lib/sentry/rake.rb

@@ -6,6 +6,7 @@ require "rake/task"
 module Sentry
   module Rake
     module Application
+      # @api private
       def display_error_message(ex)
         Sentry.capture_exception(ex) do |scope|
           task_name = top_level_tasks.join(' ')
@@ -18,6 +19,7 @@ module Sentry
     end
 
     module Task
+      # @api private
       def execute(args=nil)
         return super unless Sentry.initialized? && Sentry.get_current_hub
 
@@ -27,5 +29,13 @@ module Sentry
   end
 end
 
-Rake::Application.prepend(Sentry::Rake::Application)
-Rake::Task.prepend(Sentry::Rake::Task)
+# @api private
+module Rake
+  class Application
+    prepend(Sentry::Rake::Application)
+  end
+
+  class Task
+    prepend(Sentry::Rake::Task)
+  end
+end