sentry-ruby 5.3.1 → 5.16.1

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+return if Object.method_defined?(:duplicable?)
+
+#########################################
+#  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/cron/configuration.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Cron
+    class Configuration
+      # Defaults set here will apply to all {Cron::MonitorConfig} objects unless overwritten.
+
+      # How long (in minutes) after the expected checkin time will we wait
+      # until we consider the checkin to have been missed.
+      # @return [Integer, nil]
+      attr_accessor :default_checkin_margin
+
+      # How long (in minutes) is the checkin allowed to run for in in_progress
+      # before it is considered failed.
+      # @return [Integer, nil]
+      attr_accessor :default_max_runtime
+
+      # tz database style timezone string
+      # @return [String, nil]
+      attr_accessor :default_timezone
+    end
+  end
+end

data/lib/sentry/cron/monitor_check_ins.rb

@@ -0,0 +1,75 @@
+module Sentry
+  module Cron
+    module MonitorCheckIns
+      MAX_SLUG_LENGTH = 50
+
+      module Patch
+        def perform(*args, **opts)
+          slug = self.class.sentry_monitor_slug
+          monitor_config = self.class.sentry_monitor_config
+
+          check_in_id = Sentry.capture_check_in(slug,
+                                                :in_progress,
+                                                monitor_config: monitor_config)
+
+          start = Sentry.utc_now.to_i
+
+          begin
+            # need to do this on ruby <= 2.6 sadly
+            ret = method(:perform).super_method.arity == 0 ? super() : super
+            duration = Sentry.utc_now.to_i - start
+
+            Sentry.capture_check_in(slug,
+                                    :ok,
+                                    check_in_id: check_in_id,
+                                    duration: duration,
+                                    monitor_config: monitor_config)
+
+            ret
+          rescue Exception
+            duration = Sentry.utc_now.to_i - start
+
+            Sentry.capture_check_in(slug,
+                                    :error,
+                                    check_in_id: check_in_id,
+                                    duration: duration,
+                                    monitor_config: monitor_config)
+
+            raise
+          end
+        end
+      end
+
+      module ClassMethods
+        def sentry_monitor_check_ins(slug: nil, monitor_config: nil)
+          if monitor_config && Sentry.configuration
+            cron_config = Sentry.configuration.cron
+            monitor_config.checkin_margin ||= cron_config.default_checkin_margin
+            monitor_config.max_runtime ||= cron_config.default_max_runtime
+            monitor_config.timezone ||= cron_config.default_timezone
+          end
+
+          @sentry_monitor_slug = slug
+          @sentry_monitor_config = monitor_config
+
+          prepend Patch
+        end
+
+        def sentry_monitor_slug(name: self.name)
+          @sentry_monitor_slug ||= begin
+            slug = name.gsub('::', '-').downcase
+            slug[-MAX_SLUG_LENGTH..-1] || slug
+          end
+        end
+
+        def sentry_monitor_config
+          @sentry_monitor_config
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/sentry/cron/monitor_config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'sentry/cron/monitor_schedule'
+
+module Sentry
+  module Cron
+    class MonitorConfig
+      # The monitor schedule configuration
+      # @return [MonitorSchedule::Crontab, MonitorSchedule::Interval]
+      attr_accessor :schedule
+
+      # How long (in minutes) after the expected checkin time will we wait
+      # until we consider the checkin to have been missed.
+      # @return [Integer, nil]
+      attr_accessor :checkin_margin
+
+      # How long (in minutes) is the checkin allowed to run for in in_progress
+      # before it is considered failed.
+      # @return [Integer, nil]
+      attr_accessor :max_runtime
+
+      # tz database style timezone string
+      # @return [String, nil]
+      attr_accessor :timezone
+
+      def initialize(schedule, checkin_margin: nil, max_runtime: nil, timezone: nil)
+        @schedule = schedule
+        @checkin_margin = checkin_margin
+        @max_runtime = max_runtime
+        @timezone = timezone
+      end
+
+      def self.from_crontab(crontab, **options)
+        new(MonitorSchedule::Crontab.new(crontab), **options)
+      end
+
+      def self.from_interval(num, unit, **options)
+        return nil unless MonitorSchedule::Interval::VALID_UNITS.include?(unit)
+
+        new(MonitorSchedule::Interval.new(num, unit), **options)
+      end
+
+      def to_hash
+        {
+          schedule: schedule.to_hash,
+          checkin_margin: checkin_margin,
+          max_runtime: max_runtime,
+          timezone: timezone
+        }.compact
+      end
+    end
+  end
+end

