sentry-ruby 4.1.4 → 4.2.0

data/lib/sentry-ruby.rb

@@ -1,190 +0,0 @@
-require "forwardable"
-require "time"
-
-require "sentry/version"
-require "sentry/core_ext/object/deep_dup"
-require "sentry/utils/argument_checking_helper"
-require "sentry/configuration"
-require "sentry/logger"
-require "sentry/event"
-require "sentry/transaction_event"
-require "sentry/span"
-require "sentry/transaction"
-require "sentry/hub"
-require "sentry/background_worker"
-
-def safely_require(lib)
-  begin
-    require lib
-  rescue LoadError
-  end
-end
-
-safely_require "sentry/rake"
-safely_require "sentry/rack"
-
-module Sentry
-  class Error < StandardError
-  end
-
-  META = { "name" => "sentry.ruby", "version" => Sentry::VERSION }.freeze
-
-  LOGGER_PROGNAME = "sentry".freeze
-
-  THREAD_LOCAL = :sentry_hub
-
-  def self.sdk_meta
-    META
-  end
-
-  def self.utc_now
-    Time.now.utc
-  end
-
-  class << self
-    # Returns a hash that contains all the integrations that have been registered to the main SDK.
-    def integrations
-      @integrations ||= {}
-    end
-
-    # Registers the SDK integration with its name and version.
-    def register_integration(name, version)
-      meta = { name: "sentry.ruby.#{name}", version: version }.freeze
-      integrations[name.to_s] = meta
-    end
-  end
-
-  class << self
-    extend Forwardable
-
-    def_delegators :get_current_client, :configuration, :send_event
-    def_delegators :get_current_scope, :set_tags, :set_extras, :set_user
-
-    attr_accessor :background_worker
-
-    def init(&block)
-      config = Configuration.new
-      yield(config)
-      client = Client.new(config)
-      scope = Scope.new
-      hub = Hub.new(client, scope)
-      Thread.current[THREAD_LOCAL] = hub
-      @main_hub = hub
-      @background_worker = Sentry::BackgroundWorker.new(config)
-    end
-
-    # Returns the main thread's active hub.
-    def get_main_hub
-      @main_hub
-    end
-
-    # Takes an instance of Sentry::Breadcrumb and stores it to the current active scope.
-    def add_breadcrumb(breadcrumb)
-      get_current_scope.breadcrumbs.record(breadcrumb)
-    end
-
-    # Returns the current active hub.
-    # If the current thread doesn't have an active hub, it will clone the main thread's active hub,
-    # stores it in the current thread, and then returns it.
-    def get_current_hub
-      # we need to assign a hub to the current thread if it doesn't have one yet
-      #
-      # ideally, we should do this proactively whenever a new thread is created
-      # but it's impossible for the SDK to keep track every new thread
-      # so we need to use this rather passive way to make sure the app doesn't crash
-      Thread.current[THREAD_LOCAL] || clone_hub_to_current_thread
-    end
-
-    # Returns the current active client.
-    def get_current_client
-      get_current_hub&.current_client
-    end
-
-    # Returns the current active scope.
-    def get_current_scope
-      get_current_hub&.current_scope
-    end
-
-    # Clones the main thread's active hub and stores it to the current thread.
-    def clone_hub_to_current_thread
-      Thread.current[THREAD_LOCAL] = get_main_hub.clone
-    end
-
-    # Takes a block and yields the current active scope.
-    #
-    # ```ruby
-    # Sentry.configure_scope do |scope|
-    #   scope.set_tags(foo: "bar")
-    # end
-    #
-    # Sentry.capture_message("test message") # this event will have tags { foo: "bar" }
-    # ```
-    #
-    def configure_scope(&block)
-      get_current_hub&.configure_scope(&block)
-    end
-
-    # Takes a block and yields a temporary scope.
-    # The temporary scope will inherit all the attributes from the current active scope and replace it to be the active
-    # scope inside the block. For example:
-    #
-    # ```ruby
-    # Sentry.configure_scope do |scope|
-    #   scope.set_tags(foo: "bar")
-    # end
-    #
-    # Sentry.capture_message("test message") # this event will have tags { foo: "bar" }
-    #
-    # Sentry.with_scope do |temp_scope|
-    #   temp_scope.set_tags(foo: "baz")
-    #   Sentry.capture_message("test message 2") # this event will have tags { foo: "baz" }
-    # end
-    #
-    # Sentry.capture_message("test message 3") # this event will have tags { foo: "bar" }
-    # ```
-    #
-    def with_scope(&block)
-      get_current_hub&.with_scope(&block)
-    end
-
-    # Takes an exception and reports it to Sentry via the currently active hub.
-    def capture_exception(exception, **options, &block)
-      get_current_hub&.capture_exception(exception, **options, &block)
-    end
-
-    # Takes a message string and reports it to Sentry via the currently active hub.
-    def capture_message(message, **options, &block)
-      get_current_hub&.capture_message(message, **options, &block)
-    end
-
-    # Takes an instance of Sentry::Event and dispatches it to the currently active hub.
-    def capture_event(event)
-      get_current_hub&.capture_event(event)
-    end
-
-    # Takes or initializes a new Sentry::Transaction and makes a sampling decision for it.
-    def start_transaction(**options)
-      get_current_hub&.start_transaction(**options)
-    end
-
-    # Returns the id of the lastly reported Sentry::Event.
-    def last_event_id
-      get_current_hub&.last_event_id
-    end
-
-    def sys_command(command)
-      result = `#{command} 2>&1` rescue nil
-      return if result.nil? || result.empty? || ($CHILD_STATUS && $CHILD_STATUS.exitstatus != 0)
-
-      result.strip
-    end
-
-    def initialized?
-      !!@main_hub
-    end
-
-    def logger
-      configuration.logger
-    end
-  end
-end

