sentry-raven 3.0.1 → 3.1.1

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

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

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

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

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

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

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

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

@@ -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/sentry-ruby/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