sentry-raven 2.1.3 → 3.1.2

data/lib/raven/integrations/sidekiq.rb

@@ -1,64 +1,13 @@
 require 'time'
 require 'sidekiq'
-
-module Raven
-  class Sidekiq
-    ACTIVEJOB_RESERVED_PREFIX = "_aj_".freeze
-
-    def call(ex, context)
-      context = filter_context(context)
-      Raven.capture_exception(
-        ex,
-        :message => ex.message,
-        :extra => { :sidekiq => context },
-        :culprit => culprit_from_context(context)
-      )
-    ensure
-      Context.clear!
-      BreadcrumbBuffer.clear!
-    end
-
-    private
-
-    # Once an ActiveJob is queued, ActiveRecord references get serialized into
-    # some internal reserved keys, such as _aj_globalid.
-    #
-    # The problem is, if this job in turn gets queued back into ActiveJob with
-    # these magic reserved keys, ActiveJob will throw up and error. We want to
-    # capture these and mutate the keys so we can sanely report it.
-    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)
-      (key = key[3..-1]) if key [0..3] == ACTIVEJOB_RESERVED_PREFIX
-      [key, filter_context(value)]
-    end
-
-    # this will change in the future:
-    # https://github.com/mperham/sidekiq/pull/3161
-    def culprit_from_context(context)
-      classname = (context["class"] || (context["job"] && context["job"]["class"]))
-      if classname
-        "Sidekiq/#{classname}"
-      elsif context["event"]
-        "Sidekiq/#{context['event']}"
-      else
-        "Sidekiq"
-      end
-    end
-  end
-end
+require 'raven/integrations/sidekiq/cleanup_middleware'
+require 'raven/integrations/sidekiq/error_handler'
 
 if Sidekiq::VERSION > '3'
   Sidekiq.configure_server do |config|
-    config.error_handlers << Raven::Sidekiq.new
+    config.error_handlers << Raven::Sidekiq::ErrorHandler.new
+    config.server_middleware do |chain|
+      chain.add Raven::Sidekiq::CleanupMiddleware
+    end
   end
 end

data/lib/raven/interface.rb

@@ -1,9 +1,9 @@
 module Raven
   class Interface
     def initialize(attributes = nil)
-      attributes.each do |attr, value|
+      attributes&.each do |attr, value|
         public_send "#{attr}=", value
-      end if attributes
+      end
 
       yield self if block_given?
     end

data/lib/raven/interfaces/exception.rb

@@ -1,5 +1,3 @@
-require 'raven/interface'
-
 module Raven
   class ExceptionInterface < Interface
     attr_accessor :values

data/lib/raven/interfaces/http.rb

@@ -1,5 +1,3 @@
-require 'raven/interface'
-
 module Raven
   class HttpInterface < Interface
     attr_accessor :url, :method, :data, :query_string, :cookies, :headers, :env

data/lib/raven/interfaces/message.rb

@@ -10,7 +10,7 @@ module Raven
     end
 
     def unformatted_message
-      params.nil? ? message : message % params
+      Array(params).empty? ? message : message % params
     end
 
     def self.sentry_alias

data/lib/raven/interfaces/single_exception.rb

@@ -1,5 +1,3 @@
-require 'raven/interface'
-
 module Raven
   class SingleExceptionInterface < Interface
     attr_accessor :type

data/lib/raven/interfaces/stack_trace.rb

@@ -1,11 +1,8 @@
-require 'raven/interface'
-
 module Raven
   class StacktraceInterface < Interface
     attr_accessor :frames
 
     def initialize(*arguments)
-      self.frames = []
       super(*arguments)
     end
 
@@ -21,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 abs_path.nil?
+        return if abs_path.nil?
+        return @filename if instance_variable_defined?(:@filename)
 
         prefix =
           if under_project_root? && in_app
@@ -48,19 +38,7 @@ module Raven
             longest_load_path
           end
 
-        prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
-      end
-
-      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
-      end
-
-      def longest_load_path
-        $LOAD_PATH.select { |s| abs_path.start_with?(s.to_s) }.sort_by { |s| s.to_s.length }.last
+        @filename = prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
       end
 
       def to_hash(*args)
@@ -72,6 +50,20 @@ module Raven
         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&.to_s
+      end
+
+      def longest_load_path
+        $LOAD_PATH.select { |path| abs_path.start_with?(path.to_s) }.max_by(&:size)
+      end
     end
   end
 end

data/lib/raven/linecache.rb

@@ -1,27 +1,44 @@
 module Raven
   class LineCache
