sentry-ruby 4.1.4 → 4.2.0

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

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

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

@@ -1,48 +0,0 @@
-require "uri"
-
-module Sentry
-  class DSN
-    PORT_MAP = { 'http' => 80, 'https' => 443 }.freeze
-    REQUIRED_ATTRIBUTES = %w(host path public_key project_id).freeze
-
-    attr_reader :scheme, :secret_key, :port, *REQUIRED_ATTRIBUTES
-
-    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?
-      REQUIRED_ATTRIBUTES.all? { |k| public_send(k) }
-    end
-
-    def to_s
-      @raw_value
-    end
-
-    def server
-      server = "#{scheme}://#{host}"
-      server += ":#{port}" unless port == PORT_MAP[scheme]
-      server += path
-      server
-    end
-
-    def envelope_endpoint
-      "#{path}/api/#{project_id}/envelope/"
-    end
-  end
-end

data/lib/sentry/event.rb

@@ -1,171 +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, :request, :exception, :stacktrace
-
-    def initialize(configuration:, integration_meta: nil, 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           = integration_meta || 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?
-        env = env.dup
-
-        add_request_interface(env)
-
-        if configuration.send_default_pii
-          user[:ip_address] = calculate_real_ip_from_rack(env)
-        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_request_interface(env)
-      @request = Sentry::RequestInterface.from_rack(env)
-    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
-                initialize_stacktrace_interface(e.backtrace)
-              end
-          end
-        end
-      end
-    end
-
-    def initialize_stacktrace_interface(backtrace)
-      StacktraceInterface.new(
-        backtrace: backtrace,
-        project_root: configuration.project_root.to_s,
-        app_dirs_pattern: configuration.app_dirs_pattern,
-        linecache: configuration.linecache,
-        context_lines: configuration.context_lines,
-        backtrace_cleanup_callback: configuration.backtrace_cleanup_callback
-      )
-    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,143 +0,0 @@
-require "sentry/scope"
-require "sentry/client"
-
-module Sentry
-  class Hub
-    include ArgumentCheckingHelper
-
-    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
-
-      check_argument_type!(exception, ::Exception)
-
-      options[:hint] ||= {}
-      options[:hint][:exception] = exception
-      event = current_client.event_from_exception(exception, options[:hint])
-
-      return unless event
-
-      capture_event(event, **options, &block)
-    end
-
-    def capture_message(message, **options, &block)
-      return unless current_client
-
-      options[:hint] ||= {}
-      options[:hint][:message] = message
-      event = current_client.event_from_message(message, options[:hint])
-      capture_event(event, **options, &block)
-    end
-
-    def capture_event(event, **options, &block)
-      return unless current_client
-
-      check_argument_type!(event, Sentry::Event)
-
-      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