sentry-raven 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35bfb0236a3a8236cfe5c2ad37592f973c9612be
-  data.tar.gz: 79ee56bfc0b8243f4dd50111aa253498950548a5
+  metadata.gz: bd0a24e20bb50a520df079f36059cb0adb5d7673
+  data.tar.gz: c89f6a2a4146c6ac291e527e7ec362f12a2e82eb
 SHA512:
-  metadata.gz: d3caa9d91239b8f4bb0355f5a0bf6ea5af48e616e91f43a7abdc62f91f65638f0fca6d73dfeb63be6ba610b40a4c2defa23ca40e2256c1a8f5ad5dfd1ea5d137
-  data.tar.gz: 1cbeccc7169fba6eef992a6eb11d5c6bd8ec6aef89a780c200cb10f011a4bf970109aac68c870975f44a80849e428316382969d92ea70b300278ebe3485cf310
+  metadata.gz: ddb34f4ff56c51af45e4c369f61f9a2a01e24107bc97eca694abbb1a501902cac5254fc912e1eb9e794b8d6c21beff0a49570bb1b114d748676b39cfb7862735
+  data.tar.gz: b35f1609019436dd7f42ef6ed976f53bde10a15eab61b5c6a1bc362b99fa571e459913cafb02da7e1281ff366c70ba1a6a06ff8abf326fd455d1824f4a7cfe00

data/lib/raven/base.rb

@@ -1,5 +1,6 @@
 require 'raven/version'
 require 'raven/backtrace'
+require 'raven/breadcrumbs'
 require 'raven/processor'
 require 'raven/processor/sanitizedata'
 require 'raven/processor/removecircularreferences'
@@ -17,187 +18,33 @@ require 'raven/interfaces/single_exception'
 require 'raven/interfaces/stack_trace'
 require 'raven/interfaces/http'
 require 'raven/utils/deep_merge'
+require 'raven/instance'
+
+require 'forwardable'
 
 module Raven
   AVAILABLE_INTEGRATIONS = %w[delayed_job railties sidekiq rack rake].freeze
 
   class << self
