sentry-ruby-core 4.2.1 → 4.4.0.pre.beta.0

data/lib/sentry/interfaces/single_exception.rb

@@ -1,14 +1,26 @@
 module Sentry
   class SingleExceptionInterface < Interface
-    attr_accessor :type
-    attr_accessor :value
-    attr_accessor :module
-    attr_accessor :stacktrace
+    attr_reader :type, :value, :module, :thread_id, :stacktrace
+
+    def initialize(exception:, stacktrace: nil)
+      @type = exception.class.to_s
+      @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
+    end
 
     def to_hash
       data = super
       data[:stacktrace] = data[:stacktrace].to_hash if data[:stacktrace]
       data
     end
+
+    # patch this method if you want to change an exception's stacktrace frames
+    # also see `StacktraceBuilder.build`.
+    def self.build_with_stacktrace(exception:, stacktrace_builder:)
+      stacktrace = stacktrace_builder.build(backtrace: exception.backtrace)
+      new(exception: exception, stacktrace: stacktrace)
+    end
   end
 end

data/lib/sentry/interfaces/stacktrace.rb

@@ -2,18 +2,8 @@ module Sentry
   class StacktraceInterface
     attr_reader :frames
 
-    def initialize(backtrace:, project_root:, app_dirs_pattern:, linecache:, context_lines:, backtrace_cleanup_callback: nil)
-      @project_root = project_root
-      @frames = []
-
-      parsed_backtrace_lines = Backtrace.parse(
-        backtrace, project_root, app_dirs_pattern, &backtrace_cleanup_callback
-      ).lines
-
-      parsed_backtrace_lines.reverse.each_with_object(@frames) do |line, frames|
-        frame = convert_parsed_line_into_frame(line, project_root, linecache, context_lines)
-        frames << frame if frame.filename
-      end
+    def initialize(frames:)
+      @frames = frames
     end
 
     def to_hash
@@ -22,30 +12,24 @@ module Sentry
 
     private
 
-    def convert_parsed_line_into_frame(line, project_root, linecache, context_lines)
-      frame = StacktraceInterface::Frame.new(@project_root, line)
-      frame.set_context(linecache, context_lines) if context_lines
-      frame
-    end
-
     # Not actually an interface, but I want to use the same style
     class Frame < Interface
-      attr_accessor :abs_path, :context_line, :function, :in_app,
-                    :lineno, :module, :pre_context, :post_context, :vars
+      attr_accessor :abs_path, :context_line, :function, :in_app, :filename,
+                  :lineno, :module, :pre_context, :post_context, :vars
 
       def initialize(project_root, line)
         @project_root = project_root
 
-        @abs_path = line.file if line.file
+        @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
       end
 
-      def filename
+      def compute_filename
         return if abs_path.nil?
-        return @filename if instance_variable_defined?(:@filename)
 
         prefix =
           if under_project_root? && in_app
@@ -56,19 +40,18 @@ module Sentry
             longest_load_path
           end
 
-        @filename = prefix ? abs_path[prefix.to_s.chomp(File::SEPARATOR).length + 1..-1] : abs_path
+        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
 
-        self.pre_context, self.context_line, self.post_context = \
+        @pre_context, @context_line, @post_context = \
             linecache.get_file_context(abs_path, lineno, context_lines)
       end
 
       def to_hash(*args)
         data = super(*args)
-        data[:filename] = filename
         data.delete(:vars) unless vars && !vars.empty?
         data.delete(:pre_context) unless pre_context && !pre_context.empty?
         data.delete(:post_context) unless post_context && !post_context.empty?

data/lib/sentry/interfaces/stacktrace_builder.rb

@@ -0,0 +1,50 @@
+module Sentry
+  class StacktraceBuilder
+    attr_reader :project_root, :app_dirs_pattern, :linecache, :context_lines, :backtrace_cleanup_callback
+
+    def initialize(project_root:, app_dirs_pattern:, linecache:, context_lines:, backtrace_cleanup_callback: nil)
+      @project_root = project_root
+      @app_dirs_pattern = app_dirs_pattern
+      @linecache = linecache
+      @context_lines = context_lines
+      @backtrace_cleanup_callback = backtrace_cleanup_callback
+    end
+
+    # you can pass a block to customize/exclude frames:
+    #
+    # ```ruby
+    # builder.build(backtrace) do |frame|
+    #   if frame.module.match?(/a_gem/)
+    #     nil
+    #   else
+    #     frame
+    #   end
+    # end
+    # ```
+    def build(backtrace:, &frame_callback)
+      parsed_lines = parse_backtrace_lines(backtrace).select(&: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
+
+      StacktraceInterface.new(frames: frames)
+    end
+
+    private
+
+    def convert_parsed_line_into_frame(line)
+      frame = StacktraceInterface::Frame.new(project_root, line)
+      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
+      ).lines
+    end
+  end
+end

