sentry-raven 1.1.0 → 3.1.2

data/lib/raven/integrations/rails.rb

@@ -4,6 +4,9 @@ module Raven
   class Rails < ::Rails::Railtie
     require 'raven/integrations/rails/overrides/streaming_reporter'
     require 'raven/integrations/rails/controller_methods'
+    require 'raven/integrations/rails/controller_transaction'
+    require 'raven/integrations/rails/backtrace_cleaner'
+    require 'raven/integrations/rack'
 
     initializer "raven.use_rack_middleware" do |app|
       app.config.middleware.insert 0, Raven::Rack
@@ -12,27 +15,45 @@ module Raven
     initializer 'raven.action_controller' do
       ActiveSupport.on_load :action_controller do
         include Raven::Rails::ControllerMethods
+        include Raven::Rails::ControllerTransaction
         if ::Rails::VERSION::STRING >= "4.0.0"
-          Raven.rails_safely_prepend("StreamingReporter", :to => ActionController::Live)
+          Raven.safely_prepend(
+            "StreamingReporter",
+            :from => Raven::Rails::Overrides,
+            :to => ActionController::Live
+          )
         end
       end
     end
 
     initializer 'raven.action_view' do
       ActiveSupport.on_load :action_view do
-        Raven.rails_safely_prepend("StreamingReporter", :to => ActionView::StreamingTemplateRenderer::Body)
+        Raven.safely_prepend(
+          "StreamingReporter",
+          :from => Raven::Rails::Overrides,
+          :to => ActionView::StreamingTemplateRenderer::Body
+        )
       end
     end
 
     config.before_initialize do
-      Raven.configure do |config|
-        config.logger ||= ::Rails.logger
-        config.project_root ||= ::Rails.root
-        config.release = config.detect_release # if project_root has changed, need to re-check
+      Raven.configuration.logger = ::Rails.logger
+
+      backtrace_cleaner = Raven::Rails::BacktraceCleaner.new
+
+      Raven.configuration.backtrace_cleanup_callback = lambda do |backtrace|
+        backtrace_cleaner.clean(backtrace)
       end
     end
 
     config.after_initialize do
+      if Raven.configuration.breadcrumbs_logger.include?(:active_support_logger) ||
+         Raven.configuration.rails_activesupport_breadcrumbs
+
+        require 'raven/breadcrumbs/active_support_logger'
+        Raven::Breadcrumbs::ActiveSupportLogger.inject
+      end
+
       if Raven.configuration.rails_report_rescued_exceptions
         require 'raven/integrations/rails/overrides/debug_exceptions_catcher'
         if defined?(::ActionDispatch::DebugExceptions)
@@ -40,7 +61,18 @@ module Raven
         elsif defined?(::ActionDispatch::ShowExceptions)
           exceptions_class = ::ActionDispatch::ShowExceptions
         end
-        Raven.rails_safely_prepend("DebugExceptionsCatcher", :to => exceptions_class)
+
+        Raven.safely_prepend(
+          "DebugExceptionsCatcher",
+          :from => Raven::Rails::Overrides,
+          :to => exceptions_class
+        )
+      end
+    end
+
+    initializer 'raven.active_job' do
+      ActiveSupport.on_load :active_job do
+        require 'raven/integrations/rails/active_job'
       end
     end
 

data/lib/raven/integrations/rake.rb

@@ -4,9 +4,14 @@ require 'raven/integrations/tasks'
 
 module Rake
   class Application
-    alias :orig_display_error_messsage :display_error_message
+    alias orig_display_error_messsage display_error_message
     def display_error_message(ex)
-      Raven.capture_exception ex, :logger => 'rake', :tags => { 'rake_task' => @name }
+      Raven.capture_exception(
+        ex,
+        :transaction => top_level_tasks.join(' '),
+        :logger => 'rake',
+        :tags => { 'rake_task' => top_level_tasks.join(' ') }
+      )
       orig_display_error_messsage(ex)
     end
   end

data/lib/raven/integrations/sidekiq/cleanup_middleware.rb

@@ -0,0 +1,13 @@
+module Raven
+  module Sidekiq
+    class CleanupMiddleware
+      def call(_worker, job, queue)
+        Raven.context.transaction.push "Sidekiq/#{job['class']}"
+        Raven.extra_context(:sidekiq => job.merge("queue" => queue))
+        yield
+        Context.clear!
+        BreadcrumbBuffer.clear!
+      end
+    end
+  end
+end

