sentry-ruby-core 4.4.2 → 5.0.0

data/lib/sentry/net/http.rb

@@ -1,73 +1,89 @@
+# frozen_string_literal: true
+
 require "net/http"
 
 module Sentry
+  # @api private
   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 we're only instrumenting request when `Net::HTTP` is already started
       def request(req, body = nil, &block)
+        return super unless started?
+
+        sentry_span = start_sentry_span
+        set_sentry_trace_header(req, sentry_span)
+
         super.tap do |res|
           record_sentry_breadcrumb(req, res)
-          record_sentry_span(req, res)
+          record_sentry_span(req, res, sentry_span)
         end
       end
 
-      def do_start
-        super.tap do
-          start_sentry_span
-        end
-      end
+      private
 
-      def do_finish
-        super.tap do
-          finish_sentry_span
-        end
-      end
+      def set_sentry_trace_header(req, sentry_span)
+        return unless sentry_span
 
-      private
+        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
+        return unless 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: {
+            status: res.code.to_i,
+            **request_info
+          }
+        )
+        Sentry.add_breadcrumb(crumb)
       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
+      def record_sentry_span(req, res, sentry_span)
+        return unless 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)
+        finish_sentry_span(sentry_span)
       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
+        return unless 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
+        transaction.start_child(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f)
       end
 
-      def finish_sentry_span
-        if Sentry.initialized? && @sentry_span
-          @sentry_span.set_timestamp(Sentry.utc_now.to_f)
-          @sentry_span = nil
-        end
+      def finish_sentry_span(sentry_span)
+        return unless Sentry.initialized? && sentry_span
+
+        sentry_span.set_timestamp(Sentry.utc_now.to_f)
       end
 
       def from_sentry_sdk?
@@ -76,9 +92,17 @@ module Sentry
       end
 
       def extract_request_info(req)
-        uri = req.uri
+        uri = req.uri || URI.parse("#{use_ssl? ? 'https' : 'http'}://#{address}#{req.path}")
         url = "#{uri.scheme}://#{uri.host}#{uri.path}" rescue uri.to_s
-        { method: req.method, url: url }
+
+        result = { method: req.method, url: url }
+
+        if Sentry.configuration.send_default_pii
+          result[:url] = result[:url] + "?#{uri.query}"
+          result[:body] = req.body
+        end
+
+        result
       end
     end
   end

data/lib/sentry/rack/capture_exceptions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sentry
   module Rack
     class CaptureExceptions

data/lib/sentry/rack.rb

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

data/lib/sentry/rake.rb

@@ -1,17 +1,41 @@
+# frozen_string_literal: true
+
 require "rake"
 require "rake/task"
 
+module Sentry
+  module Rake
+    module Application
+      # @api private
+      def display_error_message(ex)
+        Sentry.capture_exception(ex) do |scope|
+          task_name = top_level_tasks.join(' ')
+          scope.set_transaction_name(task_name)
+          scope.set_tag("rake_task", task_name)
+        end if Sentry.initialized? && !Sentry.configuration.skip_rake_integration
+
+        super
+      end
+    end
+
+    module Task
+      # @api private
+      def execute(args=nil)
+        return super unless Sentry.initialized? && Sentry.get_current_hub
+
+        super
+      end
+    end
+  end
+end
+
+# @api private
 module Rake
   class Application
-    alias orig_display_error_messsage display_error_message
-    def display_error_message(ex)
-      Sentry.capture_exception(ex, hint: { background: false }) do |scope|
-        task_name = top_level_tasks.join(' ')
-        scope.set_transaction_name(task_name)
-        scope.set_tag("rake_task", task_name)
-      end if Sentry.initialized?
+    prepend(Sentry::Rake::Application)
+  end
 
-      orig_display_error_messsage(ex)
-    end
+  class Task
+    prepend(Sentry::Rake::Task)
   end
 end