data/lib/sentry/interfaces/threads.rb

@@ -1,12 +1,11 @@
 module Sentry
   class ThreadsInterface
-    attr_accessor :stacktrace
-
-    def initialize(crashed: false)
+    def initialize(crashed: false, stacktrace: nil)
       @id = Thread.current.object_id
       @name = Thread.current.name
       @current = true
       @crashed = crashed
+      @stacktrace = stacktrace
     end
 
     def to_hash
@@ -22,5 +21,12 @@ module Sentry
         ]
       }
     end
+
+    # patch this method if you want to change a threads interface's stacktrace frames
+    # also see `StacktraceBuilder.build`.
+    def self.build(backtrace:, stacktrace_builder:, **options)
+      stacktrace = stacktrace_builder.build(backtrace: backtrace) if backtrace
+      new(**options, stacktrace: stacktrace)
+    end
   end
 end

data/lib/sentry/net/http.rb

@@ -0,0 +1,87 @@
+require "net/http"
+
+module Sentry
+  module Net
+    module HTTP
+      OP_NAME = "net.http"
+
+      def request(req, body = nil, &block)
+        super.tap do |res|
+          record_sentry_breadcrumb(req, res)
+          record_sentry_span(req, res)
+        end
+      end
+
+      def do_start
+        super.tap do
+          start_sentry_span
+        end
+      end
+
+      def do_finish
+        super.tap do
+          finish_sentry_span
+        end
+      end
+
+      private
+
+      def record_sentry_breadcrumb(req, res)
+        if Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
+          return if from_sentry_sdk?
+
+          request_info = extract_request_info(req)
+          crumb = Sentry::Breadcrumb.new(
+            level: :info,
+            category: OP_NAME,
+            type: :info,
+            data: {
+              method: request_info[:method],
+              url: request_info[:url],
+              status: res.code.to_i
+            }
+          )
+          Sentry.add_breadcrumb(crumb)
+        end
+      end
+
+      def record_sentry_span(req, res)
+        if 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)
+        end
+      end
+
+      def start_sentry_span
+        if Sentry.initialized? && transaction = Sentry.get_current_scope.get_transaction
+          return if from_sentry_sdk?
+          return if transaction.sampled == false
+
+          child_span = transaction.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
+          @sentry_span = child_span
+        end
+      end
+
+      def finish_sentry_span
+        if Sentry.initialized? && @sentry_span
+          @sentry_span.set_timestamp(Sentry.utc_now.to_f)
+          @sentry_span = nil
+        end
+      end
+
+      def from_sentry_sdk?
+        dsn_host = Sentry.configuration.dsn.host
+        dsn_host == self.address
+      end
+
+      def extract_request_info(req)
+        uri = req.uri
+        url = "#{uri.scheme}://#{uri.host}#{uri.path}" rescue uri.to_s
+        { method: req.method, url: url }
+      end
+    end
+  end
+end
+
+Net::HTTP.send(:prepend, Sentry::Net::HTTP)

data/lib/sentry/rack/capture_exceptions.rb

@@ -16,27 +16,24 @@ module Sentry
           scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
           scope.set_rack_env(env)
 
-          sentry_trace = env["HTTP_SENTRY_TRACE"]
-          span = Sentry::Transaction.from_sentry_trace(sentry_trace, name: scope.transaction_name, op: transaction_op) if sentry_trace
-          span ||= Sentry.start_transaction(name: scope.transaction_name, op: transaction_op)
-
-          scope.set_span(span)
+          transaction = start_transaction(env, scope)
+          scope.set_span(transaction) if transaction
 
           begin
             response = @app.call(env)
           rescue Sentry::Error
-            finish_span(span, 500)
+            finish_transaction(transaction, 500)
             raise # Don't capture Sentry errors
           rescue Exception => e
             capture_exception(e)
-            finish_span(span, 500)
+            finish_transaction(transaction, 500)
             raise
           end
 
           exception = collect_exception(env)
           capture_exception(exception) if exception
 
-          finish_span(span, response[0])
+          finish_transaction(transaction, response[0])
 
           response
         end
@@ -56,9 +53,19 @@ module Sentry
         Sentry.capture_exception(exception)
       end
 
