sentry-ruby 5.7.0 → 5.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a60b754ccac4d1fd8cf47cd94d8896c46dc8232f87d06132681a19ed223ac14c
-  data.tar.gz: 923f906cd698d18f2fcb419bfeb2d1262c4165e6a8ffe2484de7027a90e69644
+  metadata.gz: 7a114a391fe058601b40369376152bee8ba9b1b96ab94710344283cfe1a4490b
+  data.tar.gz: 7a17648c7a5d06f22d2d643f6ff1cb25d3fed2348609e372fc5762043ebd538a
 SHA512:
-  metadata.gz: 7d46f719bd4e0abb6f9fcd254b6e6321c9796c2278bc31fa5f86dc541cc0ce54a4f6cc10078d6d0277c89ff0cd4896e2a0ec0aa04e3052214b01b85cb2aa115c
-  data.tar.gz: 14b28401b32d9ce9ee7ac0351de736d0d9f11221010e61091e4976b71a58b1fef61ca4e282ec31a714e040148197c5fab46f0a0e39e475ea1f6dd0196b5f104d
+  metadata.gz: dab19469a8e68201380e2be405332bb7c8caef7bf46fd4dae70f4dc3beaac2902ce51b2b2c902b39ca048e1bc5ff47f85b1e7d3a824b5f20ff002dcbdca2c354
+  data.tar.gz: 6bf0cba7b42dd9bfd5078e4353ad7f92d932b959a87c748cb30e505ffd8d205899c819ea4f72e5f3099f0b861139864062b870219678abdeda0a0629604963d3

data/.rspec

@@ -1,3 +1,2 @@
 --format documentation
 --color
---require spec_helper

data/Gemfile

@@ -7,14 +7,19 @@ rack_version = ENV["RACK_VERSION"]
 rack_version = "3.0.0" if rack_version.nil?
 gem "rack", "~> #{Gem::Version.new(rack_version)}" unless rack_version == "0"
 
+redis_rb_version = ENV.fetch("REDIS_RB_VERSION", "5.0")
+gem "redis", "~> #{redis_rb_version}"
+
+gem "puma"
+
 gem "rake", "~> 12.0"
 gem "rspec", "~> 3.0"
 gem "rspec-retry"
-gem "fakeredis"
 gem "timecop"
-gem 'simplecov'
+gem "simplecov"
 gem "simplecov-cobertura", "~> 1.4"
 gem "rexml"
+gem "stackprof" unless RUBY_PLATFORM == "java"
 
 gem "object_tracer"
 gem "debug", github: "ruby/debug", platform: :ruby if RUBY_VERSION.to_f >= 2.6
@@ -25,4 +30,5 @@ gem "benchmark_driver"
 gem "benchmark-ipsa"
 gem "benchmark-memory"
 
-gem "yard", "~> 0.9.27"
+gem "yard", github: "lsegal/yard"
+gem "webrick"

data/Rakefile

@@ -8,6 +8,13 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec).tap do |task|
   task.rspec_opts = "--order rand"
+  task.exclude_pattern = "spec/isolated/**/*_spec.rb"
 end
 
-task :default => :spec
+task :isolated_specs do
+  Dir["spec/isolated/*"].each do |file|
+    sh "bundle exec rspec #{file}"
+  end
+end
+
+task :default => [:spec, :isolated_specs]

data/lib/sentry/backtrace.rb

@@ -76,7 +76,7 @@ module Sentry
       end
     end
 
-    APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test)/.freeze
+    APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test|spec)/.freeze
 
     # holder for an Array of Backtrace::Line instances
     attr_reader :lines

data/lib/sentry/baggage.rb

@@ -8,17 +8,6 @@ module Sentry
     SENTRY_PREFIX = 'sentry-'
     SENTRY_PREFIX_REGEX = /^sentry-/.freeze
 
-    DSC_KEYS = %w(
-      trace_id
-      public_key
-      sample_rate
-      release
-      environment
-      transaction
-      user_id
-      user_segment
-    ).freeze
-
     # @return [Hash]
     attr_reader :items
 
@@ -68,7 +57,7 @@ module Sentry
     # hash to be used in the trace envelope header.
     # @return [Hash]
     def dynamic_sampling_context
