sentry-ruby 5.4.2 → 5.10.0

data/lib/sentry/interfaces/single_exception.rb

@@ -15,7 +15,15 @@ module Sentry
 
     def initialize(exception:, stacktrace: nil)
       @type = exception.class.to_s
-      @value = (exception.message || "").byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES)
+      exception_message =
+        if exception.respond_to?(:detailed_message)
+          exception.detailed_message(highlight: false)
+        else
+          exception.message || ""
+        end
+
+      @value = 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

data/lib/sentry/net/http.rb

@@ -26,14 +26,24 @@ module Sentry
       #
       # So we're only instrumenting request when `Net::HTTP` is already started
       def request(req, body = nil, &block)
-        return super unless started?
-
-        sentry_span = start_sentry_span
-        set_sentry_trace_header(req, sentry_span)
-
-        super.tap do |res|
-          record_sentry_breadcrumb(req, res)
-          record_sentry_span(req, res, sentry_span)
+        return super unless started? && Sentry.initialized?
+        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)
+
+          super.tap do |res|
+            record_sentry_breadcrumb(req, res)
+
+            if sentry_span
+              request_info = extract_request_info(req)
+              sentry_span.set_description("#{request_info[:method]} #{request_info[:url]}")
+              sentry_span.set_data('url', request_info[:url])
+              sentry_span.set_data('http.method', request_info[:method])
+              sentry_span.set_data('http.query', request_info[:query]) if request_info[:query]
+              sentry_span.set_data('status', res.code.to_i)
+            end
+          end
         end
       end
 
@@ -42,13 +52,17 @@ module Sentry
       def set_sentry_trace_header(req, sentry_span)
         return unless sentry_span
 
-        trace = Sentry.get_current_client.generate_sentry_trace(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?
       end
 
       def record_sentry_breadcrumb(req, res)
         return unless Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
-        return if from_sentry_sdk?
 
         request_info = extract_request_info(req)
 
@@ -64,29 +78,6 @@ module Sentry
         Sentry.add_breadcrumb(crumb)
       end
 
-      def record_sentry_span(req, res, sentry_span)
-        return unless Sentry.initialized? && 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)
-        finish_sentry_span(sentry_span)
-      end
-
-      def start_sentry_span
-        return unless Sentry.initialized? && span = Sentry.get_current_scope.get_span
-        return if from_sentry_sdk?
-        return if span.sampled == false
-
-        span.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
-      end
-
-      def finish_sentry_span(sentry_span)
-        return unless Sentry.initialized? && sentry_span
-
-        sentry_span.set_timestamp(Sentry.utc_now.to_f)
-      end
-
       def from_sentry_sdk?
         dsn = Sentry.configuration.dsn
         dsn && dsn.host == self.address
@@ -99,7 +90,7 @@ 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
 
@@ -109,7 +100,4 @@ module Sentry
   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,222 @@
+# 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
+
+    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
+      return {} unless @sampled
+      return {} unless @started
+
+      results = StackProf.results
+      return {} unless results
+      return {} if results.empty?
+      return {} if results[:samples] == 0
+      return {} unless results[:raw]
+
+      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 <= 2
+        log('Not enough samples, discarding profiler')
+        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
+  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

@@ -18,7 +18,7 @@ module Sentry
         Sentry.with_scope do |scope|
           Sentry.with_session_tracking do
             scope.clear_breadcrumbs
-            scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
+            scope.set_transaction_name(env["PATH_INFO"], source: :url) if env["PATH_INFO"]
             scope.set_rack_env(env)
 
             transaction = start_transaction(env, scope)
@@ -52,7 +52,7 @@ module Sentry
       end
 
       def transaction_op
-        "rack.request".freeze
+        "http.server".freeze
       end
 
       def capture_exception(exception, env)
@@ -63,8 +63,10 @@ module Sentry
 
       def start_transaction(env, scope)
         sentry_trace = env["HTTP_SENTRY_TRACE"]
-        options = { name: scope.transaction_name, op: transaction_op }
-        transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, **options) if 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
         Sentry.start_transaction(transaction: transaction, custom_sampling_context: { env: env }, **options)
       end
 

data/lib/sentry/rake.rb

@@ -10,7 +10,7 @@ module Sentry
       def display_error_message(ex)
         Sentry.capture_exception(ex) do |scope|
           task_name = top_level_tasks.join(' ')
-          scope.set_transaction_name(task_name)
+          scope.set_transaction_name(task_name, source: :task)
           scope.set_tag("rake_task", task_name)
         end if Sentry.initialized? && !Sentry.configuration.skip_rake_integration
 

