sentry-ruby 0.2.0 → 4.1.1

data/lib/sentry/breadcrumb_buffer.rb

@@ -10,11 +10,8 @@ module Sentry
       @buffer = Array.new(size)
     end
 
-    def record(crumb = nil)
-      if block_given?
-        crumb = Breadcrumb.new if crumb.nil?
-        yield(crumb)
-      end
+    def record(crumb)
+      yield(crumb) if block_given?
       @buffer.slice!(0)
       @buffer << crumb
     end

data/lib/sentry/client.rb

@@ -20,8 +20,10 @@ module Sentry
       end
     end
 
-    def capture_event(event, scope)
-      scope.apply_to_event(event)
+    def capture_event(event, scope, hint = {})
+      return unless configuration.sending_allowed?
+
+      scope.apply_to_event(event, hint)
 
       if configuration.async?
         begin
@@ -30,10 +32,16 @@ module Sentry
           configuration.async.call(event.to_json_compatible)
         rescue => e
           configuration.logger.error(LOGGER_PROGNAME) { "async event sending failed: #{e.message}" }
-          send_event(event)
+          send_event(event, hint)
         end
       else
-        send_event(event)
+        if hint.fetch(:background, true)
+          Sentry.background_worker.perform do
+            send_event(event, hint)
+          end
+        else
+          send_event(event, hint)
+        end
       end
 
       event
@@ -63,10 +71,8 @@ module Sentry
       end
     end
 
-    def send_event(event)
-      return false unless configuration.sending_allowed?(event)
-
-      event = configuration.before_send.call(event) if configuration.before_send
+    def send_event(event, hint = nil)
+      event = configuration.before_send.call(event, hint) if configuration.before_send
       if event.nil?
         configuration.logger.info(LOGGER_PROGNAME) { "Discarded event because before_send returned nil" }
         return

data/lib/sentry/configuration.rb

@@ -1,3 +1,5 @@
+require "concurrent/utility/processor_counter"
+
 require "sentry/utils/exception_cause_chain"
 require "sentry/dsn"
 require "sentry/transport/configuration"
@@ -15,6 +17,15 @@ module Sentry
     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
+    # but you can configure it with this configuration option
+    # E.g.: config.background_worker_threads = 5
+    #
+    # if you want to send events synchronously, set the value to 0
+    # E.g.: config.background_worker_threads = 0
+    attr_accessor :background_worker_threads
+
     # a proc/lambda that takes an array of stack traces
     # it'll be used to silence (reduce) backtrace of the exception
     #
@@ -46,13 +57,13 @@ module Sentry
     attr_accessor :context_lines
 
     # RACK_ENV by default.
-    attr_reader :current_environment
+    attr_reader :environment
 
     # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
     attr_reader :dsn
 
-    # Whitelist of environments that will send notifications to Sentry. Array of Strings.
-    attr_accessor :environments
+    # Whitelist of enabled_environments that will send notifications to Sentry. Array of Strings.
+    attr_accessor :enabled_environments
 
     # Logger 'progname's to exclude from breadcrumbs
     attr_accessor :exclude_loggers
@@ -101,12 +112,6 @@ module Sentry
 
     attr_accessor :server_name
 
-    # Provide a configurable callback to determine event capture.
-    # Note that the object passed into the block will be a String (messages) or
-    # an exception.
-    # e.g. lambda { |exc_or_msg| exc_or_msg.some_attr == false }
-    attr_reader :should_capture
-
     # Return a Transport::Configuration object for transport-related configurations.
     attr_reader :transport
 
@@ -152,10 +157,11 @@ module Sentry
 
     def initialize
       self.async = false
+      self.background_worker_threads = Concurrent.processor_count
       self.breadcrumbs_logger = []
       self.context_lines = 3
-      self.current_environment = current_environment_from_env
-      self.environments = []
+      self.environment = environment_from_env
+      self.enabled_environments = []
       self.exclude_loggers = []
       self.excluded_exceptions = IGNORE_DEFAULT.dup
       self.inspect_exception_causes_for_exclusion = false
@@ -169,7 +175,6 @@ module Sentry
       self.send_default_pii = false
       self.dsn = ENV['SENTRY_DSN']
       self.server_name = server_name_from_env
-      self.should_capture = false
 
       self.before_send = false
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
@@ -213,14 +218,6 @@ module Sentry
       @breadcrumbs_logger = logger
     end
 