-      @items.select { |k, _v| DSC_KEYS.include?(k) }
+      @items
     end
 
     # Serialize the Baggage object back to a string.

data/lib/sentry/client.rb

@@ -76,7 +76,10 @@ module Sentry
     # @param hint [Hash] the hint data that'll be passed to `before_send` callback and the scope's event processors.
     # @return [Event, nil]
     def event_from_exception(exception, hint = {})
-      return unless @configuration.sending_allowed? && @configuration.exception_class_allowed?(exception)
+      return unless @configuration.sending_allowed?
+
+      ignore_exclusions = hint.delete(:ignore_exclusions) { false }
+      return if !ignore_exclusions && !@configuration.exception_class_allowed?(exception)
 
       integration_meta = Sentry.integrations[hint[:integration]]
 
@@ -122,6 +125,16 @@ module Sentry
         end
       end
 
+      if event_type == TransactionEvent::TYPE && configuration.before_send_transaction
+        event = configuration.before_send_transaction.call(event, hint)
+
+        if event.nil?
+          log_info("Discarded event because before_send_transaction returned nil")
+          transport.record_lost_event(:before_send, 'transaction')
+          return
+        end
+      end
+
       transport.send_event(event)
 
       event

data/lib/sentry/configuration.rb

@@ -72,6 +72,19 @@ module Sentry
     # @return [Proc]
     attr_reader :before_send
 
+    # Optional Proc, called before sending an event to the server
+    # @example
+    #   config.before_send_transaction = lambda do |event, hint|
+    #     # skip unimportant transactions or strip sensitive data
+    #     if event.transaction == "/healthcheck/route"
+    #       nil
+    #     else
+    #       event
+    #     end
+    #   end
+    # @return [Proc]
+    attr_reader :before_send_transaction
+
     # An array of breadcrumbs loggers to be used. Available options are:
     # - :sentry_logger
     # - :http_logger
@@ -84,10 +97,6 @@ module Sentry
     # @return [Array<Symbol>]
     attr_reader :breadcrumbs_logger
 
-    # Whether to capture local variables from the raised exception's frame. Default is false.
-    # @return [Boolean]
-    attr_accessor :capture_exception_frame_locals
-
     # Max number of breadcrumbs a breadcrumb buffer can hold
     # @return [Integer]
     attr_accessor :max_breadcrumbs
@@ -127,6 +136,22 @@ module Sentry
     attr_accessor :inspect_exception_causes_for_exclusion
     alias inspect_exception_causes_for_exclusion? inspect_exception_causes_for_exclusion
 
+    # Whether to capture local variables from the raised exception's frame. Default is false.
+    # @return [Boolean]
+    attr_accessor :include_local_variables
+
+    # @deprecated Use {#include_local_variables} instead.
+    alias_method :capture_exception_frame_locals, :include_local_variables
+
+    # @deprecated Use {#include_local_variables=} instead.
+    def capture_exception_frame_locals=(value)
+      log_warn <<~MSG
+        `capture_exception_frame_locals` is now deprecated in favor of `include_local_variables`.
+      MSG
+
+      self.include_local_variables = value
+    end
+
     # You may provide your own LineCache for matching paths with source files.
     # This may be useful if you need to get source code from places other than the disk.
     # @see LineCache
@@ -202,6 +227,11 @@ module Sentry
     # @return [Proc]
     attr_accessor :traces_sampler
 
+    # Easier way to use performance tracing
+    # If set to true, will set traces_sample_rate to 1.0
+    # @return [Boolean, nil]
+    attr_reader :enable_tracing
+
     # Send diagnostic client reports about dropped events, true by default
     # tries to attach to an existing envelope max once every 30s
     # @return [Boolean]
@@ -215,6 +245,12 @@ module Sentry
     # @return [Symbol]
     attr_reader :instrumenter
 
+    # Take a float between 0.0 and 1.0 as the sample rate for capturing profiles.
+    # Note that this rate is relative to traces_sample_rate / traces_sampler,
+    # i.e. the profile is sampled by this rate after the transaction is sampled.
+    # @return [Float, nil]
+    attr_reader :profiles_sample_rate
+
     # these are not config options
     # @!visibility private
     attr_reader :errors, :gem_specs