data/lib/raven/integrations/sidekiq/error_handler.rb

@@ -0,0 +1,38 @@
+require 'raven/utils/context_filter'
+
+module Raven
+  module Sidekiq
+    class ErrorHandler
+      SIDEKIQ_NAME = "Sidekiq".freeze
+
+      def call(ex, context)
+        context = Utils::ContextFilter.filter_context(context)
+        Raven.context.transaction.push transaction_from_context(context)
+        Raven.capture_exception(
+          ex,
+          :message => ex.message,
+          :extra => { :sidekiq => context }
+        )
+        Context.clear!
+        BreadcrumbBuffer.clear!
+      end
+
+      private
+
+      # this will change in the future:
+      # https://github.com/mperham/sidekiq/pull/3161
+      def transaction_from_context(context)
+        classname = (context["wrapped"] || context["class"] ||
+                      (context[:job] && (context[:job]["wrapped"] || context[:job]["class"]))
+                    )
+        if classname
+          "#{SIDEKIQ_NAME}/#{classname}"
+        elsif context[:event]
+          "#{SIDEKIQ_NAME}/#{context[:event]}"
+        else
+          SIDEKIQ_NAME
+        end
+      end
+    end
+  end
+end

data/lib/raven/integrations/sidekiq.rb

@@ -1,55 +1,13 @@
 require 'time'
 require 'sidekiq'
+require 'raven/integrations/sidekiq/cleanup_middleware'
+require 'raven/integrations/sidekiq/error_handler'
 
-module Raven
-  class Sidekiq
-    def call(_worker, msg, _queue)
-      started_at = Time.now
-      yield
-    rescue Exception => ex
-      Raven.capture_exception(ex, :extra => { :sidekiq => msg },
-                                  :time_spent => Time.now-started_at)
-      raise
-    end
-  end
-end
-
-if Sidekiq::VERSION < '3'
-  # old behavior
-  ::Sidekiq.configure_server do |config|
-    config.server_middleware do |chain|
-      chain.add ::Raven::Sidekiq
-    end
-  end
-else
+if Sidekiq::VERSION > '3'
   Sidekiq.configure_server do |config|
-    config.error_handlers << Proc.new do |ex, context|
-      Raven.capture_exception(ex, :extra => {
-        :sidekiq => filter_context(context)
-      })
+    config.error_handlers << Raven::Sidekiq::ErrorHandler.new
+    config.server_middleware do |chain|
+      chain.add Raven::Sidekiq::CleanupMiddleware
     end
   end
 end
-
-def filter_context(context)
-  case context
-  when Array
-    context.map { |arg| filter_context(arg) }
-  when Hash
-    Hash[context.map { |key, value| filter_context_hash(key, value) }]
-  else
-    context
-  end
-end
-
-def filter_context_hash(key, value)
-  # Strip any `_aj` prefixes from keys.
-  # These keys come from an internal serialized object from ActiveJob.
-  # Internally, there are a subset of keys that ActiveJob references, but
-  # these are declared as private, and I don't think it's wise
-  # to keep chasing what this list is. But they all use a common prefix, so
-  # we want to strip this becuase ActiveJob will complain.
-  # e.g.: _aj_globalid -> _globalid
-  (key = key[3..-1]) if key [0..3] == "_aj_"
-  [key, filter_context(value)]
-end

data/lib/raven/integrations/tasks.rb

@@ -4,7 +4,7 @@ require 'raven/cli'
 namespace :raven do
   desc "Send a test event to the remote Sentry server"
   task :test, [:dsn] do |_t, args|
-    Rake::Task["environment"].invoke if defined? Rails
+    Rake::Task["environment"].invoke if Rake::Task.tasks.map(&:to_s).include?("environment")
 
     Raven::CLI.test(args.dsn)
   end

data/lib/raven/interface.rb

