sentry-ruby-core 4.2.1 → 4.4.0.pre.beta.0

data/lib/sentry/client.rb

@@ -2,10 +2,13 @@ require "sentry/transport"
 
 module Sentry
   class Client
-    attr_reader :transport, :configuration
+    include LoggingHelper
+
+    attr_reader :transport, :configuration, :logger
 
     def initialize(configuration)
       @configuration = configuration
+      @logger = configuration.logger
 
       if transport_class = configuration.transport.transport_class
         @transport = transport_class.new(configuration)
@@ -26,32 +29,17 @@ module Sentry
       scope.apply_to_event(event, hint)
 
       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
-          event_hash = event.to_json_compatible
-
-          if async_block.arity == 2
-            hint = JSON.parse(JSON.generate(hint))
-            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)
-        end
+        dispatch_async_event(async_block, event, hint)
+      elsif hint.fetch(:background, true)
+        dispatch_background_event(event, hint)
       else
-        if hint.fetch(:background, true)
-          Sentry.background_worker.perform do
-            send_event(event, hint)
-          end
-        else
-          send_event(event, hint)
-        end
+        send_event(event, hint)
       end
 
       event
+    rescue => e
+      log_error("Event capturing failed", e, debug: configuration.debug)
+      nil
     end
 
     def event_from_exception(exception, hint = {})
@@ -85,16 +73,51 @@ module Sentry
 
     def send_event(event, hint = nil)
       event_type = event.is_a?(Event) ? event.type : event["type"]
-      event = configuration.before_send.call(event, hint) if configuration.before_send && event_type == "event"
 
-      if event.nil?
-        configuration.logger.info(LOGGER_PROGNAME) { "Discarded event because before_send returned nil" }
-        return
+      if event_type != TransactionEvent::TYPE && configuration.before_send
+        event = configuration.before_send.call(event, hint)
+
+        if event.nil?
+          log_info("Discarded event because before_send returned nil")
+          return
+        end
       end
 
       transport.send_event(event)
 
       event
+    rescue => e
+      loggable_event_type = (event_type || "event").capitalize
+      log_error("#{loggable_event_type} sending failed", e, debug: configuration.debug)
+
+      event_info = Event.get_log_message(event.to_hash)
+      log_info("Unreported #{loggable_event_type}: #{event_info}")
+      raise
+    end
+
+    private
+
+    def dispatch_background_event(event, hint)
+      Sentry.background_worker.perform do
+        send_event(event, hint)
+      end
+    end
+
+    def dispatch_async_event(async_block, event, hint)
+      # We have to convert to a JSON-like hash, because background job
+      # processors (esp ActiveJob) may not like weird types in the event hash
+      event_hash = event.to_json_compatible
+
+      if async_block.arity == 2
+        hint = JSON.parse(JSON.generate(hint))
+        async_block.call(event_hash, hint)
+      else
+        async_block.call(event_hash)
+      end
+    rescue => e
+      loggable_event_type = event_hash["type"] || "event"
+      log_error("Async #{loggable_event_type} sending failed", e, debug: configuration.debug)
+      send_event(event, hint)
     end
   end
 end

data/lib/sentry/configuration.rb

@@ -4,9 +4,11 @@ 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
+    include LoggingHelper
     # Directories to be recognized as part of your app. e.g. if you
     # have an `engines` dir at the root of your project, you may want
     # to set this to something like /(app|config|engines|lib)/
@@ -61,12 +63,19 @@ 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
 
     # RACK_ENV by default.
     attr_reader :environment
 
+    # Whether the SDK should run in the debugging mode. Default is false.
+    # If set to true, SDK errors will be logged with backtrace
+    attr_accessor :debug
+
     # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
     attr_reader :dsn
 
@@ -163,14 +172,14 @@ module Sentry
     LOG_PREFIX = "** [Sentry] ".freeze
     MODULE_SEPARATOR = "::".freeze
 
-    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.debug = false
       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
@@ -195,6 +204,7 @@ 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)
+
       run_post_initialization_callbacks
     end
 
@@ -220,10 +230,6 @@ module Sentry
         if logger.is_a?(Array)
           logger
         else
