sentry-ruby-core 4.4.2 → 5.0.0

data/lib/sentry/envelope.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class Envelope
+    def initialize(headers)
+      @headers = headers
+      @items = []
+    end
+
+    def add_item(headers, payload)
+      @items << [headers, payload]
+    end
+
+    def to_s
+      payload = @items.map do |item_headers, item_payload|
+        <<~ENVELOPE
+          #{JSON.generate(item_headers)}
+          #{JSON.generate(item_payload)}
+        ENVELOPE
+      end.join("\n")
+
+      "#{JSON.generate(@headers)}\n#{payload}"
+    end
+  end
+end

data/lib/sentry/event.rb

@@ -6,26 +6,44 @@ require 'sentry/interface'
 require 'sentry/backtrace'
 require 'sentry/utils/real_ip'
 require 'sentry/utils/request_id'
+require 'sentry/utils/custom_inspection'
 
 module Sentry
   class Event
-    ATTRIBUTES = %i(
+    # 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
 
-    attr_accessor(*ATTRIBUTES)
-    attr_reader :configuration, :request, :exception, :threads
+    SKIP_INSPECTION_ATTRIBUTES = [:@modules, :@stacktrace_builder, :@send_default_pii, :@trusted_proxies, :@rack_env_whitelist]
 
-    def initialize(configuration:, integration_meta: nil, message: nil)
-      # this needs to go first because some setters rely on configuration
-      @configuration = configuration
+    include CustomInspection
+
+    attr_writer(*WRITER_ATTRIBUTES)
+    attr_reader(*SERIALIZEABLE_ATTRIBUTES)
+
+    # @return [RequestInterface]
+    attr_reader :request
+
+    # @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
@@ -39,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']
 
@@ -66,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]}"
@@ -75,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
 
@@ -99,9 +140,7 @@ module Sentry
       end
     end
 
-    def type
-    end
-
+    # @return [Hash]
     def to_hash
       data = serialize_attributes
       data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
@@ -112,34 +151,37 @@ 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::ATTRIBUTES.each_with_object({}) do |att, memo|
+      self.class::SERIALIZEABLE_ATTRIBUTES.each_with_object({}) do |att, memo|
         if value = public_send(att)
           memo[att] = value
         end
@@ -154,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/exceptions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   class Error < StandardError
   end

data/lib/sentry/hub.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sentry/scope"
 require "sentry/client"
 
@@ -90,10 +92,10 @@ module Sentry
     end
 
     def capture_exception(exception, **options, &block)
-      return unless current_client
-
       check_argument_type!(exception, ::Exception)
 
+      return unless current_client
+
       options[:hint] ||= {}
       options[:hint][:exception] = exception
       event = current_client.event_from_exception(exception, options[:hint])
@@ -104,19 +106,25 @@ module Sentry
     end
 
     def capture_message(message, **options, &block)
+      check_argument_type!(message, ::String)
+
       return unless current_client
 
       options[:hint] ||= {}
       options[:hint][:message] = message
-      event = current_client.event_from_message(message, options[:hint])
+      backtrace = options.delete(:backtrace)
+      event = current_client.event_from_message(message, options[:hint], backtrace: backtrace)
+
+      return unless event
+
       capture_event(event, **options, &block)
     end
 
     def capture_event(event, **options, &block)
-      return unless current_client
-
       check_argument_type!(event, Sentry::Event)
 
+      return unless current_client
+
       hint = options.delete(:hint) || {}
       scope = current_scope.dup
 
@@ -130,11 +138,18 @@ module Sentry
 
       event = current_client.capture_event(event, scope, hint)
 
+
+      if event && configuration.debug
+        configuration.log_debug(event.to_json_compatible)
+      end
+
       @last_event_id = event&.event_id
       event
     end
 
     def add_breadcrumb(breadcrumb, hint: {})
+      return unless configuration.enabled_in_current_env?
+
       if before_breadcrumb = current_client.configuration.before_breadcrumb
         breadcrumb = before_breadcrumb.call(breadcrumb, hint)
       end
@@ -144,6 +159,17 @@ module Sentry
       current_scope.add_breadcrumb(breadcrumb)
     end
 
+    # this doesn't do anything to the already initialized background worker
+    # but it temporarily disables dispatching events to it
+    def with_background_worker_disabled(&block)
+      original_background_worker_threads = configuration.background_worker_threads
+      configuration.background_worker_threads = 0
+
+      block.call
+    ensure
+      configuration.background_worker_threads = original_background_worker_threads
+    end
+
     private
 
     def current_layer