@@ -0,0 +1,25 @@
+module Raven
+  class Interface
+    def initialize(attributes = nil)
+      attributes&.each do |attr, value|
+        public_send "#{attr}=", value
+      end
+
+      yield self if block_given?
+    end
+
+    def self.inherited(klass)
+      name = klass.name.split("::").last.downcase.gsub("interface", "")
+      registered[name.to_sym] = klass
+      super
+    end
+
+    def self.registered
+      @@registered ||= {} # rubocop:disable Style/ClassVars
+    end
+
+    def to_hash
+      Hash[instance_variables.map { |name| [name[1..-1].to_sym, instance_variable_get(name)] }]
+    end
+  end
+end

data/lib/raven/interfaces/exception.rb

@@ -1,18 +1,15 @@
-require 'raven/interfaces'
-
 module Raven
   class ExceptionInterface < Interface
-    name 'exception'
     attr_accessor :values
 
+    def self.sentry_alias
+      :exception
+    end
+
     def to_hash(*args)
       data = super(*args)
-      if data[:values]
-        data[:values] = data[:values].map(&:to_hash)
-      end
+      data[:values] = data[:values].map(&:to_hash) if data[:values]
       data
     end
   end
-
-  register_interface :exception => ExceptionInterface
 end

data/lib/raven/interfaces/http.rb

@@ -1,15 +1,6 @@
-require 'raven/interfaces'
-
 module Raven
   class HttpInterface < Interface
-    name 'request'
-    attr_accessor :url
-    attr_accessor :method
-    attr_accessor :data
-    attr_accessor :query_string
-    attr_accessor :cookies
-    attr_accessor :headers
-    attr_accessor :env
+    attr_accessor :url, :method, :data, :query_string, :cookies, :headers, :env
 
     def initialize(*arguments)
       self.headers = {}
@@ -17,7 +8,9 @@ module Raven
       self.cookies = nil
       super(*arguments)
     end
-  end
 
-  register_interface :http => HttpInterface
+    def self.sentry_alias
+      :request
+    end
+  end
 end

data/lib/raven/interfaces/message.rb

@@ -1,16 +1,20 @@
-require 'raven/interfaces'
+require 'raven/interface'
 
 module Raven
   class MessageInterface < Interface
-    name 'sentry.interfaces.Message'
-    attr_accessor :message
-    attr_accessor :params
+    attr_accessor :message, :params
 
     def initialize(*arguments)
       self.params = []
       super(*arguments)
     end
-  end
 
-  register_interface :message => MessageInterface
+    def unformatted_message
+      Array(params).empty? ? message : message % params
+    end
+
+    def self.sentry_alias
+      :logentry
+    end
+  end
 end

data/lib/raven/interfaces/single_exception.rb

@@ -1,5 +1,3 @@
-require 'raven/interfaces'
-
 module Raven
   class SingleExceptionInterface < Interface
     attr_accessor :type
@@ -9,9 +7,7 @@ module Raven
 
     def to_hash(*args)
       data = super(*args)
-      if data[:stacktrace]
-        data[:stacktrace] = data[:stacktrace].to_hash
-      end
+      data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
       data
     end
   end

data/lib/raven/interfaces/stack_trace.rb

@@ -1,15 +1,15 @@
-require 'raven/interfaces'
-
 module Raven
   class StacktraceInterface < Interface
-    name 'stacktrace'
     attr_accessor :frames
 
     def initialize(*arguments)
-      self.frames = []
       super(*arguments)
     end
 
+    def self.sentry_alias
+      :stacktrace
+    end
+
     def to_hash(*args)
       data = super(*args)
       data[:frames] = data[:frames].map(&:to_hash)
@@ -18,23 +18,16 @@ module Raven
 
     # Not actually an interface, but I want to use the same style
     class Frame < Interface
-      attr_accessor :abs_path
-      attr_accessor :function
-      attr_accessor :vars
-      attr_accessor :pre_context
-      attr_accessor :post_context
-      attr_accessor :context_line
-      attr_accessor :module
-      attr_accessor :lineno
-      attr_accessor :in_app
+      attr_accessor :abs_path, :context_line, :function, :in_app,
+                    :lineno, :module, :pre_context, :post_context, :vars
 
       def initialize(*arguments)
-        self.vars, self.pre_context, self.post_context = [], [], []
         super(*arguments)
       end
 
       def filename
-        return nil if self.abs_path.nil?
+        return if abs_path.nil?
+        return @filename if instance_variable_defined?(:@filename)
 
         prefix =
           if under_project_root? && in_app
@@ -45,32 +38,32 @@ module Raven
             longest_load_path
           end
 