data/lib/sentry/cron/monitor_schedule.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Cron
+    module MonitorSchedule
+      class Crontab
+        # A crontab formatted string such as "0 * * * *".
+        # @return [String]
+        attr_accessor :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_hash
+          { type: :crontab, value: value }
+        end
+      end
+
+      class Interval
+        # The number representing duration of the interval.
+        # @return [Integer]
+        attr_accessor :value
+
+        # The unit representing duration of the interval.
+        # @return [Symbol]
+        attr_accessor :unit
+
+        VALID_UNITS = %i(year month week day hour minute)
+
+        def initialize(value, unit)
+          @value = value
+          @unit = unit
+        end
+
+        def to_hash
+          { type: :interval, value: value, unit: unit }
+        end
+      end
+    end
+  end
+end

data/lib/sentry/dsn.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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
+    end
+
+    def csp_report_uri
+      "#{server}/api/#{project_id}/security/?sentry_key=#{public_key}"
+    end
+
+    def envelope_endpoint
+      "#{path}/api/#{project_id}/envelope/"
+    end
+  end
+end

data/lib/sentry/envelope.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class Envelope
+    class Item
+      STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD = 500
+      MAX_SERIALIZED_PAYLOAD_SIZE = 1024 * 1000
+
+      attr_accessor :headers, :payload
+
+      def initialize(headers, payload)
+        @headers = headers
+        @payload = payload
+      end
+
+      def type
+        @headers[:type] || 'event'
+      end
+
+      def to_s
+        [JSON.generate(@headers), JSON.generate(@payload)].join("\n")
+      end
+
+      def serialize
+        result = to_s
+
+        if result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE
+          remove_breadcrumbs!
+          result = to_s
+        end
+
+        if result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE
+          reduce_stacktrace!
+          result = to_s
+        end
+
+        [result, result.bytesize > MAX_SERIALIZED_PAYLOAD_SIZE]
+      end
+
+      def size_breakdown
+        payload.map do |key, value|
+          "#{key}: #{JSON.generate(value).bytesize}"
+        end.join(", ")
+      end
+
+      private
+
+      def remove_breadcrumbs!
+        if payload.key?(:breadcrumbs)
+          payload.delete(:breadcrumbs)
+        elsif payload.key?("breadcrumbs")
+          payload.delete("breadcrumbs")
+        end
+      end
+
+      def reduce_stacktrace!
+        if exceptions = payload.dig(:exception, :values) || payload.dig("exception", "values")
+          exceptions.each do |exception|
+            # in most cases there is only one exception (2 or 3 when have multiple causes), so we won't loop through this double condition much
+            traces = exception.dig(:stacktrace, :frames) || exception.dig("stacktrace", "frames")
+
+            if traces && traces.size > STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD
+              size_on_both_ends = STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD / 2
+              traces.replace(
+                traces[0..(size_on_both_ends - 1)] + traces[-size_on_both_ends..-1],
+              )
+            end
+          end
+        end
+      end
+    end
+
+    attr_accessor :headers, :items
+
+    def initialize(headers = {})
+      @headers = headers
+      @items = []
+    end
+
+    def add_item(headers, payload)
+      @items << Item.new(headers, payload)
+    end
+
+    def item_types
+      @items.map(&:type)
+    end
+
+    def event_id
+      @headers[:event_id]
+    end
+  end
+end

data/lib/sentry/error_event.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Sentry
+  # ErrorEvent represents error or normal message events.
+  class ErrorEvent < Event
+    # @return [ExceptionInterface]
+    attr_reader :exception
+
+    # @return [ThreadsInterface]
+    attr_reader :threads
+
+    # @return [Hash]
+    def to_hash
+      data = super
+      data[:threads] = threads.to_hash if threads
+      data[:exception] = exception.to_hash if exception
+      data
+    end
+
+    # @!visibility private
+    def add_threads_interface(backtrace: nil, **options)
+      @threads = ThreadsInterface.build(
+        backtrace: backtrace,
+        stacktrace_builder: @stacktrace_builder,
+        **options
+      )
+    end
+
+    # @!visibility private
+    def add_exception_interface(exception)
+      if exception.respond_to?(:sentry_context)
+        @extra.merge!(exception.sentry_context)
+      end
+
+      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: @stacktrace_builder)
+    end
+  end
+end