data/lib/sentry/release_detector.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class ReleaseDetector
+    class << self
+      def detect_release(project_root:, running_on_heroku:)
+        detect_release_from_env ||
+        detect_release_from_git ||
+        detect_release_from_capistrano(project_root) ||
+        detect_release_from_heroku(running_on_heroku)
+      end
+
+      def detect_release_from_heroku(running_on_heroku)
+        return unless running_on_heroku
+        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')
+
+        if File.exist?(revision_file)
+          File.read(revision_file).strip
+        elsif File.exist?(revision_log)
+          File.open(revision_log).to_a.last.strip.sub(/.*as release ([0-9]+).*/, '\1')
+        end
+      end
+
+      def detect_release_from_git
+        Sentry.sys_command("git rev-parse --short HEAD") if File.directory?(".git")
+      end
+
+      def detect_release_from_env
+        ENV['SENTRY_RELEASE']
+      end
+    end
+  end
+end

data/lib/sentry/scope.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sentry/breadcrumb_buffer"
 require "etc"
 
@@ -9,20 +11,28 @@ module Sentry
 
     attr_reader(*ATTRIBUTES)
 
+    # @param max_breadcrumbs [Integer] the maximum number of breadcrumbs to be stored in the scope.
     def initialize(max_breadcrumbs: nil)
       @max_breadcrumbs = max_breadcrumbs
       set_default_value
     end
 
+    # Resets the scope's attributes to defaults.
+    # @return [void]
     def clear
       set_default_value
     end
 
+    # Applies stored attributes and event processors to the given event.
+    # @param event [Event]
+    # @param hint [Hash] the hint data that'll be passed to event processors.
+    # @return [Event]
     def apply_to_event(event, hint = nil)
       event.tags = tags.merge(event.tags)
       event.user = user.merge(event.user)
       event.extra = extra.merge(event.extra)
       event.contexts = contexts.merge(event.contexts)
+      event.transaction = transaction_name if transaction_name
 
       if span
         event.contexts[:trace] = span.get_trace_context
@@ -30,7 +40,6 @@ module Sentry
 
       event.fingerprint = fingerprint
       event.level = level
-      event.transaction = transaction_names.last
       event.breadcrumbs = breadcrumbs
       event.rack_env = rack_env if rack_env
 
@@ -43,14 +52,20 @@ module Sentry
       event
     end
 
+    # Adds the breadcrumb to the scope's breadcrumbs buffer.
+    # @param breadcrumb [Breadcrumb]
+    # @return [void]
     def add_breadcrumb(breadcrumb)
       breadcrumbs.record(breadcrumb)
     end
 
+    # Clears the scope's breadcrumbs buffer
+    # @return [void]
     def clear_breadcrumbs
       set_new_breadcrumb_buffer
     end
 
+    # @return [Scope]
     def dup
       copy = super
       copy.breadcrumbs = breadcrumbs.dup
@@ -64,6 +79,9 @@ module Sentry
       copy
     end
 
+    # Updates the scope's data from a given scope.
+    # @param scope [Scope]
+    # @return [void]
     def update_from_scope(scope)
       self.breadcrumbs = scope.breadcrumbs
       self.contexts = scope.contexts
@@ -75,6 +93,14 @@ module Sentry
       self.span = scope.span
     end
 
