sentry-ruby 6.4.1 → 6.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98ee25c5aaeb49754f4d101eff2633c74f00b3b01236e7c012c1b7bb5898e276
-  data.tar.gz: a463f19fe5fe50719398470b2926509ebd5708cb7702948207d164846c873a29
+  metadata.gz: 3ac6a6802b328b59cb636ac1d91b5b1ab5710e9c1427c3d910e7bd05f30b618b
+  data.tar.gz: a77ee9a574da2de452d962848dbfca19aef525304e1bdbf65b21cb11ec7e9e3b
 SHA512:
-  metadata.gz: 0d108cff7d2da68566f330f02706c31bf70ca22291e5dd8575dfb1fcc76b073e14a22d2f18a814346ca38bc51cb1868ac328989de5d7b7c8bf1eab5d3a5d85b0
-  data.tar.gz: 9e6975759fb9a06307ab201f7377822f5fa4d4f407eacb656371f083cce2ff65ba98c0b4cc418f81e608d0e8e78449ee9c53e3c26e6706a3b8b4bfe8e77c37d2
+  metadata.gz: c1f221cea1a011d2540c666e14823423d12fa37f3ea4ee59f3d68035ad36e33dd62fbc8f23712fee46b8da31e3bbb7c027e664927945b959197c15d10626f4e9
+  data.tar.gz: 95f32db537d5fa0a95b3897dcd7fc6d34dff884fe474fc9a43d0567d6a3ef6a84cb181f06c9ef60b0e1e132cb5afa28e65faf427c408c518beeb1305ddf9af1f

data/README.md

