sentry-raven 1.1.0 → 3.1.2

data/lib/raven/breadcrumbs/sentry_logger.rb

@@ -0,0 +1,73 @@
+require 'logger'
+
+module Raven
+  module Breadcrumbs
+    module SentryLogger
+      LEVELS = {
+        ::Logger::DEBUG => 'debug',
+        ::Logger::INFO => 'info',
+        ::Logger::WARN => 'warn',
+        ::Logger::ERROR => 'error',
+        ::Logger::FATAL => 'fatal'
+      }.freeze
+
+      def add(*args)
+        add_breadcrumb(*args)
+        super
+      end
+
+      def add_breadcrumb(severity, message = nil, progname = nil)
+        message = progname if message.nil? # see Ruby's Logger docs for why
+        return if ignored_logger?(progname)
+        return if message.nil? || message == ""
+
+        # some loggers will add leading/trailing space as they (incorrectly, mind you)
+        # think of logging as a shortcut to std{out,err}
+        message = message.to_s.strip
+
+        last_crumb = Raven.breadcrumbs.peek
+        # try to avoid dupes from logger broadcasts
+        if last_crumb.nil? || last_crumb.message != message
+          Raven.breadcrumbs.record do |crumb|
+            crumb.level = Raven::Breadcrumbs::SentryLogger::LEVELS.fetch(severity, nil)
+            crumb.category = progname || 'logger'
+            crumb.message = message
+            crumb.type =
+              if severity >= 3
+                "error"
+              else
+                crumb.level
+              end
+          end
+        end
+      end
+
+      private
+
+      def ignored_logger?(progname)
+        progname == "sentry" ||
+          Raven.configuration.exclude_loggers.include?(progname)
+      end
+    end
+    module OldBreadcrumbsSentryLogger
+      def self.included(base)
+        base.class_eval do
+          include Raven::Breadcrumbs::SentryLogger
+          alias_method :add_without_raven, :add
+          alias_method :add, :add_with_raven
+        end
+      end
+
+      def add_with_raven(*args)
+        add_breadcrumb(*args)
+        add_without_raven(*args)
+      end
+    end
+  end
+end
+
+Raven.safely_prepend(
+  "Breadcrumbs::SentryLogger",
+  :from => Raven,
+  :to => ::Logger
+)

data/lib/raven/breadcrumbs.rb

@@ -0,0 +1,76 @@
+module Raven
+  class Breadcrumb
+    attr_accessor :category, :data, :message, :level, :timestamp, :type
+
+    def initialize
+      @category = nil
+      @data = {}
+      @level = nil
+      @message = nil
+      @timestamp = Time.now.to_i
+      @type = nil
+    end
+
+    def to_hash
+      {
+        :category => @category,
+        :data => @data,
+        :level => @level,
+        :message => @message,
+        :timestamp => @timestamp,
+        :type => @type
+      }
+    end
+  end
+end
+
+module Raven
+  class BreadcrumbBuffer
+    include Enumerable
+
+    attr_accessor :buffer
+
+    def self.current
+      Thread.current[:sentry_breadcrumbs] ||= new
+    end
+
+    def self.clear!
+      Thread.current[:sentry_breadcrumbs] = nil
+    end
+
+    def initialize(size = 100)
+      @buffer = Array.new(size)
+    end
+
+    def record(crumb = nil)
+      if block_given?
+        crumb = Breadcrumb.new if crumb.nil?
+        yield(crumb)
+      end
+      @buffer.slice!(0)
+      @buffer << crumb
+    end
+
+    def members
+      @buffer.compact
+    end
+
+    def peek
+      members.last
+    end
+
+    def each(&block)
+      members.each(&block)
+    end
+
+    def empty?
+      members.none?
+    end
+
+    def to_hash
+      {
+        :values => members.map(&:to_hash)
+      }
+    end
+  end
+end

data/lib/raven/cli.rb

@@ -1,56 +1,48 @@
 module Raven
   class CLI
-    def self.test(dsn = nil)
-      require 'logger'
-
-      logger = ::Logger.new(STDOUT)
-      logger.level = ::Logger::ERROR
-      logger.formatter = proc do |_severity, _datetime, _progname, msg|
-        "-> #{msg}\n"
-      end
-
-      Raven.configuration.logger = logger
-      Raven.configuration.timeout = 5
-      Raven.configuration.dsn = dsn if dsn
+    def self.test(dsn = nil, silent = false, config = nil)
+      config ||= Raven.configuration
+
+      config.logger = if silent
+                        ::Logger.new(nil)
+                      else
+                        logger = ::Logger.new(STDOUT)
+                        logger.formatter = proc do |_severity, _datetime, _progname, msg|
+                          "-> #{msg}\n"
+                        end
+                        logger
+                      end
+
+      config.timeout = 5
+      config.dsn = dsn if dsn
 
       # wipe out env settings to ensure we send the event
