sentry-ruby 5.8.0 → 5.12.0

data/lib/sentry/hub.rb

@@ -88,8 +88,10 @@ module Sentry
       }
 
       sampling_context.merge!(custom_sampling_context)
-
       transaction.set_initial_sample_decision(sampling_context: sampling_context)
+
+      transaction.start_profiler!
+
       transaction
     end
 
@@ -114,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)
 
@@ -122,6 +128,7 @@ module Sentry
 
       options[:hint] ||= {}
       options[:hint][:exception] = exception
+
       event = current_client.event_from_exception(exception, options[:hint])
 
       return unless event
@@ -149,6 +156,30 @@ module Sentry
       capture_event(event, **options, &block)
     end
 
+    def capture_check_in(slug, status, **options, &block)
+      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, &block)
+      event.check_in_id
+    end
+
     def capture_event(event, **options, &block)
       check_argument_type!(event, Sentry::Event)
 
@@ -171,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
 
@@ -222,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
@@ -22,7 +23,7 @@ module Sentry
           exception.message || ""
         end
 
-      @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 +51,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

@@ -30,15 +30,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 +52,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,
@@ -87,17 +83,20 @@ module Sentry
         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 do
-  patch = Sentry::Net::HTTP
-  Net::HTTP.send(:prepend, patch) unless Net::HTTP.ancestors.include?(patch)
-end
+Sentry.register_patch(Sentry::Net::HTTP, Net::HTTP)

