sentry-ruby 5.9.0 → 5.16.1

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/envelope.rb

@@ -5,7 +5,7 @@ module Sentry
   class Envelope
     class Item
       STACKTRACE_FRAME_LIMIT_ON_OVERSIZED_PAYLOAD = 500
-      MAX_SERIALIZED_PAYLOAD_SIZE = 1024 * 200
+      MAX_SERIALIZED_PAYLOAD_SIZE = 1024 * 1000
 
       attr_accessor :headers, :payload
 

data/lib/sentry/event.rb

@@ -37,6 +37,11 @@ module Sentry
     # @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]
@@ -54,6 +59,7 @@ module Sentry
       @tags          = {}
 
       @fingerprint = []
+      @dynamic_sampling_context = nil
 
       # configuration data that's directly used by events
       @server_name = configuration.server_name
@@ -70,34 +76,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

data/lib/sentry/hub.rb

@@ -116,7 +116,11 @@ module Sentry
     end
 
     def capture_exception(exception, **options, &block)
-      check_argument_type!(exception, ::Exception)
+      if RUBY_PLATFORM == "java"
+        check_argument_type!(exception, ::Exception, ::Java::JavaLang::Throwable)
+      else
+        check_argument_type!(exception, ::Exception)
+      end
 
       return if Sentry.exception_captured?(exception)
 
@@ -152,6 +156,30 @@ module Sentry
       capture_event(event, **options, &block)
     end
 
+    def capture_check_in(slug, status, **options)
+      check_argument_type!(slug, ::String)
+      check_argument_includes!(status, Sentry::CheckInEvent::VALID_STATUSES)
+
+      return unless current_client
+
+      options[:hint] ||= {}
+      options[:hint][:slug] = slug
+
+      event = current_client.event_from_check_in(
+        slug,
+        status,
+        options[:hint],
+        duration: options.delete(:duration),
+        monitor_config: options.delete(:monitor_config),
+        check_in_id: options.delete(:check_in_id)
+      )
+
+      return unless event
+
+      capture_event(event, **options)
+      event.check_in_id
+    end
+
     def capture_event(event, **options, &block)
       check_argument_type!(event, Sentry::Event)
 
@@ -174,7 +202,7 @@ module Sentry
         configuration.log_debug(event.to_json_compatible)
       end
 
-      @last_event_id = event&.event_id unless event.is_a?(Sentry::TransactionEvent)
+      @last_event_id = event&.event_id if event.is_a?(Sentry::ErrorEvent)
       event
     end
 
@@ -225,6 +253,50 @@ module Sentry
       end_session
     end
 
+    def get_traceparent
+      return nil unless current_scope
+
+      current_scope.get_span&.to_sentry_trace ||
+        current_scope.propagation_context.get_traceparent
+    end
+
+    def get_baggage
+      return nil unless current_scope
+
+      current_scope.get_span&.to_baggage ||
+        current_scope.propagation_context.get_baggage&.serialize
+    end
+
+    def get_trace_propagation_headers
+      headers = {}
+
+      traceparent = get_traceparent
+      headers[SENTRY_TRACE_HEADER_NAME] = traceparent if traceparent
+
+      baggage = get_baggage
+      headers[BAGGAGE_HEADER_NAME] = baggage if baggage && !baggage.empty?
+
+      headers
+    end
+
+    def continue_trace(env, **options)
+      configure_scope { |s| s.generate_propagation_context(env) }
+
+      return nil unless configuration.tracing_enabled?
+
+      propagation_context = current_scope.propagation_context
+      return nil unless propagation_context.incoming_trace
+
+      Transaction.new(
+        hub: self,
+        trace_id: propagation_context.trace_id,
+        parent_span_id: propagation_context.parent_span_id,
+        parent_sampled: propagation_context.parent_sampled,
+        baggage: propagation_context.baggage,
+        **options
+      )
+    end
+
     private
 
     def current_layer

data/lib/sentry/integrable.rb

@@ -22,5 +22,11 @@ module Sentry
       options[:hint][:integration] = integration_name
       Sentry.capture_message(message, **options, &block)
     end
+
+    def capture_check_in(slug, status, **options, &block)
+      options[:hint] ||= {}
+      options[:hint][:integration] = integration_name
+      Sentry.capture_check_in(slug, status, **options, &block)
+    end
   end
 end

data/lib/sentry/interfaces/single_exception.rb

@@ -11,7 +11,8 @@ module Sentry
     OMISSION_MARK = "...".freeze
     MAX_LOCAL_BYTES = 1024
 
-    attr_reader :type, :value, :module, :thread_id, :stacktrace
+    attr_reader :type, :module, :thread_id, :stacktrace
+    attr_accessor :value
 
     def initialize(exception:, stacktrace: nil)
       @type = exception.class.to_s
@@ -21,8 +22,9 @@ module Sentry
         else
           exception.message || ""
         end
+      exception_message = exception_message.inspect unless exception_message.is_a?(String)
 
