class Airbrake::Utils::ParamsCleaner

Attributes

blacklist_filters[W]
cgi_data[R]
parameters[R]
session_data[R]
to_clean[W]
whitelist_filters[W]

Public Class Methods

new(opts = {}) click to toggle source

Public: Initialize a new Airbrake::Utils::ParamsCleaner

opts - The Hash options that contain filters and params (default: {}):

:blacklist_filters - The Array of param keys that should be filtered
:whitelist_filters - The Array of param keys that shouldn't be filtered
:to_clean - The Hash of unfiltered params
:blacklist_filters take precedence over the :whitelist_filters
# File lib/airbrake/utils/params_cleaner.rb, line 14
def initialize(opts = {})
  @blacklist_filters = (opts[:blacklist_filters] || []).flatten
  @blacklist_filters.map!{|f| f.is_a?(Symbol) ? f.to_s : f }
  @whitelist_filters = (opts[:whitelist_filters] || []).flatten
  @whitelist_filters.map!{|f| f.is_a?(Symbol) ? f.to_s : f }
  @to_clean = opts[:to_clean]
end

Public Instance Methods

clean() click to toggle source

Public: Takes the params to_clean passed in an initializer

and filters them out by filters passed.

Also normalizes unserializable data.

Returns self, so that :parameters, :cgi_data, :session_data could be extracted

# File lib/airbrake/utils/params_cleaner.rb, line 29
def clean
  clean_parameters
  clean_session_data
  clean_cgi_data
  clean_rack_request_data

  self
end

Private Instance Methods

any_filters?() click to toggle source
# File lib/airbrake/utils/params_cleaner.rb, line 78
def any_filters?
  @blacklist_filters.any? || @whitelist_filters.any?
end
blacklist_key?(key) click to toggle source
# File lib/airbrake/utils/params_cleaner.rb, line 86
def blacklist_key?(key)
  @blacklist_filters.any? do |filter|
    key == filter || filter.is_a?(Regexp) && filter.match(key)
  end
end
clean_cgi_data() click to toggle source
# File lib/airbrake/utils/params_cleaner.rb, line 50
def clean_cgi_data
  return unless @to_clean[:cgi_data]

  @cgi_data = if any_filters?
    filter(clean_unserializable_data(@to_clean[:cgi_data]))
  else
    clean_unserializable_data(@to_clean[:cgi_data])
  end
end
clean_parameters() click to toggle source
# File lib/airbrake/utils/params_cleaner.rb, line 40
def clean_parameters
  return unless @to_clean[:parameters]

  @parameters = if any_filters?
    filter(clean_unserializable_data(@to_clean[:parameters]))
  else
    clean_unserializable_data(@to_clean[:parameters])
  end
end
clean_rack_request_data() click to toggle source
# File lib/airbrake/utils/params_cleaner.rb, line 70
def clean_rack_request_data
  if @cgi_data
    @cgi_data.reject! do |key, val|
      Airbrake::FILTERED_RACK_VARS.include?(key) || Airbrake::SENSITIVE_ENV_VARS.any?{|re| re.match(key)}
    end
  end
end
clean_session_data() click to toggle source
# File lib/airbrake/utils/params_cleaner.rb, line 60
def clean_session_data
  return unless @to_clean[:session_data]

  @session_data = if any_filters?
    filter(clean_unserializable_data(@to_clean[:session_data]))
  else
    clean_unserializable_data(@to_clean[:session_data])
  end
end
clean_unserializable_data(data, stack = []) click to toggle source

Removes non-serializable data. Allowed data types are strings, arrays, and hashes. All other types are converted to strings.

# File lib/airbrake/utils/params_cleaner.rb, line 115
def clean_unserializable_data(data, stack = [])
  return "[possible infinite recursion halted]" if stack.any?{|item| item == data.object_id }
  if data.is_a?(String)
    data
  elsif data.is_a?(Hash)
    data.inject({}) do |result, (key, value)|
      result.merge!(key => clean_unserializable_data(value, stack + [data.object_id]))
    end
  elsif data.respond_to?(:to_hash)
    data.to_hash.inject({}) do |result, (key, value)|
      result.merge!(key => clean_unserializable_data(value, stack + [data.object_id]))
    end
  elsif data.respond_to?(:collect) && !data.respond_to?(:readlines)
    data = data.collect do |value|
      clean_unserializable_data(value, stack + [data.object_id])
    end
  elsif data.respond_to?(:to_ary)
    data = data.to_ary.collect do |value|
      clean_unserializable_data(value, stack + [data.object_id])
    end
  elsif data.respond_to?(:to_s)
    data.nil? ? nil : data.to_s
  end
end
filter(hash) click to toggle source
# File lib/airbrake/utils/params_cleaner.rb, line 99
def filter(hash)
  return hash unless hash.is_a?(Hash)

  hash.each do |key, value|
    if filter_key?(key)
      hash[key] = "[FILTERED]"
    elsif value.respond_to?(:to_hash)
      filter(value)
    elsif value.is_a?(Array)
      hash[key] = value.map { |item| filter(item) }
    end
  end
end
filter_key?(key) click to toggle source
# File lib/airbrake/utils/params_cleaner.rb, line 82
def filter_key?(key)
  blacklist_key?(key) || !whitelist_key?(key)
end
whitelist_key?(key) click to toggle source
# File lib/airbrake/utils/params_cleaner.rb, line 92
def whitelist_key?(key)
  return true if @whitelist_filters.empty?
  @whitelist_filters.any? do |filter|
    key == filter || filter.is_a?(Regexp) && filter.match(key)
  end
end