-          unless AVAILABLE_BREADCRUMBS_LOGGERS.include?(logger)
-            raise Sentry::Error, "Unsupported breadcrumbs logger. Supported loggers: #{AVAILABLE_BREADCRUMBS_LOGGERS}"
-          end
-
           Array(logger)
         end
 
@@ -272,10 +278,10 @@ module Sentry
     def exception_class_allowed?(exc)
       if exc.is_a?(Sentry::Error)
         # Try to prevent error reporting loops
-        logger.debug(LOGGER_PROGNAME) { "Refusing to capture Sentry error: #{exc.inspect}" }
+        log_debug("Refusing to capture Sentry error: #{exc.inspect}")
         false
       elsif excluded_exception?(exc)
-        logger.debug(LOGGER_PROGNAME) { "User excluded error: #{exc.inspect}" }
+        log_debug("User excluded error: #{exc.inspect}")
         false
       else
         true
@@ -287,7 +293,17 @@ module Sentry
     end
 
     def tracing_enabled?
-      !!((@traces_sample_rate && @traces_sample_rate > 0.0) || @traces_sampler)
+      !!((@traces_sample_rate && @traces_sample_rate >= 0.0 && @traces_sample_rate <= 1.0) || @traces_sampler)
+    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
@@ -298,7 +314,7 @@ module Sentry
         detect_release_from_capistrano ||
         detect_release_from_heroku
     rescue => e
-      logger.error(LOGGER_PROGNAME) { "Error detecting release: #{e.message}" }
+      log_error("Error detecting release", e, debug: debug)
     end
 
     def excluded_exception?(incoming_exception)
@@ -333,7 +349,7 @@ module Sentry
     def detect_release_from_heroku
       return unless running_on_heroku?
       return if ENV['CI']
-      logger.warn(LOGGER_PROGNAME) { HEROKU_DYNO_METADATA_MESSAGE } && return unless ENV['HEROKU_SLUG_COMMIT']
+      log_warn(HEROKU_DYNO_METADATA_MESSAGE) && return unless ENV['HEROKU_SLUG_COMMIT']
 
       ENV['HEROKU_SLUG_COMMIT']
     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, :threads
+    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
 
@@ -93,13 +100,11 @@ module Sentry
     end
 
     def type
-      "event"
     end
 
     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
@@ -112,47 +117,23 @@ module Sentry
     end
 
     def add_request_interface(env)
-      @request = Sentry::RequestInterface.from_rack(env)
+      @request = Sentry::RequestInterface.build(env: env)
     end
 
     def add_threads_interface(backtrace: nil, **options)
-      @threads = ThreadsInterface.new(**options)
-      @threads.stacktrace = initialize_stacktrace_interface(backtrace) if backtrace
+      @threads = ThreadsInterface.build(
+        backtrace: backtrace,
+        stacktrace_builder: configuration.stacktrace_builder,
+        **options
+      )
     end
 
-    def add_exception_interface(exc)
-      if exc.respond_to?(:sentry_context)
-        @extra.merge!(exc.sentry_context)
+    def add_exception_interface(exception)
+      if exception.respond_to?(:sentry_context)
+        @extra.merge!(exception.sentry_context)
       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
-      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

data/lib/sentry/exceptions.rb

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

data/lib/sentry/hub.rb

@@ -21,6 +21,10 @@ module Sentry
       current_layer&.client
     end
 
+    def configuration
+      current_client.configuration
+    end
+
     def current_scope
       current_layer&.scope
     end
@@ -69,9 +73,19 @@ module Sentry
       @stack.pop
     end
 
-    def start_transaction(transaction: nil, **options)
-      transaction ||= Transaction.new(**options)
-      transaction.set_initial_sample_desicion
+    def start_transaction(transaction: nil, custom_sampling_context: {}, **options)
+      return unless configuration.tracing_enabled?
+
+      transaction ||= Transaction.new(**options.merge(hub: self))
+
+      sampling_context = {
+        transaction_context: transaction.to_hash,
+        parent_sampled: transaction.parent_sampled
+      }
+
+      sampling_context.merge!(custom_sampling_context)
+
+      transaction.set_initial_sample_decision(sampling_context: sampling_context)
       transaction
     end
 

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)