alec-gem 2.7.2

data/lib/raven/integrations/rake.rb

@@ -0,0 +1,18 @@
+require 'rake'
+require 'rake/task'
+require 'raven/integrations/tasks'
+
+module Rake
+  class Application
+    alias orig_display_error_messsage display_error_message
+    def display_error_message(ex)
+      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
+end

data/lib/raven/integrations/sidekiq.rb

@@ -0,0 +1,87 @@
+require 'time'
+require 'sidekiq'
+
+module Raven
+  class SidekiqCleanupMiddleware
+    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
+
+  class SidekiqErrorHandler
+    ACTIVEJOB_RESERVED_PREFIX = "_aj_".freeze
+    HAS_GLOBALID = const_defined?('GlobalID')
+
+    def call(ex, context)
+      context = 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
+
+    # 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
+        format_globalid(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 transaction_from_context(context)
+      classname = (context["wrapped"] || context["class"] ||
+                    (context[:job] && (context[:job]["wrapped"] || context[:job]["class"]))
+                  )
+      if classname
+        "Sidekiq/#{classname}"
+      elsif context[:event]
+        "Sidekiq/#{context[:event]}"
+      else
+        "Sidekiq"
+      end
+    end
+
+    def format_globalid(context)
+      if HAS_GLOBALID && context.is_a?(GlobalID)
+        context.to_s
+      else
+        context
+      end
+    end
+  end
+end
+
+if Sidekiq::VERSION > '3'
+  Sidekiq.configure_server do |config|
+    config.error_handlers << Raven::SidekiqErrorHandler.new
+    config.server_middleware do |chain|
+      chain.add Raven::SidekiqCleanupMiddleware
+    end
+  end
+end

data/lib/raven/integrations/tasks.rb

@@ -0,0 +1,11 @@
+require 'rake'
+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 Rake::Task.tasks.map(&:to_s).include?("environment")
+
+    Raven::CLI.test(args.dsn)
+  end
+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 if attributes
+
+      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

@@ -0,0 +1,15 @@
+module Raven
+  class ExceptionInterface < Interface
+    attr_accessor :values
+
+    def self.sentry_alias
+      :exception
+    end
+
+    def to_hash(*args)
+      data = super(*args)
+      data[:values] = data[:values].map(&:to_hash) if data[:values]
+      data
+    end
+  end
+end

data/lib/raven/interfaces/http.rb

@@ -0,0 +1,16 @@
+module Raven
+  class HttpInterface < Interface
+    attr_accessor :url, :method, :data, :query_string, :cookies, :headers, :env
+
+    def initialize(*arguments)
+      self.headers = {}
+      self.env = {}
+      self.cookies = nil
+      super(*arguments)
+    end
+
+    def self.sentry_alias
+      :request
+    end
+  end
+end

data/lib/raven/interfaces/message.rb

@@ -0,0 +1,20 @@
+require 'raven/interface'
+
+module Raven
+  class MessageInterface < Interface
+    attr_accessor :message, :params
+
+    def initialize(*arguments)
+      self.params = []
+      super(*arguments)
+    end
+
+    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

@@ -0,0 +1,14 @@
+module Raven
+  class SingleExceptionInterface < Interface
+    attr_accessor :type
+    attr_accessor :value
+    attr_accessor :module
+    attr_accessor :stacktrace
+
+    def to_hash(*args)
+      data = super(*args)
+      data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
+      data
+    end
+  end
+end

data/lib/raven/interfaces/stack_trace.rb

@@ -0,0 +1,69 @@
+module Raven
+  class StacktraceInterface < Interface
+    attr_accessor :frames
+
+    def initialize(*arguments)
+      super(*arguments)
+    end
+
+    def self.sentry_alias
+      :stacktrace
+    end
+
+    def to_hash(*args)
+      data = super(*args)
+      data[:frames] = data[:frames].map(&:to_hash)
+      data
+    end
+
+    # Not actually an interface, but I want to use the same style
+    class Frame < Interface
+      attr_accessor :abs_path, :context_line, :function, :in_app,
+                    :lineno, :module, :pre_context, :post_context, :vars
+
+      def initialize(*arguments)
+        super(*arguments)
+      end
+
+      def filename
+        return if abs_path.nil?
+        return @filename if instance_variable_defined?(:@filename)
+
+        prefix =
+          if under_project_root? && in_app
+            project_root
+          elsif under_project_root?
+            longest_load_path || project_root
+          else
+            longest_load_path
+          end
+
+        @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
+      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

@@ -0,0 +1,41 @@
+module Raven
+  class LineCache
+    def initialize
+      @cache = {}
+    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 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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require 'logger'
+
+module Raven
+  class Logger < ::Logger
+    LOG_PREFIX = "** [Raven] ".freeze
+    PROGNAME   = "sentry".freeze
+
+    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
+end

data/lib/raven/processor.rb

@@ -0,0 +1,15 @@
+module Raven
+  class Processor
+    STRING_MASK = '********'.freeze
+    INT_MASK = 0
+    REGEX_SPECIAL_CHARACTERS = %w(. $ ^ { [ ( | ) * + ?).freeze
+
+    def initialize(client = nil)
+      @client = client
+    end
+
+    def process(_data)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/raven/processor/cookies.rb

@@ -0,0 +1,26 @@
+module Raven
+  class Processor::Cookies < Processor
+    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)
+      data[:request][:cookies] = STRING_MASK if data[:request][:cookies]
+
+      return unless data[:request][:headers] && data[:request][:headers]["Cookie"]
+      data[:request][:headers]["Cookie"] = STRING_MASK
+    end
+
+    def process_if_string_keys(data)
+      data["request"]["cookies"] = STRING_MASK if data["request"]["cookies"]
+
+      return unless data["request"]["headers"] && data["request"]["headers"]["Cookie"]
+      data["request"]["headers"]["Cookie"] = STRING_MASK
+    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