sentry-ruby-core 4.1.6 → 4.5.1

data/lib/sentry/net/http.rb

@@ -0,0 +1,126 @@
+require "net/http"
+
+module Sentry
+  module Net
+    module HTTP
+      OP_NAME = "net.http"
+
+      # To explain how the entire thing works, we need to know how the original Net::HTTP#request works
+      # Here's part of its definition. As you can see, it usually calls itself inside a #start block
+      #
+      # ```
+      # def request(req, body = nil, &block)
+      #   unless started?
+      #     start {
+      #       req['connection'] ||= 'close'
+      #       return request(req, body, &block) # <- request will be called for the second time from the first call
+      #     }
+      #   end
+      #   # .....
+      # end
+      # ```
+      #
+      # So when the entire flow looks like this:
+      #
+      # 1. #request is called.
+      #   - But because the request hasn't started yet, it calls #start (which then calls #do_start)
+      #   - At this moment @sentry_span is still nil, so #set_sentry_trace_header returns early
+      # 2. #do_start then creates a new Span and assigns it to @sentry_span
+      # 3. #request is called for the second time.
+      #   - This time @sentry_span should present. So #set_sentry_trace_header will set the sentry-trace header on the request object
+      # 4. Once the request finished, it
+      #   - Records a breadcrumb if http_logger is set
+      #   - Finishes the Span inside @sentry_span and clears the instance variable
+      #
+      def request(req, body = nil, &block)
+        set_sentry_trace_header(req)
+
+        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 set_sentry_trace_header(req)
+        return unless @sentry_span
+
+        trace = Sentry.get_current_client.generate_sentry_trace(@sentry_span)
+        req[SENTRY_TRACE_HEADER_NAME] = trace if trace
+      end
+
+      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 = Sentry.configuration.dsn
+        dsn && 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
+
+Sentry.register_patch do
+  patch = Sentry::Net::HTTP
+  Net::HTTP.send(:prepend, patch) unless Net::HTTP.ancestors.include?(patch)
+end

data/lib/sentry/rack/capture_exceptions.rb

@@ -16,30 +16,24 @@ module Sentry
           scope.set_transaction_name(env["PATH_INFO"]) if env["PATH_INFO"]
           scope.set_rack_env(env)
 
-          span =
-            if sentry_trace = env["HTTP_SENTRY_TRACE"]
-              Sentry::Transaction.from_sentry_trace(sentry_trace, name: scope.transaction_name, op: transaction_op)
-            else
-              Sentry.start_transaction(name: scope.transaction_name, op: transaction_op)
-            end
-
-          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
@@ -59,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/rake.rb

@@ -9,7 +9,7 @@ module Rake
         task_name = top_level_tasks.join(' ')
         scope.set_transaction_name(task_name)
         scope.set_tag("rake_task", task_name)
-      end if Sentry.initialized?
+      end if Sentry.initialized? && !Sentry.configuration.skip_rake_integration
 
       orig_display_error_messsage(ex)
     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,30 +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, **options)
+      new(trace_id: trace_id, parent_span_id: parent_span_id, parent_sampled: parent_sampled, hub: hub, **options)
     end
 
     def to_hash
@@ -42,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
@@ -66,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?(Float) && sample_rate >= 0.0 && sample_rate <= 1.0)
+      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
 
@@ -108,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?
@@ -125,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