-      @value = exception_message.byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES)
+      @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
@@ -50,7 +52,7 @@ module Sentry
                 v = v.byteslice(0..MAX_LOCAL_BYTES - 1) + OMISSION_MARK
               end
 
-              v
+              Utils::EncodingHelper.encode_to_utf_8(v)
             rescue StandardError
               PROBLEMATIC_LOCAL_VALUE_REPLACEMENT
             end

data/lib/sentry/net/http.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "net/http"
+require "resolv"
 
 module Sentry
   # @api private
@@ -30,15 +31,21 @@ module Sentry
         return super if from_sentry_sdk?
 
         Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f) do |sentry_span|
-          set_sentry_trace_header(req, sentry_span)
+          request_info = extract_request_info(req)
+
+          if propagate_trace?(request_info[:url], Sentry.configuration)
+            set_propagation_headers(req)
+          end
 
           super.tap do |res|
-            record_sentry_breadcrumb(req, res)
+            record_sentry_breadcrumb(request_info, res)
 
             if sentry_span
-              request_info = extract_request_info(req)
               sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
-              sentry_span.set_data(:status, res.code.to_i)
+              sentry_span.set_data(Span::DataConventions::URL, request_info[:url])
+              sentry_span.set_data(Span::DataConventions::HTTP_METHOD, request_info[:method])
+              sentry_span.set_data(Span::DataConventions::HTTP_QUERY, request_info[:query]) if request_info[:query]
+              sentry_span.set_data(Span::DataConventions::HTTP_STATUS_CODE, res.code.to_i)
             end
           end
         end
@@ -46,23 +53,13 @@ module Sentry
 
       private
 
-      def set_sentry_trace_header(req, sentry_span)
-        return unless sentry_span
-
-        client = Sentry.get_current_client
-
-        trace = client.generate_sentry_trace(sentry_span)
-        req[SENTRY_TRACE_HEADER_NAME] = trace if trace
-
-        baggage = client.generate_baggage(sentry_span)
-        req[BAGGAGE_HEADER_NAME] = baggage if baggage && !baggage.empty?
+      def set_propagation_headers(req)
+        Sentry.get_trace_propagation_headers&.each { |k, v| req[k] = v }
       end
 
-      def record_sentry_breadcrumb(req, res)
+      def record_sentry_breadcrumb(request_info, res)
         return unless Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
 
-        request_info = extract_request_info(req)
-
         crumb = Sentry::Breadcrumb.new(
           level: :info,
           category: BREADCRUMB_CATEGORY,
@@ -81,20 +78,29 @@ module Sentry
       end
 
       def extract_request_info(req)
-        uri = req.uri || URI.parse("#{use_ssl? ? 'https' : 'http'}://#{address}#{req.path}")
+        # IPv6 url could look like '::1/path', and that won't parse without
+        # wrapping it in square brackets.
+        hostname = address =~ Resolv::IPv6::Regex ? "[#{address}]" : address
+        uri = req.uri || URI.parse("#{use_ssl? ? 'https' : 'http'}://#{hostname}#{req.path}")
         url = "#{uri.scheme}://#{uri.host}#{uri.path}" rescue uri.to_s
 
         result = { method: req.method, url: url }
 
         if Sentry.configuration.send_default_pii
-          result[:url] = result[:url] + "?#{uri.query}"
+          result[:query] = uri.query
           result[:body] = req.body
         end
 
         result
       end
+
+      def propagate_trace?(url, configuration)
+        url &&
+          configuration.propagate_traces &&
+          configuration.trace_propagation_targets.any? { |target| url.match?(target) }
+      end
     end
   end
 end
 
-Sentry.register_patch(Sentry::Net::HTTP, Net::HTTP)
+Sentry.register_patch(:http, Sentry::Net::HTTP, Net::HTTP)

data/lib/sentry/profiler.rb

@@ -9,6 +9,7 @@ module Sentry
     # 101 Hz in microseconds
     DEFAULT_INTERVAL = 1e6 / 101
     MICRO_TO_NANO_SECONDS = 1e3
+    MIN_SAMPLES_REQUIRED = 2
 
     attr_reader :sampled, :started, :event_id
 
@@ -73,14 +74,19 @@ module Sentry
     end
 
     def to_hash
-      return {} unless @sampled
+      unless @sampled
+        record_lost_event(:sample_rate)
+        return {}
+      end
+
       return {} unless @started
 
       results = StackProf.results
-      return {} unless results
-      return {} if results.empty?
-      return {} if results[:samples] == 0
-      return {} unless results[:raw]
+
+      if !results || results.empty? || results[:samples] == 0 || !results[:raw]
+        record_lost_event(:insufficient_data)
+        return {}
+      end
 
       frame_map = {}
 
@@ -103,7 +109,7 @@ module Sentry
         }
 
         frame_hash[:module] = mod if mod
-        frame_hash[:lineno] = frame_data[:line] if frame_data[:line]
+        frame_hash[:lineno] = frame_data[:line] if frame_data[:line] && frame_data[:line] >= 0
 
         frame_hash
       end