@@ -243,9 +279,18 @@ module Sentry
 
     INSTRUMENTERS = [:sentry, :otel]
 
-    # Post initialization callbacks are called at the end of initialization process
-    # allowing extending the configuration of sentry-ruby by multiple extensions
-    @@post_initialization_callbacks = []
+    class << self
+      # Post initialization callbacks are called at the end of initialization process
+      # allowing extending the configuration of sentry-ruby by multiple extensions
+      def post_initialization_callbacks
+        @post_initialization_callbacks ||= []
+      end
+
+    # allow extensions to add their hooks to the Configuration class
+      def add_post_initialization_callback(&block)
+        post_initialization_callbacks << block
+      end
+    end
 
     def initialize
       self.app_dirs_pattern = nil
@@ -255,7 +300,7 @@ module Sentry
       self.max_breadcrumbs = BreadcrumbBuffer::DEFAULT_SIZE
       self.breadcrumbs_logger = []
       self.context_lines = 3
-      self.capture_exception_frame_locals = false
+      self.include_local_variables = false
       self.environment = environment_from_env
       self.enabled_environments = []
       self.exclude_loggers = []
@@ -278,9 +323,11 @@ module Sentry
       self.instrumenter = :sentry
 
       self.before_send = nil
+      self.before_send_transaction = nil
       self.rack_env_whitelist = RACK_ENV_WHITELIST_DEFAULT
       self.traces_sample_rate = nil
       self.traces_sampler = nil
+      self.enable_tracing = nil
 
       @transport = Transport::Configuration.new
       @gem_specs = Hash[Gem::Specification.map { |spec| [spec.name, spec.version.to_s] }] if Gem::Specification.respond_to?(:map)
@@ -329,6 +376,12 @@ module Sentry
       @before_send = value
     end
 
+    def before_send_transaction=(value)
+      check_callable!("before_send_transaction", value)
+
+      @before_send_transaction = value
+    end
+
     def before_breadcrumb=(value)
       check_callable!("before_breadcrumb", value)
 
@@ -343,6 +396,16 @@ module Sentry
       @instrumenter = INSTRUMENTERS.include?(instrumenter) ? instrumenter : :sentry
     end
 
+    def enable_tracing=(enable_tracing)
+      @enable_tracing = enable_tracing
+      @traces_sample_rate ||= 1.0 if enable_tracing
+    end
+
+    def profiles_sample_rate=(profiles_sample_rate)
+      log_info("Please make sure to include the 'stackprof' gem in your Gemfile to use Profiling with Sentry.") unless defined?(StackProf)
+      @profiles_sample_rate = profiles_sample_rate
+    end
+
     def sending_allowed?
       @errors = []
 
@@ -373,7 +436,20 @@ module Sentry
     end
 
     def tracing_enabled?
-      !!((@traces_sample_rate && @traces_sample_rate >= 0.0 && @traces_sample_rate <= 1.0) || @traces_sampler) && sending_allowed?
+      valid_sampler = !!((@traces_sample_rate &&
+                          @traces_sample_rate >= 0.0 &&
+                          @traces_sample_rate <= 1.0) ||
+                         @traces_sampler)
+
+      (@enable_tracing != false) && valid_sampler && sending_allowed?
+    end
+
+    def profiling_enabled?
+      valid_sampler = !!(@profiles_sample_rate &&
+                         @profiles_sample_rate >= 0.0 &&
+                         @profiles_sample_rate <= 1.0)
+
+      tracing_enabled? && valid_sampler && sending_allowed?
     end
 
     # @return [String, nil]
@@ -498,16 +574,5 @@ module Sentry
         instance_eval(&hook)
       end
     end
-
-    # allow extensions to add their hooks to the Configuration class
-    def self.add_post_initialization_callback(&block)
-      self.post_initialization_callbacks << block
-    end
-
-    protected
-
-    def self.post_initialization_callbacks
-      @@post_initialization_callbacks
-    end
   end
 end

data/lib/sentry/envelope.rb

@@ -19,10 +19,7 @@ module Sentry
       end
 
       def to_s
-        <<~ITEM
-          #{JSON.generate(@headers)}
-          #{JSON.generate(@payload)}
-        ITEM
+        [JSON.generate(@headers), JSON.generate(@payload)].join("\n")
       end
 
       def serialize

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
 