-    # The client object is responsible for delivering formatted data to the Sentry server.
-    # Must respond to #send. See Raven::Client.
-    attr_writer :client
-
-    # A Raven configuration object. Must act like a hash and return sensible
-    # values for all Raven configuration options. See Raven::Configuration.
-    attr_writer :configuration
-
-    def context
-      Context.current
-    end
-
-    def logger
-      @logger ||= Logger.new
-    end
-
-    # The configuration object.
-    # @see Raven.configure
-    def configuration
-      @configuration ||= Configuration.new
-    end
-
-    # The client object is responsible for delivering formatted data to the Sentry server.
-    def client
-      @client ||= Client.new(configuration)
-    end
-
-    # Tell the log that the client is good to go
-    def report_status
-      return if client.configuration.silence_ready
-      if client.configuration.send_in_current_environment?
-        logger.info "Raven #{VERSION} ready to catch errors"
-      else
-        logger.info "Raven #{VERSION} configured not to send errors."
-      end
-    end
-    alias_method :report_ready, :report_status
-
-    # Call this method to modify defaults in your initializers.
-    #
-    # @example
-    #   Raven.configure do |config|
-    #     config.server = 'http://...'
-    #   end
-    def configure
-      yield(configuration) if block_given?
-
-      self.client = Client.new(configuration)
-      report_status
-      self.client
-    end
-
-    # Send an event to the configured Sentry server
-    #
-    # @example
-    #   evt = Raven::Event.new(:message => "An error")
-    #   Raven.send_event(evt)
-    def send_event(event)
-      client.send_event(event)
-    end
-
-    # Capture and process any exceptions from the given block, or globally if
-    # no block is given
-    #
-    # @example
-    #   Raven.capture do
-    #     MyApp.run
-    #   end
-    def capture(options = {})
-      if block_given?
-        begin
-          yield
-        rescue Error
-          raise # Don't capture Raven errors
-        rescue Exception => e
-          capture_exception(e, options)
-          raise
-        end
-      else
-        install_at_exit_hook(options)
-      end
-    end
-
-    def capture_type(obj, options = {})
-      return false unless should_capture?(obj)
-      message_or_exc = obj.is_a?(String) ? "message" : "exception"
-      if (evt = Event.send("from_" + message_or_exc, obj, options))
-        yield evt if block_given?
-        if configuration.async?
-          configuration.async.call(evt)
-        else
-          send_event(evt)
-        end
-        Thread.current[:sentry_last_event_id] = evt.id
-        evt
-      end
-    end
-    alias_method :capture_message, :capture_type
-    alias_method :capture_exception, :capture_type
-
-    def last_event_id
-      Thread.current[:sentry_last_event_id]
-    end
-
-    def should_capture?(message_or_exc)
-      if configuration.should_capture
-        configuration.should_capture.call(*[message_or_exc])
-      else
-        true
-      end
-    end
-
-    # Provides extra context to the exception prior to it being handled by
-    # Raven. An exception can have multiple annotations, which are merged
-    # together.
-    #
-    # The options (annotation) is treated the same as the ``options``
-    # parameter to ``capture_exception`` or ``Event.from_exception``, and
-    # can contain the same ``:user``, ``:tags``, etc. options as these
-    # methods.
-    #
-    # These will be merged with the ``options`` parameter to
-    # ``Event.from_exception`` at the top of execution.
-    #
-    # @example
-    #   begin
-    #     raise "Hello"
-    #   rescue => exc
-    #     Raven.annotate_exception(exc, :user => { 'id' => 1,
-    #                              'email' => 'foo@example.com' })
-    #   end
-    def annotate_exception(exc, options = {})
-      notes = (exc.instance_variable_defined?(:@__raven_context) && exc.instance_variable_get(:@__raven_context)) || {}
-      notes.merge!(options)
-      exc.instance_variable_set(:@__raven_context, notes)
-      exc
-    end
-
-    # Bind user context. Merges with existing context (if any).
-    #
-    # It is recommending that you send at least the ``id`` and ``email``
-    # values. All other values are arbitrary.
-    #
-    # @example
-    #   Raven.user_context('id' => 1, 'email' => 'foo@example.com')
-    def user_context(options = nil)
-      self.context.user = options || {}
-    end
+    extend Forwardable
 
-    # Bind tags context. Merges with existing context (if any).
-    #
-    # Tags are key / value pairs which generally represent things like application version,
-    # environment, role, and server names.
-    #
-    # @example
-    #   Raven.tags_context('my_custom_tag' => 'tag_value')
-    def tags_context(options = nil)
-      self.context.tags.merge!(options || {})
+    def instance
+      @instance ||= Raven::Instance.new
     end
 
-    # Bind extra context. Merges with existing context (if any).
-    #
-    # Extra context shows up as Additional Data within Sentry, and is completely arbitrary.
-    #
-    # @example
-    #   Raven.extra_context('my_custom_data' => 'value')
-    def extra_context(options = nil)
-      self.context.extra.merge!(options || {})
-    end
+    def_delegators :instance, :client=, :configuration=, :context, :logger, :configuration,
+                   :client, :report_status, :configure, :send_event, :capture, :capture_type,
+                   :last_event_id, :should_capture?, :annotate_exception, :user_context,
+                   :tags_context, :extra_context, :rack_context, :breadcrumbs
 
-    def rack_context(env)
-      if env.empty?
-        env = nil
-      end
-      self.context.rack_env = env
-    end
+    def_delegator :instance, :report_status, :report_ready
+    def_delegator :instance, :capture_type, :capture_message
+    def_delegator :instance, :capture_type, :capture_exception
+    # For cross-language compatibility
+    def_delegator :instance, :capture_type, :captureException
+    def_delegator :instance, :capture_type, :captureMessage
+    def_delegator :instance, :annotate_exception, :annotateException
+    def_delegator :instance, :annotate_exception, :annotate
 
     # Injects various integrations. Default behavior: inject all available integrations
     def inject
@@ -232,29 +79,12 @@ module Raven
       self.logger.warn "Unable to load raven/integrations/#{integration}: #{error}"
     end
 