-    def should_capture=(value)
-      unless value == false || value.respond_to?(:call)
-        raise ArgumentError, "should_capture must be callable (or false to disable)"
-      end
-
-      @should_capture = value
-    end
-
     def before_send=(value)
       unless value == false || value.respond_to?(:call)
         raise ArgumentError, "before_send must be callable (or false to disable)"
@@ -229,20 +226,17 @@ module Sentry
       @before_send = value
     end
 
-    def current_environment=(environment)
-      @current_environment = environment.to_s
+    def environment=(environment)
+      @environment = environment.to_s
     end
 
-    def capture_allowed?(message_or_exc = nil)
+    def sending_allowed?
       @errors = []
 
       valid? &&
-        capture_in_current_environment? &&
-        capture_allowed_by_callback?(message_or_exc) &&
+        capture_in_environment? &&
         sample_allowed?
     end
-    # If we cannot capture, we cannot send.
-    alias sending_allowed? capture_allowed?
 
     def error_messages
       @errors = [@errors[0]] + @errors[1..-1].map(&:downcase) # fix case of all but first
@@ -267,7 +261,7 @@ module Sentry
     end
 
     def enabled_in_current_env?
-      environments.empty? || environments.include?(current_environment)
+      enabled_environments.empty? || enabled_environments.include?(environment)
     end
 
     def tracing_enabled?
@@ -353,17 +347,10 @@ module Sentry
       ENV['SENTRY_RELEASE']
     end
 
-    def capture_in_current_environment?
+    def capture_in_environment?
       return true if enabled_in_current_env?
 
-      @errors << "Not configured to send/capture in environment '#{current_environment}'"
-      false
-    end
-
-    def capture_allowed_by_callback?(message_or_exc)
-      return true if !should_capture || message_or_exc.nil? || should_capture.call(message_or_exc)
-
-      @errors << "should_capture returned false"
+      @errors << "Not configured to send/capture in environment '#{environment}'"
       false
     end
 
@@ -394,7 +381,7 @@ module Sentry
         Socket.gethostbyname(hostname).first rescue server_name
     end
 
-    def current_environment_from_env
+    def environment_from_env
       ENV['SENTRY_CURRENT_ENV'] || ENV['SENTRY_ENVIRONMENT'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'default'
     end
 

data/lib/sentry/event.rb

@@ -5,6 +5,7 @@ require 'securerandom'
 require 'sentry/interface'
 require 'sentry/backtrace'
 require 'sentry/utils/real_ip'
+require 'sentry/utils/request_id'
 
 module Sentry
   class Event
@@ -17,7 +18,7 @@ module Sentry
     )
 
     attr_accessor(*ATTRIBUTES)
-    attr_reader :configuration
+    attr_reader :configuration, :request, :exception, :stacktrace
 
     def initialize(configuration:, message: nil)
       # this needs to go first because some setters rely on configuration
@@ -37,7 +38,7 @@ module Sentry
       @fingerprint = []
 
       @server_name = configuration.server_name
-      @environment = configuration.current_environment
+      @environment = configuration.environment
       @release = configuration.release
       @modules = configuration.gem_specs if configuration.send_modules
 
@@ -74,7 +75,7 @@ module Sentry
     end
 
     def rack_env=(env)
-      unless @request || env.empty?
+      unless request || env.empty?
         @request = Sentry::RequestInterface.new.tap do |int|
           int.from_rack(env)
         end
@@ -82,6 +83,9 @@ module Sentry
         if configuration.send_default_pii && ip = calculate_real_ip_from_rack(env.dup)
           user[:ip_address] = ip
         end
+        if request_id = Utils::RequestId.read_from(env)
+          tags[:request_id] = request_id
+        end
       end
     end
 
@@ -92,9 +96,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[:stacktrace] = stacktrace.to_hash if stacktrace
+      data[:request] = request.to_hash if request
+      data[:exception] = exception.to_hash if exception
 
       data
     end

data/lib/sentry/hub.rb

@@ -80,12 +80,16 @@ module Sentry
 
       return unless event
 
+      options[:hint] ||= {}
+      options[:hint] = options[:hint].merge(exception: exception)
       capture_event(event, **options, &block)
     end
 
     def capture_message(message, **options, &block)
       return unless current_client
 
+      options[:hint] ||= {}
+      options[:hint] = options[:hint].merge(message: message)
       event = current_client.event_from_message(message)
       capture_event(event, **options, &block)
     end
