sentry-ruby 5.13.0 → 5.19.0

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

@@ -1,9 +1,11 @@
 module Sentry
   module Cron
     module MonitorCheckIns
+      MAX_SLUG_LENGTH = 50
+
       module Patch
-        def perform(*args)
-          slug = self.class.sentry_monitor_slug || self.class.name
+        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,
@@ -11,39 +13,53 @@ module Sentry
                                                 monitor_config: monitor_config)
 
           start = Sentry.utc_now.to_i
-          ret = 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
+
+          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
-          @sentry_monitor_slug
+        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
@@ -51,8 +67,6 @@ module Sentry
         end
       end
 
-      extend ClassMethods
-
       def self.included(base)
         base.extend(ClassMethods)
       end

data/lib/sentry/cron/monitor_schedule.rb

@@ -26,7 +26,7 @@ module Sentry
         # @return [Symbol]
         attr_accessor :unit
 
-        VALID_UNITS = %i(year month week day hour minute)
+        VALID_UNITS = %i[year month week day hour minute]
 
         def initialize(value, unit)
           @value = value

data/lib/sentry/dsn.rb

@@ -5,7 +5,7 @@ require "uri"
 module Sentry
   class DSN
     PORT_MAP = { 'http' => 80, 'https' => 443 }.freeze
-    REQUIRED_ATTRIBUTES = %w(host path public_key project_id).freeze
+    REQUIRED_ATTRIBUTES = %w[host path public_key project_id].freeze
 
     attr_reader :scheme, :secret_key, :port, *REQUIRED_ATTRIBUTES
 

data/lib/sentry/envelope.rb

@@ -18,8 +18,25 @@ module Sentry
         @headers[:type] || 'event'
       end
 
+      # rate limits and client reports use the data_category rather than envelope item type
+      def self.data_category(type)
+        case type
+        when 'session', 'attachment', 'transaction', 'profile', 'span' then type
+        when 'sessions' then 'session'
+        when 'check_in' then 'monitor'
+        when 'statsd', 'metric_meta' then 'metric_bucket'
+        when 'event' then 'error'
+        when 'client_report' then 'internal'
+        else 'default'
+        end
+      end
+
+      def data_category
+        self.class.data_category(type)
+      end
+
       def to_s
-        [JSON.generate(@headers), JSON.generate(@payload)].join("\n")
+        [JSON.generate(@headers), @payload.is_a?(String) ? @payload : JSON.generate(@payload)].join("\n")
       end
 
       def serialize

data/lib/sentry/error_event.rb

@@ -27,12 +27,12 @@ module Sentry
     end
 
     # @!visibility private
-    def add_exception_interface(exception)
+    def add_exception_interface(exception, mechanism:)
       if exception.respond_to?(:sentry_context)
         @extra.merge!(exception.sentry_context)
       end
 
-      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: @stacktrace_builder)
+      @exception = Sentry::ExceptionInterface.build(exception: exception, stacktrace_builder: @stacktrace_builder, mechanism: mechanism)
     end
   end
 end

data/lib/sentry/event.rb

@@ -14,16 +14,16 @@ module Sentry
   class Event
     TYPE = "event"
     # These are readable attributes.
-    SERIALIZEABLE_ATTRIBUTES = %i(
+    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)
+    WRITER_ATTRIBUTES = SERIALIZEABLE_ATTRIBUTES - %i[type timestamp level]
 
     MAX_MESSAGE_SIZE_IN_BYTES = 1024 * 8
 
@@ -42,6 +42,9 @@ module Sentry
     # @return [Hash, nil]
     attr_accessor :dynamic_sampling_context
 
+    # @return [Array<Attachment>]
+    attr_accessor :attachments
+
     # @param configuration [Configuration]
     # @param integration_meta [Hash, nil]
     # @param message [String, nil]
@@ -57,6 +60,7 @@ module Sentry
       @extra         = {}
       @contexts      = {}
       @tags          = {}
+      @attachments   = []
 
       @fingerprint = []
       @dynamic_sampling_context = nil
