sentry-raven 2.9.0 → 3.0.1

data/lib/raven/breadcrumbs/activesupport.rb

@@ -1,19 +1,19 @@
 module Raven
   module ActiveSupportBreadcrumbs
     class << self
-        def add(name, started, _finished, _unique_id, data)
-          Raven.breadcrumbs.record do |crumb|
-            crumb.data = data
-            crumb.category = name
-            crumb.timestamp = started.to_i
-          end
+      def add(name, started, _finished, _unique_id, data)
+        Raven.breadcrumbs.record do |crumb|
+          crumb.data = data
+          crumb.category = name
+          crumb.timestamp = started.to_i
         end
+      end
 
-        def inject
-          ActiveSupport::Notifications.subscribe(/.*/) do |name, started, finished, unique_id, data|
-            add(name, started, finished, unique_id, data)
-          end
+      def inject
+        ActiveSupport::Notifications.subscribe(/.*/) do |name, started, finished, unique_id, data|
+          add(name, started, finished, unique_id, data)
         end
+      end
     end
   end
 end

data/lib/raven/breadcrumbs/logger.rb

@@ -4,13 +4,13 @@ module Raven
   module BreadcrumbLogger
     LEVELS = {
       ::Logger::DEBUG => 'debug',
-      ::Logger::INFO  => 'info',
-      ::Logger::WARN  => 'warn',
+      ::Logger::INFO => 'info',
+      ::Logger::WARN => 'warn',
       ::Logger::ERROR => 'error',
       ::Logger::FATAL => 'fatal'
     }.freeze
 
-    EXC_FORMAT = /^([a-zA-Z0-9]+)\:\s(.*)$/
+    EXC_FORMAT = /^([a-zA-Z0-9]+)\:\s(.*)$/.freeze
 
     def self.parse_exception(message)
       lines = message.split(/\n\s*/)
@@ -36,7 +36,7 @@ module Raven
 
       # some loggers will add leading/trailing space as they (incorrectly, mind you)
       # think of logging as a shortcut to std{out,err}
-      message = message.strip
+      message = message.to_s.strip
 
       last_crumb = Raven.breadcrumbs.peek
       # try to avoid dupes from logger broadcasts

data/lib/raven/breadcrumbs.rb

@@ -64,7 +64,7 @@ module Raven
     end
 
     def empty?
-      !members.any?
+      members.none?
     end
 
     def to_hash

data/lib/raven/cli.rb

@@ -29,8 +29,8 @@ module Raven
 
       begin
         1 / 0
-      rescue ZeroDivisionError => exception
-        evt = instance.capture_exception(exception)
+      rescue ZeroDivisionError => e
+        evt = instance.capture_exception(e)
       end
 
       if evt && !(evt.is_a? Thread)

data/lib/raven/client.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
+
 require 'base64'
 require 'json'
 require 'zlib'
 
+require "raven/transports"
+
 module Raven
   # Encodes events and sends them to the Sentry server.
   class Client
-    PROTOCOL_VERSION = '5'.freeze
-    USER_AGENT = "raven-ruby/#{Raven::VERSION}".freeze
-    CONTENT_TYPE = 'application/json'.freeze
+    PROTOCOL_VERSION = '5'
+    USER_AGENT = "raven-ruby/#{Raven::VERSION}"
+    CONTENT_TYPE = 'application/json'
 
     attr_accessor :configuration
 
@@ -35,7 +38,8 @@ module Raven
         return
       end
 
-      configuration.logger.info "Sending event #{event[:event_id]} to Sentry"
+      event_id = event[:event_id] || event['event_id']
+      configuration.logger.info "Sending event #{event_id} to Sentry"
 
       content_type, encoded_data = encode(event)
 
@@ -79,8 +83,20 @@ module Raven
       end
     end
 
+    def get_message_from_exception(event)
+      (
+        event &&
+        event[:exception] &&
+        event[:exception][:values] &&
+        event[:exception][:values][0] &&
+        event[:exception][:values][0][:type] &&
+        event[:exception][:values][0][:value] &&
+        "#{event[:exception][:values][0][:type]}: #{event[:exception][:values][0][:value]}"
+      )
+    end
+
     def get_log_message(event)
-      (event && event[:message]) || '<no message value>'
+      (event && event[:message]) || (event && event['message']) || get_message_from_exception(event) || '<no message value>'
     end
 
     def generate_auth_header
@@ -100,14 +116,16 @@ module Raven
     end
 
     def failed_send(e, event)
-      @state.failure
       if e # exception was raised
-        configuration.logger.error "Unable to record event with remote Sentry server (#{e.class} - #{e.message}):\n#{e.backtrace[0..10].join("\n")}"
+        @state.failure
+        configuration.logger.warn "Unable to record event with remote Sentry server (#{e.class} - #{e.message}):\n#{e.backtrace[0..10].join("\n")}"
       else
-        configuration.logger.error "Not sending event due to previous failure(s)."
+        configuration.logger.warn "Not sending event due to previous failure(s)."
       end
