sentry-ruby 0.1.1

data/lib/sentry/core_ext/object/deep_dup.rb

@@ -0,0 +1,57 @@
+require 'sentry/core_ext/object/duplicable'
+
+#########################################
+#  This file was copied from Rails 5.2  #
+#########################################
+
+class Object
+  # Returns a deep copy of object if it's duplicable. If it's
+  # not duplicable, returns +self+.
+  #
+  #   object = Object.new
+  #   dup    = object.deep_dup
+  #   dup.instance_variable_set(:@a, 1)
+  #
+  #   object.instance_variable_defined?(:@a) # => false
+  #   dup.instance_variable_defined?(:@a)    # => true
+  def deep_dup
+    duplicable? ? dup : self
+  end
+end
+
+class Array
+  # Returns a deep copy of array.
+  #
+  #   array = [1, [2, 3]]
+  #   dup   = array.deep_dup
+  #   dup[1][2] = 4
+  #
+  #   array[1][2] # => nil
+  #   dup[1][2]   # => 4
+  def deep_dup
+    map(&:deep_dup)
+  end
+end
+
+class Hash
+  # Returns a deep copy of hash.
+  #
+  #   hash = { a: { b: 'b' } }
+  #   dup  = hash.deep_dup
+  #   dup[:a][:c] = 'c'
+  #
+  #   hash[:a][:c] # => nil
+  #   dup[:a][:c]  # => "c"
+  def deep_dup
+    hash = dup
+    each_pair do |key, value|
+      if key.frozen? && ::String === key
+        hash[key] = value.deep_dup
+      else
+        hash.delete(key)
+        hash[key.deep_dup] = value.deep_dup
+      end
+    end
+    hash
+  end
+end

data/lib/sentry/core_ext/object/duplicable.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+#########################################
+#  This file was copied from Rails 5.2  #
+#########################################
+
+#--
+# Most objects are cloneable, but not all. For example you can't dup methods:
+#
+#   method(:puts).dup # => TypeError: allocator undefined for Method
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+#   arbitrary_object.dup rescue object
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That rescue is very expensive (like 40 times slower than a predicate), and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check duplicable? instead of
+# using that rescue idiom.
+#++
+class Object
+  # Can you safely dup this object?
+  #
+  # False for method objects;
+  # true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass
+  begin
+    nil.dup
+  rescue TypeError
+    # +nil+ is not duplicable:
+    #
+    #   nil.duplicable? # => false
+    #   nil.dup         # => TypeError: can't dup NilClass
+    def duplicable?
+      false
+    end
+  end
+end
+
+class FalseClass
+  begin
+    false.dup
+  rescue TypeError
+    # +false+ is not duplicable:
+    #
+    #   false.duplicable? # => false
+    #   false.dup         # => TypeError: can't dup FalseClass
+    def duplicable?
+      false
+    end
+  end
+end
+
+class TrueClass
+  begin
+    true.dup
+  rescue TypeError
+    # +true+ is not duplicable:
+    #
+    #   true.duplicable? # => false
+    #   true.dup         # => TypeError: can't dup TrueClass
+    def duplicable?
+      false
+    end
+  end
+end
+
+class Symbol
+  begin
+    :symbol.dup # Ruby 2.4.x.
+    "symbol_from_string".to_sym.dup # Some symbols can't `dup` in Ruby 2.4.0.
+  rescue TypeError
+    # Symbols are not duplicable:
+    #
+    #   :my_symbol.duplicable? # => false
+    #   :my_symbol.dup         # => TypeError: can't dup Symbol
+    def duplicable?
+      false
+    end
+  end
+end
+
+class Numeric
+  begin
+    1.dup
+  rescue TypeError
+    # Numbers are not duplicable:
+    #
+    #  3.duplicable? # => false
+    #  3.dup         # => TypeError: can't dup Integer
+    def duplicable?
+      false
+    end
+  end
+end
+
+require "bigdecimal"
+class BigDecimal
+  # BigDecimals are duplicable:
+  #
+  #   BigDecimal("1.2").duplicable? # => true
+  #   BigDecimal("1.2").dup         # => #<BigDecimal:...,'0.12E1',18(18)>
+  def duplicable?
+    true
+  end
+end
+
+class Method
+  # Methods are not duplicable:
+  #
+  #  method(:puts).duplicable? # => false
+  #  method(:puts).dup         # => TypeError: allocator undefined for Method
+  def duplicable?
+    false
+  end
+end
+
+class Complex
+  begin
+    Complex(1).dup
+  rescue TypeError
+    # Complexes are not duplicable:
+    #
+    #   Complex(1).duplicable? # => false
+    #   Complex(1).dup         # => TypeError: can't copy Complex
+    def duplicable?
+      false
+    end
+  end
+end
+
+class Rational
+  begin
+    Rational(1).dup
+  rescue TypeError
+    # Rationals are not duplicable:
+    #
+    #   Rational(1).duplicable? # => false
+    #   Rational(1).dup         # => TypeError: can't copy Rational
+    def duplicable?
+      false
+    end
+  end
+end

