sentry-ruby 5.18.2 → 5.28.1

data/lib/sentry/profiler.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
-require 'securerandom'
+require "securerandom"
+require_relative "profiler/helpers"
+require "sentry/utils/uuid"
 
 module Sentry
   class Profiler
-    VERSION = '1'
-    PLATFORM = 'ruby'
+    include Profiler::Helpers
+
+    VERSION = "1"
+    PLATFORM = "ruby"
     # 101 Hz in microseconds
     DEFAULT_INTERVAL = 1e6 / 101
     MICRO_TO_NANO_SECONDS = 1e3
@@ -14,14 +18,14 @@ module Sentry
     attr_reader :sampled, :started, :event_id
 
     def initialize(configuration)
-      @event_id = SecureRandom.uuid.delete('-')
+      @event_id = Utils.uuid
       @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
+      @app_dirs_pattern = configuration.app_dirs_pattern
       @in_app_pattern = Regexp.new("^(#{@project_root}/)?#{@app_dirs_pattern}")
     end
 
@@ -33,7 +37,7 @@ module Sentry
                                  raw: true,
                                  aggregate: false)
 
-      @started ? log('Started') : log('Not started since running elsewhere')
+      @started ? log("Started") : log("Not started since running elsewhere")
     end
 
     def stop
@@ -41,7 +45,11 @@ module Sentry
       return unless @started
 
       StackProf.stop
-      log('Stopped')
+      log("Stopped")
+    end
+
+    def active_thread_id
+      "0"
     end
 
     # Sets initial sampling decision of the profile.
@@ -54,14 +62,14 @@ module Sentry
 
       unless transaction_sampled
         @sampled = false
-        log('Discarding profile because transaction not sampled')
+        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')
+        log("Discarding profile because sample_rate is 0")
         return
       when 1.0
         @sampled = true
@@ -70,7 +78,7 @@ module Sentry
         @sampled = Random.rand < @profiles_sample_rate
       end
 
-      log('Discarding profile due to sampling decision') unless @sampled
+      log("Discarding profile due to sampling decision") unless @sampled
     end
 
     def to_hash
@@ -90,13 +98,12 @@ module Sentry
 
       frame_map = {}
 
-      frames = results[:frames].to_enum.with_index.map do |frame, idx|
-        frame_id, frame_data = frame
-
+      frames = results[:frames].map.with_index do |(frame_id, frame_data), idx|
         # need to map over stackprof frame ids to ours
         frame_map[frame_id] = idx
 
         file_path = frame_data[:file]
+        lineno = frame_data[:line]
         in_app = in_app?(file_path)
         filename = compute_filename(file_path, in_app)
         function, mod = split_module(frame_data[:name])
@@ -109,7 +116,7 @@ module Sentry
         }
 
         frame_hash[:module] = mod if mod
-        frame_hash[:lineno] = frame_data[:line] if frame_data[:line] && frame_data[:line] >= 0
+        frame_hash[:lineno] = lineno if lineno && lineno >= 0
 
         frame_hash
       end
@@ -130,7 +137,7 @@ module Sentry
         num_seen << results[:raw][idx + len]
         idx += len + 1
 
-        log('Unknown frame in stack') if stack.size != len
+        log("Unknown frame in stack") if stack.size != len
       end
 
       idx = 0
@@ -155,16 +162,16 @@ module Sentry
             # 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',
+            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]
+      log("Some samples thrown away") if samples.size != results[:samples]
 
       if samples.size <= MIN_SAMPLES_REQUIRED
-        log('Not enough samples, discarding profiler')
+        log("Not enough samples, discarding profiler")
         record_lost_event(:insufficient_data)
         return {}
       end
@@ -186,48 +193,11 @@ module Sentry
     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]
+      Sentry.sdk_logger.debug(LOGGER_PROGNAME) { "[Profiler] #{message}" }
     end
 
     def record_lost_event(reason)
