sentry-ruby-core 4.1.5.pre.beta.0

data/lib/sentry/integrable.rb

@@ -0,0 +1,24 @@
+module Sentry
+  module Integrable
+    def register_integration(name:, version:)
+      Sentry.register_integration(name, version)
+      @integration_name = name
+    end
+
+    def integration_name
+      @integration_name
+    end
+
+    def capture_exception(exception, **options, &block)
+      options[:hint] ||= {}
+      options[:hint][:integration] = integration_name
+      Sentry.capture_exception(exception, **options, &block)
+    end
+
+    def capture_message(message, **options, &block)
+      options[:hint] ||= {}
+      options[:hint][:integration] = integration_name
+      Sentry.capture_message(message, **options, &block)
+    end
+  end
+end

data/lib/sentry/interface.rb

@@ -0,0 +1,22 @@
+module Sentry
+  class Interface
+    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
+
+require "sentry/interfaces/exception"
+require "sentry/interfaces/request"
+require "sentry/interfaces/single_exception"
+require "sentry/interfaces/stacktrace"

data/lib/sentry/interfaces/exception.rb

@@ -0,0 +1,11 @@
+module Sentry
+  class ExceptionInterface < Interface
+    attr_accessor :values
+
+    def to_hash
+      data = super
+      data[:values] = data[:values].map(&:to_hash) if data[:values]
+      data
+    end
+  end
+end

data/lib/sentry/interfaces/request.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Sentry
+  class RequestInterface < Interface
+    REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
+    CONTENT_HEADERS = %w(CONTENT_TYPE CONTENT_LENGTH).freeze
+    IP_HEADERS = [
+      "REMOTE_ADDR",
+      "HTTP_CLIENT_IP",
+      "HTTP_X_REAL_IP",
+      "HTTP_X_FORWARDED_FOR"
+    ].freeze
+
+    # See Sentry server default limits at
+    # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
+    MAX_BODY_LIMIT = 4096 * 4
+
+    attr_accessor :url, :method, :data, :query_string, :cookies, :headers, :env
+
+    def self.from_rack(env)
+      env = clean_env(env)
+      req = ::Rack::Request.new(env)
+      self.new(req)
+    end
+
+    def self.clean_env(env)
+      unless Sentry.configuration.send_default_pii
+        # need to completely wipe out ip addresses
+        RequestInterface::IP_HEADERS.each do |header|
+          env.delete(header)
+        end
+      end
+
+      env
+    end
+
+    def initialize(req)
+      env = req.env
+
+      if Sentry.configuration.send_default_pii
+        self.data = read_data_from(req)
+        self.cookies = req.cookies
+      end
+
+      self.url = req.scheme && req.url.split('?').first
+      self.method = req.request_method
+      self.query_string = req.query_string
+
+      self.headers = filter_and_format_headers(env)
+      self.env     = filter_and_format_env(env)
+    end
+
+    private
+
+    def read_data_from(request)
+      if request.form_data?
+        request.POST
+      elsif request.body # JSON requests, etc
+        data = request.body.read(MAX_BODY_LIMIT)
+        request.body.rewind
+        data
+      end
+    rescue IOError => e
+      e.message
+    end
+
+    def filter_and_format_headers(env)
+      env.each_with_object({}) do |(key, value), memo|
+        begin
+          key = key.to_s # rack env can contain symbols
+          next memo['X-Request-Id'] ||= Utils::RequestId.read_from(env) if Utils::RequestId::REQUEST_ID_HEADERS.include?(key)
+          next if is_server_protocol?(key, value, env["SERVER_PROTOCOL"])
+          next if is_skippable_header?(key)
+
+          # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
+          key = key.sub(/^HTTP_/, "")
+          key = key.split('_').map(&:capitalize).join('-')
+          memo[key] = value.to_s
+        rescue StandardError => e
+          # Rails adds objects to the Rack env that can sometimes raise exceptions
+          # when `to_s` is called.
+          # See: https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/middleware/remote_ip.rb#L134
+          Sentry.logger.warn(LOGGER_PROGNAME) { "Error raised while formatting headers: #{e.message}" }
+          next
+        end
+      end
+    end
+
+    def is_skippable_header?(key)
+      key.upcase != key || # lower-case envs aren't real http headers
+        key == "HTTP_COOKIE" || # Cookies don't go here, they go somewhere else
+        !(key.start_with?('HTTP_') || CONTENT_HEADERS.include?(key))
+    end
+
+    # Rack adds in an incorrect HTTP_VERSION key, which causes downstream
+    # to think this is a Version header. Instead, this is mapped to
+    # env['SERVER_PROTOCOL']. But we don't want to ignore a valid header
+    # if the request has legitimately sent a Version header themselves.
+    # See: https://github.com/rack/rack/blob/028438f/lib/rack/handler/cgi.rb#L29
+    # NOTE: This will be removed in version 3.0+
+    def is_server_protocol?(key, value, protocol_version)
+      key == 'HTTP_VERSION' && value == protocol_version
+    end
+
+    def filter_and_format_env(env)
+      return env if Sentry.configuration.rack_env_whitelist.empty?
+
+      env.select do |k, _v|
+        Sentry.configuration.rack_env_whitelist.include? k.to_s
+      end
+    end
+  end
+end