@@ -157,8 +163,9 @@ module Sentry
 
       log('Some samples thrown away') if samples.size != results[:samples]
 
-      if samples.size <= 2
+      if samples.size <= MIN_SAMPLES_REQUIRED
         log('Not enough samples, discarding profiler')
+        record_lost_event(:insufficient_data)
         return {}
       end
 
@@ -218,5 +225,9 @@ module Sentry
 
       [function, mod]
     end
+
+    def record_lost_event(reason)
+      Sentry.get_current_client&.transport&.record_lost_event(reason, 'profile')
+    end
   end
 end

data/lib/sentry/propagation_context.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "sentry/baggage"
+
+module Sentry
+  class PropagationContext
+    SENTRY_TRACE_REGEXP = Regexp.new(
+      "^[ \t]*" +  # whitespace
+      "([0-9a-f]{32})?" +  # trace_id
+      "-?([0-9a-f]{16})?" +  # span_id
+      "-?([01])?" +  # sampled
+      "[ \t]*$"  # whitespace
+    )
+
+    # An uuid that can be used to identify a trace.
+    # @return [String]
+    attr_reader :trace_id
+    # An uuid that can be used to identify the span.
+    # @return [String]
+    attr_reader :span_id
+    # Span parent's span_id.
+    # @return [String, nil]
+    attr_reader :parent_span_id
+    # The sampling decision of the parent transaction.
+    # @return [Boolean, nil]
+    attr_reader :parent_sampled
+    # Is there an incoming trace or not?
+    # @return [Boolean]
+    attr_reader :incoming_trace
+    # This is only for accessing the current baggage variable.
+    # Please use the #get_baggage method for interfacing outside this class.
+    # @return [Baggage, nil]
+    attr_reader :baggage
+
+    def initialize(scope, env = nil)
+      @scope = scope
+      @parent_span_id = nil
+      @parent_sampled = nil
+      @baggage = nil
+      @incoming_trace = false
+
+      if env
+        sentry_trace_header = env["HTTP_SENTRY_TRACE"] || env[SENTRY_TRACE_HEADER_NAME]
+        baggage_header = env["HTTP_BAGGAGE"] || env[BAGGAGE_HEADER_NAME]
+
+        if sentry_trace_header
+          sentry_trace_data = self.class.extract_sentry_trace(sentry_trace_header)
+
+          if sentry_trace_data
+            @trace_id, @parent_span_id, @parent_sampled = sentry_trace_data
+
+            @baggage = if baggage_header && !baggage_header.empty?
+                        Baggage.from_incoming_header(baggage_header)
+                      else
+                        # If there's an incoming sentry-trace but no incoming baggage header,
+                        # for instance in traces coming from older SDKs,
+                        # baggage will be empty and frozen and won't be populated as head SDK.
+                        Baggage.new({})
+                      end
+
+            @baggage.freeze!
+            @incoming_trace = true
+          end
+        end
+      end
+
+      @trace_id ||= SecureRandom.uuid.delete("-")
+      @span_id = SecureRandom.uuid.delete("-").slice(0, 16)
+    end
+
+    # Extract the trace_id, parent_span_id and parent_sampled values from a sentry-trace header.
+    #
+    # @param sentry_trace [String] the sentry-trace header value from the previous transaction.
+    # @return [Array, nil]
+    def self.extract_sentry_trace(sentry_trace)
+      match = SENTRY_TRACE_REGEXP.match(sentry_trace)
+      return nil if match.nil?
+
+      trace_id, parent_span_id, sampled_flag = match[1..3]
+      parent_sampled = sampled_flag.nil? ? nil : sampled_flag != "0"
+
+      [trace_id, parent_span_id, parent_sampled]
+    end
+
+    # Returns the trace context that can be used to embed in an Event.
+    # @return [Hash]
+    def get_trace_context
+      {
+        trace_id: trace_id,
+        span_id: span_id,
+        parent_span_id: parent_span_id
+      }
+    end
+
+    # Returns the sentry-trace header from the propagation context.
+    # @return [String]
+    def get_traceparent
+      "#{trace_id}-#{span_id}"
+    end
+
+    # Returns the Baggage from the propagation context or populates as head SDK if empty.
+    # @return [Baggage, nil]
+    def get_baggage
+      populate_head_baggage if @baggage.nil? || @baggage.mutable
+      @baggage
+    end
+
+    # Returns the Dynamic Sampling Context from the baggage.
+    # @return [String, nil]
+    def get_dynamic_sampling_context
+      get_baggage&.dynamic_sampling_context
+    end
+
+    private
+
+    def populate_head_baggage
+      return unless Sentry.initialized?
+
+      configuration = Sentry.configuration
+
+      items = {
+        "trace_id" => trace_id,
+        "environment" => configuration.environment,
+        "release" => configuration.release,
+        "public_key" => configuration.dsn&.public_key,
+        "user_segment" => @scope.user && @scope.user["segment"]
+      }
+
+      items.compact!
+      @baggage = Baggage.new(items, mutable: false)
+    end
+  end
+end