@@ -93,6 +97,7 @@ module Sentry
     def capture_event(event, **options, &block)
       return unless current_client
 
+      hint = options.delete(:hint) || {}
       scope = current_scope.dup
 
       if block
@@ -103,9 +108,9 @@ module Sentry
         scope.update_from_options(**options)
       end
 
-      event = current_client.capture_event(event, scope)
+      event = current_client.capture_event(event, scope, hint)
 
-      @last_event_id = event.event_id
+      @last_event_id = event&.event_id
       event
     end
 

data/lib/sentry/interfaces/request.rb

@@ -1,5 +1,3 @@
-require 'rack'
-
 module Sentry
   class RequestInterface < Interface
     REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
@@ -18,36 +16,8 @@ module Sentry
       self.cookies = nil
     end
 
-    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
-
     private
 
-    # Request ID based on ActionDispatch::RequestId
-    def read_request_id_from(env_hash)
-      REQUEST_ID_HEADERS.each do |key|
-        request_id = env_hash[key]
-        return request_id if request_id
-      end
-      nil
-    end
-
     # See Sentry server default limits at
     # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
     def read_data_from(request)
@@ -67,7 +37,7 @@ module Sentry
         begin
           key = key.to_s # rack env can contain symbols
           value = value.to_s
-          next memo['X-Request-Id'] ||= read_request_id_from(env_hash) if REQUEST_ID_HEADERS.include?(key)
+          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

data/lib/sentry/rack.rb

@@ -1,5 +1,5 @@
-require 'time'
 require 'rack'
 
-require 'sentry/rack/capture_exception'
-require 'sentry/rack/tracing'
+require 'sentry/rack/capture_exceptions'
+require 'sentry/rack/interface'
+require 'sentry/rack/deprecations'

data/lib/sentry/rack/{capture_exception.rb → capture_exceptions.rb}

@@ -1,45 +1,54 @@
 module Sentry
   module Rack
-    class CaptureException
+    class CaptureExceptions
       def initialize(app)
         @app = app
       end
 
       def call(env)
-        # this call clones the main (global) hub
-        # and assigns it to the current thread's Sentry#get_current_hub
-        # it's essential for multi-thread servers (e.g. puma)
-        Sentry.clone_hub_to_current_thread unless Sentry.get_current_hub
-        # this call creates an isolated scope for every request
-        # it's essential for multi-process servers (e.g. unicorn)
+        return @app.call(env) unless Sentry.initialized?
+
+        # make sure the current thread has a clean hub
+        Sentry.clone_hub_to_current_thread
+
         Sentry.with_scope do |scope|
-          # there could be some breadcrumbs already stored in the top-level scope
-          # and for request information, we don't need those breadcrumbs
           scope.clear_breadcrumbs
-          env['sentry.client'] = Sentry.get_current_client
-
           scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
           scope.set_rack_env(env)
 
+          span = Sentry.start_transaction(name: scope.transaction_name, op: "rack.request")
+          scope.set_span(span)
+
           begin
             response = @app.call(env)
           rescue Sentry::Error
+            finish_span(span, 500)
             raise # Don't capture Sentry errors
           rescue Exception => e
             Sentry.capture_exception(e)
+            finish_span(span, 500)
             raise
           end
 
           exception = collect_exception(env)
           Sentry.capture_exception(exception) if exception
 
+          finish_span(span, response[0])
+
           response
         end
       end
 
+      private
+
       def collect_exception(env)
         env['rack.exception'] || env['sinatra.error']
       end
+
+      def finish_span(span, status_code)
+        span.set_http_status(status_code)
+        span.finish
+      end
     end
   end
 end

data/lib/sentry/rack/deprecations.rb

@@ -0,0 +1,19 @@
+module Sentry
+  module Rack
+    class DeprecatedMiddleware
+      def initialize(_)
+        raise Sentry::Error.new <<~MSG
+
+You're seeing this message because #{self.class} has been replaced by Sentry::Rack::CaptureExceptions.
+Removing this middleware from your app and upgrading sentry-rails to 4.1.0+ should solve the issue.
+        MSG
+      end
+    end
+
+    class Tracing < DeprecatedMiddleware
+    end
+
+    class CaptureException < DeprecatedMiddleware
+    end
+  end
+end

data/lib/sentry/rack/interface.rb

@@ -0,0 +1,22 @@
+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