@@ -76,34 +80,6 @@ module Sentry
       @message = (message || "").byteslice(0..MAX_MESSAGE_SIZE_IN_BYTES)
     end
 
-    class << self
-      # @!visibility private
-      def get_log_message(event_hash)
-        message = event_hash[:message] || event_hash['message']
-
-        return message unless message.nil? || message.empty?
-
-        message = get_message_from_exception(event_hash)
-
-        return message unless message.nil? || message.empty?
-
-        message = event_hash[:transaction] || event_hash["transaction"]
-
-        return message unless message.nil? || message.empty?
-
-        '<no message value>'
-      end
-
-      # @!visibility private
-      def get_message_from_exception(event_hash)
-        if exception = event_hash.dig(:exception, :values, 0)
-          "#{exception[:type]}: #{exception[:value]}"
-        elsif exception = event_hash.dig("exception", "values", 0)
-          "#{exception["type"]}: #{exception["value"]}"
-        end
-      end
-    end
-
     # @deprecated This method will be removed in v5.0.0. Please just use Sentry.configuration
     # @return [Configuration]
     def configuration
@@ -132,9 +108,7 @@ module Sentry
       unless request || env.empty?
         add_request_interface(env)
 
-        if @send_default_pii
-          user[:ip_address] = calculate_real_ip_from_rack(env)
-        end
+        user[:ip_address] ||= calculate_real_ip_from_rack(env) if @send_default_pii
 
         if request_id = Utils::RequestId.read_from(env)
           tags[:request_id] = request_id
@@ -173,11 +147,11 @@ module Sentry
     # 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
+        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

data/lib/sentry/faraday.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Faraday
+    OP_NAME = "http.client"
+
+    module Connection
+      # Since there's no way to preconfigure Faraday connections and add our instrumentation
+      # by default, we need to extend the connection constructor and do it there
+      #
+      # @see https://lostisland.github.io/faraday/#/customization/index?id=configuration
+      def initialize(url = nil, options = nil)
+        super
+
+        # Ensure that we attach instrumentation only if the adapter is not net/http
+        # because if is is, then the net/http instrumentation will take care of it
+        if builder.adapter.name != "Faraday::Adapter::NetHttp"
+          # Make sure that it's going to be the first middleware so that it can capture
+          # the entire request processing involving other middlewares
+          builder.insert(0, ::Faraday::Request::Instrumentation, name: OP_NAME, instrumenter: Instrumenter.new)
+        end
+      end
+    end
+
+    class Instrumenter
+      SPAN_ORIGIN = "auto.http.faraday"
+      BREADCRUMB_CATEGORY = "http"
+
+      include Utils::HttpTracing
+
+      def instrument(op_name, env, &block)
+        return block.call unless Sentry.initialized?
+
+        Sentry.with_child_span(op: op_name, start_timestamp: Sentry.utc_now.to_f, origin: SPAN_ORIGIN) do |sentry_span|
+          request_info = extract_request_info(env)
+
+          if propagate_trace?(request_info[:url])
+            set_propagation_headers(env[:request_headers])
+          end
+
+          res = block.call
+          response_status = res.status
+
+          if record_sentry_breadcrumb?
+            record_sentry_breadcrumb(request_info, response_status)
+          end
+
+          if sentry_span
+            set_span_info(sentry_span, request_info, response_status)
+          end
+
+          res
+        end
+      end
+
+      private
+
+      def extract_request_info(env)
+        url = env[:url].scheme + "://" + env[:url].host + env[:url].path
+        result = { method: env[:method].to_s.upcase, url: url }
+
+        if Sentry.configuration.send_default_pii
+          result[:query] = env[:url].query
+          result[:body] = env[:body]
+        end
+
+        result
+      end
+    end
+  end
+end
+
+Sentry.register_patch(:faraday) do
+  if defined?(::Faraday)
+    ::Faraday::Connection.prepend(Sentry::Faraday::Connection)
+  end
+end