data/lib/sentry/dsn.rb

@@ -0,0 +1,45 @@
+require "uri"
+
+module Sentry
+  class DSN
+    attr_reader :scheme, :project_id, :public_key, :secret_key, :host, :port, :path
+
+    def initialize(dsn_string)
+      @raw_value = dsn_string
+
+      uri = URI.parse(dsn_string)
+      uri_path = uri.path.split('/')
+
+      if uri.user
+        # DSN-style string
+        @project_id = uri_path.pop
+        @public_key = uri.user
+        @secret_key = !(uri.password.nil? || uri.password.empty?) ? uri.password : nil
+      end
+
+      @scheme = uri.scheme
+      @host = uri.host
+      @port = uri.port if uri.port
+      @path = uri_path.join('/')
+    end
+
+    def valid?
+      %w(host path public_key project_id).all? { |k| public_send(k) }
+    end
+
+    def to_s
+      @raw_value
+    end
+
+    def server
+      server = "#{scheme}://#{host}"
+      server += ":#{port}" unless port == { 'http' => 80, 'https' => 443 }[scheme]
+      server += path
+      server
+    end
+
+    def envelope_endpoint
+      "#{path}/api/#{project_id}/envelope/"
+    end
+  end
+end

data/lib/sentry/event.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'securerandom'
+require 'sentry/event/options'
+require 'sentry/interface'
+require 'sentry/backtrace'
+require 'sentry/utils/deep_merge'
+require 'sentry/utils/real_ip'
+
+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
+    )
+
+    attr_accessor(*ATTRIBUTES)
+    attr_reader :id, :configuration
+
+    alias event_id id
+
+    def initialize(options:, configuration:)
+      # this needs to go first because some setters rely on configuration
+      @configuration = configuration
+
+      # Set some simple default values
+      @id            = SecureRandom.uuid.delete("-")
+      @timestamp     = Time.now.utc
+      @platform      = :ruby
+      @sdk           = Sentry.sdk_meta
+
+      @user          = options.user
+      @extra         = options.extra
+      @contexts      = options.contexts
+      @tags          = configuration.tags.merge(options.tags)
+
+      @fingerprint = options.fingerprint
+
+      @server_name = options.server_name || configuration.server_name
+      @environment = options.environment || configuration.current_environment
+      @release = options.release || configuration.release
+      @modules = list_gem_specs if configuration.send_modules
+
+      @message = options.message if options.message
+
+      self.level = options.level
+
+      if !options.backtrace.empty?
+        @stacktrace = Sentry::StacktraceInterface.new.tap do |int|
+          int.frames = stacktrace_interface_from(options.backtrace)
+        end
+      end
+    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.empty?
+        message = '<no message value>' if 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.strftime('%Y-%m-%dT%H:%M:%S') : 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
+      end
+    end
+
+    def to_hash
+      data = ATTRIBUTES.each_with_object({}) do |att, memo|
+        memo[att] = public_send(att) if public_send(att)
+      end
+
+      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)
+      @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
+
+    # 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
+
+    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/lib/sentry/event/options.rb

@@ -0,0 +1,31 @@
+module Sentry
+  class Event
+    class Options
+      attr_reader :message,
+        :user, :extra, :tags, :contexts,
+        :backtrace, :level, :fingerprint,
+        :server_name, :release, :environment
+
+      def initialize(
+        message: "",
+        user: {}, extra: {}, tags: {}, contexts: {},
+        backtrace: [], level: :error, fingerprint: [],
+        # nilable attributes because we'll fallback to the configuration's values
+        server_name: nil, release: nil, environment: nil
+      )
+        @message = message || ""
+        @user = user || {}
+        @extra = extra || {}
+        @tags = tags || {}
+        @contexts = contexts || {}
+        @backtrace = backtrace || []
+        @fingerprint = fingerprint || []
+        @level = level || :error
+        @server_name = server_name
+        @environment = environment
+        @release = release
+      end
+    end
+  end
+end
+