sentry-ruby 0.1.3 → 4.1.0

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 false 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
@@ -51,10 +59,20 @@ module Sentry
       Event.new(configuration: configuration, message: message)
     end
 
-    def send_event(event)
-      return false unless configuration.sending_allowed?(event)
+    def event_from_transaction(transaction)
+      TransactionEvent.new(configuration: configuration).tap do |event|
+        event.transaction = transaction.name
+        event.contexts.merge!(trace: transaction.get_trace_context)
+        event.timestamp = transaction.timestamp
+        event.start_timestamp = transaction.start_timestamp
+
+        finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
+        event.spans = finished_spans.map(&:to_hash)
+      end
+    end
 
-      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,37 @@ 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
+    #
+    # for example:
+    #
+    # ```ruby
+    # Sentry.configuration.backtrace_cleanup_callback = lambda do |backtrace|
+    #   Rails.backtrace_cleaner.clean(backtrace)
+    # end
+    # ```
+    #
+    attr_accessor :backtrace_cleanup_callback
+
+    # Optional Proc, called before sending an event to the server/
+    # E.g.: lambda { |event| event }
+    # E.g.: lambda { |event| nil }
+    # E.g.: lambda { |event|
+    #   event[:message] = 'a'
+    #   event
+    # }
+    attr_reader :before_send
+
     # An array of breadcrumbs loggers to be used. Available options are:
     # - :sentry_logger
     # - :active_support_logger
@@ -24,10 +57,13 @@ module Sentry
     attr_accessor :context_lines
 
     # RACK_ENV by default.
-    attr_reader :current_environment
+    attr_reader :environment
 
-    # Whitelist of environments that will send notifications to Sentry. Array of Strings.
-    attr_accessor :environments
+    # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
+    attr_reader :dsn
+
+    # 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
@@ -64,51 +100,36 @@ module Sentry
     # any events, and a value of 1.0 will send 100% of events.
     attr_accessor :sample_rate
 
-    # a proc/lambda that takes an array of stack traces
-    # it'll be used to silence (reduce) backtrace of the exception
-    #
-    # for example:
-    #
-    # ```ruby
-    # Sentry.configuration.backtrace_cleanup_callback = lambda do |backtrace|
-    #   Rails.backtrace_cleaner.clean(backtrace)
-    # end
-    # ```
-    #
-    attr_accessor :backtrace_cleanup_callback
-
     # Include module versions in reports - boolean.
     attr_accessor :send_modules
 
+    # When send_default_pii's value is false (default), sensitive information like
+    # - user ip
+    # - user cookie
+    # - request body
+    # will not be sent to Sentry.
     attr_accessor :send_default_pii
 
     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
-
-    # Silences ready message when true.
-    attr_accessor :silence_ready
-
+    # Return a Transport::Configuration object for transport-related configurations.
     attr_reader :transport
 
-    # Optional Proc, called before sending an event to the server/
-    # E.g.: lambda { |event| event }
-    # E.g.: lambda { |event| nil }
-    # E.g.: lambda { |event|
-    #   event[:message] = 'a'
-    #   event
-    # }
-    attr_reader :before_send
+    # Take a float between 0.0 and 1.0 as the sample rate for tracing events (transactions).
+    attr_accessor :traces_sample_rate
 
-    # Errors object - an Array that contains error messages. See #
-    attr_reader :errors
+    # Take a Proc that controls the sample rate for every tracing event, e.g.
+    # ```
+    # lambda do |tracing_context|
+    #   # tracing_context[:transaction_context] contains the information about the transaction
+    #   # tracing_context[:parent_sampled] contains the transaction's parent's sample decision
+    #   true # return value can be a boolean or a float between 0.0 and 1.0
+    # end
+    # ```
+    attr_accessor :traces_sampler
 
-    # the dsn value, whether it's set via `config.dsn=` or `ENV["SENTRY_DSN"]`
-    attr_reader :dsn
+    # these are not config options
+    attr_reader :errors, :gem_specs
 
     # Most of these errors generate 4XX responses. In general, Sentry clients
     # only automatically report 5xx responses.
@@ -136,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
@@ -153,11 +175,12 @@ module Sentry
       self.send_default_pii = false
       self.dsn = ENV['SENTRY_DSN']
       self.server_name = server_name_from_env
-      self.should_capture = false
 
-      @transport = Transport::Configuration.new
       self.before_send = false
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
+
+      @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
     end
 
@@ -195,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)"
@@ -211,31 +226,21 @@ module Sentry
       @before_send = value
     end
 
-    # Allows config options to be read like a hash
-    #
-    # @param [Symbol] option Key for a given attribute
-    def [](option)
-      public_send(option)
+    def environment=(environment)
+      @environment = environment.to_s
     end
 
-    def current_environment=(environment)
-      @current_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
-      errors.join(", ")
+      @errors = [@errors[0]] + @errors[1..-1].map(&:downcase) # fix case of all but first
+      @errors.join(", ")
     end
 
     def project_root=(root_dir)
@@ -256,7 +261,11 @@ 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?
+      !!((@traces_sample_rate && @traces_sample_rate > 0.0) || @traces_sampler)
     end
 
     private
@@ -279,13 +288,17 @@ module Sentry
     end
 
     def excluded_exception?(incoming_exception)
-      excluded_exceptions.any? do |excluded_exception|
-        matches_exception?(get_exception_class(excluded_exception), incoming_exception)
+      excluded_exception_classes.any? do |excluded_exception|
+        matches_exception?(excluded_exception, incoming_exception)
       end
     end
 
+    def excluded_exception_classes
+      @excluded_exception_classes ||= excluded_exceptions.map { |e| get_exception_class(e) }
+    end
+
     def get_exception_class(x)