data/lib/sentry/graphql.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+Sentry.register_patch(:graphql) do |config|
+  if defined?(::GraphQL::Schema) && defined?(::GraphQL::Tracing::SentryTrace) && ::GraphQL::Schema.respond_to?(:trace_with)
+    ::GraphQL::Schema.trace_with(::GraphQL::Tracing::SentryTrace, set_transaction_name: true)
+  else
+    config.logger.warn(Sentry::LOGGER_PROGNAME) { 'You tried to enable the GraphQL integration but no GraphQL gem was detected. Make sure you have the `graphql` gem (>= 2.2.6) in your Gemfile.' }
+  end
+end

data/lib/sentry/hub.rb

@@ -156,7 +156,7 @@ module Sentry
       capture_event(event, **options, &block)
     end
 
-    def capture_check_in(slug, status, **options, &block)
+    def capture_check_in(slug, status, **options)
       check_argument_type!(slug, ::String)
       check_argument_includes!(status, Sentry::CheckInEvent::VALID_STATUSES)
 
@@ -176,7 +176,7 @@ module Sentry
 
       return unless event
 
-      capture_event(event, **options, &block)
+      capture_event(event, **options)
       event.check_in_id
     end
 
@@ -193,7 +193,14 @@ module Sentry
       elsif custom_scope = options[:scope]
         scope.update_from_scope(custom_scope)
       elsif !options.empty?
-        scope.update_from_options(**options)
+        unsupported_option_keys = scope.update_from_options(**options)
+
+        unless unsupported_option_keys.empty?
+          configuration.log_debug <<~MSG
+            Options #{unsupported_option_keys} are not supported and will not be applied to the event.
+            You may want to set them under the `extra` option.
+          MSG
+        end
       end
 
       event = current_client.capture_event(event, scope, hint)
@@ -245,7 +252,7 @@ module Sentry
     end
 
     def with_session_tracking(&block)
-      return yield unless configuration.auto_session_tracking
+      return yield unless configuration.session_tracking?
 
       start_session
       yield
@@ -279,6 +286,12 @@ module Sentry
       headers
     end
 
+    def get_trace_propagation_meta
+      get_trace_propagation_headers.map do |k, v|
+        "<meta name=\"#{k}\" content=\"#{v}\">"
+      end.join("\n")
+    end
+
     def continue_trace(env, **options)
       configure_scope { |s| s.generate_propagation_context(env) }
 

data/lib/sentry/integrable.rb

@@ -14,6 +14,10 @@ module Sentry
     def capture_exception(exception, **options, &block)
       options[:hint] ||= {}
       options[:hint][:integration] = integration_name
+
+      # within an integration, we usually intercept uncaught exceptions so we set handled to false.
+      options[:hint][:mechanism] ||= Sentry::Mechanism.new(type: integration_name, handled: false)
+
       Sentry.capture_exception(exception, **options, &block)
     end
 

data/lib/sentry/interface.rb

@@ -14,3 +14,4 @@ require "sentry/interfaces/request"
 require "sentry/interfaces/single_exception"
 require "sentry/interfaces/stacktrace"
 require "sentry/interfaces/threads"
+require "sentry/interfaces/mechanism"

data/lib/sentry/interfaces/exception.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "set"
 
 module Sentry
@@ -23,17 +24,18 @@ module Sentry
     # @param stacktrace_builder [StacktraceBuilder]
     # @see SingleExceptionInterface#build_with_stacktrace
     # @see SingleExceptionInterface#initialize
+    # @param mechanism [Mechanism]
     # @return [ExceptionInterface]
-    def self.build(exception:, stacktrace_builder:)
+    def self.build(exception:, stacktrace_builder:, mechanism:)
       exceptions = Sentry::Utils::ExceptionCauseChain.exception_to_array(exception).reverse
       processed_backtrace_ids = Set.new
 
       exceptions = exceptions.map do |e|
         if e.backtrace && !processed_backtrace_ids.include?(e.backtrace.object_id)
           processed_backtrace_ids << e.backtrace.object_id
-          SingleExceptionInterface.build_with_stacktrace(exception: e, stacktrace_builder: stacktrace_builder)
+          SingleExceptionInterface.build_with_stacktrace(exception: e, stacktrace_builder: stacktrace_builder, mechanism: mechanism)
         else