-      Sentry.get_current_client&.transport&.record_lost_event(reason, 'profile')
+      Sentry.get_current_client&.transport&.record_lost_event(reason, "profile")
     end
   end
 end

data/lib/sentry/propagation_context.rb

@@ -2,15 +2,15 @@
 
 require "securerandom"
 require "sentry/baggage"
+require "sentry/utils/uuid"
+require "sentry/utils/sample_rand"
 
 module Sentry
   class PropagationContext
     SENTRY_TRACE_REGEXP = Regexp.new(
-      "^[ \t]*" +  # whitespace
-      "([0-9a-f]{32})?" +  # trace_id
+      "\\A([0-9a-f]{32})?" + # trace_id
       "-?([0-9a-f]{16})?" +  # span_id
-      "-?([01])?" +  # sampled
-      "[ \t]*$"  # whitespace
+      "-?([01])?\\z"         # sampled
     )
 
     # An uuid that can be used to identify a trace.
@@ -32,6 +32,53 @@ module Sentry
     # Please use the #get_baggage method for interfacing outside this class.
     # @return [Baggage, nil]
     attr_reader :baggage
+    # The propagated random value used for sampling decisions.
+    # @return [Float, nil]
+    attr_reader :sample_rand
+
+    # 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)
+      value = sentry_trace.to_s.strip
+      return if value.empty?
+
+      match = SENTRY_TRACE_REGEXP.match(value)
+      return 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
+
+    def self.extract_sample_rand_from_baggage(baggage, trace_id = nil)
+      return unless baggage&.items
+
+      sample_rand_str = baggage.items["sample_rand"]
+      return unless sample_rand_str
+
+      generator = Utils::SampleRand.new(trace_id: trace_id)
+      generator.generate_from_value(sample_rand_str)
+    end
+
+    def self.generate_sample_rand(baggage, trace_id, parent_sampled)
+      generator = Utils::SampleRand.new(trace_id: trace_id)
+
+      if baggage&.items && !parent_sampled.nil?
+        sample_rate_str = baggage.items["sample_rate"]
+        sample_rate = sample_rate_str&.to_f
+
+        if sample_rate && !parent_sampled.nil?
+          generator.generate_from_sampling_decision(parent_sampled, sample_rate)
+        else
+          generator.generate_from_trace_id
+        end
+      else
+        generator.generate_from_trace_id
+      end
+    end
 
     def initialize(scope, env = nil)
       @scope = scope
@@ -39,6 +86,7 @@ module Sentry
       @parent_sampled = nil
       @baggage = nil
       @incoming_trace = false
+      @sample_rand = nil
 
       if env
         sentry_trace_header = env["HTTP_SENTRY_TRACE"] || env[SENTRY_TRACE_HEADER_NAME]
@@ -60,28 +108,17 @@ module Sentry
                 Baggage.new({})
               end
 
+            @sample_rand = self.class.extract_sample_rand_from_baggage(@baggage, @trace_id)
+
             @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]
+      @trace_id ||= Utils.uuid
+      @span_id = Utils.uuid.slice(0, 16)
+      @sample_rand ||= self.class.generate_sample_rand(@baggage, @trace_id, @parent_sampled)
     end
 
     # Returns the trace context that can be used to embed in an Event.
@@ -108,7 +145,7 @@ module Sentry
     end
 
     # Returns the Dynamic Sampling Context from the baggage.
-    # @return [String, nil]
+    # @return [Hash, nil]
     def get_dynamic_sampling_context
       get_baggage&.dynamic_sampling_context
     end
@@ -122,10 +159,10 @@ module Sentry
 
       items = {
         "trace_id" => trace_id,
+        "sample_rand" => Utils::SampleRand.format(@sample_rand),
         "environment" => configuration.environment,
         "release" => configuration.release,
-        "public_key" => configuration.dsn&.public_key,
-        "user_segment" => @scope.user && @scope.user["segment"]
+        "public_key" => configuration.dsn&.public_key
       }
 
       items.compact!