data/lib/sentry/redis.rb

@@ -3,7 +3,7 @@
 module Sentry
   # @api private
   class Redis
-    OP_NAME = "db.redis.command"
+    OP_NAME = "db.redis"
     LOGGER_NAME = :redis_logger
 
     def initialize(commands, host, port, db)
@@ -13,9 +13,14 @@ module Sentry
     def instrument
       return yield unless Sentry.initialized?
 
-      record_span do
+      Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f) do |span|
         yield.tap do
           record_breadcrumb
+
+          if span
+            span.set_description(commands_description)
+            span.set_data(:server, server_description)
+          end
         end
       end
     end
@@ -24,19 +29,8 @@ module Sentry
 
     attr_reader :commands, :host, :port, :db
 
-    def record_span
-      return yield unless (transaction = Sentry.get_current_scope.get_transaction) && transaction.sampled
-
-      sentry_span = transaction.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
-
-      yield.tap do
-        sentry_span.set_description(commands_description)
-        sentry_span.set_data(:server, server_description)
-        sentry_span.set_timestamp(Sentry.utc_now.to_f)
-      end
-    end
-
     def record_breadcrumb
+      return unless Sentry.initialized?
       return unless Sentry.configuration.breadcrumbs_logger.include?(LOGGER_NAME)
 
       Sentry.add_breadcrumb(
@@ -61,10 +55,16 @@ module Sentry
     def parsed_commands
       commands.map do |statement|
         command, key, *arguments = statement
+        command_set = { command: command.to_s.upcase }
+        command_set[:key] = key if Utils::EncodingHelper.valid_utf_8?(key)
 
-        { command: command.to_s.upcase, key: key }.tap do |command_set|
-          command_set[:arguments] = arguments.join(" ") if Sentry.configuration.send_default_pii
+        if Sentry.configuration.send_default_pii
+          command_set[:arguments] = arguments
+                                    .select { |a| Utils::EncodingHelper.valid_utf_8?(a) }
+                                    .join(" ")
         end
+
+        command_set
       end
     end
 
@@ -72,19 +72,32 @@ module Sentry
       "#{host}:#{port}/#{db}"
     end
 
-    module Client
+    module OldClientPatch
       def logging(commands, &block)
-        Sentry::Redis.new(commands, host, port, db).instrument do
-          super
-        end
+        Sentry::Redis.new(commands, host, port, db).instrument { super }
+      end
+    end
+
+    module GlobalRedisInstrumentation
+      def call(command, redis_config)
+        Sentry::Redis
+          .new([command], redis_config.host, redis_config.port, redis_config.db)
+          .instrument { super }
+      end
+
+      def call_pipelined(commands, redis_config)
+        Sentry::Redis
+          .new(commands, redis_config.host, redis_config.port, redis_config.db)
+          .instrument { super }
       end
     end
   end
 end
 
 if defined?(::Redis::Client)
-  Sentry.register_patch do
-    patch = Sentry::Redis::Client
-    Redis::Client.prepend(patch) unless Redis::Client.ancestors.include?(patch)
+  if Gem::Version.new(::Redis::VERSION) < Gem::Version.new("5.0")
+    Sentry.register_patch(Sentry::Redis::OldClientPatch, ::Redis::Client)
+  elsif defined?(RedisClient)
+    RedisClient.register(Sentry::Redis::GlobalRedisInstrumentation)
   end
 end

data/lib/sentry/scope.rb

@@ -7,7 +7,21 @@ module Sentry
   class Scope
     include ArgumentCheckingHelper
 
-    ATTRIBUTES = [:transaction_names, :contexts, :extra, :tags, :user, :level, :breadcrumbs, :fingerprint, :event_processors, :rack_env, :span, :session]
+    ATTRIBUTES = [
+      :transaction_names,
+      :transaction_sources,
+      :contexts,
+      :extra,
+      :tags,
+      :user,
+      :level,
+      :breadcrumbs,
+      :fingerprint,
+      :event_processors,
+      :rack_env,
+      :span,
+      :session
+    ]
 
     attr_reader(*ATTRIBUTES)
 
@@ -33,6 +47,7 @@ module Sentry
       event.extra = extra.merge(event.extra)
       event.contexts = contexts.merge(event.contexts)
       event.transaction = transaction_name if transaction_name
+      event.transaction_info = { source: transaction_source } if transaction_source
 
       if span
         event.contexts[:trace] = span.get_trace_context
@@ -43,8 +58,10 @@ module Sentry
       event.breadcrumbs = breadcrumbs
       event.rack_env = rack_env if rack_env
 
-      unless @event_processors.empty?
-        @event_processors.each do |processor_block|
+      all_event_processors = self.class.global_event_processors + @event_processors
+
+      unless all_event_processors.empty?
+        all_event_processors.each do |processor_block|
           event = processor_block.call(event, hint)
         end
       end
@@ -73,7 +90,8 @@ module Sentry
       copy.extra = extra.deep_dup
       copy.tags = tags.deep_dup
       copy.user = user.deep_dup
-      copy.transaction_names = transaction_names.deep_dup
+      copy.transaction_names = transaction_names.dup
+      copy.transaction_sources = transaction_sources.dup
       copy.fingerprint = fingerprint.deep_dup
       copy.span = span.deep_dup
       copy.session = session.deep_dup
@@ -90,6 +108,7 @@ module Sentry
       self.tags = scope.tags
       self.user = scope.user
       self.transaction_names = scope.transaction_names
+      self.transaction_sources = scope.transaction_sources
       self.fingerprint = scope.fingerprint
       self.span = scope.span
     end
@@ -173,6 +192,10 @@ module Sentry
     # @return [Hash]
     def set_contexts(contexts_hash)
       check_argument_type!(contexts_hash, Hash)
+      contexts_hash.values.each do |val|
+        check_argument_type!(val, Hash)
+      end
+
       @contexts.merge!(contexts_hash) do |key, old, new|
         old.merge(new)
       end
@@ -195,8 +218,9 @@ module Sentry
     # The "transaction" here does not refer to `Transaction` objects.
     # @param transaction_name [String]
     # @return [void]
-    def set_transaction_name(transaction_name)
+    def set_transaction_name(transaction_name, source: :custom)
       @transaction_names << transaction_name
+      @transaction_sources << source
     end
 
     # Sets the currently active session on the scope.
@@ -213,6 +237,13 @@ module Sentry
       @transaction_names.last
     end
 
+    # Returns current transaction source.
+    # The "transaction" here does not refer to `Transaction` objects.
+    # @return [String, nil]
+    def transaction_source
+      @transaction_sources.last
+    end
+
     # Returns the associated Transaction object.
     # @return [Transaction, nil]
     def get_transaction
@@ -256,6 +287,7 @@ module Sentry
       @level = :error
       @fingerprint = []
       @transaction_names = []
+      @transaction_sources = []
       @event_processors = []
       @rack_env = {}
       @span = nil
@@ -277,7 +309,8 @@ module Sentry
               name: uname[:sysname] || RbConfig::CONFIG["host_os"],
               version: uname[:version],
               build: uname[:release],
-              kernel_version: uname[:version]
+              kernel_version: uname[:version],
+              machine: uname[:machine]
             }
           end
       end
