sentry-ruby 4.1.2 → 4.1.5

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,74 +0,0 @@
-module Sentry
-  class RequestInterface < Interface
-    REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
-    IP_HEADERS = [
-      "REMOTE_ADDR",
-      "HTTP_CLIENT_IP",
-      "HTTP_X_REAL_IP",
-      "HTTP_X_FORWARDED_FOR"
-    ].freeze
-
-    attr_accessor :url, :method, :data, :query_string, :cookies, :headers, :env
-
-    def initialize
-      self.headers = {}
-      self.env = {}
-      self.cookies = nil
-    end
-
-    private
-
-    # See Sentry server default limits at
-    # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
-    def read_data_from(request)
-      if request.form_data?
-        request.POST
-      elsif request.body # JSON requests, etc
-        data = request.body.read(4096 * 4) # Sentry server limit
-        request.body.rewind
-        data
-      end
-    rescue IOError => e
-      e.message
-    end
-
-    def format_headers_for_sentry(env_hash)
-      env_hash.each_with_object({}) do |(key, value), memo|
-        begin
-          key = key.to_s # rack env can contain symbols
-          value = value.to_s
-          next memo['X-Request-Id'] ||= Utils::RequestId.read_from(env_hash) if Utils::RequestId::REQUEST_ID_HEADERS.include?(key)
-          next unless key.upcase == key # Non-upper case stuff isn't either
-
-          # 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
-          next if key == 'HTTP_VERSION' && value == env_hash['SERVER_PROTOCOL']
-          next if key == 'HTTP_COOKIE' # Cookies don't go here, they go somewhere else
-          next unless key.start_with?('HTTP_') || %w(CONTENT_TYPE CONTENT_LENGTH).include?(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
-        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 format_env_for_sentry(env_hash)
-      return env_hash if Sentry.configuration.rack_env_whitelist.empty?
-
-      env_hash.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,57 +0,0 @@
-module Sentry
-  class StacktraceInterface < Interface
-    attr_accessor :frames
-
-    def to_hash
-      data = super
-      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(project_root)
-        @project_root = project_root
-      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 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,5 +0,0 @@
-require 'rack'
-
-require 'sentry/rack/capture_exceptions'
-require 'sentry/rack/interface'
-require 'sentry/rack/deprecations'

data/lib/sentry/rack/capture_exceptions.rb

@@ -1,62 +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 = Sentry.start_transaction(name: scope.transaction_name, op: transaction_op)
-          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/rack/interface.rb

@@ -1,22 +0,0 @@
-module Sentry
-  class RequestInterface
-    def from_rack(env_hash)
-      req = ::Rack::Request.new(env_hash)
-
-      if Sentry.configuration.send_default_pii
-        self.data = read_data_from(req)
-        self.cookies = req.cookies
-      else
-        # need to completely wipe out ip addresses
-        IP_HEADERS.each { |h| env_hash.delete(h) }
-      end
-
-      self.url = req.scheme && req.url.split('?').first
-      self.method = req.request_method
-      self.query_string = req.query_string
-
-      self.headers = format_headers_for_sentry(env_hash)
-      self.env     = format_env_for_sentry(env_hash)
-    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

data/lib/sentry/scope.rb

@@ -1,214 +0,0 @@
-require "sentry/breadcrumb_buffer"
-require "etc"
-
-module Sentry
-  class Scope
-    ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env, :span]
-
-    attr_reader(*ATTRIBUTES)
-
-    def initialize
-      set_default_value
-    end
-
-    def clear
-      set_default_value
-    end
-
-    def apply_to_event(event, hint = nil)
-      event.tags = tags.merge(event.tags)
-      event.user = user.merge(event.user)
-      event.extra = extra.merge(event.extra)
-      event.contexts = contexts.merge(event.contexts)
-
-      if span
-        event.contexts[:trace] = span.get_trace_context
-      end
-
-      event.fingerprint = fingerprint
-      event.level = level
-      event.transaction = transaction_names.last
-      event.breadcrumbs = breadcrumbs
-      event.rack_env = rack_env if rack_env
-
-      unless @event_processors.empty?
-        @event_processors.each do |processor_block|
-          event = processor_block.call(event, hint)
-        end
-      end
-
-      event
-    end
-
-    def add_breadcrumb(breadcrumb)
-      breadcrumbs.record(breadcrumb)
-    end
-
-    def clear_breadcrumbs
-      @breadcrumbs = BreadcrumbBuffer.new
-    end
-
-    def dup
-      copy = super
-      copy.breadcrumbs = breadcrumbs.dup
-      copy.contexts = contexts.deep_dup
-      copy.extra = extra.deep_dup
-      copy.tags = tags.deep_dup
-      copy.user = user.deep_dup
-      copy.transaction_names = transaction_names.deep_dup
-      copy.fingerprint = fingerprint.deep_dup
-      copy.span = span.deep_dup
-      copy
-    end
-
-    def update_from_scope(scope)
-      self.breadcrumbs = scope.breadcrumbs
-      self.contexts = scope.contexts
-      self.extra = scope.extra
-      self.tags = scope.tags
-      self.user = scope.user
-      self.transaction_names = scope.transaction_names
-      self.fingerprint = scope.fingerprint
-      self.span = scope.span
-    end
-
-    def update_from_options(
-      contexts: nil,
-      extra: nil,
-      tags: nil,
-      user: nil,
-      level: nil,
-      fingerprint: nil
-    )
-      self.contexts.merge!(contexts) if contexts
-      self.extra.merge!(extra) if extra
-      self.tags.merge!(tags) if tags
-      self.user = user if user
-      self.level = level if level
-      self.fingerprint = fingerprint if fingerprint
-    end
-
-    def set_rack_env(env)
-      env = env || {}
-      @rack_env = env
-    end
-
-    def set_span(span)
-      check_argument_type!(span, Span)
-      @span = span
-    end
-
-    def set_user(user_hash)
-      check_argument_type!(user_hash, Hash)
-      @user = user_hash
-    end
-
-    def set_extras(extras_hash)
-      check_argument_type!(extras_hash, Hash)
-      @extra.merge!(extras_hash)
-    end
-
-    def set_extra(key, value)
-      @extra.merge!(key => value)
-    end
-
-    def set_tags(tags_hash)
-      check_argument_type!(tags_hash, Hash)
-      @tags.merge!(tags_hash)
-    end
-
-    def set_tag(key, value)
-      @tags.merge!(key => value)
-    end
-
-    def set_contexts(contexts_hash)
-      check_argument_type!(contexts_hash, Hash)
-      @contexts = contexts_hash
-    end
-
-    def set_context(key, value)
-      @contexts.merge!(key => value)
-    end
-
-    def set_level(level)
-      @level = level
-    end
-
-    def set_transaction_name(transaction_name)
-      @transaction_names << transaction_name
-    end
-
-    def transaction_name
-      @transaction_names.last
-    end
-
-    def get_transaction
-      # transaction will always be the first in the span_recorder
-      span.span_recorder.spans.first if span
-    end
-
-    def get_span
-      span
-    end
-
-    def set_fingerprint(fingerprint)
-      check_argument_type!(fingerprint, Array)
-
-      @fingerprint = fingerprint
-    end
-
-    def add_event_processor(&block)
-      @event_processors << block
-    end
-
-    protected
-
-    # for duplicating scopes internally
-    attr_writer(*ATTRIBUTES)
-
-    private
-
-    def check_argument_type!(argument, expected_type)
-      unless argument.is_a?(expected_type)
-        raise ArgumentError, "expect the argument to be a #{expected_type}, got #{argument.class} (#{argument})"
-      end
-    end
-
-    def set_default_value
-      @breadcrumbs = BreadcrumbBuffer.new
-      @contexts = { :os => self.class.os_context, :runtime => self.class.runtime_context }
-      @extra = {}
-      @tags = {}
-      @user = {}
-      @level = :error
-      @fingerprint = []
-      @transaction_names = []
-      @event_processors = []
-      @rack_env = {}
-      @span = nil
-    end
-
-    class << self
-      def os_context
-        @os_context ||=
-          begin
-            uname = Etc.uname
-            {
-              name: uname[:sysname] || RbConfig::CONFIG["host_os"],
-              version: uname[:version],
-              build: uname[:release],
-              kernel_version: uname[:version]
-            }
-          end
-      end
-
-      def runtime_context
-        @runtime_context ||= {
-          name: RbConfig::CONFIG["ruby_install_name"],
-          version: RUBY_DESCRIPTION || Sentry.sys_command("ruby -v")
-        }
-      end
-    end
-
-  end
-end