-        prefix ? self.abs_path[prefix.to_s.chomp(File::SEPARATOR).length+1..-1] : self.abs_path
+        @filename = prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
+      end
+
+      def to_hash(*args)
+        data = super(*args)
+        data[:filename] = filename
+        data.delete(:vars) unless vars && !vars.empty?
+        data.delete(:pre_context) unless pre_context && !pre_context.empty?
+        data.delete(:post_context) unless post_context && !post_context.empty?
+        data.delete(:context_line) unless context_line && !context_line.empty?
+        data
       end
 
+      private
+
       def under_project_root?
         project_root && abs_path.start_with?(project_root)
       end
 
       def project_root
-        @project_root ||= Raven.configuration.project_root && Raven.configuration.project_root.to_s
+        @project_root ||= Raven.configuration.project_root&.to_s
       end
 
       def longest_load_path
-        $LOAD_PATH.select { |s| self.abs_path.start_with?(s.to_s) }.sort_by { |s| s.to_s.length }.last
-      end
-
-      def to_hash(*args)
-        data = super(*args)
-        data[:filename] = self.filename
-        data.delete(:vars) unless self.vars && !self.vars.empty?
-        data.delete(:pre_context) unless self.pre_context && !self.pre_context.empty?
-        data.delete(:post_context) unless self.post_context && !self.post_context.empty?
-        data.delete(:context_line) unless self.context_line && !self.context_line.empty?
-        data
+        $LOAD_PATH.select { |path| abs_path.start_with?(path.to_s) }.max_by(&:size)
       end
     end
   end
-
-  register_interface :stack_trace => StacktraceInterface
 end

data/lib/raven/linecache.rb

@@ -1,32 +1,44 @@
-# A much simpler source line cacher because linecache sucks at platform compat
-
 module Raven
   class LineCache
-    class << self
-      # TODO: a constant isn't appropriate here, refactor
-      # also would there be threading bugs essentially using this as a class
-      # variable?
-      CACHE = {} # rubocop:disable Style/MutableConstant
-
-      def is_valid_file(path)
-        lines = getlines(path)
-        !lines.nil?
-      end
+    def initialize
+      @cache = {}
+    end
 
-      def getlines(path)
-        CACHE[path] ||= begin
-          IO.readlines(path)
-        rescue
-          nil
-        end
+    # Any linecache you provide to Raven must implement this method.
+    # Returns an Array of Strings representing the lines in the source
+    # file. The number of lines retrieved is (2 * context) + 1, the middle
+    # line should be the line requested by lineno. See specs for more information.
+    def get_file_context(filename, lineno, context)
+      return nil, nil, nil unless valid_path?(filename)
+
+      lines = Array.new(2 * context + 1) do |i|
+        getline(filename, lineno - context + i)
       end
+      [lines[0..(context - 1)], lines[context], lines[(context + 1)..-1]]
+    end
+
+    private
 
-      def getline(path, n)
-        return nil if n < 1
-        lines = getlines(path)
-        return nil if lines.nil?
-        lines[n - 1]
+    def valid_path?(path)
+      lines = getlines(path)
+      !lines.nil?
+    end
+
+    def getlines(path)
+      @cache[path] ||= begin
+        IO.readlines(path)
+                       rescue
+                         nil
       end
     end
+
+    def getline(path, n)
+      return nil if n < 1
+
+      lines = getlines(path)
+      return nil if lines.nil?
+
+      lines[n - 1]
+    end
   end
 end

data/lib/raven/logger.rb

@@ -1,22 +1,19 @@
 # frozen_string_literal: true
-module Raven
-  class Logger
-    LOG_PREFIX = "** [Raven] ".freeze
 
-    [
-      :fatal,
-      :error,
-      :warn,
-      :info,
-      :debug,
-    ].each do |level|
-      define_method level do |*args, &block|
-        msg = args[0] # Block-level default args is a 1.9 feature
-        msg ||= block.call if block
-        logger = Raven.configuration[:logger]
-        logger = ::Logger.new(STDOUT) if logger.nil?
+require 'logger'
+
+module Raven
+  class Logger < ::Logger
+    LOG_PREFIX = "** [Raven] "
+    PROGNAME   = "sentry"
 