-    def rails_safely_prepend(module_name, opts = {})
-      return if opts[:to].nil?
+    def safely_prepend(module_name, opts = {})
+      return if opts[:to].nil? || opts[:from].nil?
       if opts[:to].respond_to?(:prepend, true)
-        opts[:to].send(:prepend, Raven::Rails::Overrides.const_get(module_name))
+        opts[:to].send(:prepend, opts[:from].const_get(module_name))
       else
-        opts[:to].send(:include, Raven::Rails::Overrides.const_get("Old" + module_name))
-      end
-    end
-
-    # For cross-language compat
-    alias :captureException :capture_exception
-    alias :captureMessage :capture_message
-    alias :annotateException :annotate_exception
-    alias :annotate :annotate_exception
-
-    private
-
-    def install_at_exit_hook(options)
-      at_exit do
-        if $!
-          logger.debug "Caught a post-mortem exception: #{$!.inspect}"
-          capture_exception($!, options)
-        end
+        opts[:to].send(:include, opts[:from].const_get("Old" + module_name))
       end
     end
   end

data/lib/raven/breadcrumbs.rb

@@ -0,0 +1,74 @@
+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
+
+    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.any?
+    end
+
+    def to_hash
+      {
+        :values => members.map(&:to_hash)
+      }
+    end
+  end
+end

data/lib/raven/breadcrumbs/activesupport.rb

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

@@ -0,0 +1,93 @@
+require 'logger'
+
+module Raven
+  module BreadcrumbLogger
+    LEVELS = {
+      ::Logger::DEBUG => 'debug',
+      ::Logger::INFO  => 'info',
+      ::Logger::WARN  => 'warn',
+      ::Logger::ERROR => 'error',
+      ::Logger::FATAL => 'fatal'
+    }.freeze
+
+    EXC_FORMAT = /^([a-zA-Z0-9]+)\:\s(.*)$/
+
+    def self.parse_exception(message)
+      lines = message.split(/\n\s*/)
+      # TODO: wat
+      return nil unless lines.length > 2
+
+      match = lines[0].match(EXC_FORMAT)
+      return nil unless match
+
+      _, type, value = match.to_a
+      [type, value]
+    end
+
+    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.strip
+
+      last_crumb = Raven.breadcrumbs.peek
+      # try to avoid dupes from logger broadcasts
+      if last_crumb.nil? || last_crumb.message != message
+        error = Raven::BreadcrumbLogger.parse_exception(message)
+        # TODO(dcramer): we need to filter out the "currently captured error"
+        if error
+          Raven.breadcrumbs.record do |crumb|
+            crumb.level = Raven::BreadcrumbLogger::LEVELS.fetch(severity, nil)
+            crumb.category = progname || 'error'
+            crumb.type = 'error'
+            crumb.data = {
+              :type => error[0],
+              :value => error[1]
+            }
+          end
+        else
+          Raven.breadcrumbs.record do |crumb|
+            crumb.level = Raven::BreadcrumbLogger::LEVELS.fetch(severity, nil)
+            crumb.category = progname || 'logger'
+            crumb.message = message
+          end
+        end
+      end
+    end
+
+    private
+
+    def ignored_logger?(progname)
+      progname == "sentry" ||
+        Raven.configuration.exclude_loggers.include?(progname)
+    end
+  end
+  module OldBreadcrumbLogger
+    def self.included(base)
+      base.class_eval do
+        include Raven::BreadcrumbLogger
+        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
+
+Raven.safely_prepend(
+  "BreadcrumbLogger",
+  :from => Raven,
+  :to => ::Logger
+)

data/lib/raven/client.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
-require 'zlib'
 require 'base64'
+require 'json'
+require 'zlib'
 
 require 'raven/version'
-require 'raven/okjson'
 require 'raven/transports/http'
 
 module Raven
@@ -73,7 +73,7 @@ module Raven
 
     def encode(event)
       hash = @processors.reduce(event.to_hash) { |memo, p| p.process(memo) }
-      encoded = OkJson.encode(hash)
+      encoded = JSON.generate(hash)
 
       case configuration.encoding
       when 'gzip'