sentry-ruby 4.1.4 → 4.1.5.pre.beta.0

data/lib/sentry/integrable.rb

@@ -1,24 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,113 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,20 +0,0 @@
-# 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

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

data/lib/sentry/rack/capture_exceptions.rb

@@ -1,68 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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