-        logger.send(level, "#{LOG_PREFIX}#{msg}") if logger
+    def initialize(*)
+      super
+      @level = ::Logger::INFO
+      original_formatter = ::Logger::Formatter.new
+      @default_formatter = proc do |severity, datetime, _progname, msg|
+        msg = "#{LOG_PREFIX}#{msg}"
+        original_formatter.call(severity, datetime, PROGNAME, msg)
       end
     end
   end

data/lib/raven/processor/cookies.rb

@@ -1,16 +1,36 @@
 module Raven
   class Processor::Cookies < Processor
     def process(data)
-      if data[:request]
-        # Remove possibly sensitive cookies
-        data[:request][:cookies] = nil if data[:request][:cookies]
+      process_if_symbol_keys(data) if data[:request]
+      process_if_string_keys(data) if data["request"]
 
-        if data[:request][:headers] && data[:request][:headers]["Cookie"]
-          data[:request][:headers]["Cookie"] = nil
-        end
+      data
+    end
+
+    private
+
+    def process_if_symbol_keys(data)
+      if cookies = data.dig(:request, :cookies)
+        data[:request][:cookies] = generate_masked_cookies(cookies)
       end
 
-      data
+      if cookies_header = data[:request][:headers]["Cookie"]
+        data[:request][:headers]["Cookie"] = generate_masked_cookies(cookies_header)
+      end
+    end
+
+    def process_if_string_keys(data)
+      if cookies = data.dig("request", "cookies")
+        data["request"]["cookies"] = generate_masked_cookies(cookies)
+      end
+
+      if cookies_header = data.dig("request", "headers", "Cookie")
+        data["request"]["headers"]["Cookie"] = generate_masked_cookies(cookies_header)
+      end
+    end
+
+    def generate_masked_cookies(cookies)
+      cookies.merge(cookies) { STRING_MASK } if cookies.respond_to?(:merge)
     end
   end
 end

data/lib/raven/processor/http_headers.rb

@@ -0,0 +1,55 @@
+module Raven
+  class Processor::HTTPHeaders < Processor
+    DEFAULT_FIELDS = ["Authorization"].freeze
+
+    attr_accessor :sanitize_http_headers
+
+    def initialize(client)
+      super
+      self.sanitize_http_headers = client.configuration.sanitize_http_headers
+    end
+
+    def process(data)
+      process_if_symbol_keys(data) if data[:request]
+      process_if_string_keys(data) if data["request"]
+
+      data
+    end
+
+    private
+
+    def process_if_symbol_keys(data)
+      return unless data[:request][:headers]
+
+      data[:request][:headers].keys.select { |k| fields_re.match(k.to_s) }.each do |k|
+        data[:request][:headers][k] = STRING_MASK
+      end
+    end
+
+    def process_if_string_keys(data)
+      return unless data["request"]["headers"]
+
+      data["request"]["headers"].keys.select { |k| fields_re.match(k) }.each do |k|
+        data["request"]["headers"][k] = STRING_MASK
+      end
+    end
+
+    def matches_regexes?(k)
+      fields_re.match(k.to_s)
+    end
+
+    def fields_re
+      @fields_re ||= /#{(DEFAULT_FIELDS | sanitize_http_headers).map do |f|
+        use_boundary?(f) ? "\\b#{f}\\b" : f
+      end.join("|")}/i
+    end
+
+    def use_boundary?(string)
+      !DEFAULT_FIELDS.include?(string) && !special_characters?(string)
+    end
+
+    def special_characters?(string)
+      REGEX_SPECIAL_CHARACTERS.select { |r| string.include?(r) }.any?
+    end
+  end
+end

data/lib/raven/processor/post_data.rb

@@ -1,11 +1,24 @@
 module Raven
   class Processor::PostData < Processor
     def process(data)
-      if data[:request] && data[:request][:method] == "POST"
-        data[:request][:data] = nil # Remove possibly sensitive POST data
-      end
+      process_if_symbol_keys(data) if data[:request]
+      process_if_string_keys(data) if data["request"]
 
       data
     end
+
+    private
+
+    def process_if_symbol_keys(data)
+      return unless data[:request][:method] == "POST"
+
+      data[:request][:data] = STRING_MASK
+    end
+
+    def process_if_string_keys(data)
+      return unless data["request"]["method"] == "POST"
+
+      data["request"]["data"] = STRING_MASK
+    end
   end
 end