-      def finish_span(span, status_code)
-        span.set_http_status(status_code)
-        span.finish
+      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
+        Sentry.start_transaction(transaction: transaction, **options)
+      end
+
+
+      def finish_transaction(transaction, status_code)
+        return unless transaction
+
+        transaction.set_http_status(status_code)
+        transaction.finish
       end
     end
   end

data/lib/sentry/scope.rb

@@ -9,7 +9,8 @@ module Sentry
 
     attr_reader(*ATTRIBUTES)
 
-    def initialize
+    def initialize(max_breadcrumbs: nil)
+      @max_breadcrumbs = max_breadcrumbs
       set_default_value
     end
 
@@ -47,7 +48,7 @@ module Sentry
     end
 
     def clear_breadcrumbs
-      @breadcrumbs = BreadcrumbBuffer.new
+      set_new_breadcrumb_buffer
     end
 
     def dup
@@ -125,10 +126,11 @@ module Sentry
 
     def set_contexts(contexts_hash)
       check_argument_type!(contexts_hash, Hash)
-      @contexts = contexts_hash
+      @contexts.merge!(contexts_hash)
     end
 
     def set_context(key, value)
+      check_argument_type!(value, Hash)
       @contexts.merge!(key => value)
     end
 
@@ -145,8 +147,7 @@ module Sentry
     end
 
     def get_transaction
-      # transaction will always be the first in the span_recorder
-      span.span_recorder.spans.first if span
+      span.transaction if span
     end
 
     def get_span
@@ -171,7 +172,6 @@ module Sentry
     private
 
     def set_default_value
-      @breadcrumbs = BreadcrumbBuffer.new
       @contexts = { :os => self.class.os_context, :runtime => self.class.runtime_context }
       @extra = {}
       @tags = {}
@@ -182,8 +182,14 @@ module Sentry
       @event_processors = []
       @rack_env = {}
       @span = nil
+      set_new_breadcrumb_buffer
     end
 
+    def set_new_breadcrumb_buffer
+      @breadcrumbs = BreadcrumbBuffer.new(@max_breadcrumbs)
+    end
+
+
     class << self
       def os_context
         @os_context ||=

data/lib/sentry/span.rb

@@ -19,9 +19,18 @@ module Sentry
 
 
     attr_reader :trace_id, :span_id, :parent_span_id, :sampled, :start_timestamp, :timestamp, :description, :op, :status, :tags, :data
-    attr_accessor :span_recorder
-
-    def initialize(description: nil, op: nil, status: nil, trace_id: nil, parent_span_id: nil, sampled: nil, start_timestamp: nil, timestamp: nil)
+    attr_accessor :span_recorder, :transaction
+
+    def initialize(
+      description: nil,
+      op: nil,
+      status: nil,
+      trace_id: nil,
+      parent_span_id: nil,
+      sampled: nil,
+      start_timestamp: nil,
+      timestamp: nil
+    )
       @trace_id = trace_id || SecureRandom.uuid.delete("-")
       @span_id = SecureRandom.hex(8)
       @parent_span_id = parent_span_id
@@ -78,7 +87,15 @@ module Sentry
 
     def start_child(**options)
       options = options.dup.merge(trace_id: @trace_id, parent_span_id: @span_id, sampled: @sampled)
-      Span.new(**options)
+      new_span = Span.new(**options)
+      new_span.transaction = transaction
+      new_span.span_recorder = span_recorder
+
+      if span_recorder
+        span_recorder.add(new_span)
+      end
+
+      new_span
     end
 
     def with_child_span(**options, &block)

data/lib/sentry/transaction.rb

@@ -10,31 +10,38 @@ module Sentry
     UNLABELD_NAME = "<unlabeled transaction>".freeze
     MESSAGE_PREFIX = "[Tracing]"
 
-    attr_reader :name, :parent_sampled
+    include LoggingHelper
 
-    def initialize(name: nil, parent_sampled: nil, **options)
+    attr_reader :name, :parent_sampled, :hub, :configuration, :logger
+
+    def initialize(name: nil, parent_sampled: nil, hub:, **options)
       super(**options)
 
       @name = name
       @parent_sampled = parent_sampled
-      set_span_recorder
-    end
-
-    def set_span_recorder
-      @span_recorder = SpanRecorder.new(1000)
-      @span_recorder.add(self)
+      @transaction = self
+      @hub = hub
+      @configuration = hub.configuration
+      @logger = configuration.logger
+      init_span_recorder
     end
 
-    def self.from_sentry_trace(sentry_trace, **options)
+    def self.from_sentry_trace(sentry_trace, hub: Sentry.get_current_hub, **options)
+      return unless hub.configuration.tracing_enabled?
       return unless sentry_trace
 
       match = SENTRY_TRACE_REGEXP.match(sentry_trace)
       return if match.nil?
       trace_id, parent_span_id, sampled_flag = match[1..3]
 
