sentry-ruby 0.3.0 → 4.3.0

data/lib/sentry/event.rb

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-
-require 'socket'
-require 'securerandom'
-require 'sentry/interface'
-require 'sentry/backtrace'
-require 'sentry/utils/real_ip'
-require 'sentry/utils/request_id'
-
-module Sentry
-  class Event
-    ATTRIBUTES = %i(
-      event_id level timestamp
-      release environment server_name modules
-      message user tags contexts extra
-      fingerprint breadcrumbs backtrace transaction
-      platform sdk type
-    )
-
-    attr_accessor(*ATTRIBUTES)
-    attr_reader :configuration
-
-    def initialize(configuration:, message: nil)
-      # this needs to go first because some setters rely on configuration
-      @configuration = configuration
-
-      # Set some simple default values
-      @event_id      = SecureRandom.uuid.delete("-")
-      @timestamp     = Sentry.utc_now.iso8601
-      @platform      = :ruby
-      @sdk           = Sentry.sdk_meta
-
-      @user          = {}
-      @extra         = {}
-      @contexts      = {}
-      @tags          = {}
-
-      @fingerprint = []
-
-      @server_name = configuration.server_name
-      @environment = configuration.environment
-      @release = configuration.release
-      @modules = configuration.gem_specs if configuration.send_modules
-
-      @message = message || ""
-
-      self.level = :error
-    end
-
-    class << self
-      def get_log_message(event_hash)
-        message = event_hash[:message] || event_hash['message']
-        message = get_message_from_exception(event_hash) if message.nil? || message.empty?
-        message = '<no message value>' if message.nil? || message.empty?
-        message
-      end
-
-      def get_message_from_exception(event_hash)
-        (
-          event_hash &&
-          event_hash[:exception] &&
-          event_hash[:exception][:values] &&
-          event_hash[:exception][:values][0] &&
-          "#{event_hash[:exception][:values][0][:type]}: #{event_hash[:exception][:values][0][:value]}"
-        )
-      end
-    end
-
-    def timestamp=(time)
-      @timestamp = time.is_a?(Time) ? time.to_f : time
-    end
-
-    def level=(new_level) # needed to meet the Sentry spec
-      @level = new_level.to_s == "warn" ? :warning : new_level
-    end
-
-    def rack_env=(env)
-      unless @request || env.empty?
-        @request = Sentry::RequestInterface.new.tap do |int|
-          int.from_rack(env)
-        end
-
-        if configuration.send_default_pii && ip = calculate_real_ip_from_rack(env.dup)
-          user[:ip_address] = ip
-        end
-        if request_id = Utils::RequestId.read_from(env)
-          tags[:request_id] = request_id
-        end
-      end
-    end
-
-    def type
-      "event"
-    end
-
-    def to_hash
-      data = serialize_attributes
-      data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
-      data[:stacktrace] = @stacktrace.to_hash if @stacktrace
-      data[:request] = @request.to_hash if @request
-      data[:exception] = @exception.to_hash if @exception
-
-      data
-    end
-
-    def to_json_compatible
-      JSON.parse(JSON.generate(to_hash))
-    end
-
-    def add_exception_interface(exc)
-      if exc.respond_to?(:sentry_context)
-        @extra.merge!(exc.sentry_context)
-      end
-
-      @exception = Sentry::ExceptionInterface.new.tap do |exc_int|
-        exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exc).reverse
-        backtraces = Set.new
-        exc_int.values = exceptions.map do |e|
-          SingleExceptionInterface.new.tap do |int|
-            int.type = e.class.to_s
-            int.value = e.to_s
-            int.module = e.class.to_s.split('::')[0...-1].join('::')
-
-            int.stacktrace =
-              if e.backtrace && !backtraces.include?(e.backtrace.object_id)
-                backtraces << e.backtrace.object_id
-                StacktraceInterface.new.tap do |stacktrace|
-                  stacktrace.frames = stacktrace_interface_from(e.backtrace)
-                end
-              end
-          end
-        end
-      end
-    end
-
-    def stacktrace_interface_from(backtrace)
-      project_root = configuration.project_root.to_s
-
-      Backtrace.parse(backtrace, configuration: configuration).lines.reverse.each_with_object([]) do |line, memo|
-        frame = StacktraceInterface::Frame.new(project_root)
-        frame.abs_path = line.file if line.file
-        frame.function = line.method if line.method
-        frame.lineno = line.number
-        frame.in_app = line.in_app
-        frame.module = line.module_name if line.module_name
-
-        if configuration.context_lines && frame.abs_path
-          frame.pre_context, frame.context_line, frame.post_context = \
-            configuration.linecache.get_file_context(frame.abs_path, frame.lineno, configuration.context_lines)
-        end
-
-        memo << frame if frame.filename
-      end
-    end
-
-    private
-
-    def serialize_attributes
-      self.class::ATTRIBUTES.each_with_object({}) do |att, memo|
-        if value = public_send(att)
-          memo[att] = value
-        end
-      end
-    end
-
-    # When behind a proxy (or if the user is using a proxy), we can't use
-    # REMOTE_ADDR to determine the Event IP, and must use other headers instead.
-    def calculate_real_ip_from_rack(env)
-      Utils::RealIp.new(
-        :remote_addr => env["REMOTE_ADDR"],
-        :client_ip => env["HTTP_CLIENT_IP"],
-        :real_ip => env["HTTP_X_REAL_IP"],
-        :forwarded_for => env["HTTP_X_FORWARDED_FOR"]
-      ).calculate_ip
-    end
-  end
-end