-    class << self
-      CACHE = {} # rubocop:disable Style/MutableConstant
+    def initialize
+      @cache = {}
+    end
 
-      def valid_file?(path)
-        lines = getlines(path)
-        !lines.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)
 
-      def getlines(path)
-        CACHE[path] ||= begin
-          IO.readlines(path)
-        rescue
-          nil
-        end
+      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 valid_path?(path)
+      lines = getlines(path)
+      !lines.nil?
+    end
 
-      def getline(path, n)
-        return nil if n < 1
-        lines = getlines(path)
-        return nil if lines.nil?
-        lines[n - 1]
+    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,26 +1,19 @@
 # frozen_string_literal: true
+
 require 'logger'
 
 module Raven
-  class Logger
-    LOG_PREFIX = "** [Raven] ".freeze
-
-    [
-      :fatal,
-      :error,
-      :warn,
-      :info,
-      :debug
-    ].each do |level|
-      define_method level do |*args, &block|
-        logger = Raven.configuration[:logger]
-        logger = ::Logger.new(STDOUT) if logger.nil?
-        return unless logger
-
-        msg = args[0] # Block-level default args is a 1.9 feature
-        msg ||= block.call if block
+  class Logger < ::Logger
+    LOG_PREFIX = "** [Raven] "
+    PROGNAME   = "sentry"
 
-        logger.send(level, "sentry") { "#{LOG_PREFIX}#{msg}" }
+    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] = STRING_MASK 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"] = STRING_MASK
-        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

@@ -10,17 +10,30 @@ module Raven
     end
 
     def process(data)
-      if data[:request] && 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
+      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

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] = STRING_MASK # 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

data/lib/raven/processor/removecircularreferences.rb

@@ -1,14 +1,18 @@
 module Raven
   class Processor::RemoveCircularReferences < Processor
-    def process(v, visited = [])
-      return "(...)" if visited.include?(v.__id__)
-      visited += [v.__id__]
-      if v.is_a?(Hash)
-        v.each_with_object({}) { |(k, v_), memo| memo[k] = process(v_, visited) }
-      elsif v.is_a?(Array)
-        v.map { |v_| process(v_, visited) }
+    ELISION_STRING = "(...)".freeze
+    def process(value, visited = [])
+      return ELISION_STRING if visited.include?(value.__id__)
+
+      visited << value.__id__ if value.is_a?(Array) || value.is_a?(Hash)
+
+      case value
+      when Hash
+        !value.frozen? ? value.merge!(value) { |_, v| process v, visited } : value.merge(value) { |_, v| process v, visited }
+      when Array
+        !value.frozen? ? value.map! { |v| process v, visited } : value.map { |v| process v, visited }
       else
-        v
+        value
       end
     end
   end

data/lib/raven/processor/removestacktrace.rb

@@ -1,13 +1,24 @@
 module Raven
   class Processor::RemoveStacktrace < Processor
-    def process(value)
-      if value[:exception]
-        value[:exception][:values].map do |single_exception|
-          single_exception.delete(:stacktrace) if single_exception[:stacktrace]
-        end
+    def process(data)
+      process_if_symbol_keys(data) if data[:exception]
+      process_if_string_keys(data) if data["exception"]
+
+      data
+    end
+
+    private
+
+    def process_if_symbol_keys(data)
+      data[:exception][:values].map do |single_exception|
+        single_exception.delete(:stacktrace) if single_exception[:stacktrace]
       end
+    end
 
-      value
+    def process_if_string_keys(data)
+      data["exception"]["values"].map do |single_exception|
+        single_exception.delete("stacktrace") if single_exception["stacktrace"]
+      end
     end
   end
 end

data/lib/raven/processor/sanitizedata.rb

@@ -1,61 +1,118 @@
 # frozen_string_literal: true
+
 require 'json'
 
 module Raven
   class Processor::SanitizeData < Processor
     DEFAULT_FIELDS = %w(authorization password passwd secret ssn social(.*)?sec).freeze
-    CREDIT_CARD_RE = /^(?:\d[ -]*?){13,16}$/
+    CREDIT_CARD_RE = /\b(?:3[47]\d|(?:4\d|5[1-5]|65)\d{2}|6011)\d{12}\b/.freeze
+    QUERY_STRING = ['query_string', :query_string].freeze
+    JSON_STARTS_WITH = ["[", "{"].freeze
 
-    attr_accessor :sanitize_fields, :sanitize_credit_cards
+    attr_accessor :sanitize_fields, :sanitize_credit_cards, :sanitize_fields_excluded
 
     def initialize(client)
       super
       self.sanitize_fields = client.configuration.sanitize_fields
       self.sanitize_credit_cards = client.configuration.sanitize_credit_cards