data/lib/sentry/profiler.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Sentry
+  class Profiler
+    VERSION = '1'
+    PLATFORM = 'ruby'
+    # 101 Hz in microseconds
+    DEFAULT_INTERVAL = 1e6 / 101
+    MICRO_TO_NANO_SECONDS = 1e3
+    MIN_SAMPLES_REQUIRED = 2
+
+    attr_reader :sampled, :started, :event_id
+
+    def initialize(configuration)
+      @event_id = SecureRandom.uuid.delete('-')
+      @started = false
+      @sampled = nil
+
+      @profiling_enabled = defined?(StackProf) && configuration.profiling_enabled?
+      @profiles_sample_rate = configuration.profiles_sample_rate
+      @project_root = configuration.project_root
+      @app_dirs_pattern = configuration.app_dirs_pattern || Backtrace::APP_DIRS_PATTERN
+      @in_app_pattern = Regexp.new("^(#{@project_root}/)?#{@app_dirs_pattern}")
+    end
+
+    def start
+      return unless @sampled
+
+      @started = StackProf.start(interval: DEFAULT_INTERVAL,
+                                 mode: :wall,
+                                 raw: true,
+                                 aggregate: false)
+
+      @started ? log('Started') : log('Not started since running elsewhere')
+    end
+
+    def stop
+      return unless @sampled
+      return unless @started
+
+      StackProf.stop
+      log('Stopped')
+    end
+
+    # Sets initial sampling decision of the profile.
+    # @return [void]
+    def set_initial_sample_decision(transaction_sampled)
+      unless @profiling_enabled
+        @sampled = false
+        return
+      end
+
+      unless transaction_sampled
+        @sampled = false
+        log('Discarding profile because transaction not sampled')
+        return
+      end
+
+      case @profiles_sample_rate
+      when 0.0
+        @sampled = false
+        log('Discarding profile because sample_rate is 0')
+        return
+      when 1.0
+        @sampled = true
+        return
+      else
+        @sampled = Random.rand < @profiles_sample_rate
+      end
+
+      log('Discarding profile due to sampling decision') unless @sampled
+    end
+
+    def to_hash
+      unless @sampled
+        record_lost_event(:sample_rate)
+        return {}
+      end
+
+      return {} unless @started
+
+      results = StackProf.results
+
+      if !results || results.empty? || results[:samples] == 0 || !results[:raw]
+        record_lost_event(:insufficient_data)
+        return {}
+      end
+
+      frame_map = {}
+
+      frames = results[:frames].to_enum.with_index.map do |frame, idx|
+        frame_id, frame_data = frame
+
+        # need to map over stackprof frame ids to ours
+        frame_map[frame_id] = idx
+
+        file_path = frame_data[:file]
+        in_app = in_app?(file_path)
+        filename = compute_filename(file_path, in_app)
+        function, mod = split_module(frame_data[:name])
+
+        frame_hash = {
+          abs_path: file_path,
+          function: function,
+          filename: filename,
+          in_app: in_app
+        }
+
+        frame_hash[:module] = mod if mod
+        frame_hash[:lineno] = frame_data[:line] if frame_data[:line]
+
+        frame_hash
+      end
+
+      idx = 0
+      stacks = []
+      num_seen = []
+
+      # extract stacks from raw
+      # raw is a single array of [.., len_stack, *stack_frames(len_stack), num_stack_seen , ..]
+      while (len = results[:raw][idx])
+        idx += 1
+
+        # our call graph is reversed
+        stack = results[:raw].slice(idx, len).map { |id| frame_map[id] }.compact.reverse
+        stacks << stack
+
+        num_seen << results[:raw][idx + len]
+        idx += len + 1
+
+        log('Unknown frame in stack') if stack.size != len
+      end
+
+      idx = 0
+      elapsed_since_start_ns = 0
+      samples = []
+
+      num_seen.each_with_index do |n, i|
+        n.times do
+          # stackprof deltas are in microseconds
+          delta = results[:raw_timestamp_deltas][idx]
+          elapsed_since_start_ns += (delta * MICRO_TO_NANO_SECONDS).to_i
+          idx += 1
+
+          # Not sure why but some deltas are very small like 0/1 values,
+          # they pollute our flamegraph so just ignore them for now.
+          # Open issue at https://github.com/tmm1/stackprof/issues/201
+          next if delta < 10
+
+          samples << {
+            stack_id: i,
+            # TODO-neel-profiler we need to patch rb_profile_frames and write our own C extension to enable threading info.
+            # Till then, on multi-threaded servers like puma, we will get frames from other active threads when the one
+            # we're profiling is idle/sleeping/waiting for IO etc.
+            # https://bugs.ruby-lang.org/issues/10602
+            thread_id: '0',
+            elapsed_since_start_ns: elapsed_since_start_ns.to_s
+          }
+        end
+      end
+
+      log('Some samples thrown away') if samples.size != results[:samples]
+
+      if samples.size <= MIN_SAMPLES_REQUIRED
+        log('Not enough samples, discarding profiler')
+        record_lost_event(:insufficient_data)
+        return {}
+      end
+
+      profile = {
+        frames: frames,
+        stacks: stacks,
+        samples: samples
+      }
+
+      {
+        event_id: @event_id,
+        platform: PLATFORM,
+        version: VERSION,
+        profile: profile
+      }
+    end
+
+    private
+
+    def log(message)
+      Sentry.logger.debug(LOGGER_PROGNAME) { "[Profiler] #{message}" }
+    end
+
+    def in_app?(abs_path)
+      abs_path.match?(@in_app_pattern)
+    end
+
+    # copied from stacktrace.rb since I don't want to touch existing code
+    # TODO-neel-profiler try to fetch this from stackprof once we patch
+    # the native extension
+    def compute_filename(abs_path, in_app)
+      return nil if abs_path.nil?
+
+      under_project_root = @project_root && abs_path.start_with?(@project_root)
+
+      prefix =
+        if under_project_root && in_app
+          @project_root
+        else
+          longest_load_path = $LOAD_PATH.select { |path| abs_path.start_with?(path.to_s) }.max_by(&:size)
+
+          if under_project_root
+            longest_load_path || @project_root
+          else
+            longest_load_path
+          end
+        end
+
+      prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
+    end
+
+    def split_module(name)
+      # last module plus class/instance method
+      i = name.rindex('::')
+      function = i ? name[(i + 2)..-1] : name
+      mod = i ? name[0...i] : nil
+
+      [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

data/lib/sentry/puma.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Puma
+    module Server
+      def lowlevel_error(e, env, status=500)
+        result = super
+
+        begin
+          Sentry.capture_exception(e) do |scope|
+            scope.set_rack_env(env)
+          end
+        rescue
+          # if anything happens, we don't want to break the app
+        end
+
+        result
+      end
+    end
+  end
+end
+
+if defined?(Puma::Server)
+  Sentry.register_patch(Sentry::Puma::Server, Puma::Server)
+end

data/lib/sentry/rack/capture_exceptions.rb

@@ -62,11 +62,8 @@ module Sentry
       end
 
       def start_transaction(env, scope)
-        sentry_trace = env["HTTP_SENTRY_TRACE"]
-        baggage = env["HTTP_BAGGAGE"]
-
         options = { name: scope.transaction_name, source: scope.transaction_source, op: transaction_op }
-        transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, baggage: baggage, **options) if sentry_trace
+        transaction = Sentry.continue_trace(env, **options)
         Sentry.start_transaction(transaction: transaction, custom_sampling_context: { env: env }, **options)
       end
 

data/lib/sentry/redis.rb

@@ -19,7 +19,10 @@ module Sentry
 
           if span
             span.set_description(commands_description)
-            span.set_data(:server, server_description)
+            span.set_data(Span::DataConventions::DB_SYSTEM, "redis")
+            span.set_data(Span::DataConventions::DB_NAME, db)
+            span.set_data(Span::DataConventions::SERVER_ADDRESS, host)
+            span.set_data(Span::DataConventions::SERVER_PORT, port)
           end
         end
       end
@@ -30,6 +33,7 @@ module Sentry
     attr_reader :commands, :host, :port, :db
 
     def record_breadcrumb
+      return unless Sentry.initialized?
       return unless Sentry.configuration.breadcrumbs_logger.include?(LOGGER_NAME)
 
       Sentry.add_breadcrumb(
@@ -95,12 +99,7 @@ end
 
 if defined?(::Redis::Client)
   if Gem::Version.new(::Redis::VERSION) < Gem::Version.new("5.0")
-    Sentry.register_patch do
-      patch = Sentry::Redis::OldClientPatch
-      unless Redis::Client.ancestors.include?(patch)
-        Redis::Client.prepend(patch)
-      end
-    end
+    Sentry.register_patch(Sentry::Redis::OldClientPatch, ::Redis::Client)
   elsif defined?(RedisClient)
     RedisClient.register(Sentry::Redis::GlobalRedisInstrumentation)
   end