-      unless Raven.configuration.send_in_current_environment?
-        env_name = Raven.configuration.environments.pop || 'production'
-        puts "Setting environment to #{env_name}"
-        Raven.configuration.current_environment = env_name
+      unless config.capture_allowed?
+        env_name = config.environments.last || 'production'
+        config.current_environment = env_name
       end
 
-      Raven.configuration.verify!
+      instance = Raven::Instance.new(nil, config)
 
-      puts "Sending a test event:"
-      puts ""
+      instance.logger.debug "Sending a test event:"
+      instance.logger.debug ""
 
       begin
         1 / 0
-      rescue ZeroDivisionError => exception
-        evt = Raven.capture_exception(exception)
+      rescue ZeroDivisionError => e
+        evt = instance.capture_exception(e)
       end
 
-      if evt && !(evt.is_a? Thread)
-        if evt.is_a? Hash
-          puts "-> event ID: #{evt[:event_id]}"
-        else
-          puts "-> event ID: #{evt.id}"
-        end
-      elsif evt #async configuration
-        if evt.value.is_a? Hash
-          puts "-> event ID: #{evt.value[:event_id]}"
-        else
-          puts "-> event ID: #{evt.value.id}"
-        end
+      if evt
+        instance.logger.debug "-> event ID: #{evt.id}"
+        instance.logger.debug ""
+        instance.logger.debug "Done!"
+        evt
       else
-        puts ""
-        puts "An error occurred while attempting to send the event."
-        exit 1
+        instance.logger.debug ""
+        instance.logger.debug "An error occurred while attempting to send the event."
+        false
       end
-
-      puts ""
-      puts "Done!"
     end
   end
 end

data/lib/raven/client.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
-require 'zlib'
+
 require 'base64'
+require 'json'
+require 'zlib'
 
-require 'raven/version'
-require 'raven/okjson'
-require 'raven/transports/http'
+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
 
@@ -21,8 +21,14 @@ module Raven
       @state = ClientState.new
     end
 
-    def send_event(event)
-      return false unless configuration_allows_sending
+    def send_event(event, hint = nil)
+      return false unless configuration.sending_allowed?(event)
+
+      event = configuration.before_send.call(event, hint) if configuration.before_send
+      if event.nil?
+        configuration.logger.info "Discarded event because before_send returned nil"
+        return
+      end
 
       # Convert to hash
       event = event.to_hash
@@ -32,13 +38,14 @@ module Raven
         return
       end
 
-      Raven.logger.debug "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)
 
       begin
         transport.send_event(generate_auth_header, encoded_data,
-                       :content_type => content_type)
+                             :content_type => content_type)
         successful_send
       rescue => e
         failed_send(e, event)
@@ -53,6 +60,8 @@ module Raven
         case configuration.scheme
         when 'http', 'https'
           Transports::HTTP.new(configuration)
+        when 'stdout'
+          Transports::Stdout.new(configuration)
         when 'dummy'
           Transports::Dummy.new(configuration)
         else
@@ -62,18 +71,9 @@ module Raven
 
     private
 
-    def configuration_allows_sending
-      if configuration.send_in_current_environment?
-        true
-      else
-        configuration.log_excluded_environment_message
-        false
-      end
-    end
-
     def encode(event)
-      hash = @processors.reduce(event.to_hash) { |memo, p| p.process(memo) }
-      encoded = OkJson.encode(hash)
+      hash = @processors.reduce(event.to_hash) { |a, e| e.process(a) }
+      encoded = JSON.fast_generate(hash)
 
       case configuration.encoding
       when 'gzip'
@@ -83,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
@@ -93,9 +105,9 @@ module Raven
         'sentry_version' => PROTOCOL_VERSION,
         'sentry_client' => USER_AGENT,
         'sentry_timestamp' => now,
-        'sentry_key' => configuration.public_key,
-        'sentry_secret' => configuration.secret_key
+        'sentry_key' => configuration.public_key
       }
+      fields['sentry_secret'] = configuration.secret_key unless configuration.secret_key.nil?
       'Sentry ' + fields.map { |key, value| "#{key}=#{value}" }.join(', ')
     end
 
@@ -104,15 +116,16 @@ module Raven
     end
 
     def failed_send(e, event)
-      @state.failure
       if e # exception was raised
-        Raven.logger.error "Unable to record event with remote Sentry server (#{e.class} - #{e.message})"
-        e.backtrace[0..10].each { |line| Raven.logger.error(line) }
+        @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
-        Raven.logger.error "Not sending event due to previous failure(s)."
+        configuration.logger.warn "Not sending event due to previous failure(s)."
       end
-      Raven.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, e) if configuration.transport_failure_callback # rubocop:disable Style/SafeNavigation
     end
   end
 
@@ -124,7 +137,7 @@ module Raven
     def should_try?
       return true if @status == :online
 
-      interval = @retry_after || [@retry_number, 6].min ** 2
+      interval = @retry_after || [@retry_number, 6].min**2
       return true if Time.now - @last_check >= interval
 
       false