data/lib/sentry/rack/capture_exceptions.rb

@@ -50,11 +50,11 @@ module Sentry
       private
 
       def collect_exception(env)
-        env['rack.exception'] || env['sinatra.error']
+        env["rack.exception"] || env["sinatra.error"]
       end
 
       def transaction_op
-        "http.server".freeze
+        "http.server"
       end
 
       def capture_exception(exception, env)

data/lib/sentry/rack.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require 'rack'
+require "rack"
 
-require 'sentry/rack/capture_exceptions'
+require "sentry/rack/capture_exceptions"

data/lib/sentry/rake.rb

@@ -8,10 +8,10 @@ module Sentry
     module Application
       # @api private
       def display_error_message(ex)
-        mechanism = Sentry::Mechanism.new(type: 'rake', handled: false)
+        mechanism = Sentry::Mechanism.new(type: "rake", handled: false)
 
         Sentry.capture_exception(ex, hint: { mechanism: mechanism }) do |scope|
-          task_name = top_level_tasks.join(' ')
+          task_name = top_level_tasks.join(" ")
           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/release_detector.rb

@@ -13,12 +13,12 @@ module Sentry
 
       def detect_release_from_heroku(running_on_heroku)
         return unless running_on_heroku
-        ENV['HEROKU_SLUG_COMMIT']
+        ENV["HEROKU_SLUG_COMMIT"]
       end
 
       def detect_release_from_capistrano(project_root)
-        revision_file = File.join(project_root, 'REVISION')
-        revision_log = File.join(project_root, '..', 'revisions.log')
+        revision_file = File.join(project_root, "REVISION")
+        revision_log = File.join(project_root, "..", "revisions.log")
 
         if File.exist?(revision_file)
           File.read(revision_file).strip
@@ -32,7 +32,7 @@ module Sentry
       end
 
       def detect_release_from_env
-        ENV['SENTRY_RELEASE']
+        ENV["SENTRY_RELEASE"]
       end
     end
   end

data/lib/sentry/rspec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+RSpec::Matchers.define :include_sentry_event do |event_message = "", **opts|
+  match do |sentry_events|
+    @expected_exception = expected_exception(**opts)
+    @context = context(**opts)
+    @tags = tags(**opts)
+
+    @expected_event = expected_event(event_message)
+    @matched_event = find_matched_event(event_message, sentry_events)
+
+    return false unless @matched_event
+
+    [verify_context(), verify_tags()].all?
+  end
+
+  chain :with_context do |context|
+    @context = context
+  end
+
+  chain :with_tags do |tags|
+    @tags = tags
+  end
+
+  failure_message do |sentry_events|
+    info = ["Failed to find event matching:\n"]
+    info << "  message: #{@expected_event.message.inspect}"
+    info << "  exception: #{@expected_exception.inspect}"
+    info << "  context: #{@context.inspect}"
+    info << "  tags: #{@tags.inspect}"
+    info << "\n"
+    info << "Captured events:\n"
+    info << dump_events(sentry_events)
+    info.join("\n")
+  end
+
+  def expected_event(event_message)
+    if @expected_exception
+      Sentry.get_current_client.event_from_exception(@expected_exception)
+    else
+      Sentry.get_current_client.event_from_message(event_message)
+    end
+  end
+
+  def expected_exception(**opts)
+    opts[:exception].new(opts[:message]) if opts[:exception]
+  end
+
+  def context(**opts)
+    opts.fetch(:context, @context || {})
+  end
+
+  def tags(**opts)
+    opts.fetch(:tags, @tags || {})
+  end
+
+  def find_matched_event(event_message, sentry_events)
+    @matched_event ||= sentry_events
+      .find { |event|
+        if @expected_exception
+          # Is it OK that we only compare the first exception?
+          event_exception = event.exception.values.first
+          expected_event_exception = @expected_event.exception.values.first
+
+          event_exception.type == expected_event_exception.type && event_exception.value == expected_event_exception.value
+        else
+          event.message == @expected_event.message
+        end
+      }
+  end
+
+  def dump_events(sentry_events)
+    sentry_events.map(&Kernel.method(:Hash)).map do |hash|
+      hash.select { |k, _| [:message, :contexts, :tags, :exception].include?(k) }
+    end.map do |hash|
+      JSON.pretty_generate(hash)
+    end.join("\n\n")
+  end
+
+  def verify_context
+    return true if @context.empty?
+
+    @matched_event.contexts.any? { |key, value| value == @context[key] }
+  end
+
+  def verify_tags
+    return true if @tags.empty?
+
+    @tags.all? { |key, value| @matched_event.tags.include?(key) && @matched_event.tags[key] == value }
+  end
+end