@@ -289,6 +322,22 @@ module Sentry
           version: RUBY_DESCRIPTION || Sentry.sys_command("ruby -v")
         }
       end
+
+      # Returns the global event processors array.
+      # @return [Array<Proc>]
+      def global_event_processors
+        @global_event_processors ||= []
+      end
+
+      # Adds a new global event processor [Proc].
+      # Sometimes we need a global event processor without needing to configure scope.
+      # These run before scope event processors.
+      #
+      # @param block [Proc]
+      # @return [void]
+      def add_global_event_processor(&block)
+        global_event_processors << block
+      end
     end
 
   end

data/lib/sentry/session.rb

@@ -2,7 +2,7 @@
 
 module Sentry
   class Session
-    attr_reader :started, :status
+    attr_reader :started, :status, :aggregation_key
 
     # TODO-neel add :crashed after adding handled mechanism
     STATUSES = %i(ok errored exited)
@@ -11,6 +11,10 @@ module Sentry
     def initialize
       @started = Sentry.utc_now
       @status = :ok
+
+      # truncate seconds from the timestamp since we only care about
+      # minute level granularity for aggregation
+      @aggregation_key = Time.utc(@started.year, @started.month, @started.day, @started.hour, @started.min)
     end
 
     # TODO-neel add :crashed after adding handled mechanism
@@ -22,12 +26,6 @@ module Sentry
       @status = :exited if @status == :ok
     end
 
-    # truncate seconds from the timestamp since we only care about
-    # minute level granularity for aggregation
-    def aggregation_key
-      Time.utc(started.year, started.month, started.day, started.hour, started.min)
-    end
-
     def deep_dup
       dup
     end