@@ -122,6 +124,7 @@ module Sentry
 
       options[:hint] ||= {}
       options[:hint][:exception] = exception
+
       event = current_client.event_from_exception(exception, options[:hint])
 
       return unless event

data/lib/sentry/net/http.rb

@@ -97,7 +97,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/redis.rb

@@ -54,7 +54,8 @@ module Sentry
     def parsed_commands
       commands.map do |statement|
         command, key, *arguments = statement
-        command_set = { command: command.to_s.upcase, key: key }
+        command_set = { command: command.to_s.upcase }
+        command_set[:key] = key if Utils::EncodingHelper.valid_utf_8?(key)
 
         if Sentry.configuration.send_default_pii
           command_set[:arguments] = arguments
@@ -70,19 +71,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

@@ -58,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
@@ -190,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
@@ -303,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
@@ -315,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/span.rb

@@ -169,6 +169,10 @@ module Sentry
       yield(child_span)
 
       child_span.finish
+    rescue
+      child_span.set_http_status(500)
+      child_span.finish
+      raise
     end
 
     def deep_dup

data/lib/sentry/test_helper.rb

@@ -25,7 +25,7 @@ module Sentry
       copied_config.background_worker_threads = 0
 
       # user can overwrite some of the configs, with a few exceptions like:
-      # - capture_exception_frame_locals
+      # - include_local_variables
       # - auto_session_tracking
       block&.call(copied_config)
 

data/lib/sentry/transaction.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "sentry/baggage"
+require "sentry/profiler"
 
 module Sentry
   class Transaction < Span
@@ -37,6 +38,10 @@ module Sentry
     # @return [Baggage, nil]
     attr_reader :baggage
 
+    # The measurements added to the transaction.
+    # @return [Hash]
+    attr_reader :measurements
+
     # @deprecated Use Sentry.get_current_hub instead.
     attr_reader :hub
 
@@ -54,6 +59,10 @@ module Sentry
     # @return [Hash]
     attr_reader :contexts
 
+    # The Profiler instance for this transaction.
+    # @return [Profiler]
+    attr_reader :profiler
+
     def initialize(
       hub:,
       name: nil,
@@ -78,6 +87,8 @@ module Sentry
       @dsn = hub.configuration.dsn
       @effective_sample_rate = nil
       @contexts = {}
+      @measurements = {}
+      @profiler = Profiler.new(@configuration)
       init_span_recorder
     end
 
@@ -163,6 +174,15 @@ module Sentry
       copy
     end
 
+    # Sets a custom measurement on the transaction.
+    # @param name [String] name of the measurement
+    # @param value [Float] value of the measurement
+    # @param unit [String] unit of the measurement
+    # @return [void]
+    def set_measurement(name, value, unit = "")
+      @measurements[name] = { value: value, unit: unit }
+    end
+
     # Sets initial sampling decision of the transaction.
     # @param sampling_context [Hash] a context Hash that'll be passed to `traces_sampler` (if provided).
     # @return [void]
@@ -240,6 +260,8 @@ module Sentry
         @name = UNLABELD_NAME
       end
 
+      @profiler.stop
+
       if @sampled
         event = hub.current_client.event_from_transaction(self)
         hub.capture_event(event)
@@ -274,6 +296,13 @@ module Sentry
       @contexts[key] = value
     end
 
+    # Start the profiler.
+    # @return [void]
+    def start_profiler!
+      profiler.set_initial_sample_decision(sampled)
+      profiler.start
+    end
+
     protected
 
     def init_span_recorder(limit = 1000)

data/lib/sentry/transaction_event.rb

@@ -11,9 +11,15 @@ module Sentry
     # @return [Hash, nil]
     attr_accessor :dynamic_sampling_context
 
+    # @return [Hash]
+    attr_accessor :measurements
+
     # @return [Float, nil]
     attr_reader :start_timestamp
 
+    # @return [Hash, nil]
+    attr_accessor :profile
+
     def initialize(transaction:, **options)
       super(**options)
 
@@ -25,9 +31,12 @@ module Sentry
       self.start_timestamp = transaction.start_timestamp
       self.tags = transaction.tags
       self.dynamic_sampling_context = transaction.get_baggage.dynamic_sampling_context
+      self.measurements = transaction.measurements
 
       finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
       self.spans = finished_spans.map(&:to_hash)
+
+      populate_profile(transaction)
     end
 
     # Sets the event's start_timestamp.
@@ -42,7 +51,33 @@ module Sentry
       data = super
       data[:spans] = @spans.map(&:to_hash) if @spans
       data[:start_timestamp] = @start_timestamp
+      data[:measurements] = @measurements
       data
     end
+
+    private
+
+    def populate_profile(transaction)
+      profile_hash = transaction.profiler.to_hash
+      return if profile_hash.empty?
+
+      profile_hash.merge!(
+        environment: environment,
+        release: release,
+        timestamp: Time.at(start_timestamp).iso8601,
+        device: { architecture: Scope.os_context[:machine] },
+        os: { name: Scope.os_context[:name], version: Scope.os_context[:version] },
+        runtime: Scope.runtime_context,
+        transaction: {
+          id: event_id,
+          name: transaction.name,
+          trace_id: transaction.trace_id,
+          # TODO-neel-profiler stubbed for now, see thread_id note in profiler.rb
+          active_thead_id: '0'
+        }
+      )
+
+      self.profile = profile_hash
+    end
   end
 end

data/lib/sentry/transport.rb

@@ -154,6 +154,13 @@ module Sentry
         event_payload
       )
 