data/lib/sentry/scope.rb

@@ -2,6 +2,7 @@
 
 require "sentry/breadcrumb_buffer"
 require "sentry/propagation_context"
+require "sentry/attachment"
 require "etc"
 
 module Sentry
@@ -22,6 +23,7 @@ module Sentry
       :rack_env,
       :span,
       :session,
+      :attachments,
       :propagation_context
     ]
 
@@ -44,7 +46,7 @@ module Sentry
     # @param hint [Hash] the hint data that'll be passed to event processors.
     # @return [Event]
     def apply_to_event(event, hint = nil)
-      unless event.is_a?(CheckInEvent)
+      unless event.is_a?(CheckInEvent) || event.is_a?(LogEvent)
         event.tags = tags.merge(event.tags)
         event.user = user.merge(event.user)
         event.extra = extra.merge(event.extra)
@@ -55,13 +57,25 @@ module Sentry
         event.level = level
         event.breadcrumbs = breadcrumbs
         event.rack_env = rack_env if rack_env
+        event.attachments = attachments
+      end
+
+      if event.is_a?(LogEvent)
+        event.user = user.merge(event.user)
       end
 
       if span
         event.contexts[:trace] ||= span.get_trace_context
+
+        if event.respond_to?(:dynamic_sampling_context)
+          event.dynamic_sampling_context ||= span.get_dynamic_sampling_context
+        end
       else
         event.contexts[:trace] ||= propagation_context.get_trace_context
-        event.dynamic_sampling_context ||= propagation_context.get_dynamic_sampling_context
+
+        if event.respond_to?(:dynamic_sampling_context)
+          event.dynamic_sampling_context ||= propagation_context.get_dynamic_sampling_context
+        end
       end
 
       all_event_processors = self.class.global_event_processors + @event_processors
@@ -102,6 +116,7 @@ module Sentry
       copy.span = span.deep_dup
       copy.session = session.deep_dup
       copy.propagation_context = propagation_context.deep_dup
+      copy.attachments = attachments.dup
       copy
     end
 
@@ -119,6 +134,7 @@ module Sentry
       self.fingerprint = scope.fingerprint
       self.span = scope.span
       self.propagation_context = scope.propagation_context
+      self.attachments = scope.attachments
     end
 
     # Updates the scope's data from the given options.
@@ -128,6 +144,7 @@ module Sentry
     # @param user [Hash]
     # @param level [String, Symbol]
     # @param fingerprint [Array]
+    # @param attachments [Array<Attachment>]
     # @return [Array]
     def update_from_options(
       contexts: nil,
@@ -136,6 +153,7 @@ module Sentry
       user: nil,
       level: nil,
       fingerprint: nil,
+      attachments: nil,
       **options
     )
       self.contexts.merge!(contexts) if contexts
@@ -283,6 +301,12 @@ module Sentry
       @propagation_context = PropagationContext.new(self, env)
     end
 