-      x.is_a?(Module) ? x : qualified_const_get(x)
+      x.is_a?(Module) ? x : safe_const_get(x)
     end
 
     def matches_exception?(excluded_exception_class, incoming_exception)
@@ -296,14 +309,9 @@ module Sentry
       end
     end
 
-    # In Ruby <2.0 const_get can't lookup "SomeModule::SomeClass" in one go
-    def qualified_const_get(x)
-      x = x.to_s
-      if !x.match(/::/)
-        Object.const_get(x)
-      else
-        x.split(MODULE_SEPARATOR).reject(&:empty?).inject(Object) { |a, e| a.const_get(e) }
-      end
+    def safe_const_get(x)
+      x = x.to_s unless x.is_a?(String)
+      Object.const_get(x)
     rescue NameError # There's no way to safely ask if a constant exist for an unknown string
       nil
     end
@@ -339,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
 
@@ -380,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/dsn.rb

@@ -2,7 +2,10 @@ require "uri"
 
 module Sentry
   class DSN
-    attr_reader :scheme, :project_id, :public_key, :secret_key, :host, :port, :path
+    PORT_MAP = { 'http' => 80, 'https' => 443 }.freeze
+    REQUIRED_ATTRIBUTES = %w(host path public_key project_id).freeze
+
+    attr_reader :scheme, :secret_key, :port, *REQUIRED_ATTRIBUTES
 
     def initialize(dsn_string)
       @raw_value = dsn_string
@@ -24,7 +27,7 @@ module Sentry
     end
 
     def valid?
-      %w(host path public_key project_id).all? { |k| public_send(k) }
+      REQUIRED_ATTRIBUTES.all? { |k| public_send(k) }
     end
 
     def to_s
@@ -33,7 +36,7 @@ module Sentry
 
     def server
       server = "#{scheme}://#{host}"
-      server += ":#{port}" unless port == { 'http' => 80, 'https' => 443 }[scheme]
+      server += ":#{port}" unless port == PORT_MAP[scheme]
       server += path
       server
     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
@@ -13,21 +14,19 @@ module Sentry
       release environment server_name modules
       message user tags contexts extra
       fingerprint breadcrumbs backtrace transaction
-      platform sdk
+      platform sdk type
     )
 
     attr_accessor(*ATTRIBUTES)
-    attr_reader :id, :configuration
-
-    alias event_id id
+    attr_reader :configuration, :request, :exception, :stacktrace
 
     def initialize(configuration:, message: nil)
       # this needs to go first because some setters rely on configuration
       @configuration = configuration
 
       # Set some simple default values
-      @id            = SecureRandom.uuid.delete("-")
-      @timestamp     = Time.now.utc
+      @event_id      = SecureRandom.uuid.delete("-")
+      @timestamp     = Sentry.utc_now.iso8601
       @platform      = :ruby
       @sdk           = Sentry.sdk_meta
 
@@ -39,9 +38,9 @@ module Sentry
       @fingerprint = []
 
       @server_name = configuration.server_name
-      @environment = configuration.current_environment
+      @environment = configuration.environment
       @release = configuration.release
-      @modules = list_gem_specs if configuration.send_modules
+      @modules = configuration.gem_specs if configuration.send_modules
 
       @message = message || ""
 
@@ -51,8 +50,8 @@ 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.empty?
-        message = '<no message value>' if message.empty?
+        message = get_message_from_exception(event_hash) if message.nil? || message.empty?
+        message = '<no message value>' if message.nil? || message.empty?
         message
       end
 
@@ -68,7 +67,7 @@ module Sentry
     end
 
     def timestamp=(time)
-      @timestamp = time.is_a?(Time) ? time.strftime('%Y-%m-%dT%H:%M:%S') : time
+      @timestamp = time.is_a?(Time) ? time.to_f : time
     end
 
     def level=(new_level) # needed to meet the Sentry spec
@@ -76,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
@@ -84,18 +83,22 @@ 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
 
-    def to_hash
-      data = ATTRIBUTES.each_with_object({}) do |att, memo|
-        memo[att] = public_send(att) if public_send(att)
-      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[:stacktrace] = stacktrace.to_hash if stacktrace
+      data[:request] = request.to_hash if request
+      data[:exception] = exception.to_hash if exception
 
       data
     end
@@ -141,9 +144,9 @@ module Sentry
         frame.in_app = line.in_app
         frame.module = line.module_name if line.module_name
 
-        if configuration[:context_lines] && frame.abs_path
+        if configuration.context_lines && frame.abs_path
           frame.pre_context, frame.context_line, frame.post_context = \
-            configuration.linecache.get_file_context(frame.abs_path, frame.lineno, configuration[:context_lines])
+            configuration.linecache.get_file_context(frame.abs_path, frame.lineno, configuration.context_lines)
         end
 
         memo << frame if frame.filename
@@ -152,6 +155,14 @@ module Sentry
 
     private
 
+    def serialize_attributes
+      self.class::ATTRIBUTES.each_with_object({}) do |att, memo|
+        if value = public_send(att)
+          memo[att] = value
+        end
+      end
+    end
+
     # When behind a proxy (or if the user is using a proxy), we can't use
     # REMOTE_ADDR to determine the Event IP, and must use other headers instead.
     def calculate_real_ip_from_rack(env)
@@ -162,10 +173,5 @@ module Sentry
         :forwarded_for => env["HTTP_X_FORWARDED_FOR"]
       ).calculate_ip
     end
-
-    def list_gem_specs
-      # Older versions of Rubygems don't support iterating over all specs
-      Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
-    end
   end
 end