+      self.sanitize_fields_excluded = client.configuration.sanitize_fields_excluded
+    end
+
+    def process(value, key = nil)
+      case value
+      when Hash
+        sanitize_hash_value(key, value)
+      when Array
+        sanitize_array_value(key, value)
+      when Integer
+        matches_regexes?(key, value.to_s) ? INT_MASK : value
+      when String
+        sanitize_string_value(key, value)
+      else
+        value
+      end
     end
 
-    def process(value)
-      value.each_with_object(value) { |(k, v), memo| memo[k] = sanitize(k, v) }
+    private
+
+    # CGI.parse takes our nice UTF-8 strings and converts them back to ASCII,
+    # so we have to convert them back, again.
+    def utf8_processor
+      @utf8_processor ||= Processor::UTF8Conversion.new
     end
 
-    def sanitize(k, v)
-      if v.is_a?(Hash)
-        process(v)
-      elsif v.is_a?(Array)
-        v.map { |a| sanitize(k, a) }
-      elsif k.to_s == 'query_string'
-        sanitize_query_string(v)
-      elsif v.is_a?(Integer) && matches_regexes?(k, v)
-        INT_MASK
-      elsif v.is_a?(String)
-        if fields_re.match(v.to_s) && (json = parse_json_or_nil(v))
-          # if this string is actually a json obj, convert and sanitize
-          json.is_a?(Hash) ? process(json).to_json : v
-        elsif matches_regexes?(k, v)
-          STRING_MASK
-        else
-          v
-        end
+    def sanitize_hash_value(key, value)
+      if key =~ sensitive_fields
+        STRING_MASK
+      elsif value.frozen?
+        value.merge(value) { |k, v| process v, k }
       else
-        v
+        value.merge!(value) { |k, v| process v, k }
       end
     end
 
-    private
+    def sanitize_array_value(key, value)
+      if value.frozen?
+        value.map { |v| process v, key }
+      else
+        value.map! { |v| process v, key }
+      end
+    end
+
+    def sanitize_string_value(key, value)
+      if value =~ sensitive_fields && (json = parse_json_or_nil(value))
+        # if this string is actually a json obj, convert and sanitize
+        process(json).to_json
+      elsif matches_regexes?(key, value)
+        STRING_MASK
+      elsif QUERY_STRING.include?(key)
+        sanitize_query_string(value)
+      elsif value =~ sensitive_fields
+        sanitize_sensitive_string_content(value)
+      else
+        value
+      end
+    end
 
     def sanitize_query_string(query_string)
       query_hash = CGI.parse(query_string)
-      processed_query_hash = process(query_hash)
+      sanitized = utf8_processor.process(query_hash)
+      processed_query_hash = process(sanitized)
       URI.encode_www_form(processed_query_hash)
     end
 
+    # this scrubs some sensitive info from the string content. for example:
+    #
+    # ```
+    # unexpected token at '{
+    # "role": "admin","password": "Abc@123","foo": "bar"
+    # }'
+    # ```
+    #
+    # will become
+    #
+    # ```
+    # unexpected token at '{
+    # "role": "admin","password": *******,"foo": "bar"
+    # }'
+    # ```
+    #
+    # it's particularly useful in hash or param-parsing related errors
+    def sanitize_sensitive_string_content(value)
+      value.gsub(/(#{sensitive_fields}['":]\s?(:|=>)?\s?)(".*?"|'.*?')/, '\1' + STRING_MASK)
+    end
+
     def matches_regexes?(k, v)
-      (sanitize_credit_cards && CREDIT_CARD_RE.match(v.to_s)) ||
-        fields_re.match(k.to_s)
+      (sanitize_credit_cards && v =~ CREDIT_CARD_RE) ||
+        k =~ sensitive_fields
     end
 
-    def fields_re
-      @fields_re ||= /#{(DEFAULT_FIELDS | sanitize_fields).map do |f|
+    def sensitive_fields
+      return @sensitive_fields if instance_variable_defined?(:@sensitive_fields)
+
+      fields = DEFAULT_FIELDS | sanitize_fields
+      fields -= sanitize_fields_excluded
+      @sensitive_fields = /#{fields.map do |f|
         use_boundary?(f) ? "\\b#{f}\\b" : f
       end.join("|")}/i
     end
@@ -69,6 +126,8 @@ module Raven
     end
 
     def parse_json_or_nil(string)
+      return unless string.start_with?(*JSON_STARTS_WITH)
+
       JSON.parse(string)
     rescue JSON::ParserError, NoMethodError
       nil