sentry-ruby 5.1.0 → 5.4.2

data/lib/sentry/backtrace.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Sentry
+  # @api private
+  class Backtrace
+    # Handles backtrace parsing line by line
+    class Line
+      RB_EXTENSION = ".rb"
+      # regexp (optional leading X: on windows, or JRuby9000 class-prefix)
+      RUBY_INPUT_FORMAT = /
+        ^ \s* (?: [a-zA-Z]: | uri:classloader: )? ([^:]+ | <.*>):
+        (\d+)
+        (?: :in \s `([^']+)')?$
+      /x.freeze
+
+      # org.jruby.runtime.callsite.CachingCallSite.call(CachingCallSite.java:170)
+      JAVA_INPUT_FORMAT = /^(.+)\.([^\.]+)\(([^\:]+)\:(\d+)\)$/.freeze
+
+      # The file portion of the line (such as app/models/user.rb)
+      attr_reader :file
+
+      # The line number portion of the line
+      attr_reader :number
+
+      # The method of the line (such as index)
+      attr_reader :method
+
+      # The module name (JRuby)
+      attr_reader :module_name
+
+      attr_reader :in_app_pattern
+
+      # Parses a single line of a given backtrace
+      # @param [String] unparsed_line The raw line from +caller+ or some backtrace
+      # @return [Line] The parsed backtrace line
+      def self.parse(unparsed_line, in_app_pattern)
+        ruby_match = unparsed_line.match(RUBY_INPUT_FORMAT)
+        if ruby_match
+          _, file, number, method = ruby_match.to_a
+          file.sub!(/\.class$/, RB_EXTENSION)
+          module_name = nil
+        else
+          java_match = unparsed_line.match(JAVA_INPUT_FORMAT)
+          _, module_name, method, file, number = java_match.to_a
+        end
+        new(file, number, method, module_name, in_app_pattern)
+      end
+
+      def initialize(file, number, method, module_name, in_app_pattern)
+        @file = file
+        @module_name = module_name
+        @number = number.to_i
+        @method = method
+        @in_app_pattern = in_app_pattern
+      end
+
+      def in_app
+        if file =~ in_app_pattern
+          true
+        else
+          false
+        end
+      end
+
+      # Reconstructs the line in a readable fashion
+      def to_s
+        "#{file}:#{number}:in `#{method}'"
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      def inspect
+        "<Line:#{self}>"
+      end
+    end
+
+    APP_DIRS_PATTERN = /(bin|exe|app|config|lib|test)/.freeze
+
+    # holder for an Array of Backtrace::Line instances
+    attr_reader :lines
+
+    def self.parse(backtrace, project_root, app_dirs_pattern, &backtrace_cleanup_callback)
+      ruby_lines = backtrace.is_a?(Array) ? backtrace : backtrace.split(/\n\s*/)
+
+      ruby_lines = backtrace_cleanup_callback.call(ruby_lines) if backtrace_cleanup_callback
+
+      in_app_pattern ||= begin
+        Regexp.new("^(#{project_root}/)?#{app_dirs_pattern || APP_DIRS_PATTERN}")
+      end
+
+      lines = ruby_lines.to_a.map do |unparsed_line|
+        Line.parse(unparsed_line, in_app_pattern)
+      end
+
+      new(lines)
+    end
+
+    def initialize(lines)
+      @lines = lines
+    end
+
+    def inspect
+      "<Backtrace: " + lines.map(&:inspect).join(", ") + ">"
+    end
+
+    def to_s
+      content = []
+      lines.each do |line|
+        content << line
+      end
+      content.join("\n")
+    end
+
+    def ==(other)
+      if other.respond_to?(:lines)
+        lines == other.lines
+      else
+        false
+      end
+    end
+  end
+end

data/lib/sentry/breadcrumb/sentry_logger.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Sentry
+  class Breadcrumb
+    module SentryLogger
+      LEVELS = {
+        ::Logger::DEBUG => 'debug',
+        ::Logger::INFO => 'info',
+        ::Logger::WARN => 'warn',
+        ::Logger::ERROR => 'error',
+        ::Logger::FATAL => 'fatal'
+      }.freeze
+
+      def add(*args, &block)
+        super
+        add_breadcrumb(*args, &block)
+        nil
+      end
+
+      def add_breadcrumb(severity, message = nil, progname = nil)
+        # because the breadcrumbs now belongs to different Hub's Scope in different threads
+        # we need to make sure the current thread's Hub has been set before adding breadcrumbs
+        return unless Sentry.initialized? && Sentry.get_current_hub
+
+        category = "logger"
+
+        # this is because the nature of Ruby Logger class:
+        #
+        # when given 1 argument, the argument will become both message and progname
+        #
+        # ```
+        # logger.info("foo")
+        # # message == progname == "foo"
+        # ```
+        #
+        # and to specify progname with a different message,
+        # we need to pass the progname as the argument and pass the message as a proc
+        #
+        # ```
+        # logger.info("progname") { "the message" }
+        # ```
+        #
+        # so the condition below is to replicate the similar behavior
+        if message.nil?
+          if block_given?
+            message = yield
+            category = progname
+          else
+            message = progname
+          end
+        end
+
+        return if ignored_logger?(progname) || message == ""
+
+        # some loggers will add leading/trailing space as they (incorrectly, mind you)
+        # think of logging as a shortcut to std{out,err}
+        message = message.to_s.strip
+
+        last_crumb = current_breadcrumbs.peek
+        # try to avoid dupes from logger broadcasts
+        if last_crumb.nil? || last_crumb.message != message
+          level = Sentry::Breadcrumb::SentryLogger::LEVELS.fetch(severity, nil)
+          crumb = Sentry::Breadcrumb.new(
+            level: level,
+            category: category,
+            message: message,
+            type: severity >= 3 ? "error" : level
+          )
+
+          Sentry.add_breadcrumb(crumb, hint: { severity: severity })
+        end
+      end
+
+      private
+
+      def ignored_logger?(progname)
+        progname == LOGGER_PROGNAME ||
+          Sentry.configuration.exclude_loggers.include?(progname)
+      end
+
+      def current_breadcrumbs
+        Sentry.get_current_scope.breadcrumbs
+      end
+    end
+  end
+end
+
+::Logger.send(:prepend, Sentry::Breadcrumb::SentryLogger)

data/lib/sentry/breadcrumb.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Sentry
+  class Breadcrumb
+    DATA_SERIALIZATION_ERROR_MESSAGE = "[data were removed due to serialization issues]"
+
+    # @return [String, nil]
+    attr_accessor :category
+    # @return [Hash, nil]
+    attr_accessor :data
+    # @return [String, nil]
+    attr_accessor :level
+    # @return [Time, Integer, nil]
+    attr_accessor :timestamp
+    # @return [String, nil]
+    attr_accessor :type
+    # @return [String, nil]
+    attr_reader :message
+
+    # @param category [String, nil]
+    # @param data [Hash, nil]
+    # @param message [String, nil]
+    # @param timestamp [Time, Integer, nil]
+    # @param level [String, nil]
+    # @param type [String, nil]
+    def initialize(category: nil, data: nil, message: nil, timestamp: nil, level: nil, type: nil)
+      @category = category
+      @data = data || {}
+      @level = level
+      @timestamp = timestamp || Sentry.utc_now.to_i
+      @type = type
+      self.message = message
+    end
+
+    # @return [Hash]
+    def to_hash
+      {
+        category: @category,
+        data: serialized_data,
+        level: @level,
+        message: @message,
+        timestamp: @timestamp,
+        type: @type
+      }
+    end
+
+    # @param message [String]
+    # @return [void]
+    def message=(message)
+      @message = (message || "").byteslice(0..Event::MAX_MESSAGE_SIZE_IN_BYTES)
+    end
+
+    private
+
+    def serialized_data
+      begin
+        ::JSON.parse(::JSON.generate(@data))
+      rescue Exception => e
+        Sentry.logger.debug(LOGGER_PROGNAME) do
+          <<~MSG
+can't serialize breadcrumb data because of error: #{e}
+data: #{@data}
+          MSG
+        end
+
+        DATA_SERIALIZATION_ERROR_MESSAGE
+      end
+    end
+  end
+end

data/lib/sentry/breadcrumb_buffer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "sentry/breadcrumb"
+
+module Sentry
+  class BreadcrumbBuffer
+    DEFAULT_SIZE = 100
+    include Enumerable
+
+    # @return [Array]
+    attr_accessor :buffer
+
+    # @param size [Integer, nil] If it's not provided, it'll fallback to DEFAULT_SIZE
+    def initialize(size = nil)
+      @buffer = Array.new(size || DEFAULT_SIZE)
+    end
+
+    # @param crumb [Breadcrumb]
+    # @return [void]
+    def record(crumb)
+      yield(crumb) if block_given?
+      @buffer.slice!(0)
+      @buffer << crumb
+    end
+
+    # @return [Array]
+    def members
+      @buffer.compact
+    end
+
+    # Returns the last breadcrumb stored in the buffer. If the buffer it's empty, it returns nil.
+    # @return [Breadcrumb, nil]
+    def peek
+      members.last
+    end
+
+    # Iterates through all breadcrumbs.
+    # @param block [Proc]
+    # @yieldparam crumb [Breadcrumb]
+    # @return [Array]
+    def each(&block)
+      members.each(&block)
+    end
+
+    # @return [Boolean]
+    def empty?
+      members.none?
+    end
+
+    # @return [Hash]
+    def to_hash
+      {
+        values: members.map(&:to_hash)
+      }
+    end
+
+    # @return [BreadcrumbBuffer]
+    def dup
+      copy = super
+      copy.buffer = buffer.deep_dup
+      copy
+    end
+  end
+end

data/lib/sentry/client.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "sentry/transport"
+
+module Sentry
+  class Client
+    include LoggingHelper
+
+    # The Transport object that'll send events for the client.
+    # @return [Transport]
+    attr_reader :transport
+
+    # @!macro configuration
+    attr_reader :configuration
+
+    # @deprecated Use Sentry.logger to retrieve the current logger instead.
+    attr_reader :logger
+
+    # @param configuration [Configuration]
+    def initialize(configuration)
+      @configuration = configuration
+      @logger = configuration.logger
+
+      if transport_class = configuration.transport.transport_class
+        @transport = transport_class.new(configuration)
+      else
+        @transport =
+          case configuration.dsn&.scheme
+          when 'http', 'https'
+            HTTPTransport.new(configuration)
+          else
+            DummyTransport.new(configuration)
+          end
+      end
+    end
+
+    # Applies the given scope's data to the event and sends it to Sentry.
+    # @param event [Event] the event to be sent.
+    # @param scope [Scope] the scope with contextual data that'll be applied to the event before it's sent.
+    # @param hint [Hash] the hint data that'll be passed to `before_send` callback and the scope's event processors.
+    # @return [Event, nil]
+    def capture_event(event, scope, hint = {})
+      return unless configuration.sending_allowed?
+
+      unless event.is_a?(TransactionEvent) || configuration.sample_allowed?
+        transport.record_lost_event(:sample_rate, 'event')
+        return
+      end
+
+      event_type = event.is_a?(Event) ? event.type : event["type"]
+      event = scope.apply_to_event(event, hint)
+
+      if event.nil?
+        log_info("Discarded event because one of the event processors returned nil")
+        transport.record_lost_event(:event_processor, event_type)
+        return
+      end
+
+      if async_block = configuration.async
+        dispatch_async_event(async_block, event, hint)
+      elsif configuration.background_worker_threads != 0 && hint.fetch(:background, true)
+        queued = dispatch_background_event(event, hint)
+        transport.record_lost_event(:queue_overflow, event_type) unless queued
+      else
+        send_event(event, hint)
+      end
+
+      event
+    rescue => e
+      log_error("Event capturing failed", e, debug: configuration.debug)
+      nil
+    end
+
+    # Initializes an Event object with the given exception. Returns `nil` if the exception's class is excluded from reporting.
+    # @param exception [Exception] the exception to be reported.
+    # @param hint [Hash] the hint data that'll be passed to `before_send` callback and the scope's event processors.
+    # @return [Event, nil]
+    def event_from_exception(exception, hint = {})
+      return unless @configuration.sending_allowed? && @configuration.exception_class_allowed?(exception)
+
+      integration_meta = Sentry.integrations[hint[:integration]]
+
+      ErrorEvent.new(configuration: configuration, integration_meta: integration_meta).tap do |event|
+        event.add_exception_interface(exception)
+        event.add_threads_interface(crashed: true)
+        event.level = :error
+      end
+    end
+
+    # Initializes an Event object with the given message.
+    # @param message [String] the message to be reported.
+    # @param hint [Hash] the hint data that'll be passed to `before_send` callback and the scope's event processors.
+    # @return [Event]
+    def event_from_message(message, hint = {}, backtrace: nil)
+      return unless @configuration.sending_allowed?
+
+      integration_meta = Sentry.integrations[hint[:integration]]
+      event = ErrorEvent.new(configuration: configuration, integration_meta: integration_meta, message: message)
+      event.add_threads_interface(backtrace: backtrace || caller)
+      event.level = :error
+      event
+    end
+
+    # Initializes an Event object with the given Transaction object.
+    # @param transaction [Transaction] the transaction to be recorded.
+    # @return [TransactionEvent]
+    def event_from_transaction(transaction)
+      TransactionEvent.new(configuration: configuration).tap do |event|
+        event.transaction = transaction.name
+        event.contexts.merge!(trace: transaction.get_trace_context)
+        event.timestamp = transaction.timestamp
+        event.start_timestamp = transaction.start_timestamp
+        event.tags = transaction.tags
+
+        finished_spans = transaction.span_recorder.spans.select { |span| span.timestamp && span != transaction }
+        event.spans = finished_spans.map(&:to_hash)
+      end
+    end
+
+    # @!macro send_event
+    def send_event(event, hint = nil)
+      event_type = event.is_a?(Event) ? event.type : event["type"]
+
+      if event_type != TransactionEvent::TYPE && configuration.before_send
+        event = configuration.before_send.call(event, hint)
+
+        if event.nil?
+          log_info("Discarded event because before_send returned nil")
+          transport.record_lost_event(:before_send, 'event')
+          return
+        end
+      end
+
+      transport.send_event(event)
+
+      event
+    rescue => e
+      loggable_event_type = event_type.capitalize
+      log_error("#{loggable_event_type} sending failed", e, debug: configuration.debug)
+
+      event_info = Event.get_log_message(event.to_hash)
+      log_info("Unreported #{loggable_event_type}: #{event_info}")
+      transport.record_lost_event(:network_error, event_type)
+      raise
+    end
+
+    # Generates a Sentry trace for distribted tracing from the given Span.
+    # Returns `nil` if `config.propagate_traces` is `false`.
+    # @param span [Span] the span to generate trace from.
+    # @return [String, nil]
+    def generate_sentry_trace(span)
+      return unless configuration.propagate_traces
+
+      trace = span.to_sentry_trace
+      log_debug("[Tracing] Adding #{SENTRY_TRACE_HEADER_NAME} header to outgoing request: #{trace}")
+      trace
+    end
+
+    private
+
+    def dispatch_background_event(event, hint)
+      Sentry.background_worker.perform do
+        send_event(event, hint)
+      end
+    end
+
+    def dispatch_async_event(async_block, event, hint)
+      # We have to convert to a JSON-like hash, because background job
+      # processors (esp ActiveJob) may not like weird types in the event hash
+
+      event_hash =
+        begin
+          event.to_json_compatible
+        rescue => e
+          log_error("Converting #{event.type} (#{event.event_id}) to JSON compatible hash failed", e, debug: configuration.debug)
+          return
+        end
+
+      if async_block.arity == 2
+        hint = JSON.parse(JSON.generate(hint))
+        async_block.call(event_hash, hint)
+      else
+        async_block.call(event_hash)
+      end
+    rescue => e
+      log_error("Async #{event_hash["type"]} sending failed", e, debug: configuration.debug)
+      send_event(event, hint)
+    end
+  end
+end