sentry-ruby 0.1.1 → 4.0.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

@@ -1,5 +1,4 @@
 require "sentry/transport"
-require 'sentry/utils/deep_merge'
 
 module Sentry
   class Client
@@ -21,55 +20,51 @@ module Sentry
       end
     end
 
-    def capture_exception(exception, scope:, **options, &block)
-      event = event_from_exception(exception, **options)
-      return unless event
-
-      block.call(event) if block
-      capture_event(event, scope)
-    end
-
-    def capture_message(message, scope:, **options, &block)
-      event = event_from_message(message, **options)
-      block.call(event) if block
-      capture_event(event, scope)
-    end
+    def capture_event(event, scope, hint = nil)
+      scope.apply_to_event(event, hint)
+
+      if 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
+          configuration.async.call(event.to_json_compatible)
+        rescue => e
+          configuration.logger.error(LOGGER_PROGNAME) { "async event sending failed: #{e.message}" }
+          send_event(event, hint)
+        end
+      else
+        send_event(event, hint)
+      end
 
-    def capture_event(event, scope)
-      scope.apply_to_event(event)
-      send_event(event)
       event
     end
 
-    def event_from_exception(exception, **options)
-      exception_context =
-        if exception.instance_variable_defined?(:@__sentry_context)
-          exception.instance_variable_get(:@__sentry_context)
-        elsif exception.respond_to?(:sentry_context)
-          exception.sentry_context
-        else
-          {}
-        end
-
-      options = Utils::DeepMergeHash.deep_merge(exception_context, options)
-
+    def event_from_exception(exception)
       return unless @configuration.exception_class_allowed?(exception)
 
-      options = Event::Options.new(**options)
-
-      Event.new(configuration: configuration, options: options).tap do |event|
+      Event.new(configuration: configuration).tap do |event|
         event.add_exception_interface(exception)
       end
     end
 
-    def event_from_message(message, **options)
-      options.merge!(message: message)
-      options = Event::Options.new(options)
-      Event.new(configuration: configuration, options: options)
+    def event_from_message(message)
+      Event.new(configuration: configuration, message: message)
+    end
+
+    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
 
     def send_event(event, hint = nil)
-      return false unless configuration.sending_allowed?(event)
+      return false unless configuration.sending_allowed?
 
       event = configuration.before_send.call(event, hint) if configuration.before_send
       if event.nil?

data/lib/sentry/configuration.rb

@@ -15,6 +15,28 @@ module Sentry
     attr_reader :async
     alias async? async
 
+    # 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 +46,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,54 +89,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
-
-    # Default tags for events. Hash.
-    attr_accessor :tags
-
+    # 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, hint| event }
-    # E.g.: lambda { |event, hint| nil }
-    # E.g.: lambda { |event, hint|
-    #   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.
@@ -141,8 +148,8 @@ module Sentry
       self.async = false
       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
@@ -156,11 +163,12 @@ module Sentry
       self.send_default_pii = false
       self.dsn = ENV['SENTRY_DSN']
       self.server_name = server_name_from_env
-      self.should_capture = false
-      self.tags = {}
-      @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
 
@@ -198,14 +206,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)"
@@ -214,31 +214,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)
@@ -259,7 +249,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
@@ -282,13 +276,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)
@@ -299,14 +297,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
@@ -342,17 +335,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
 
@@ -383,7 +369,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

@@ -2,11 +2,10 @@
 
 require 'socket'
 require 'securerandom'
-require 'sentry/event/options'
 require 'sentry/interface'
 require 'sentry/backtrace'
-require 'sentry/utils/deep_merge'
 require 'sentry/utils/real_ip'
+require 'sentry/utils/request_id'
 
 module Sentry
   class Event
@@ -15,52 +14,44 @@ 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
+    attr_reader :configuration
 
-    alias event_id id
-
-    def initialize(options:, configuration:)
+    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
 
-      @user          = options.user
-      @extra         = options.extra
-      @contexts      = options.contexts
-      @tags          = configuration.tags.merge(options.tags)
-
-      @fingerprint = options.fingerprint
+      @user          = {}
+      @extra         = {}
+      @contexts      = {}
+      @tags          = {}
 
-      @server_name = options.server_name || configuration.server_name
-      @environment = options.environment || configuration.current_environment
-      @release = options.release || configuration.release
-      @modules = list_gem_specs if configuration.send_modules
+      @fingerprint = []
 
-      @message = options.message if options.message
+      @server_name = configuration.server_name
+      @environment = configuration.environment
+      @release = configuration.release
+      @modules = configuration.gem_specs if configuration.send_modules
 
-      self.level = options.level
+      @message = message || ""
 
-      if !options.backtrace.empty?
-        @stacktrace = Sentry::StacktraceInterface.new.tap do |int|
-          int.frames = stacktrace_interface_from(options.backtrace)
-        end
-      end
+      self.level = :error
     end
 
     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
 
@@ -76,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
@@ -92,14 +83,18 @@ 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
@@ -113,6 +108,10 @@ module Sentry
     end
 
     def add_exception_interface(exc)
+      if exc.respond_to?(:sentry_context)
+        @extra.merge!(exc.sentry_context)
+      end
+
       @exception = Sentry::ExceptionInterface.new.tap do |exc_int|
         exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exc).reverse
         backtraces = Set.new
@@ -145,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
@@ -156,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)
@@ -166,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