+      if event.is_a?(TransactionEvent) && event.profile
+        envelope.add_item(
+          { type: 'profile', content_type: 'application/json' },
+          event.profile
+        )
+      end
+
       client_report_headers, client_report_payload = fetch_pending_client_report
       envelope.add_item(client_report_headers, client_report_payload) if client_report_headers
 

data/lib/sentry/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sentry
-  VERSION = "5.7.0"
+  VERSION = "5.9.0"
 end

data/lib/sentry-ruby.rb

@@ -73,8 +73,18 @@ module Sentry
     ##### Patch Registration #####
 
     # @!visibility private
-    def register_patch(&block)
-      registered_patches << block
+    def register_patch(patch = nil, target = nil, &block)
+      if patch && block
+        raise ArgumentError.new("Please provide either a patch and its target OR a block, but not both")
+      end
+
+      if block
+        registered_patches << block
+      else
+        registered_patches << proc do
+          target.send(:prepend, patch) unless target.ancestors.include?(patch)
+        end
+      end
     end
 
     # @!visibility private
@@ -212,7 +222,7 @@ module Sentry
                            nil
                          end
 
-      if config.capture_exception_frame_locals
+      if config.include_local_variables
         exception_locals_tp.enable
       end
 
@@ -234,7 +244,7 @@ module Sentry
         @session_flusher = nil
       end
 
-      if configuration&.capture_exception_frame_locals
+      if configuration&.include_local_variables
         exception_locals_tp.disable
       end
 
@@ -462,6 +472,23 @@ module Sentry
       !!exc.instance_variable_get(CAPTURED_SIGNATURE)
     end
 
+    # Add a global event processor [Proc].
+    # These run before scope event processors.
+    #
+    # @yieldparam event [Event]
+    # @yieldparam hint [Hash, nil]
+    # @return [void]
+    #
+    # @example
+    #   Sentry.add_global_event_processor do |event, hint|
+    #     event.tags = { foo: 42 }
+    #     event
+    #   end
+    #
+    def add_global_event_processor(&block)
+      Scope.add_global_event_processor(&block)
+    end
+
     ##### Helpers #####
 
     # @!visibility private
@@ -492,3 +519,4 @@ end
 # patches
 require "sentry/net/http"
 require "sentry/redis"
+require "sentry/puma"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 5.7.0
+  version: 5.9.0
 platform: ruby
 authors:
 - Sentry Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-01 00:00:00.000000000 Z
+date: 2023-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -78,6 +78,8 @@ files:
 - lib/sentry/linecache.rb
 - lib/sentry/logger.rb
 - lib/sentry/net/http.rb
+- lib/sentry/profiler.rb
+- lib/sentry/puma.rb
 - lib/sentry/rack.rb
 - lib/sentry/rack/capture_exceptions.rb
 - lib/sentry/rake.rb