data/lib/sentry/hub.rb

@@ -1,137 +0,0 @@
-require "sentry/scope"
-require "sentry/client"
-
-module Sentry
-  class Hub
-    attr_reader :last_event_id
-
-    def initialize(client, scope)
-      first_layer = Layer.new(client, scope)
-      @stack = [first_layer]
-      @last_event_id = nil
-    end
-
-    def new_from_top
-      Hub.new(current_client, current_scope)
-    end
-
-    def current_client
-      current_layer&.client
-    end
-
-    def current_scope
-      current_layer&.scope
-    end
-
-    def clone
-      layer = current_layer
-
-      if layer
-        scope = layer.scope&.dup
-
-        Hub.new(layer.client, scope)
-      end
-    end
-
-    def bind_client(client)
-      layer = current_layer
-
-      if layer
-        layer.client = client
-      end
-    end
-
-    def configure_scope(&block)
-      block.call(current_scope)
-    end
-
-    def with_scope(&block)
-      push_scope
-      yield(current_scope)
-    ensure
-      pop_scope
-    end
-
-    def push_scope
-      new_scope =
-        if current_scope
-          current_scope.dup
-        else
-          Scope.new
-        end
-
-      @stack << Layer.new(current_client, new_scope)
-    end
-
-    def pop_scope
-      @stack.pop
-    end
-
-    def start_transaction(transaction: nil, **options)
-      transaction ||= Transaction.new(**options)
-      transaction.set_initial_sample_desicion
-      transaction
-    end
-
-    def capture_exception(exception, **options, &block)
-      return unless current_client
-
-      event = current_client.event_from_exception(exception)
-
-      return unless event
-
-      options[:hint] ||= {}
-      options[:hint] = options[:hint].merge(exception: exception)
-      capture_event(event, **options, &block)
-    end
-
-    def capture_message(message, **options, &block)
-      return unless current_client
-
-      options[:hint] ||= {}
-      options[:hint] = options[:hint].merge(message: message)
-      event = current_client.event_from_message(message)
-      capture_event(event, **options, &block)
-    end
-
-    def capture_event(event, **options, &block)
-      return unless current_client
-
-      hint = options.delete(:hint)
-      scope = current_scope.dup
-
-      if block
-        block.call(scope)
-      elsif custom_scope = options[:scope]
-        scope.update_from_scope(custom_scope)
-      elsif !options.empty?
-        scope.update_from_options(**options)
-      end
-
-      event = current_client.capture_event(event, scope, hint)
-
-      @last_event_id = event.event_id
-      event
-    end
-
-    def add_breadcrumb(breadcrumb)
-      current_scope.add_breadcrumb(breadcrumb)
-    end
-
-    private
-
-    def current_layer
-      @stack.last
-    end
-
-    class Layer
-      attr_accessor :client
-      attr_reader :scope
-
-      def initialize(client, scope)
-        @client = client
-        @scope = scope
-      end
-    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,95 +0,0 @@
-require 'rack'
-
-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
-
-    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
-
-    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/capture_exception.rb

@@ -1,45 +0,0 @@
-module Sentry
-  module Rack
-    class CaptureException
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        # this call clones the main (global) hub
-        # and assigns it to the current thread's Sentry#get_current_hub
-        # it's essential for multi-thread servers (e.g. puma)
-        Sentry.clone_hub_to_current_thread unless Sentry.get_current_hub
-        # this call creates an isolated scope for every request
-        # it's essential for multi-process servers (e.g. unicorn)
-        Sentry.with_scope do |scope|
-          # there could be some breadcrumbs already stored in the top-level scope
-          # and for request information, we don't need those breadcrumbs
-          scope.clear_breadcrumbs
-          env['sentry.client'] = Sentry.get_current_client
-
-          scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
-          scope.set_rack_env(env)
-
-          begin
-            response = @app.call(env)
-          rescue Sentry::Error
-            raise # Don't capture Sentry errors
-          rescue Exception => e
-            Sentry.capture_exception(e)
-            raise
-          end
-
-          exception = collect_exception(env)
-          Sentry.capture_exception(exception) if exception
-
-          response
-        end
-      end
-
-      def collect_exception(env)
-        env['rack.exception'] || env['sinatra.error']
-      end
-    end
-  end
-end

data/lib/sentry/rack/tracing.rb

@@ -1,39 +0,0 @@
-module Sentry
-  module Rack
-    class Tracing
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        Sentry.clone_hub_to_current_thread unless Sentry.get_current_hub
-
-        if Sentry.configuration.traces_sample_rate.to_f == 0.0
-          return @app.call(env)
-        end
-
-        Sentry.with_scope do |scope|
-          scope.clear_breadcrumbs
-          scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
-          span = Sentry.start_transaction(name: scope.transaction_name, op: "rack.request")
-          scope.set_span(span)
-
-          begin
-            response = @app.call(env)
-          rescue
-            finish_span(span, 500)
-            raise
-          end
-
-          finish_span(span, response[0])
-          response
-        end
-      end
-
-      def finish_span(span, status_code)
-        span.set_http_status(status_code)
-        span.finish
-      end
-    end
-  end
-end

data/lib/sentry/rack.rb

@@ -1,5 +0,0 @@
-require 'time'
-require 'rack'
-
-require 'sentry/rack/capture_exception'
-require 'sentry/rack/tracing'