-          SingleExceptionInterface.new(exception: exception)
+          SingleExceptionInterface.new(exception: exception, mechanism: mechanism)
         end
       end
 

data/lib/sentry/interfaces/mechanism.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Sentry
+  class Mechanism < Interface
+    # Generic identifier, mostly the source integration for this exception.
+    # @return [String]
+    attr_accessor :type
+
+    # A manually captured exception has handled set to true,
+    # false if coming from an integration where we intercept an uncaught exception.
+    # Defaults to true here and will be set to false explicitly in integrations.
+    # @return [Boolean]
+    attr_accessor :handled
+
+    def initialize(type: 'generic', handled: true)
+      @type = type
+      @handled = handled
+    end
+  end
+end

data/lib/sentry/interfaces/request.rb

@@ -2,8 +2,8 @@
 
 module Sentry
   class RequestInterface < Interface
-    REQUEST_ID_HEADERS = %w(action_dispatch.request_id HTTP_X_REQUEST_ID).freeze
-    CONTENT_HEADERS = %w(CONTENT_TYPE CONTENT_LENGTH).freeze
+    REQUEST_ID_HEADERS = %w[action_dispatch.request_id HTTP_X_REQUEST_ID].freeze
+    CONTENT_HEADERS = %w[CONTENT_TYPE CONTENT_LENGTH].freeze
     IP_HEADERS = [
       "REMOTE_ADDR",
       "HTTP_CLIENT_IP",

data/lib/sentry/interfaces/single_exception.rb

@@ -11,10 +11,10 @@ module Sentry
     OMISSION_MARK = "...".freeze
     MAX_LOCAL_BYTES = 1024
 
-    attr_reader :type, :module, :thread_id, :stacktrace
+    attr_reader :type, :module, :thread_id, :stacktrace, :mechanism
     attr_accessor :value
 
-    def initialize(exception:, stacktrace: nil)
+    def initialize(exception:, mechanism:, stacktrace: nil)
       @type = exception.class.to_s
       exception_message =
         if exception.respond_to?(:detailed_message)
@@ -22,23 +22,26 @@ module Sentry
         else
           exception.message || ""
         end
+      exception_message = exception_message.inspect unless exception_message.is_a?(String)
 
       @value = Utils::EncodingHelper.encode_to_utf_8(exception_message.byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES))
 
       @module = exception.class.to_s.split('::')[0...-1].join('::')
       @thread_id = Thread.current.object_id
       @stacktrace = stacktrace
+      @mechanism = mechanism
     end
 
     def to_hash
       data = super
       data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
+      data[:mechanism] = data[:mechanism].to_hash
       data
     end
 
     # patch this method if you want to change an exception's stacktrace frames
     # also see `StacktraceBuilder.build`.
-    def self.build_with_stacktrace(exception:, stacktrace_builder:)
+    def self.build_with_stacktrace(exception:, stacktrace_builder:, mechanism:)
       stacktrace = stacktrace_builder.build(backtrace: exception.backtrace)
 
       if locals = exception.instance_variable_get(:@sentry_locals)
@@ -60,7 +63,7 @@ module Sentry
         stacktrace.frames.last.vars = locals
       end
 
-      new(exception: exception, stacktrace: stacktrace)
+      new(exception: exception, stacktrace: stacktrace, mechanism: mechanism)
     end
   end
 end

data/lib/sentry/interfaces/stacktrace_builder.rb

@@ -62,6 +62,14 @@ module Sentry
       StacktraceInterface.new(frames: frames)
     end
 
+    # Get the code location hash for a single line for where metrics where added.
+    # @return [Hash]
+    def metrics_code_location(unparsed_line)
+      parsed_line = Backtrace::Line.parse(unparsed_line)
+      frame = convert_parsed_line_into_frame(parsed_line)
+      frame.to_hash.reject { |k, _| %i[project_root in_app].include?(k) }
+    end
+
     private
 
     def convert_parsed_line_into_frame(line)