sentry-ruby 5.3.1 → 5.16.1

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|spec)/.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/baggage.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module Sentry
+  # A {https://www.w3.org/TR/baggage W3C Baggage Header} implementation.
+  class Baggage
+    SENTRY_PREFIX = 'sentry-'
+    SENTRY_PREFIX_REGEX = /^sentry-/.freeze
+
+    # @return [Hash]
+    attr_reader :items
+
+    # @return [Boolean]
+    attr_reader :mutable
+
+    def initialize(items, mutable: true)
+      @items = items
+      @mutable = mutable
+    end
+
+    # Creates a Baggage object from an incoming W3C Baggage header string.
+    #
+    # Sentry items are identified with the 'sentry-' prefix and stored in a hash.
+    # The presence of a Sentry item makes the baggage object immutable.
+    #
+    # @param header [String] The incoming Baggage header string.
+    # @return [Baggage, nil]
+    def self.from_incoming_header(header)
+      items = {}
+      mutable = true
+
+      header.split(',').each do |item|
+        item = item.strip
+        key, val = item.split('=')
+
+        next unless key && val
+        next unless key =~ SENTRY_PREFIX_REGEX
+
+        baggage_key = key.split('-')[1]
+        next unless baggage_key
+
+        items[CGI.unescape(baggage_key)] = CGI.unescape(val)
+        mutable = false
+      end
+
+      new(items, mutable: mutable)
+    end
+
+    # Make the Baggage immutable.
+    # @return [void]
+    def freeze!
+      @mutable = false
+    end
+
+    # A {https://develop.sentry.dev/sdk/performance/dynamic-sampling-context/#envelope-header Dynamic Sampling Context}
+    # hash to be used in the trace envelope header.
+    # @return [Hash]
+    def dynamic_sampling_context
+      @items
+    end
+
+    # Serialize the Baggage object back to a string.
+    # @return [String]
+    def serialize
+      items = @items.map { |k, v| "#{SENTRY_PREFIX}#{CGI.escape(k)}=#{CGI.escape(v)}" }
+      items.join(',')
+    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,76 @@
+# 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_reader :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 || {}
+      @timestamp = timestamp || Sentry.utc_now.to_i
+      @type = type
+      self.message = message
+      self.level = level
+    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
+
+    # @param level [String]
+    # @return [void]
+    def level=(level) # needed to meet the Sentry spec
+      @level = level == "warn" ? "warning" : level
+    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/check_in_event.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'sentry/cron/monitor_config'
+
+module Sentry
+  class CheckInEvent < Event
+    TYPE = 'check_in'
+
+    # uuid to identify this check-in.
+    # @return [String]
+    attr_accessor :check_in_id
+
+    # Identifier of the monitor for this check-in.
+    # @return [String]
+    attr_accessor :monitor_slug
+
+    # Duration of this check since it has started in seconds.
+    # @return [Integer, nil]
+    attr_accessor :duration
+
+    # Monitor configuration to support upserts.
+    # @return [Cron::MonitorConfig, nil]
+    attr_accessor :monitor_config
+
+    # Status of this check-in.
+    # @return [Symbol]
+    attr_accessor :status
+
+    VALID_STATUSES = %i(ok in_progress error)
+
+    def initialize(
+      slug:,
+      status:,
+      duration: nil,
+      monitor_config: nil,
+      check_in_id: nil,
+      **options
+    )
+      super(**options)
+
+      self.monitor_slug = slug
+      self.status = status
+      self.duration = duration
+      self.monitor_config = monitor_config
+      self.check_in_id = check_in_id || SecureRandom.uuid.delete('-')
+    end
+
+    # @return [Hash]
+    def to_hash
+      data = super
+      data[:check_in_id] = check_in_id
+      data[:monitor_slug] = monitor_slug
+      data[:status] = status
+      data[:duration] = duration if duration
+      data[:monitor_config] = monitor_config.to_hash if monitor_config
+      data
+    end
+  end
+end