sentry-raven 3.1.1 → 3.1.2

data/sentry-ruby/lib/sentry/event.rb

@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-
-require 'socket'
-require 'securerandom'
-require 'sentry/interface'
-require 'sentry/backtrace'
-require 'sentry/utils/deep_merge'
-
-module Sentry
-  class Event
-    # See Sentry server default limits at
-    # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
-    MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
-    REQUIRED_OPTION_KEYS = [:configuration].freeze
-
-    SDK = { "name" => "sentry-ruby", "version" => Sentry::VERSION }.freeze
-
-    attr_accessor :id, :logger, :transaction, :server_name, :release, :modules,
-                  :extra, :tags, :context, :configuration, :checksum,
-                  :fingerprint, :environment, :server_os, :runtime,
-                  :breadcrumbs, :user, :backtrace, :platform, :sdk
-    alias event_id id
-
-    attr_reader :level, :timestamp, :time_spent
-
-    def initialize(
-      configuration:,
-      message: nil,
-      user: {}, extra: {}, tags: {},
-      backtrace: [], level: :error, checksum: nil, fingerprint: [],
-      server_name: nil, release: nil, environment: nil
-    )
-      # this needs to go first because some setters rely on configuration
-      self.configuration = configuration
-
-      # Set some simple default values
-      self.id            = SecureRandom.uuid.delete("-")
-      self.timestamp     = Time.now.utc
-      self.level         = level
-      self.platform      = :ruby
-      self.sdk           = SDK
-
-      # Set some attributes with empty hashes to allow merging
-      @interfaces        = {}
-
-      self.user          = user || {}
-      self.extra         = extra || {}
-      self.tags          = configuration.tags.merge(tags || {})
-
-      self.message       = message
-      self.server_os     = {} # TODO: contexts
-      self.runtime       = {} # TODO: contexts
-
-      self.checksum = checksum
-      self.fingerprint = fingerprint
-
-      self.server_name = server_name
-      self.environment = environment
-      self.release = release
-
-      # Allow attributes to be set on the event at initialization
-      yield self if block_given?
-      # options.each_pair { |key, val| public_send("#{key}=", val) unless val.nil? }
-
-      if !backtrace.empty?
-        interface(:stacktrace) do |int|
-          int.frames = stacktrace_interface_from(backtrace)
-        end
-      end
-
-      set_core_attributes_from_configuration
-    end
-
-    def message
-      @interfaces[:logentry]&.unformatted_message
-    end
-
-    def message=(message)
-      unless message.is_a?(String)
-        configuration.logger.debug("You're passing a non-string message")
-        message = message.to_s
-      end
-
-      interface(:message) do |int|
-        int.message = message.byteslice(0...MAX_MESSAGE_SIZE_IN_BYTES) # Messages limited to 10kb
-      end
-    end
-
-    def timestamp=(time)
-      @timestamp = time.is_a?(Time) ? time.strftime('%Y-%m-%dT%H:%M:%S') : time
-    end
-
-    def time_spent=(time)
-      @time_spent = time.is_a?(Float) ? (time * 1000).to_i : time
-    end
-
-    def level=(new_level) # needed to meet the Sentry spec
-      @level = new_level.to_s == "warn" ? :warning : new_level
-    end
-
-    def interface(name, value = nil, &block)
-      int = Interface.registered[name]
-      raise(Error, "Unknown interface: #{name}") unless int
-
-      @interfaces[int.sentry_alias] = int.new(value, &block) if value || block
-      @interfaces[int.sentry_alias]
-    end
-
-    def [](key)
-      interface(key)
-    end
-
-    def []=(key, value)
-      interface(key, value)
-    end
-
-    def to_hash
-      data = [:checksum, :environment, :event_id, :extra, :fingerprint, :level,
-              :logger, :message, :modules, :platform, :release, :sdk, :server_name,
-              :tags, :time_spent, :timestamp, :transaction, :user].each_with_object({}) do |att, memo|
-        memo[att] = public_send(att) if public_send(att)
-      end
-
-      # TODO-v4: Fix this
-      # data[:breadcrumbs] = @breadcrumbs.to_hash unless @breadcrumbs.empty?
-
-      @interfaces.each_pair do |name, int_data|
-        data[name.to_sym] = int_data.to_hash
-      end
-      data
-    end
-
-    def to_json_compatible
-      JSON.parse(JSON.generate(to_hash))
-    end
-
-    def add_exception_interface(exc)
-      interface(:exception) do |exc_int|
-        exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exc).reverse
-        backtraces = Set.new
-        exc_int.values = exceptions.map do |e|
-          SingleExceptionInterface.new 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 do |stacktrace|
-                  stacktrace.frames = stacktrace_interface_from(e.backtrace)
-                end
-              end
-          end
-        end
-      end
-    end
-
-    def stacktrace_interface_from(backtrace)
-      Backtrace.parse(backtrace, configuration: configuration).lines.reverse.each_with_object([]) do |line, memo|
-        frame = StacktraceInterface::Frame.new(configuration: configuration)
-        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 set_core_attributes_from_configuration
-      self.server_name ||= configuration.server_name
-      self.release     ||= configuration.release
-      self.modules       = list_gem_specs if configuration.send_modules
-      self.environment ||= configuration.current_environment
-    end
-
-    def add_rack_context
-      interface :http do |int|
-        int.from_rack(context.rack_env)
-      end
-      context.user[:ip_address] = calculate_real_ip_from_rack
-    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
-      Utils::RealIp.new(
-        :remote_addr => context.rack_env["REMOTE_ADDR"],
-        :client_ip => context.rack_env["HTTP_CLIENT_IP"],
-        :real_ip => context.rack_env["HTTP_X_REAL_IP"],
-        :forwarded_for => context.rack_env["HTTP_X_FORWARDED_FOR"]
-      ).calculate_ip
-    end
-
-    def list_gem_specs
-      # Older versions of Rubygems don't support iterating over all specs
-      Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
-    end
-  end
-end

data/sentry-ruby/lib/sentry/interface.rb

@@ -1,31 +0,0 @@
-module Sentry
-  class Interface
-    def initialize(attributes = nil)
-      attributes&.each do |attr, value|
-        public_send "#{attr}=", value
-      end
-
-      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
-
-require "sentry/interfaces/exception"
-require "sentry/interfaces/http"
-require "sentry/interfaces/message"
-require "sentry/interfaces/single_exception"
-require "sentry/interfaces/stack_trace"

data/sentry-ruby/lib/sentry/interfaces/exception.rb

@@ -1,15 +0,0 @@
-module Sentry
-  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/sentry-ruby/lib/sentry/interfaces/http.rb

@@ -1,16 +0,0 @@
-module Sentry
-  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/sentry-ruby/lib/sentry/interfaces/message.rb

@@ -1,18 +0,0 @@
-module Sentry
-  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/sentry-ruby/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(*args)
-      data = super(*args)
-      data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
-      data
-    end
-  end
-end

data/sentry-ruby/lib/sentry/interfaces/stack_trace.rb

@@ -1,69 +0,0 @@
-module Sentry
-  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, :configuration
-
-      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 ||= 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/sentry-ruby/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/sentry-ruby/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