+    # Add a new attachment to the scope.
+    def add_attachment(**opts)
+      attachments << (attachment = Attachment.new(**opts))
+      attachment
+    end
+
     protected
 
     # for duplicating scopes internally
@@ -303,6 +327,7 @@ module Sentry
       @rack_env = {}
       @span = nil
       @session = nil
+      @attachments = []
       generate_propagation_context
       set_new_breadcrumb_buffer
     end

data/lib/sentry/session_flusher.rb

@@ -5,11 +5,12 @@ module Sentry
     FLUSH_INTERVAL = 60
 
     def initialize(configuration, client)
-      super(configuration.logger, FLUSH_INTERVAL)
+      super(configuration.sdk_logger, FLUSH_INTERVAL)
       @client = client
       @pending_aggregates = {}
       @release = configuration.release
       @environment = configuration.environment
+      @mutex = Mutex.new
 
       log_debug("[Sessions] Sessions won't be captured without a valid release") unless @release
     end
@@ -18,7 +19,6 @@ module Sentry
       return if @pending_aggregates.empty?
 
       @client.capture_envelope(pending_envelope)
-      @pending_aggregates = {}
     end
 
     alias_method :run, :flush
@@ -42,11 +42,15 @@ module Sentry
     end
 
     def pending_envelope
-      envelope = Envelope.new
-
-      header = { type: 'sessions' }
-      payload = { attrs: attrs, aggregates: @pending_aggregates.values }
+      aggregates = @mutex.synchronize do
+        aggregates = @pending_aggregates.values
+        @pending_aggregates = {}
+        aggregates
+      end
 
+      envelope = Envelope.new
+      header = { type: "sessions" }
+      payload = { attrs: attrs, aggregates: aggregates }
       envelope.add_item(header, payload)
       envelope
     end

data/lib/sentry/span.rb

@@ -2,6 +2,7 @@
 
 require "securerandom"
 require "sentry/metrics/local_aggregator"
+require "sentry/utils/uuid"
 
 module Sentry
   class Span
@@ -44,6 +45,11 @@ module Sentry
       LINENO = "code.lineno"
       FUNCTION = "code.function"
       NAMESPACE = "code.namespace"
+
+      MESSAGING_MESSAGE_ID = "messaging.message.id"
+      MESSAGING_DESTINATION_NAME = "messaging.destination.name"
+      MESSAGING_MESSAGE_RECEIVE_LATENCY = "messaging.message.receive.latency"
+      MESSAGING_MESSAGE_RETRY_COUNT = "messaging.message.retry.count"
     end
 
     STATUS_MAP = {
@@ -122,8 +128,8 @@ module Sentry
       timestamp: nil,
       origin: nil
     )
-      @trace_id = trace_id || SecureRandom.uuid.delete("-")
-      @span_id = span_id || SecureRandom.uuid.delete("-").slice(0, 16)
+      @trace_id = trace_id || Utils.uuid
+      @span_id = span_id || Utils.uuid.slice(0, 16)
       @parent_span_id = parent_span_id
       @sampled = sampled
       @start_timestamp = start_timestamp || Sentry.utc_now.to_f
@@ -160,6 +166,12 @@ module Sentry
       transaction.get_baggage&.serialize
     end
 
+    # Returns the Dynamic Sampling Context from the transaction baggage.
+    # @return [Hash, nil]
+    def get_dynamic_sampling_context
+      transaction.get_baggage&.dynamic_sampling_context
+    end
+
     # @return [Hash]
     def to_hash
       hash = {
@@ -192,7 +204,8 @@ module Sentry
         description: @description,
         op: @op,
         status: @status,
-        origin: @origin
+        origin: @origin,
+        data: @data
       }
     end
 
@@ -249,7 +262,7 @@ module Sentry
 
 
     # Sets the span's status.
-    # @param satus [String] status of the span.
+    # @param status [String] status of the span.
     def set_status(status)
       @status = status
     end