-      configuration.logger.error("Failed to submit event: #{get_log_message(event)}")
-      configuration.transport_failure_callback.call(event) if configuration.transport_failure_callback
+      configuration.logger.warn("Failed to submit event: #{get_log_message(event)}")
+
+      # configuration.transport_failure_callback can be false & nil
+      configuration.transport_failure_callback.call(event) if configuration.transport_failure_callback # rubocop:disable Style/SafeNavigation
     end
   end
 

data/lib/raven/configuration.rb

@@ -1,7 +1,7 @@
 require 'uri'
 
 module Raven
-  class Configuration # rubocop:disable Metrics/ClassLength
+  class Configuration
     # 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)/
@@ -236,6 +236,7 @@ module Raven
 
     def server=(value)
       return if value.nil?
+
       uri = URI.parse(value)
       uri_path = uri.path.split('/')
 
@@ -253,13 +254,14 @@ module Raven
 
       # For anyone who wants to read the base server string
       @server = "#{scheme}://#{host}"
-      @server << ":#{port}" unless port == { 'http' => 80, 'https' => 443 }[scheme]
-      @server << path
+      @server += ":#{port}" unless port == { 'http' => 80, 'https' => 443 }[scheme]
+      @server += path
     end
     alias dsn= server=
 
     def encoding=(encoding)
       raise(Error, 'Unsupported encoding') unless %w(gzip json).include? encoding
+
       @encoding = encoding
     end
 
@@ -267,6 +269,7 @@ module Raven
       unless value == false || value.respond_to?(:call)
         raise(ArgumentError, "async must be callable (or false to disable)")
       end
+
       @async = value
     end
 
@@ -274,6 +277,7 @@ module Raven
       unless value == false || value.respond_to?(:call)
         raise(ArgumentError, "transport_failure_callback must be callable (or false to disable)")
       end
+
       @transport_failure_callback = value
     end
 
@@ -281,6 +285,7 @@ module Raven
       unless value == false || value.respond_to?(:call)
         raise ArgumentError, "should_capture must be callable (or false to disable)"
       end
+
       @should_capture = value
     end
 
@@ -288,6 +293,7 @@ module Raven
       unless value == false || value.respond_to?(:call)
         raise ArgumentError, "before_send must be callable (or false to disable)"
       end
+
       @before_send = value
     end
 
@@ -347,11 +353,12 @@ module Raven
     end
 
     def detect_release
-      detect_release_from_git ||
+      detect_release_from_env ||
+        detect_release_from_git ||
         detect_release_from_capistrano ||
         detect_release_from_heroku
-    rescue => ex
-      logger.error "Error detecting release: #{ex.message}"
+    rescue => e
+      logger.error "Error detecting release: #{e.message}"
     end
 
     def excluded_exception?(incoming_exception)
@@ -411,20 +418,27 @@ module Raven
       Raven.sys_command("git rev-parse --short HEAD") if File.directory?(".git")
     end
 
+    def detect_release_from_env
+      ENV['SENTRY_RELEASE']
+    end
+
     def capture_in_current_environment?
       return true unless environments.any? && !environments.include?(current_environment)
+
       @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])
+      return true if !should_capture || message_or_exc.nil? || should_capture.call(message_or_exc)
+
       @errors << "should_capture returned false"
       false
     end
 
     def valid?
       return true if %w(server host path public_key project_id).all? { |k| public_send(k) }
+
       if server
         %w(server host path public_key project_id).map do |key|
           @errors << "No #{key} specified" unless public_send(key)
@@ -437,6 +451,7 @@ module Raven
 
     def sample_allowed?
       return true if sample_rate == 1.0
+
       if Random::DEFAULT.rand >= sample_rate
         @errors << "Excluded by random sample"
         false
@@ -453,7 +468,7 @@ module Raven
     end
 
     def current_environment_from_env