data/lib/sentry/interfaces/single_exception.rb

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

data/lib/sentry/interfaces/stacktrace.rb

@@ -0,0 +1,90 @@
+module Sentry
+  class StacktraceInterface
+    attr_reader :frames
+
+    def initialize(backtrace:, project_root:, app_dirs_pattern:, linecache:, context_lines:, backtrace_cleanup_callback: nil)
+      @project_root = project_root
+      @frames = []
+
+      parsed_backtrace_lines = Backtrace.parse(
+        backtrace, project_root, app_dirs_pattern, &backtrace_cleanup_callback
+      ).lines
+
+      parsed_backtrace_lines.reverse.each_with_object(@frames) do |line, frames|
+        frame = convert_parsed_line_into_frame(line, project_root, linecache, context_lines)
+        frames << frame if frame.filename
+      end
+    end
+
+    def to_hash
+      { frames: @frames.map(&:to_hash) }
+    end
+
+    private
+
+    def convert_parsed_line_into_frame(line, project_root, linecache, context_lines)
+      frame = StacktraceInterface::Frame.new(@project_root, line)
+      frame.set_context(linecache, context_lines) if context_lines
+      frame
+    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(project_root, line)
+        @project_root = project_root
+
+        @abs_path = line.file if line.file
+        @function = line.method if line.method
+        @lineno = line.number
+        @in_app = line.in_app
+        @module = line.module_name if line.module_name
+      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 set_context(linecache, context_lines)
+        return unless abs_path
+
+        self.pre_context, self.context_line, self.post_context = \
+            linecache.get_file_context(abs_path, lineno, context_lines)
+      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 longest_load_path
+        $LOAD_PATH.select { |path| abs_path.start_with?(path.to_s) }.max_by(&:size)
+      end
+    end
+  end
+end

data/lib/sentry/linecache.rb

@@ -0,0 +1,44 @@
+module Sentry
+  class LineCache
+    def initialize
+      @cache = {}
+    end
+
+    # Any linecache you provide to Sentry 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/sentry/logger.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Sentry
+  class Logger < ::Logger
+    LOG_PREFIX = "** [Sentry] "
+    PROGNAME   = "sentry"
+
+    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/sentry/rack.rb

@@ -0,0 +1,4 @@
+require 'rack'
+
+require 'sentry/rack/capture_exceptions'
+require 'sentry/rack/deprecations'

data/lib/sentry/rack/capture_exceptions.rb

@@ -0,0 +1,68 @@
+module Sentry
+  module Rack
+    class CaptureExceptions
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless Sentry.initialized?
+
+        # make sure the current thread has a clean hub
+        Sentry.clone_hub_to_current_thread
+
+        Sentry.with_scope do |scope|
+          scope.clear_breadcrumbs
+          scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
+          scope.set_rack_env(env)
+
+          span =
+            if sentry_trace = env["sentry-trace"]
+              Sentry::Transaction.from_sentry_trace(sentry_trace, name: scope.transaction_name, op: transaction_op)
+            else
+              Sentry.start_transaction(name: scope.transaction_name, op: transaction_op)
+            end
+
+          scope.set_span(span)
+
+          begin
+            response = @app.call(env)
+          rescue Sentry::Error
+            finish_span(span, 500)
+            raise # Don't capture Sentry errors
+          rescue Exception => e
+            capture_exception(e)
+            finish_span(span, 500)
+            raise
+          end
+
+          exception = collect_exception(env)
+          capture_exception(exception) if exception
+
+          finish_span(span, response[0])
+
+          response
+        end
+      end
+
+      private
+
+      def collect_exception(env)
+        env['rack.exception'] || env['sinatra.error']
+      end
+
+      def transaction_op
+        "rack.request".freeze
+      end
+
+      def capture_exception(exception)
+        Sentry.capture_exception(exception)
+      end
+
+      def finish_span(span, status_code)
+        span.set_http_status(status_code)
+        span.finish
+      end
+    end
+  end
+end

data/lib/sentry/rack/deprecations.rb

@@ -0,0 +1,19 @@
+module Sentry
+  module Rack
+    class DeprecatedMiddleware
+      def initialize(_)
+        raise Sentry::Error.new <<~MSG
+
+You're seeing this message because #{self.class} has been replaced by Sentry::Rack::CaptureExceptions.
+Removing this middleware from your app and upgrading sentry-rails to 4.1.0+ should solve the issue.
+        MSG
+      end
+    end
+
+    class Tracing < DeprecatedMiddleware
+    end
+
+    class CaptureException < DeprecatedMiddleware
+    end
+  end
+end

data/lib/sentry/rake.rb

@@ -0,0 +1,17 @@
+require "rake"
+require "rake/task"
+
+module Rake
+  class Application
+    alias orig_display_error_messsage display_error_message
+    def display_error_message(ex)
+      Sentry.capture_exception(ex, hint: { background: false }) do |scope|
+        task_name = top_level_tasks.join(' ')
+        scope.set_transaction_name(task_name)
+        scope.set_tag("rake_task", task_name)
+      end if Sentry.initialized?
+
+      orig_display_error_messsage(ex)
+    end
+  end
+end