data/lib/sentry/background_worker.rb

@@ -1,37 +0,0 @@
-require "concurrent/executor/thread_pool_executor"
-require "concurrent/executor/immediate_executor"
-
-module Sentry
-  class BackgroundWorker
-    attr_reader :max_queue, :number_of_threads
-
-    def initialize(configuration)
-      @max_queue = 30
-      @number_of_threads = configuration.background_worker_threads
-
-      @executor =
-        if configuration.async
-          configuration.logger.debug(LOGGER_PROGNAME) { "config.async is set, BackgroundWorker is disabled" }
-          Concurrent::ImmediateExecutor.new
-        elsif @number_of_threads == 0
-          configuration.logger.debug(LOGGER_PROGNAME) { "config.background_worker_threads is set to 0, all events will be sent synchronously" }
-          Concurrent::ImmediateExecutor.new
-        else
-          configuration.logger.debug(LOGGER_PROGNAME) { "initialized a background worker with #{@number_of_threads} threads" }
-
-          Concurrent::ThreadPoolExecutor.new(
-            min_threads: 0,
-            max_threads: @number_of_threads,
-            max_queue: @max_queue,
-            fallback_policy: :discard
-          )
-        end
-    end
-
-    def perform(&block)
-      @executor.post do
-        block.call
-      end
-    end
-  end
-end

data/lib/sentry/backtrace.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-## Inspired by Rails' and Airbrake's backtrace parsers.
-
-module Sentry
-  # Front end to parsing the backtrace for each notice
-  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/benchmarks/benchmark_transport.rb

@@ -1,14 +0,0 @@
-module Sentry
-  class BenchmarkTransport < Transport
-    attr_accessor :events
-
-    def initialize(*)
-      super
-      @events = []
-    end
-
-    def send_event(event)
-      @events << encode(event.to_hash)
-    end
-  end
-end

data/lib/sentry/breadcrumb.rb

@@ -1,25 +0,0 @@
-module Sentry
-  class Breadcrumb
-    attr_accessor :category, :data, :message, :level, :timestamp, :type
-
-    def initialize(category: nil, data: nil, message: nil, timestamp: nil, level: nil, type: nil)
-      @category = category
-      @data = data || {}
-      @level = level
-      @message = message
-      @timestamp = timestamp || Sentry.utc_now.to_i
-      @type = type
-    end
-
-    def to_hash
-      {
-        :category => @category,
-        :data => @data,
-        :level => @level,
-        :message => @message,
-        :timestamp => @timestamp,
-        :type => @type
-      }
-    end
-  end
-end

data/lib/sentry/breadcrumb/sentry_logger.rb

@@ -1,87 +0,0 @@
-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)
-      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.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.empty?
-
-        # 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)
-        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)