sentry-ruby 5.3.0 → 5.8.0

data/lib/sentry/interfaces/threads.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Sentry
+  class ThreadsInterface
+    # @param crashed [Boolean]
+    # @param stacktrace [Array]
+    def initialize(crashed: false, stacktrace: nil)
+      @id = Thread.current.object_id
+      @name = Thread.current.name
+      @current = true
+      @crashed = crashed
+      @stacktrace = stacktrace
+    end
+
+    # @return [Hash]
+    def to_hash
+      {
+        values: [
+          {
+            id: @id,
+            name: @name,
+            crashed: @crashed,
+            current: @current,
+            stacktrace: @stacktrace&.to_hash
+          }
+        ]
+      }
+    end
+
+    # Builds the ThreadsInterface with given backtrace and stacktrace_builder.
+    # Patch this method if you want to change a threads interface's stacktrace frames.
+    # @see StacktraceBuilder.build
+    # @param backtrace [Array]
+    # @param stacktrace_builder [StacktraceBuilder]
+    # @param crashed [Hash]
+    # @return [ThreadsInterface]
+    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/linecache.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class LineCache
+    def initialize
+      @cache = {}
+    end
+
+    # Any linecache you provide to Sentry must implement this method.
+    # Returns an Array of Strings representing the lines in the source
+    # 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 = Array.new(2 * context + 1) do |i|
+        getline(filename, lineno - context + i)
+      end
+      [lines[0..(context - 1)], lines[context], lines[(context + 1)..-1]]
+    end
+
+    private
+
+    def valid_path?(path)
+      lines = getlines(path)
+      !lines.nil?
+    end
+
+    def getlines(path)
+      @cache[path] ||= begin
+        IO.readlines(path)
+                       rescue
+                         nil
+      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/logger.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Sentry
+  class Logger < ::Logger
+    LOG_PREFIX = "** [Sentry] "
+    PROGNAME   = "sentry"
+
+    def initialize(*)
+      super
+      @level = ::Logger::INFO
+      original_formatter = ::Logger::Formatter.new
+      @default_formatter = proc do |severity, datetime, _progname, msg|
+        msg = "#{LOG_PREFIX}#{msg}"
+        original_formatter.call(severity, datetime, PROGNAME, msg)
+      end
+    end
+  end
+end

data/lib/sentry/net/http.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module Sentry
+  # @api private
+  module Net
+    module HTTP
+      OP_NAME = "http.client"
+      BREADCRUMB_CATEGORY = "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.initialized?
+        return super if from_sentry_sdk?
+
+        Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f) do |sentry_span|
+          set_sentry_trace_header(req, sentry_span)
+
+          super.tap do |res|
+            record_sentry_breadcrumb(req, res)
+
+            if 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
+        end
+      end
+
+      private
+
+      def set_sentry_trace_header(req, sentry_span)
+        return unless sentry_span
+
+        client = Sentry.get_current_client
+
+        trace = client.generate_sentry_trace(sentry_span)
+        req[SENTRY_TRACE_HEADER_NAME] = trace if trace
+
+        baggage = client.generate_baggage(sentry_span)
+        req[BAGGAGE_HEADER_NAME] = baggage if baggage && !baggage.empty?
+      end
+
+      def record_sentry_breadcrumb(req, res)
+        return unless Sentry.initialized? && Sentry.configuration.breadcrumbs_logger.include?(:http_logger)
+
+        request_info = extract_request_info(req)
+
+        crumb = Sentry::Breadcrumb.new(
+          level: :info,
+          category: BREADCRUMB_CATEGORY,
+          type: :info,
+          data: {
+            status: res.code.to_i,
+            **request_info
+          }
+        )
+        Sentry.add_breadcrumb(crumb)
+      end
+
+      def from_sentry_sdk?
+        dsn = Sentry.configuration.dsn
+        dsn && dsn.host == self.address
+      end
+
+      def extract_request_info(req)
+        uri = req.uri || URI.parse("#{use_ssl? ? 'https' : 'http'}://#{address}#{req.path}")
+        url = "#{uri.scheme}://#{uri.host}#{uri.path}" rescue uri.to_s
+
+        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
+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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Sentry
+  module Rack
+    class CaptureExceptions
+      ERROR_EVENT_ID_KEY = "sentry.error_event_id"
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless Sentry.initialized?
+
+        # make sure the current thread has a clean hub
+        Sentry.clone_hub_to_current_thread
+
+        Sentry.with_scope do |scope|
+          Sentry.with_session_tracking do
+            scope.clear_breadcrumbs
+            scope.set_transaction_name(env["PATH_INFO"], source: :url) if env["PATH_INFO"]
+            scope.set_rack_env(env)
+
+            transaction = start_transaction(env, scope)
+            scope.set_span(transaction) if transaction
+
+            begin
+              response = @app.call(env)
+            rescue Sentry::Error
+              finish_transaction(transaction, 500)
+              raise # Don't capture Sentry errors
+            rescue Exception => e
+              capture_exception(e, env)
+              finish_transaction(transaction, 500)
+              raise
+            end
+
+            exception = collect_exception(env)
+            capture_exception(exception, env) if exception
+
+            finish_transaction(transaction, response[0])
+
+            response
+          end
+        end
+      end
+
+      private
+
+      def collect_exception(env)
+        env['rack.exception'] || env['sinatra.error']
+      end
+
+      def transaction_op
+        "http.server".freeze
+      end
+
+      def capture_exception(exception, env)
+        Sentry.capture_exception(exception).tap do |event|
+          env[ERROR_EVENT_ID_KEY] = event.event_id if event
+        end
+      end
+
+      def start_transaction(env, scope)
+        sentry_trace = env["HTTP_SENTRY_TRACE"]
+        baggage = env["HTTP_BAGGAGE"]
+
+        options = { name: scope.transaction_name, source: scope.transaction_source, op: transaction_op }
+        transaction = Sentry::Transaction.from_sentry_trace(sentry_trace, baggage: baggage, **options) if sentry_trace
+        Sentry.start_transaction(transaction: transaction, custom_sampling_context: { env: env }, **options)
+      end
+
+
+      def finish_transaction(transaction, status_code)
+        return unless transaction
+
+        transaction.set_http_status(status_code)
+        transaction.finish
+      end
+    end
+  end
+end