data/lib/sentry/integrable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Integrable
     def register_integration(name:, version:)

data/lib/sentry/interface.rb

@@ -1,15 +1,8 @@
+# frozen_string_literal: true
+
 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

@@ -1,15 +1,25 @@
+# frozen_string_literal: true
+
 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
@@ -23,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
 
-    def self.clean_env(env)
-      unless Sentry.configuration.send_default_pii
+    # @return [Hash]
+    attr_accessor :headers
+
+    # @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
@@ -47,7 +63,7 @@ module Sentry
       self.method = request.request_method
 
       self.headers = filter_and_format_headers(env)
-      self.env     = filter_and_format_env(env)
+      self.env     = filter_and_format_env(env, rack_env_whitelist)
     end
 
     private
@@ -57,6 +73,7 @@ module Sentry
         request.POST
       elsif request.body # JSON requests, etc
         data = request.body.read(MAX_BODY_LIMIT)
+        data = encode_to_utf_8(data.to_s)
         request.body.rewind
         data
       end
@@ -75,7 +92,8 @@ module Sentry
           # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
           key = key.sub(/^HTTP_/, "")
           key = key.split('_').map(&:capitalize).join('-')
-          memo[key] = value.to_s
+
+          memo[key] = encode_to_utf_8(value.to_s)
         rescue StandardError => e
           # Rails adds objects to the Rack env that can sometimes raise exceptions
           # when `to_s` is called.
@@ -86,6 +104,18 @@ module Sentry
       end
     end
 
+    def encode_to_utf_8(value)
+      if value.encoding != Encoding::UTF_8 && value.respond_to?(:force_encoding)
+        value = value.dup.force_encoding(Encoding::UTF_8)
+      end
+
+      if !value.valid_encoding?
+        value = value.scrub
+      end
+
+      value
+    end
+
     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
@@ -102,11 +132,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/single_exception.rb

@@ -1,5 +1,16 @@
+# frozen_string_literal: true
+
+require "sentry/utils/exception_cause_chain"
+
 module Sentry
   class SingleExceptionInterface < Interface
+    include CustomInspection
+
+    SKIP_INSPECTION_ATTRIBUTES = [:@stacktrace]
+    PROBLEMATIC_LOCAL_VALUE_REPLACEMENT = "[ignored due to error]".freeze
+    OMISSION_MARK = "...".freeze
+    MAX_LOCAL_BYTES = 1024
+
     attr_reader :type, :value, :module, :thread_id, :stacktrace
 
     def initialize(exception:, stacktrace: nil)
@@ -20,6 +31,26 @@ module Sentry
     # also see `StacktraceBuilder.build`.
     def self.build_with_stacktrace(exception:, stacktrace_builder:)
       stacktrace = stacktrace_builder.build(backtrace: exception.backtrace)
+
+      if locals = exception.instance_variable_get(:@sentry_locals)
+        locals.each do |k, v|
+          locals[k] =
+            begin
+              v = v.inspect unless v.is_a?(String)
+
+              if v.length >= MAX_LOCAL_BYTES
+                v = v.byteslice(0..MAX_LOCAL_BYTES - 1) + OMISSION_MARK
+              end
+
+              v
+            rescue StandardError
+              PROBLEMATIC_LOCAL_VALUE_REPLACEMENT
+            end
+        end
+
+        stacktrace.frames.last.vars = locals
+      end
+
       new(exception: exception, stacktrace: stacktrace)
     end
   end

data/lib/sentry/interfaces/stacktrace.rb

@@ -1,15 +1,25 @@
+# frozen_string_literal: true
+
 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
+
     private
 
     # Not actually an interface, but I want to use the same style
@@ -28,6 +38,10 @@ module Sentry
         @filename = compute_filename
       end
 
+      def to_s
+        "#{@filename}:#{@lineno}"
+      end
+
       def compute_filename
         return if abs_path.nil?
 

data/lib/sentry/interfaces/stacktrace_builder.rb

@@ -1,7 +1,32 @@
+# frozen_string_literal: true
+
 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
@@ -10,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

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 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
@@ -8,6 +12,7 @@ module Sentry
       @stacktrace = stacktrace
     end
 
+    # @return [Hash]
     def to_hash
       {
         values: [
@@ -22,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,4 +1,7 @@
+# frozen_string_literal: true
+
 module Sentry
+  # @api private
   class LineCache
     def initialize
       @cache = {}