data/lib/sentry/event.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'securerandom'
+require 'sentry/interface'
+require 'sentry/backtrace'
+require 'sentry/utils/real_ip'
+require 'sentry/utils/request_id'
+require 'sentry/utils/custom_inspection'
+
+module Sentry
+  # This is an abstract class that defines the shared attributes of an event.
+  # Please don't use it directly. The user-facing classes are its child classes.
+  class Event
+    TYPE = "event"
+    # These are readable attributes.
+    SERIALIZEABLE_ATTRIBUTES = %i(
+      event_id level timestamp
+      release environment server_name modules
+      message user tags contexts extra
+      fingerprint breadcrumbs transaction transaction_info
+      platform sdk type
+    )
+
+    # These are writable attributes.
+    WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i(type timestamp level)
+
+    MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
+
+    SKIP_INSPECTION_ATTRIBUTES = [:@modules, :@stacktrace_builder, :@send_default_pii, :@trusted_proxies, :@rack_env_whitelist]
+
+    include CustomInspection
+
+    attr_writer(*WRITER_ATTRIBUTES)
+    attr_reader(*SERIALIZEABLE_ATTRIBUTES)
+
+    # @return [RequestInterface]
+    attr_reader :request
+
+    # Dynamic Sampling Context (DSC) that gets attached
+    # as the trace envelope header in the transport.
+    # @return [Hash, nil]
+    attr_accessor :dynamic_sampling_context
+
+    # @param configuration [Configuration]
+    # @param integration_meta [Hash, nil]
+    # @param message [String, nil]
+    def initialize(configuration:, integration_meta: nil, message: nil)
+      # Set some simple default values
+      @event_id      = SecureRandom.uuid.delete("-")
+      @timestamp     = Sentry.utc_now.iso8601
+      @platform      = :ruby
+      @type          = self.class::TYPE
+      @sdk           = integration_meta || Sentry.sdk_meta
+
+      @user          = {}
+      @extra         = {}
+      @contexts      = {}
+      @tags          = {}
+
+      @fingerprint = []
+      @dynamic_sampling_context = nil
+
+      # configuration data that's directly used by events
+      @server_name = configuration.server_name
+      @environment = configuration.environment
+      @release = configuration.release
+      @modules = configuration.gem_specs if configuration.send_modules
+
+      # configuration options to help events process data
+      @send_default_pii = configuration.send_default_pii
+      @trusted_proxies = configuration.trusted_proxies
+      @stacktrace_builder = configuration.stacktrace_builder
+      @rack_env_whitelist = configuration.rack_env_whitelist
+
+      @message = (message || "").byteslice(0..MAX_MESSAGE_SIZE_IN_BYTES)
+    end
+
+    # @deprecated This method will be removed in v5.0.0. Please just use Sentry.configuration
+    # @return [Configuration]
+    def configuration
+      Sentry.configuration
+    end
+
+    # Sets the event's timestamp.
+    # @param time [Time, Float]
+    # @return [void]
+    def timestamp=(time)
+      @timestamp = time.is_a?(Time) ? time.to_f : time
+    end
+
+    # Sets the event's level.
+    # @param level [String, Symbol]
+    # @return [void]
+    def level=(level) # needed to meet the Sentry spec
+      @level = level.to_s == "warn" ? :warning : level
+    end
+
+    # Sets the event's request environment data with RequestInterface.
+    # @see RequestInterface
+    # @param env [Hash]
+    # @return [void]
+    def rack_env=(env)
+      unless request || env.empty?
+        add_request_interface(env)
+
+        if @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
+
+    # @return [Hash]
+    def to_hash
+      data = serialize_attributes
+      data[:breadcrumbs] = breadcrumbs.to_hash if breadcrumbs
+      data[:request] = request.to_hash if request
+      data
+    end
+
+    # @return [Hash]
+    def to_json_compatible
+      JSON.parse(JSON.generate(to_hash))
+    end
+
+    private
+
+    def add_request_interface(env)
+      @request = Sentry::RequestInterface.new(env: env, send_default_pii: @send_default_pii, rack_env_whitelist: @rack_env_whitelist)
+    end
+
+    def serialize_attributes
+      self.class::SERIALIZEABLE_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"],
+        :trusted_proxies => @trusted_proxies
+      ).calculate_ip
+    end
+  end
+end

data/lib/sentry/exceptions.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Sentry
+  class Error < StandardError
+  end
+
+  class ExternalError < Error
+  end
+end