@@ -21,6 +21,7 @@ Sentry SDK for Ruby
 | [![Gem Version](https://img.shields.io/gem/v/sentry-delayed_job?label=sentry-delayed_job)](https://rubygems.org/gems/sentry-delayed_job)       | [![Build Status](https://github.com/getsentry/sentry-ruby/actions/workflows/tests.yml/badge.svg)](https://github.com/getsentry/sentry-ruby/actions/workflows/tests.yml)     | [![codecov](https://codecov.io/gh/getsentry/sentry-ruby/graph/badge.svg?token=ZePzrpZFP6&component=sentry-delayed_job)](https://codecov.io/gh/getsentry/sentry-ruby) | [![API doc](https://img.shields.io/badge/API%20doc-rubydoc.info-blue)](https://www.rubydoc.info/gems/sentry-delayed_job)   |
 | [![Gem Version](https://img.shields.io/gem/v/sentry-resque?label=sentry-resque)](https://rubygems.org/gems/sentry-resque)                      | [![Build Status](https://github.com/getsentry/sentry-ruby/actions/workflows/tests.yml/badge.svg)](https://github.com/getsentry/sentry-ruby/actions/workflows/tests.yml)               | [![codecov](https://codecov.io/gh/getsentry/sentry-ruby/graph/badge.svg?token=ZePzrpZFP6&component=sentry-resque)](https://codecov.io/gh/getsentry/sentry-ruby) | [![API doc](https://img.shields.io/badge/API%20doc-rubydoc.info-blue)](https://www.rubydoc.info/gems/sentry-resque)        |
 | [![Gem Version](https://img.shields.io/gem/v/sentry-opentelemetry?label=sentry-opentelemetry)](https://rubygems.org/gems/sentry-opentelemetry) | [![Build Status](https://github.com/getsentry/sentry-ruby/actions/workflows/tests.yml/badge.svg)](https://github.com/getsentry/sentry-ruby/actions/workflows/tests.yml) | [![codecov](https://codecov.io/gh/getsentry/sentry-ruby/graph/badge.svg?token=ZePzrpZFP6&component=sentry-opentelemetry)](https://codecov.io/gh/getsentry/sentry-ruby) | [![API doc](https://img.shields.io/badge/API%20doc-rubydoc.info-blue)](https://www.rubydoc.info/gems/sentry-opentelemetry) |
+| [![Gem Version](https://img.shields.io/gem/v/sentry-yabeda?label=sentry-yabeda)](https://rubygems.org/gems/sentry-yabeda) | [![Build Status](https://github.com/getsentry/sentry-ruby/actions/workflows/tests.yml/badge.svg)](https://github.com/getsentry/sentry-ruby/actions/workflows/tests.yml) | [![codecov](https://codecov.io/gh/getsentry/sentry-ruby/graph/badge.svg?token=ZePzrpZFP6&component=sentry-yabeda)](https://codecov.io/gh/getsentry/sentry-ruby) | [![API doc](https://img.shields.io/badge/API%20doc-rubydoc.info-blue)](https://www.rubydoc.info/gems/sentry-yabeda) |
 
 
 
@@ -53,6 +54,7 @@ gem "sentry-sidekiq"
 gem "sentry-delayed_job"
 gem "sentry-resque"
 gem "sentry-opentelemetry"
+gem "sentry-yabeda"
 ```
 
 ### Configuration
@@ -93,6 +95,7 @@ To learn more about sampling transactions, please visit the [official documentat
 - [DelayedJob](https://docs.sentry.io/platforms/ruby/guides/delayed_job/)
 - [Resque](https://docs.sentry.io/platforms/ruby/guides/resque/)
 - [OpenTelemetry](https://docs.sentry.io/platforms/ruby/performance/instrumentation/opentelemetry/)
+- [Yabeda](https://docs.sentry.io/platforms/ruby/guides/yabeda/)
 
 ### Enriching Events
 

data/lib/sentry/backtrace/line.rb

@@ -6,6 +6,7 @@ module Sentry
     # Handles backtrace parsing line by line
     class Line
       RB_EXTENSION = ".rb"
+      CLASS_EXTENSION = ".class"
       # regexp (optional leading X: on windows, or JRuby9000 class-prefix)
       RUBY_INPUT_FORMAT = /
         ^ \s* (?: [a-zA-Z]: | uri:classloader: )? ([^:]+ | <.*>):
@@ -37,12 +38,21 @@ module Sentry
         ruby_match = unparsed_line.match(RUBY_INPUT_FORMAT)
 
         if ruby_match
-          _, file, number, _, module_name, method = ruby_match.to_a
-          file.sub!(/\.class$/, RB_EXTENSION)
-          module_name = module_name
+          file = ruby_match[1]
+          number = ruby_match[2]
+          module_name = ruby_match[4]
+          method = ruby_match[5]
+          if file.end_with?(CLASS_EXTENSION)
+            file.sub!(/\.class$/, RB_EXTENSION)
+          end
         else
           java_match = unparsed_line.match(JAVA_INPUT_FORMAT)
-          _, module_name, method, file, number = java_match.to_a
+          if java_match
+            module_name = java_match[1]
+            method = java_match[2]
+            file = java_match[3]
+            number = java_match[4]
+          end
         end
         new(file, number, method, module_name, in_app_pattern)
       end
@@ -74,12 +84,9 @@ module Sentry
 
       def in_app
         return false unless in_app_pattern
+        return false unless file
 
-        if file =~ in_app_pattern
-          true
-        else
-          false
-        end
+        file.match?(in_app_pattern)
       end
 
       # Reconstructs the line in a readable fashion

data/lib/sentry/backtrace.rb

@@ -10,14 +10,16 @@ module Sentry
     # holder for an Array of Backtrace::Line instances
     attr_reader :lines
 
-    def self.parse(backtrace, project_root, app_dirs_pattern, &backtrace_cleanup_callback)
+    # @deprecated project_root, in_app_pattern passed from outside
+    # @deprecated app_dirs_pattern, in_app_pattern passed from outside
+    def self.parse(backtrace, project_root, app_dirs_pattern, in_app_pattern: nil, &backtrace_cleanup_callback)
       ruby_lines = backtrace.is_a?(Array) ? backtrace : backtrace.split(/\n\s*/)
 
       ruby_lines = backtrace_cleanup_callback.call(ruby_lines) if backtrace_cleanup_callback
 
-      in_app_pattern ||= begin
-        Regexp.new("^(#{project_root}/)?#{app_dirs_pattern}")
-      end
+      # in_app_pattern is now passed in from StacktraceBuilder, so this regex won't be triggered
+      # only here for backwards compat and will be deleted
+      in_app_pattern ||= Regexp.new("^(#{project_root}/)?#{app_dirs_pattern}")
 
       lines = ruby_lines.to_a.map do |unparsed_line|
         Line.parse(unparsed_line, in_app_pattern)

data/lib/sentry/baggage.rb

@@ -25,7 +25,7 @@ module Sentry
     # The presence of a Sentry item makes the baggage object immutable.
     #
     # @param header [String] The incoming Baggage header string.
-    # @return [Baggage, nil]
+    # @return [Baggage]
     def self.from_incoming_header(header)
       items = {}
       mutable = true

data/lib/sentry/configuration.rb

@@ -371,6 +371,24 @@ module Sentry
     # @return [Proc, nil]
     attr_reader :std_lib_logger_filter
 
+    # An optional organization ID. The SDK will try to extract it from the DSN in most cases
+    # but you can provide it explicitly for self-hosted and Relay setups.
+    # This value is used for trace propagation and for features like strict_trace_continuation.
+    # @return [String, nil]
+    attr_reader :org_id
+
+    # If set to true, the SDK will only continue a trace if the org_id of the incoming trace found in the
+    # baggage header matches the org_id of the current Sentry client and only if BOTH are present.
+    #
+    # If set to false, consistency of org_id will only be enforced if both are present.
+    # If either are missing, the trace will be continued.
+    #
+    # The client's organization ID is extracted from the DSN or can be set with the org_id option.
+    # If the organization IDs do not match, the SDK will start a new trace instead of continuing the incoming one.
+    # This is useful to prevent traces of unknown third-party services from being continued in your application.
+    # @return [Boolean]
+    attr_accessor :strict_trace_continuation
+
     # these are not config options
     # @!visibility private
     attr_reader :errors, :gem_specs
@@ -443,7 +461,8 @@ module Sentry
       def callbacks
         @callbacks ||= {
           initialize: { before: [], after: [] },
-          configured: { before: [], after: [] }
+          configured: { before: [], after: [] },
+          closed: { before: [], after: [] }
         }
       end
 
@@ -520,6 +539,8 @@ module Sentry
       self.trusted_proxies = []
       self.dsn = ENV["SENTRY_DSN"]
       self.capture_queue_time = true
+      self.org_id = nil
+      self.strict_trace_continuation = false
 
       spotlight_env = ENV["SENTRY_SPOTLIGHT"]
       spotlight_bool = Sentry::Utils::EnvHelper.env_to_bool(spotlight_env, strict: true)
@@ -673,6 +694,16 @@ module Sentry
       @profiler_class = profiler_class
     end
 
+    def org_id=(value)
+      @org_id = value&.to_s
+    end
+
+    # Returns the effective org ID, preferring the explicit config option over the DSN-parsed value.
+    # @return [String, nil]
+    def effective_org_id
+      org_id || dsn&.org_id
+    end
+
     def sending_allowed?
       spotlight || sending_to_dsn_allowed?
     end
@@ -768,6 +799,11 @@ module Sentry
       @errors.join(", ")
     end
 
+    # @api private
+    def run_after_close_callbacks
+      run_callbacks(:after, :closed)
+    end
+
     private
 
     def init_dsn(dsn_string)

data/lib/sentry/dsn.rb

@@ -11,8 +11,9 @@ module Sentry
     REQUIRED_ATTRIBUTES = %w[host path public_key project_id].freeze
     LOCALHOST_NAMES = %w[localhost 127.0.0.1 ::1 [::1]].freeze
     LOCALHOST_PATTERN = /\.local(host|domain)?$/i
+    ORG_ID_REGEX = /\Ao(\d+)\./
 
-    attr_reader :scheme, :secret_key, :port, *REQUIRED_ATTRIBUTES
+    attr_reader :scheme, :secret_key, :port, :org_id, *REQUIRED_ATTRIBUTES
 
     def initialize(dsn_string)
       @raw_value = dsn_string
@@ -31,6 +32,8 @@ module Sentry
       @host = uri.host
       @port = uri.port if uri.port
       @path = uri_path.join("/")
+
+      @org_id = extract_org_id_from_host
     end
 
     def valid?
@@ -101,5 +104,14 @@ module Sentry
 
       "Sentry " + fields.map { |key, value| "#{key}=#{value}" }.join(", ")
     end
+
+    private
+
+    def extract_org_id_from_host
+      return nil unless @host
+
+      match = ORG_ID_REGEX.match(@host)
+      match ? match[1] : nil
+    end
   end
 end

data/lib/sentry/exceptions.rb

@@ -6,4 +6,7 @@ module Sentry
 
   class ExternalError < Error
   end
+
+  class SizeExceededError < ExternalError
+  end
 end

data/lib/sentry/hub.rb

@@ -54,6 +54,12 @@ module Sentry
       current_layer&.client
     end
 
+    # All clients bound across the hub's scope stack, base layer first.
+    # @return [Array<Client>]
+    def clients
+      @stack.map(&:client).compact
+    end
+
     def configuration
       current_client.configuration
     end

data/lib/sentry/interfaces/request.rb

@@ -11,6 +11,9 @@ module Sentry
       "HTTP_X_FORWARDED_FOR"
     ].freeze
 
+    # Regex to detect lowercase chars — match? is allocation-free (no MatchData/String)
+    LOWERCASE_PATTERN = /[a-z]/.freeze
+
     # See Sentry server default limits at
     # https://github.com/getsentry/sentry/blob/master/src/sentry/conf/server.py
     MAX_BODY_LIMIT = 4096 * 4
@@ -93,7 +96,7 @@ module Sentry
           next if key == "HTTP_AUTHORIZATION" && !send_default_pii
 
           # Rack stores headers as HTTP_WHAT_EVER, we need What-Ever
-          key = key.sub(/^HTTP_/, "")
+          key = key.delete_prefix("HTTP_")
           key = key.split("_").map(&:capitalize).join("-")
 
           memo[key] = Utils::EncodingHelper.encode_to_utf_8(value.to_s)
@@ -108,7 +111,7 @@ module Sentry
     end
 
     def is_skippable_header?(key)
-      key.upcase != key || # lower-case envs aren't real http headers
+      key.match?(LOWERCASE_PATTERN) || # lower-case envs aren't real http headers
         key == "HTTP_COOKIE" || # Cookies don't go here, they go somewhere else
         !(key.start_with?("HTTP_") || CONTENT_HEADERS.include?(key))
     end
@@ -119,12 +122,18 @@ module Sentry
     # if the request has legitimately sent a Version header themselves.
     # See: https://github.com/rack/rack/blob/028438f/lib/rack/handler/cgi.rb#L29
     def is_server_protocol?(key, value, protocol_version)
-      rack_version = Gem::Version.new(::Rack.release)
-      return false if rack_version >= Gem::Version.new("3.0")
+      return false if self.class.rack_3_or_above?
 
       key == "HTTP_VERSION" && value == protocol_version
     end
 
+    def self.rack_3_or_above?
+      return @rack_3_or_above if defined?(@rack_3_or_above)
+
+      @rack_3_or_above = defined?(::Rack) &&
+        Gem::Version.new(::Rack.release) >= Gem::Version.new("3.0")
+    end
+
     def filter_and_format_env(env, rack_env_whitelist)
       return env if rack_env_whitelist.empty?
 

data/lib/sentry/interfaces/stacktrace.rb

@@ -27,38 +27,19 @@ module Sentry
       attr_accessor :abs_path, :context_line, :function, :in_app, :filename,
                   :lineno, :module, :pre_context, :post_context, :vars
 
-      def initialize(project_root, line, strip_backtrace_load_path = true)
-        @project_root = project_root
-        @strip_backtrace_load_path = strip_backtrace_load_path
-
+      def initialize(project_root, line, strip_backtrace_load_path = true, filename_cache: nil)
         @abs_path = line.file
         @function = line.method if line.method
         @lineno = line.number
         @in_app = line.in_app
         @module = line.module_name if line.module_name
-        @filename = compute_filename
+        @filename = filename_cache&.compute_filename(@abs_path, @in_app, strip_backtrace_load_path)
       end
 
       def to_s
         "#{@filename}:#{@lineno}"
       end
 
-      def compute_filename
-        return if abs_path.nil?
-        return abs_path unless @strip_backtrace_load_path
-
-        prefix =
-          if under_project_root? && in_app
-            @project_root
-          elsif under_project_root?
-            longest_load_path || @project_root
-          else
-            longest_load_path
-          end
-
-        prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
-      end
-
       def set_context(linecache, context_lines)
         return unless abs_path
 
@@ -76,14 +57,6 @@ module Sentry
       end
 
       private
-
-      def under_project_root?
-        @project_root && abs_path.start_with?(@project_root)
-      end
-
-      def longest_load_path
-        $LOAD_PATH.select { |path| abs_path.start_with?(path.to_s) }.max_by(&:size)
-      end
     end
   end
 end

data/lib/sentry/interfaces/stacktrace_builder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "sentry/utils/filename_cache"
+
 module Sentry
   class StacktraceBuilder
     # @return [String]
@@ -20,6 +22,9 @@ module Sentry
     # @return [Boolean]
     attr_reader :strip_backtrace_load_path
 
+    # @return [FilenameCache]
+    attr_reader :filename_cache
+
     # @param project_root [String]
     # @param app_dirs_pattern [Regexp, nil]
     # @param linecache [LineCache]
@@ -46,6 +51,8 @@ module Sentry
       @context_lines = context_lines
       @backtrace_cleanup_callback = backtrace_cleanup_callback
       @strip_backtrace_load_path = strip_backtrace_load_path
+      @in_app_pattern = Regexp.new("^(#{project_root}/)?#{app_dirs_pattern}") if app_dirs_pattern
+      @filename_cache = FilenameCache.new(project_root)
     end
 
     # Generates a StacktraceInterface with the given backtrace.
@@ -64,13 +71,21 @@ module Sentry
     # @yieldparam frame [StacktraceInterface::Frame]
     # @return [StacktraceInterface]
     def build(backtrace:, &frame_callback)
-      parsed_lines = parse_backtrace_lines(backtrace).select(&:file)
+      parsed_lines = parse_backtrace_lines(backtrace)
+
+      # Build frames in reverse order, skipping lines without files
+      # Single pass instead of select + reverse + map + compact
+      frames = []
+      i = parsed_lines.size - 1
+      while i >= 0
+        line = parsed_lines[i]
+        i -= 1
+        next unless line.file
 
-      frames = parsed_lines.reverse.map do |line|
         frame = convert_parsed_line_into_frame(line)
         frame = frame_callback.call(frame) if frame_callback
-        frame
-      end.compact
+        frames << frame if frame
+      end
 
       StacktraceInterface.new(frames: frames)
     end
@@ -78,14 +93,15 @@ module Sentry
     private
 
     def convert_parsed_line_into_frame(line)
-      frame = StacktraceInterface::Frame.new(project_root, line, strip_backtrace_load_path)
+      frame = StacktraceInterface::Frame.new(project_root, line, strip_backtrace_load_path, filename_cache: @filename_cache)
       frame.set_context(linecache, context_lines) if context_lines
       frame
     end
 
     def parse_backtrace_lines(backtrace)
       Backtrace.parse(
-        backtrace, project_root, app_dirs_pattern, &backtrace_cleanup_callback
+        backtrace, project_root, app_dirs_pattern,
+        in_app_pattern: @in_app_pattern, &backtrace_cleanup_callback
       ).lines
     end
   end

data/lib/sentry/linecache.rb

@@ -12,36 +12,33 @@ module Sentry
     # file. The number of lines retrieved is (2 * context) + 1, the middle
     # line should be the line requested by lineno. See specs for more information.
     def get_file_context(filename, lineno, context)
-      return nil, nil, nil unless valid_path?(filename)
+      lines = getlines(filename)
+      return nil, nil, nil unless lines
 
-      lines = Array.new(2 * context + 1) do |i|
-        getline(filename, lineno - context + i)
-      end
-      [lines[0..(context - 1)], lines[context], lines[(context + 1)..-1]]
+      first_line = lineno - context
+      pre = Array.new(context) { |i| line_at(lines, first_line + i) }
+      context_line = line_at(lines, lineno)
+      post = Array.new(context) { |i| line_at(lines, lineno + 1 + i) }
+
+      [pre, context_line, post]
     end
 
     private
 
-    def valid_path?(path)
-      lines = getlines(path)
-      !lines.nil?
+    def line_at(lines, n)
+      return nil if n < 1
+
+      lines[n - 1]
     end
 
     def getlines(path)
-      @cache[path] ||= begin
-        File.open(path, "r", &:readlines)
-      rescue
-        nil
+      @cache.fetch(path) do
+        @cache[path] = begin
+          File.open(path, "r", &:readlines)
+        rescue
+          nil
+        end
       end
     end
-
-    def getline(path, n)
-      return nil if n < 1
-
-      lines = getlines(path)
-      return nil if lines.nil?
-
-      lines[n - 1]
-    end
   end
 end

data/lib/sentry/metric_event.rb

@@ -43,7 +43,7 @@ module Sentry
     private
 
     def serialize_attributes
-      @attributes.transform_values! { |v| attribute_hash(v) }
+      @attributes.transform_values { |v| attribute_hash(v) }
     end
   end
 end

data/lib/sentry/profiler/helpers.rb

@@ -9,28 +9,8 @@ module Sentry
         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
+        @filename_cache.compute_filename(abs_path, in_app, true)
       end
 
       def split_module(name)

data/lib/sentry/profiler.rb

@@ -26,6 +26,7 @@ module Sentry
       @project_root = configuration.project_root
       @app_dirs_pattern = configuration.app_dirs_pattern
       @in_app_pattern = Regexp.new("^(#{@project_root}/)?#{@app_dirs_pattern}")
+      @filename_cache = configuration.stacktrace_builder.filename_cache
     end
 
     def start

data/lib/sentry/propagation_context.rb

@@ -53,6 +53,44 @@ module Sentry
       [trace_id, parent_span_id, parent_sampled]
     end
 
+    # Determines whether we should continue an incoming trace based on org_id matching
+    # and the strict_trace_continuation configuration option.
+    #
+    # @param incoming_baggage [Baggage] the baggage from the incoming request
+    # @return [Boolean]
+    def self.should_continue_trace?(incoming_baggage)
+      return true unless Sentry.initialized?
+
+      configuration = Sentry.configuration
+      sdk_org_id = configuration.effective_org_id
+      baggage_org_id = incoming_baggage.items["org_id"]
+
+      # Mismatched org IDs always start a new trace regardless of strict mode
+      if sdk_org_id && baggage_org_id && sdk_org_id != baggage_org_id
+        Sentry.sdk_logger.debug(LOGGER_PROGNAME) do
+          "Starting a new trace because org IDs don't match (incoming baggage org_id: #{baggage_org_id}, SDK org_id: #{sdk_org_id})"
+        end
+
+        return false
+      end
+
+      return true unless configuration.strict_trace_continuation
+
+      # In strict mode, both must be present and match (unless both are missing)
+      if sdk_org_id.nil? && baggage_org_id.nil?
+        true
+      elsif sdk_org_id.nil? || baggage_org_id.nil?
+        Sentry.sdk_logger.debug(LOGGER_PROGNAME) do
+          "Starting a new trace because strict trace continuation is enabled and one org ID is missing " \
+            "(incoming baggage org_id: #{baggage_org_id.inspect}, SDK org_id: #{sdk_org_id.inspect})"
+        end
+
+        false
+      else
+        true
+      end
+    end
+
     def self.extract_sample_rand_from_baggage(baggage, trace_id = nil)
       return unless baggage&.items
 
@@ -96,9 +134,7 @@ module Sentry
           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 =
+            incoming_baggage =
               if baggage_header && !baggage_header.empty?
                 Baggage.from_incoming_header(baggage_header)
               else
@@ -108,10 +144,13 @@ module Sentry
                 Baggage.new({})
               end
 
-            @sample_rand = self.class.extract_sample_rand_from_baggage(@baggage, @trace_id)
-
-            @baggage.freeze!
-            @incoming_trace = true
+            if self.class.should_continue_trace?(incoming_baggage)
+              @trace_id, @parent_span_id, @parent_sampled = sentry_trace_data
+              @baggage = incoming_baggage
+              @sample_rand = self.class.extract_sample_rand_from_baggage(@baggage, @trace_id)
+              @baggage.freeze!
+              @incoming_trace = true
+            end
           end
         end
       end
@@ -162,7 +201,8 @@ module Sentry
         "sample_rand" => Utils::SampleRand.format(@sample_rand),
         "environment" => configuration.environment,
         "release" => configuration.release,
-        "public_key" => configuration.dsn&.public_key
+        "public_key" => configuration.dsn&.public_key,
+        "org_id" => configuration.effective_org_id
       }
 
       items.compact!

data/lib/sentry/release_detector.rb

@@ -6,6 +6,7 @@ module Sentry
     class << self
       def detect_release(project_root:, running_on_heroku:)
         detect_release_from_env ||
+        detect_release_from_kamal ||
         detect_release_from_git ||
         detect_release_from_capistrano(project_root) ||
         detect_release_from_heroku(running_on_heroku)
@@ -13,7 +14,7 @@ module Sentry
 
       def detect_release_from_heroku(running_on_heroku)
         return unless running_on_heroku
-        ENV["HEROKU_SLUG_COMMIT"]
+        ENV["HEROKU_BUILD_COMMIT"] || ENV["HEROKU_SLUG_COMMIT"]
       end
 
       def detect_release_from_capistrano(project_root)
@@ -31,6 +32,10 @@ module Sentry
         Sentry.sys_command("git rev-parse HEAD") if File.directory?(".git")
       end
 
+      def detect_release_from_kamal
+        ENV["KAMAL_VERSION"]
+      end
+
       def detect_release_from_env
         ENV["SENTRY_RELEASE"]
       end

data/lib/sentry/scope.rb

@@ -135,6 +135,7 @@ module Sentry
       copy.session = session.deep_dup
       copy.propagation_context = propagation_context.deep_dup
       copy.attachments = attachments.dup
+      copy.event_processors = event_processors.dup
       copy
     end
 

data/lib/sentry/test_helper.rb

@@ -37,13 +37,25 @@ module Sentry
       # - auto_session_tracking
       block&.call(dummy_config)
 
+      # Install the testing clients on the *main* hub rather than the current
+      # thread's hub. `Sentry.clone_hub_to_current_thread` (used by
+      # Sentry::Rack::CaptureExceptions) always clones the main hub, so if we
+      # only mutated the thread-local hub a request-time clone would observe a
+      # stale transport.
+      main_hub = Sentry.get_main_hub
+
       # the base layer's client should already use the dummy config so nothing will be sent by accident
       base_client = Sentry::Client.new(dummy_config)
-      Sentry.get_current_hub.bind_client(base_client)
+      main_hub.bind_client(base_client)
       # create a new layer so mutations made to the testing scope or configuration could be simply popped later
-      Sentry.get_current_hub.push_scope
+      main_hub.push_scope
       test_client = Sentry::Client.new(dummy_config.dup)
-      Sentry.get_current_hub.bind_client(test_client)
+      main_hub.bind_client(test_client)
+
+      # Realign the current thread's hub with the main hub so direct
+      # `sentry_events` reads and any hub the Rack middleware clones from the
+      # main hub all observe the same DummyTransport.
+      Thread.current.thread_variable_set(Sentry::THREAD_LOCAL, main_hub)
     end
 
     # Clears all stored events and envelopes.
@@ -54,11 +66,15 @@ module Sentry
 
       clear_sentry_events
 
-      # pop testing layer created by `setup_sentry_test`
-      # but keep the base layer to avoid nil-pointer errors
+      # pop the testing layer created by `setup_sentry_test` off the *main*
+      # hub (that is where `setup_sentry_test` pushed it), keeping the base
+      # layer to avoid nil-pointer errors. Popping the current thread's hub
+      # would leave the test layer dangling on the main hub, which the next
+      # request-time clone would inherit.
       # TODO: find a way to notify users if they somehow popped the test layer before calling this method
-      if Sentry.get_current_hub.instance_variable_get(:@stack).size > 1
-        Sentry.get_current_hub.pop_scope
+      main_hub = Sentry.get_main_hub
+      if main_hub.instance_variable_get(:@stack).size > 1
+        main_hub.pop_scope
       end
       Sentry::Scope.global_event_processors.clear
     end
@@ -66,7 +82,13 @@ module Sentry
     def clear_sentry_events
       return unless Sentry.initialized?
 
-      sentry_transport.clear if sentry_transport.respond_to?(:clear)
+      # Clear every transport reachable from the current thread's hub and the
+      # main hub (including its base layer). A request-time clone shares the
+      # main hub's base-layer transport, so clearing only the current
+      # transport would let stale events survive into the next test.
+      sentry_test_transports.each do |transport|
+        transport.clear if transport.respond_to?(:clear)
+      end
 
       if Sentry.configuration.enable_logs && sentry_logger.respond_to?(:clear)
         sentry_logger.clear
@@ -83,6 +105,17 @@ module Sentry
       Sentry.get_current_client.transport
     end
 
+    # Every transport reachable from the current thread's hub and the main
+    # hub, across all stack layers. Used by `clear_sentry_events` so a stale
+    # DummyTransport (e.g. the main hub's base layer that a request-time clone
+    # shares) cannot carry leftover events into the next test.
+    # @return [Array<Transport>]
+    def sentry_test_transports
+      [Sentry.get_current_hub, Sentry.get_main_hub].compact.uniq.flat_map do |hub|
+        hub.clients.map(&:transport)
+      end.compact.uniq
+    end
+
     # Returns the captured event objects.
     # @return [Array<Event>]
     def sentry_events

data/lib/sentry/transaction.rb

@@ -295,7 +295,8 @@ module Sentry
         "sampled" => sampled&.to_s,
         "environment" => configuration&.environment,
         "release" => configuration&.release,
-        "public_key" => configuration&.dsn&.public_key
+        "public_key" => configuration&.dsn&.public_key,
+        "org_id" => configuration&.effective_org_id
       }
 
       items["transaction"] = name unless source_low_quality?

data/lib/sentry/transport/dummy_transport.rb

@@ -18,5 +18,12 @@ module Sentry
     def send_envelope(envelope)
       @envelopes << envelope
     end
+
+    # Empties the captured events and envelopes so `TestHelper.clear_sentry_events`
+    # also clears the dummy transport instance
+    def clear
+      @events.clear
+      @envelopes.clear
+    end
   end
 end

data/lib/sentry/transport/http_transport.rb

@@ -49,6 +49,12 @@ module Sentry
 
       if response.code.match?(/\A2\d{2}/)
         handle_rate_limited_response(response) if has_rate_limited_header?(response)
+      elsif response.code == "413"
+        error_message = "HTTP 413: Envelope dropped due to exceeded size limit"
+        error_message += " (body: #{response.body})" if response.body && !response.body.empty?
+        log_warn(error_message)
+
+        raise Sentry::SizeExceededError, error_message
       elsif response.code == "429"
         log_debug("the server responded with status 429")
         handle_rate_limited_response(response)

data/lib/sentry/transport.rb

@@ -19,7 +19,8 @@ module Sentry
       :before_send,
       :event_processor,
       :insufficient_data,
-      :backpressure
+      :backpressure,
+      :send_error
     ]
 
     include LoggingHelper
@@ -61,6 +62,10 @@ module Sentry
         log_debug("[Transport] Sending envelope with items [#{serialized_items.map(&:type).join(', ')}] #{envelope.event_id} to Sentry")
         send_data(data)
       end
+    rescue Sentry::SizeExceededError
+      serialized_items&.each do |item|
+        record_lost_event(:send_error, item.data_category)
+      end
     end
 
     def serialize_envelope(envelope)

data/lib/sentry/utils/filename_cache.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Sentry
+  class FilenameCache
+    attr_reader :cache
+
+    def initialize(project_root)
+      @project_root = project_root
+      @load_paths = $LOAD_PATH.map(&:to_s).sort_by(&:size).reverse.freeze
+      @cache = {}
+    end
+
+    def compute_filename(abs_path, in_app, strip_backtrace_load_path)
+      return unless abs_path
+      return abs_path unless strip_backtrace_load_path
+
+      @cache.fetch(abs_path) do
+        under_root = @project_root && abs_path.start_with?(@project_root)
+        prefix =
+          if under_root && in_app
+            @project_root
+          elsif under_root
+            longest_load_path(abs_path) || @project_root
+          else
+            longest_load_path(abs_path)
+          end
+
+        @cache[abs_path] = if prefix
+          offset = if prefix.end_with?(File::SEPARATOR)
+            prefix.bytesize
+          else
+            prefix.bytesize + 1
+          end
+          abs_path.byteslice(offset, abs_path.bytesize - offset)
+        else
+          abs_path
+        end
+      end
+    end
+
+    private
+
+    def longest_load_path(abs_path)
+      @load_paths.find { |path| abs_path.start_with?(path) }
+    end
+  end
+end

data/lib/sentry/utils/http_tracing.rb

@@ -12,7 +12,13 @@ module Sentry
       end
 
       def set_propagation_headers(req)
-        Sentry.get_trace_propagation_headers&.each { |k, v| req[k] = v }
+        Sentry.get_trace_propagation_headers&.each do |k, v|
+          if k == BAGGAGE_HEADER_NAME && req[k]
+            req[k] = "#{v},#{req[k]}"
+          else
+            req[k] = v
+          end
+        end
       end
 
       def record_sentry_breadcrumb(request_info, response_status)

data/lib/sentry/vernier/output.rb

@@ -10,11 +10,12 @@ module Sentry
 
       attr_reader :profile
 
-      def initialize(profile, project_root:, in_app_pattern:, app_dirs_pattern:)
+      def initialize(profile, project_root:, in_app_pattern:, app_dirs_pattern:, filename_cache:)
         @profile = profile
         @project_root = project_root
         @in_app_pattern = in_app_pattern
         @app_dirs_pattern = app_dirs_pattern
+        @filename_cache = filename_cache
       end
 
       def to_h

data/lib/sentry/vernier/profiler.rb

@@ -24,6 +24,7 @@ module Sentry
         @project_root = configuration.project_root
         @app_dirs_pattern = configuration.app_dirs_pattern
         @in_app_pattern = Regexp.new("^(#{@project_root}/)?#{@app_dirs_pattern}")
+        @filename_cache = configuration.stacktrace_builder.filename_cache
       end
 
       def set_initial_sample_decision(transaction_sampled)
@@ -125,7 +126,8 @@ module Sentry
           result,
           project_root: @project_root,
           app_dirs_pattern: @app_dirs_pattern,
-          in_app_pattern: @in_app_pattern
+          in_app_pattern: @in_app_pattern,
+          filename_cache: @filename_cache
         )
       end
     end

data/lib/sentry/version.rb

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

data/lib/sentry-ruby.rb

@@ -268,6 +268,7 @@ module Sentry
       end
 
       if client = get_current_client
+        client.configuration.run_after_close_callbacks
         client.flush
 
         if client.configuration.include_local_variables

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sentry-ruby
 version: !ruby/object:Gem::Version
-  version: 6.4.1
+  version: 6.6.0
 platform: ruby
 authors:
 - Sentry Team
@@ -157,6 +157,7 @@ files:
 - lib/sentry/utils/encoding_helper.rb
 - lib/sentry/utils/env_helper.rb
 - lib/sentry/utils/exception_cause_chain.rb
+- lib/sentry/utils/filename_cache.rb
 - lib/sentry/utils/http_tracing.rb
 - lib/sentry/utils/logging_helper.rb
 - lib/sentry/utils/real_ip.rb
@@ -169,15 +170,15 @@ files:
 - lib/sentry/version.rb
 - sentry-ruby-core.gemspec
 - sentry-ruby.gemspec
-homepage: https://github.com/getsentry/sentry-ruby/tree/6.4.1/sentry-ruby
+homepage: https://github.com/getsentry/sentry-ruby/tree/6.6.0/sentry-ruby
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/getsentry/sentry-ruby/tree/6.4.1/sentry-ruby
-  source_code_uri: https://github.com/getsentry/sentry-ruby/tree/6.4.1/sentry-ruby
-  changelog_uri: https://github.com/getsentry/sentry-ruby/blob/6.4.1/CHANGELOG.md
+  homepage_uri: https://github.com/getsentry/sentry-ruby/tree/6.6.0/sentry-ruby
+  source_code_uri: https://github.com/getsentry/sentry-ruby/tree/6.6.0/sentry-ruby
+  changelog_uri: https://github.com/getsentry/sentry-ruby/blob/6.6.0/CHANGELOG.md
   bug_tracker_uri: https://github.com/getsentry/sentry-ruby/issues
-  documentation_uri: http://www.rubydoc.info/gems/sentry-ruby/6.4.1
+  documentation_uri: http://www.rubydoc.info/gems/sentry-ruby/6.6.0
 rdoc_options: []
 require_paths:
 - lib