data/lib/sentry/rack.rb

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

data/lib/sentry/rake.rb

@@ -0,0 +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, source: :task)
+          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
+    prepend(Sentry::Rake::Application)
+  end
+
+  class Task
+    prepend(Sentry::Rake::Task)
+  end
+end

data/lib/sentry/redis.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class Redis
+    OP_NAME = "db.redis"
+    LOGGER_NAME = :redis_logger
+
+    def initialize(commands, host, port, db)
+      @commands, @host, @port, @db = commands, host, port, db
+    end
+
+    def instrument
+      return yield unless Sentry.initialized?
+
+      Sentry.with_child_span(op: OP_NAME, start_timestamp: Sentry.utc_now.to_f) do |span|
+        yield.tap do
+          record_breadcrumb
+
+          if span
+            span.set_description(commands_description)
+            span.set_data(:server, server_description)
+          end
+        end
+      end
+    end
+
+    private
+
+    attr_reader :commands, :host, :port, :db
+
+    def record_breadcrumb
+      return unless Sentry.configuration.breadcrumbs_logger.include?(LOGGER_NAME)
+
+      Sentry.add_breadcrumb(
+        Sentry::Breadcrumb.new(
+          level: :info,
+          category: OP_NAME,
+          type: :info,
+          data: {
+            commands: parsed_commands,
+            server: server_description
+          }
+        )
+      )
+    end
+
+    def commands_description
+      parsed_commands.map do |statement|
+        statement.values.join(" ").strip
+      end.join(", ")
+    end
+
+    def parsed_commands
+      commands.map do |statement|
+        command, key, *arguments = statement
+        command_set = { command: command.to_s.upcase }
+        command_set[:key] = key if Utils::EncodingHelper.valid_utf_8?(key)
+
+        if Sentry.configuration.send_default_pii
+          command_set[:arguments] = arguments
+                                    .select { |a| Utils::EncodingHelper.valid_utf_8?(a) }
+                                    .join(" ")
+        end
+
+        command_set
+      end
+    end
+
+    def server_description
+      "#{host}:#{port}/#{db}"
+    end
+
+    module OldClientPatch
+      def logging(commands, &block)
+        Sentry::Redis.new(commands, host, port, db).instrument { super }
+      end
+    end
+
+    module GlobalRedisInstrumentation
+      def call(command, redis_config)
+        Sentry::Redis
+          .new([command], redis_config.host, redis_config.port, redis_config.db)
+          .instrument { super }
+      end
+
+      def call_pipelined(commands, redis_config)
+        Sentry::Redis
+          .new(commands, redis_config.host, redis_config.port, redis_config.db)
+          .instrument { super }
+      end
+    end
+  end
+end
+
+if defined?(::Redis::Client)
+  if Gem::Version.new(::Redis::VERSION) < Gem::Version.new("5.0")
+    Sentry.register_patch do
+      patch = Sentry::Redis::OldClientPatch
+      unless Redis::Client.ancestors.include?(patch)
+        Redis::Client.prepend(patch)
+      end
+    end
+  elsif defined?(RedisClient)
+    RedisClient.register(Sentry::Redis::GlobalRedisInstrumentation)
+  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