-      ENV['SENTRY_CURRENT_ENV'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'default'
+      ENV['SENTRY_CURRENT_ENV'] || ENV['SENTRY_ENVIRONMENT'] || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'default'
     end
 
     def server_name_from_env

data/lib/raven/event.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'socket'
 require 'securerandom'
 
@@ -59,10 +60,7 @@ module Raven
       return unless configuration.exception_class_allowed?(exc)
 
       new(options) do |evt|
-        evt.message = "#{exc.class}: #{exc.message}"
-
         evt.add_exception_interface(exc)
-
         yield evt if block
       end
     end
@@ -79,7 +77,7 @@ module Raven
     end
 
     def message
-      @interfaces[:logentry] && @interfaces[:logentry].unformatted_message
+      @interfaces[:logentry]&.unformatted_message
     end
 
     def message=(args)
@@ -99,12 +97,13 @@ module Raven
     end
 
     def level=(new_level) # needed to meet the Sentry spec
-      @level = new_level == "warn" || new_level == :warn ? :warning : new_level
+      @level = new_level.to_s == "warn" ? :warning : new_level
     end
 
     def interface(name, value = nil, &block)
       int = Interface.registered[name]
       raise(Error, "Unknown interface: #{name}") unless int
+
       @interfaces[int.sentry_alias] = int.new(value, &block) if value || block
       @interfaces[int.sentry_alias]
     end
@@ -231,10 +230,7 @@ module Raven
     end
 
     def async_json_processors
-      [
-        Raven::Processor::RemoveCircularReferences,
-        Raven::Processor::UTF8Conversion
-      ].map { |v| v.new(self) }
+      configuration.processors.map { |v| v.new(self) }
     end
 
     def list_gem_specs

data/lib/raven/instance.rb

@@ -51,6 +51,7 @@ module Raven
     # Tell the log that the client is good to go
     def report_status
       return if configuration.silence_ready
+
       if configuration.capture_allowed?
         logger.info "Raven #{VERSION} ready to catch errors"
       else
@@ -111,15 +112,15 @@ module Raven
       message_or_exc = obj.is_a?(String) ? "message" : "exception"
       options[:configuration] = configuration
       options[:context] = context
-      if (evt = Event.send("from_" + message_or_exc, obj, options))
+      if evt = Event.send("from_" + message_or_exc, obj, options)
         yield evt if block_given?
         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(evt.to_json_compatible)
-          rescue => ex
-            logger.error("async event sending failed: #{ex.message}")
+          rescue => e
+            logger.error("async event sending failed: #{e.message}")
             send_event(evt, make_hint(obj))
           end
         else
@@ -183,6 +184,10 @@ module Raven
     #   Raven.tags_context('my_custom_tag' => 'tag_value')
     def tags_context(options = nil)
       context.tags.merge!(options || {})
+      yield if block_given?
+      context.tags
+    ensure
+      context.tags.delete_if { |k, _| options.keys.include? k } if block_given?
     end
 
     # Bind extra context. Merges with existing context (if any).
@@ -194,6 +199,10 @@ module Raven
     #   Raven.extra_context('my_custom_data' => 'value')
     def extra_context(options = nil)
       context.extra.merge!(options || {})
+      yield if block_given?
+      context.extra
+    ensure
+      context.extra.delete_if { |k, _| options.keys.include? k } if block_given?
     end
 
     def rack_context(env)

data/lib/raven/integrations/delayed_job.rb

@@ -8,19 +8,18 @@ module Delayed
           begin
             # Forward the call to the next callback in the callback chain
             block.call(job, *args)
-
-          rescue Exception => exception
+          rescue Exception => e
             # Log error to Sentry
             extra = {
               :delayed_job => {
-                :id          => job.id,
-                :priority    => job.priority,
-                :attempts    => job.attempts,
-                :run_at      => job.run_at,
-                :locked_at   => job.locked_at,
-                :locked_by   => job.locked_by,
-                :queue       => job.queue,
-                :created_at  => job.created_at
+                :id => job.id.to_s,
+                :priority => job.priority,
+                :attempts => job.attempts,
+                :run_at => job.run_at,
+                :locked_at => job.locked_at,
+                :locked_by => job.locked_by,
+                :queue => job.queue,
+                :created_at => job.created_at
               }
             }
             # last_error can be nil
@@ -32,16 +31,16 @@ module Delayed
             if job.respond_to?('payload_object') && job.payload_object.respond_to?('job_data')
               extra[:active_job] = job.payload_object.job_data
             end
-            ::Raven.capture_exception(exception,
-                                      :logger  => 'delayed_job',
-                                      :tags    => {
+            ::Raven.capture_exception(e,
+                                      :logger => 'delayed_job',
+                                      :tags => {
                                         :delayed_job_queue => job.queue,
-                                        :delayed_job_id => job.id
+                                        :delayed_job_id => job.id.to_s
                                       },
                                       :extra => extra)
 
             # Make sure we propagate the failure!
-            raise exception
+            raise e
           ensure
             ::Raven::Context.clear!
             ::Raven::BreadcrumbBuffer.clear!

data/lib/raven/integrations/rack-timeout.rb

@@ -14,6 +14,5 @@ module RackTimeoutExtensions
   end
 end
 
-# Include is private in Ruby 1.9
-Rack::Timeout::Error.__send__(:include, RackTimeoutExtensions)
-Rack::Timeout::RequestTimeoutException.__send__(:include, RackTimeoutExtensions)
+Rack::Timeout::Error.include(RackTimeoutExtensions)
+Rack::Timeout::RequestTimeoutException.include(RackTimeoutExtensions)

data/lib/raven/integrations/rack.rb

@@ -92,8 +92,8 @@ module Raven
         request.body.rewind
         data
       end
-    rescue IOError => ex
-      ex.message
+    rescue IOError => e
+      e.message
     end
 
     def format_headers_for_sentry(env_hash)
@@ -112,8 +112,9 @@ module Raven
           next if key == 'HTTP_COOKIE' # Cookies don't go here, they go somewhere else
 
           next unless key.start_with?('HTTP_') || %w(CONTENT_TYPE CONTENT_LENGTH).include?(key)
+
           # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
-          key = key.gsub("HTTP_", "")
+          key = key.sub(/^HTTP_/, "")
           key = key.split('_').map(&:capitalize).join('-')
           memo[key] = value
         rescue StandardError => e