+    # Updates the scope's data from the given options.
+    # @param contexts [Hash]
+    # @param extras [Hash]
+    # @param tags [Hash]
+    # @param user [Hash]
+    # @param level [String, Symbol]
+    # @param fingerprint [Array]
+    # @return [void]
     def update_from_options(
       contexts: nil,
       extra: nil,
@@ -91,75 +117,118 @@ module Sentry
       self.fingerprint = fingerprint if fingerprint
     end
 
+    # Sets the scope's rack_env attribute.
+    # @param env [Hash]
+    # @return [Hash]
     def set_rack_env(env)
       env = env || {}
       @rack_env = env
     end
 
+    # Sets the scope's span attribute.
+    # @param span [Span]
+    # @return [Span]
     def set_span(span)
       check_argument_type!(span, Span)
       @span = span
     end
 
+    # @!macro set_user
     def set_user(user_hash)
       check_argument_type!(user_hash, Hash)
       @user = user_hash
     end
 
+    # @!macro set_extras
     def set_extras(extras_hash)
       check_argument_type!(extras_hash, Hash)
       @extra.merge!(extras_hash)
     end
 
+    # Adds a new key-value pair to current extras.
+    # @param key [String, Symbol]
+    # @param value [Object]
+    # @return [Hash]
     def set_extra(key, value)
-      @extra.merge!(key => value)
+      set_extras(key => value)
     end
 
+    # @!macro set_tags
     def set_tags(tags_hash)
       check_argument_type!(tags_hash, Hash)
       @tags.merge!(tags_hash)
     end
 
+    # Adds a new key-value pair to current tags.
+    # @param key [String, Symbol]
+    # @param value [Object]
+    # @return [Hash]
     def set_tag(key, value)
-      @tags.merge!(key => value)
+      set_tags(key => value)
     end
 
+    # Updates the scope's contexts attribute by merging with the old value.
+    # @param contexts [Hash]
+    # @return [Hash]
     def set_contexts(contexts_hash)
       check_argument_type!(contexts_hash, Hash)
-      @contexts.merge!(contexts_hash)
+      @contexts.merge!(contexts_hash) do |key, old, new|
+        new.merge(old)
+      end
     end
 
+    # @!macro set_context
     def set_context(key, value)
       check_argument_type!(value, Hash)
-      @contexts.merge!(key => value)
+      set_contexts(key => value)
     end
 
+    # Sets the scope's level attribute.
+    # @param level [String, Symbol]
+    # @return [void]
     def set_level(level)
       @level = level
     end
 
+    # Appends a new transaction name to the scope.
+    # The "transaction" here does not refer to `Transaction` objects.
+    # @param transaction_name [String]
+    # @return [void]
     def set_transaction_name(transaction_name)
       @transaction_names << transaction_name
     end
 
+    # Returns current transaction name.
+    # The "transaction" here does not refer to `Transaction` objects.
+    # @return [String, nil]
     def transaction_name
       @transaction_names.last
     end
 
+    # Returns the associated Transaction object.
+    # @return [Transaction, nil]
     def get_transaction
       span.transaction if span
     end
 
+    # Returns the associated Span object.
+    # @return [Span, nil]
     def get_span
       span
     end
 
+    # Sets the scope's fingerprint attribute.
+    # @param fingerprint [Array]
+    # @return [Array]
     def set_fingerprint(fingerprint)
       check_argument_type!(fingerprint, Array)
 
       @fingerprint = fingerprint
     end
 
+    # Adds a new event processor [Proc] to the scope.
+    # @param block [Proc]
+    # @return [void]
     def add_event_processor(&block)
       @event_processors << block
     end
@@ -189,8 +258,8 @@ module Sentry
       @breadcrumbs = BreadcrumbBuffer.new(@max_breadcrumbs)
     end
 
-
     class << self
+      # @return [Hash]
       def os_context
         @os_context ||=
           begin
@@ -204,6 +273,7 @@ module Sentry
           end
       end
 
+      # @return [Hash]
       def runtime_context
         @runtime_context ||= {
           name: RbConfig::CONFIG["ruby_install_name"],

data/lib/sentry/span.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "securerandom"
 
 module Sentry
@@ -17,9 +18,49 @@ module Sentry
       504 => "deadline_exceeded"
     }
 
-
-    attr_reader :trace_id, :span_id, :parent_span_id, :sampled, :start_timestamp, :timestamp, :description, :op, :status, :tags, :data
-    attr_accessor :span_recorder, :transaction
+    # An uuid that can be used to identify a trace.
+    # @return [String]
+    attr_reader :trace_id
+    # An uuid that can be used to identify the span.
+    # @return [String]
+    attr_reader :span_id
+    # Span parent's span_id.
+    # @return [String]
+    attr_reader :parent_span_id
+    # Sampling result of the span.
+    # @return [Boolean, nil]
+    attr_reader :sampled
+    # Starting timestamp of the span.
+    # @return [Float]
+    attr_reader :start_timestamp
+    # Finishing timestamp of the span.
+    # @return [Float]
+    attr_reader :timestamp
+    # Span description
+    # @return [String]
+    attr_reader :description
+    # Span operation
+    # @return [String]
+    attr_reader :op
+    # Span status
+    # @return [String]
+    attr_reader :status
+    # Span tags
+    # @return [Hash]
+    attr_reader :tags
+    # Span data
+    # @return [Hash]
+    attr_reader :data
+
+    # The SpanRecorder the current span belongs to.
+    # SpanRecorder holds all spans under the same Transaction object (including the Transaction itself).
+    # @return [SpanRecorder]
+    attr_accessor :span_recorder
+
+    # The Transaction object the Span belongs to.
+    # Every span needs to be attached to a Transaction and their child spans will also inherit the same transaction.
+    # @return [Transaction]
+    attr_accessor :transaction
 
     def initialize(
       description: nil,
@@ -44,6 +85,8 @@ module Sentry
       @tags = {}
     end
 
+    # Finishes the span by adding a timestamp.
+    # @return [self]
     def finish
       # already finished
       return if @timestamp
@@ -52,6 +95,8 @@ module Sentry
       self
     end
 
+    # Generates a trace string that can be used to connect other transactions.
+    # @return [String]
     def to_sentry_trace
       sampled_flag = ""
       sampled_flag = @sampled ? 1 : 0 unless @sampled.nil?
@@ -59,6 +104,7 @@ module Sentry
       "#{@trace_id}-#{@span_id}-#{sampled_flag}"
     end
 
+    # @return [Hash]
     def to_hash
       {
         trace_id: @trace_id,
@@ -74,6 +120,8 @@ module Sentry
       }
     end
 
+    # Returns the span's context that can be used to embed in an Event.
+    # @return [Hash]
     def get_trace_context
       {
         trace_id: @trace_id,
@@ -85,9 +133,11 @@ module Sentry
       }
     end
 
-    def start_child(**options)
-      options = options.dup.merge(trace_id: @trace_id, parent_span_id: @span_id, sampled: @sampled)
-      new_span = Span.new(**options)
+    # Starts a child span with given attributes.
+    # @param attributes [Hash] the attributes for the child span.
+    def start_child(**attributes)
+      attributes = attributes.dup.merge(trace_id: @trace_id, parent_span_id: @span_id, sampled: @sampled)
+      new_span = Span.new(**attributes)
       new_span.transaction = transaction
       new_span.span_recorder = span_recorder
 
@@ -98,8 +148,17 @@ module Sentry
       new_span
     end
 
-    def with_child_span(**options, &block)
-      child_span = start_child(**options)
+    # Starts a child span, yield it to the given block, and then finish the span after the block is executed.
+    # @example
+    #   span.with_child_span do |child_span|
+    #     # things happen here will be recorded in a child span
+    #   end
+    #
+    # @param attributes [Hash] the attributes for the child span.
+    # @param block [Proc] the action to be recorded in the child span.
+    # @yieldparam child_span [Span]
+    def with_child_span(**attributes, &block)
+      child_span = start_child(**attributes)
 
       yield(child_span)
 
@@ -110,22 +169,33 @@ module Sentry
       dup
     end
 
+    # Sets the span's operation.
+    # @param op [String] operation of the span.
     def set_op(op)
       @op = op
     end
 
+    # Sets the span's description.
+    # @param description [String] description of the span.
     def set_description(description)
       @description = description
     end
 
+
+    # Sets the span's status.
+    # @param satus [String] status of the span.
     def set_status(status)
       @status = status
     end
 
+    # Sets the span's finish timestamp.
+    # @param timestamp [Float] finished time in float format (most precise).
     def set_timestamp(timestamp)
       @timestamp = timestamp
     end
 
+    # Sets the span's status with given http status code.
+    # @param status_code [String] example: "500".
     def set_http_status(status_code)
       status_code = status_code.to_i
       set_data("status_code", status_code)
@@ -139,10 +209,16 @@ module Sentry
       set_status(status)
     end
 
+    # Inserts a key-value pair to the span's data payload.
+    # @param key [String, Symbol]
+    # @param value [Object]
     def set_data(key, value)
       @data[key] = value
     end
 
+    # Sets a tag to the span.
+    # @param key [String, Symbol]
+    # @param value [String]
     def set_tag(key, value)
       @tags[key] = value
     end