-      sampled = sampled_flag != "0"
+      parent_sampled =
+        if sampled_flag.nil?
+          nil
+        else
+          sampled_flag != "0"
+        end
 
-      new(trace_id: trace_id, parent_span_id: parent_span_id, parent_sampled: sampled, sampled: sampled, **options)
+      new(trace_id: trace_id, parent_span_id: parent_span_id, parent_sampled: parent_sampled, hub: hub, **options)
     end
 
     def to_hash
@@ -43,20 +50,9 @@ module Sentry
       hash
     end
 
-    def start_child(**options)
-      child_span = super
-      child_span.span_recorder = @span_recorder
-
-      if @sampled
-        @span_recorder.add(child_span)
-      end
-
-      child_span
-    end
-
     def deep_dup
       copy = super
-      copy.set_span_recorder
+      copy.init_span_recorder(@span_recorder.max_length)
 
       @span_recorder.spans.each do |span|
         # span_recorder's first span is the current span, which should not be added to the copy's spans
@@ -67,38 +63,36 @@ module Sentry
       copy
     end
 
-    def set_initial_sample_desicion(sampling_context = {})
-      unless Sentry.configuration.tracing_enabled?
+    def set_initial_sample_decision(sampling_context:)
+      unless configuration.tracing_enabled?
         @sampled = false
         return
       end
 
       return unless @sampled.nil?
 
-      transaction_description = generate_transaction_description
-
-      logger = Sentry.configuration.logger
-      sample_rate = Sentry.configuration.traces_sample_rate
-      traces_sampler = Sentry.configuration.traces_sampler
+      traces_sampler = configuration.traces_sampler
 
-      if traces_sampler.is_a?(Proc)
-        sampling_context = sampling_context.merge(
-          parent_sampled: @parent_sampled,
-          transaction_context: self.to_hash
-        )
+      sample_rate =
+        if traces_sampler.is_a?(Proc)
+          traces_sampler.call(sampling_context)
+        elsif !sampling_context[:parent_sampled].nil?
+          sampling_context[:parent_sampled]
+        else
+          configuration.traces_sample_rate
+        end
 
-        sample_rate = traces_sampler.call(sampling_context)
-      end
+      transaction_description = generate_transaction_description
 
       unless [true, false].include?(sample_rate) || (sample_rate.is_a?(Numeric) && sample_rate >= 0.0 && sample_rate <= 1.0)
         @sampled = false
-        logger.warn("#{MESSAGE_PREFIX} Discarding #{transaction_description} because of invalid sample_rate: #{sample_rate}")
+        log_warn("#{MESSAGE_PREFIX} Discarding #{transaction_description} because of invalid sample_rate: #{sample_rate}")
         return
       end
 
       if sample_rate == 0.0 || sample_rate == false
         @sampled = false
-        logger.debug("#{MESSAGE_PREFIX} Discarding #{transaction_description} because traces_sampler returned 0 or false")
+        log_debug("#{MESSAGE_PREFIX} Discarding #{transaction_description} because traces_sampler returned 0 or false")
         return
       end
 
@@ -109,15 +103,26 @@ module Sentry
       end
 
       if @sampled
-        logger.debug("#{MESSAGE_PREFIX} Starting #{transaction_description}")
+        log_debug("#{MESSAGE_PREFIX} Starting #{transaction_description}")
       else
-        logger.debug(
+        log_debug(
           "#{MESSAGE_PREFIX} Discarding #{transaction_description} because it's not included in the random sample (sampling rate = #{sample_rate})"
         )
       end
     end
 
     def finish(hub: nil)
+      if hub
+        log_warn(
+          <<~MSG
+            Specifying a different hub in `Transaction#finish` will be deprecated in version 5.0.
+            Please use `Hub#start_transaction` with the designated hub.
+          MSG
+        )
+      end
+
+      hub ||= @hub
+
       super() # Span#finish doesn't take arguments
 
       if @name.nil?
@@ -126,11 +131,17 @@ module Sentry
 
       return unless @sampled || @parent_sampled
 
-      hub ||= Sentry.get_current_hub
       event = hub.current_client.event_from_transaction(self)
       hub.capture_event(event)
     end
 
+    protected
+
+    def init_span_recorder(limit = 1000)
+      @span_recorder = SpanRecorder.new(limit)
+      @span_recorder.add(self)
+    end
+
     private
 
     def generate_transaction_description