sentry-ruby-core 4.1.5.pre.beta.0

data/Rakefile

@@ -0,0 +1,13 @@
+require "rake/clean"
+CLOBBER.include "pkg"
+
+require "bundler/gem_helper"
+Bundler::GemHelper.install_tasks(name: "sentry-ruby")
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec).tap do |task|
+  task.rspec_opts = "--order rand"
+end
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sentry/ruby"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sentry-ruby.rb

@@ -0,0 +1,191 @@
+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"
+
+
+[
+  "sentry/rake",
+  "sentry/rack",
+].each do |lib|
+  begin
+    require lib
+  rescue LoadError
+  end
+end
+
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,126 @@
+# 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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,87 @@
+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)