celerbrake-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 05635c625ddcfffc4ee0d02816587d8ae16eb9114fbb856c32c27c3eb3f934b6
+  data.tar.gz: 592b95064454a6c385583aa5ba60baceaf27731912f77c6e9d7310c7e3afc8c5
+SHA512:
+  metadata.gz: d8f415e4ae3c11ed67984395dfe11371f3660d17e160e472e36cbad94718f6a7f76579d976bd7e63eb87924bedf9333daa4d60b5ac10f515f22e666ff2f26cb5
+  data.tar.gz: '05581f19888a99ebbd515213165caeb25787f5b373c6ea4537a284b8ba09802d32c177a971e39a7ce92a4238d32ac958cce00a3527ffe87a998d4fa3511ed32c'

data/lib/celerbrake-ruby/async_sender.rb

@@ -0,0 +1,57 @@
+module Celerbrake
+  # Responsible for sending notices to Celerbrake asynchronously.
+  #
+  # @see SyncSender
+  # @api private
+  # @since v1.0.0
+  class AsyncSender
+    def initialize(method = :post, name = 'async-sender')
+      @config = Celerbrake::Config.instance
+      @sync_sender = SyncSender.new(method)
+      @name = name
+    end
+
+    # Asynchronously sends a notice to Celerbrake.
+    #
+    # @param [Celerbrake::Notice] data Whatever needs to be sent
+    # @param [Celerbrake::Promise] promise
+    # @param [URI] endpoint Where to send +data+
+    # @return [Celerbrake::Promise]
+    def send(data, promise, endpoint = @config.error_endpoint)
+      unless thread_pool << [data, promise, endpoint]
+        return promise.reject(
+          "AsyncSender has reached its capacity of #{@config.queue_size}",
+        )
+      end
+
+      promise
+    end
+
+    # @return [void]
+    def close
+      @sync_sender.close
+      thread_pool.close
+    end
+
+    # @return [Boolean]
+    def closed?
+      thread_pool.closed?
+    end
+
+    # @return [Boolean]
+    def has_workers?
+      thread_pool.has_workers?
+    end
+
+    private
+
+    def thread_pool
+      @thread_pool ||= ThreadPool.new(
+        name: @name,
+        worker_size: @config.workers,
+        queue_size: @config.queue_size,
+        block: proc { |args| @sync_sender.send(*args) },
+      )
+    end
+  end
+end

data/lib/celerbrake-ruby/backlog.rb

@@ -0,0 +1,123 @@
+module Celerbrake
+  # Backlog accepts notices and APM events and synchronously sends them in the
+  # background at regular intervals. The backlog is a queue of data that failed
+  # to be sent due to some error. In a nutshell, it's a retry mechanism.
+  #
+  # @api private
+  # @since v6.2.0
+  class Backlog
+    include Loggable
+
+    # @return [Integer] how many records to keep in the backlog
+    BACKLOG_SIZE = 100
+
+    # @return [Integer] flush period in seconds
+    TWO_MINUTES = 60 * 2
+
+    def initialize(sync_sender, flush_period = TWO_MINUTES)
+      @sync_sender = sync_sender
+      @flush_period = flush_period
+      @queue = SizedQueue.new(BACKLOG_SIZE).extend(MonitorMixin)
+      @has_backlog_data = @queue.new_cond
+      @schedule_flush = nil
+
+      @seen = Set.new
+    end
+
+    # Appends data to the backlog. Once appended, the flush schedule will
+    # start. Chainable.
+    #
+    # @example
+    #   backlog << [{ 'data' => 1 }, 'https://celerbrake.com/api']
+    #
+    # @param [Array<#to_json, String>] data An array of two elements, where the
+    #   first element is the data we are sending and the second element is the
+    #   URL that we are sending to
+    # @return [self]
+    def <<(data)
+      @queue.synchronize do
+        return self if @seen.include?(data)
+
+        @seen << data
+
+        begin
+          @queue.push(data, true)
+        rescue ThreadError
+          logger.error("#{LOG_LABEL} Celerbrake::Backlog full")
+          return self
+        end
+
+        @has_backlog_data.signal
+        schedule_flush
+
+        self
+      end
+    end
+
+    # Closes all the resources that this sender has allocated.
+    #
+    # @return [void]
+    # @since v6.2.0
+    def close
+      @queue.synchronize do
+        if @schedule_flush
+          @schedule_flush.kill
+          logger.debug("#{LOG_LABEL} Celerbrake::Backlog closed")
+        end
+      end
+    end
+
+    private
+
+    def schedule_flush
+      @schedule_flush ||= Thread.new do
+        loop do
+          @queue.synchronize do
+            wait
+            next if @queue.empty?
+
+            flush
+          end
+        end
+      end
+    end
+
+    def wait
+      @has_backlog_data.wait(@flush_period) while time_elapsed < @flush_period
+      @last_flush = nil
+    end
+
+    def time_elapsed
+      MonotonicTime.time_in_s - last_flush
+    end
+
+    def last_flush
+      @last_flush ||= MonotonicTime.time_in_s
+    end
+
+    def flush
+      unless @queue.empty?
+        logger.debug(
+          "#{LOG_LABEL} Celerbrake::Backlog flushing #{@queue.size} messages",
+        )
+      end
+
+      failed = 0
+
+      until @queue.empty?
+        data, endpoint = @queue.pop
+        promise = Celerbrake::Promise.new
+        @sync_sender.send(data, promise, endpoint)
+        failed += 1 if promise.rejected?
+      end
+
+      if failed > 0
+        logger.debug(
+          "#{LOG_LABEL} Celerbrake::Backlog #{failed} messages were not flushed",
+        )
+      end
+
+      @seen.clear
+    end
+  end
+end

data/lib/celerbrake-ruby/backtrace.rb

@@ -0,0 +1,197 @@
+module Celerbrake
+  # Represents a cross-Ruby backtrace from exceptions (including JRuby Java
+  # exceptions). Provides information about stack frames (such as line number,
+  # file and method) in convenient for Celerbrake format.
+  #
+  # @example
+  #   begin
+  #     raise 'Oops!'
+  #   rescue
+  #     Backtrace.parse($!)
+  #   end
+  #
+  # @api private
+  # @since v1.0.0
+  module Backtrace
+    module Patterns
+      # @return [Regexp] the pattern that matches standard Ruby stack frames,
+      #   such as ./spec/notice_spec.rb:43:in `block (3 levels) in <top (required)>'
+      RUBY = %r{\A
+        (?<file>.+)       # Matches './spec/notice_spec.rb'
+        :
+        (?<line>\d+)      # Matches '43'
+        :in\s
+        `(?<function>.*)' # Matches "`block (3 levels) in <top (required)>'"
+      \z}x.freeze
+
+      # @return [Regexp] the pattern that matches JRuby Java stack frames, such
+      #  as org.jruby.ast.NewlineNode.interpret(NewlineNode.java:105)
+      JAVA = %r{\A
+        (?<function>.+)  # Matches 'org.jruby.ast.NewlineNode.interpret'
+        \(
+          (?<file>
+            (?:uri:classloader:/.+(?=:)) # Matches '/META-INF/jruby.home/protocol.rb'
+            |
+            (?:uri_3a_classloader_3a_.+(?=:)) # Matches 'uri_3a_classloader_3a_/gems/...'
+            |
+            [^:]+        # Matches 'NewlineNode.java'
+          )
+          :?
+          (?<line>\d+)?  # Matches '105'
+        \)
+      \z}x.freeze
+
+      # @return [Regexp] the pattern that tries to assume what a generic stack
+      #   frame might look like, when exception's backtrace is set manually.
+      GENERIC = %r{\A
+        (?:from\s)?
+        (?<file>.+)              # Matches '/foo/bar/baz.ext'
+        :
+        (?<line>\d+)?            # Matches '43' or nothing
+        (?:
+          in\s`(?<function>.+)'  # Matches "in `func'"
+        |
+          :in\s(?<function>.+)   # Matches ":in func"
+        )?                       # ... or nothing
+      \z}x.freeze
+
+      # @return [Regexp] the pattern that matches exceptions from PL/SQL such as
+      #   ORA-06512: at "STORE.LI_LICENSES_PACK", line 1945
+      # @note This is raised by https://github.com/kubo/ruby-oci8
+      OCI = /\A
+        (?:
+          ORA-\d{5}
+          :\sat\s
+          (?:"(?<function>.+)",\s)?
+          line\s(?<line>\d+)
+        |
+          #{GENERIC}
+        )
+      \z/x.freeze
+
+      # @return [Regexp] the pattern that matches CoffeeScript backtraces
+      #   usually coming from Rails & ExecJS
+      EXECJS = /\A
+        (?:
+          # Matches 'compile ((execjs):6692:19)'
+          (?<function>.+)\s\((?<file>.+):(?<line>\d+):\d+\)
+        |
+          # Matches 'bootstrap_node.js:467:3'
+          (?<file>.+):(?<line>\d+):\d+(?<function>)
+        |
+          # Matches the Ruby part of the backtrace
+          #{RUBY}
+        )
+      \z/x.freeze
+    end
+
+    # @return [Integer] how many first frames should include code hunks
+    CODE_FRAME_LIMIT = 10
+
+    # Parses an exception's backtrace.
+    #
+    # @param [Exception] exception The exception, which contains a backtrace to
+    #   parse
+    # @return [Array<Hash{Symbol=>String,Integer}>] the parsed backtrace
+    def self.parse(exception)
+      return [] if exception.backtrace.nil? || exception.backtrace.none?
+
+      parse_backtrace(exception)
+    end
+
+    # Checks whether the given exception was generated by JRuby's VM.
+    #
+    # @param [Exception] exception
+    # @return [Boolean]
+    def self.java_exception?(exception)
+      if defined?(Java::JavaLang::Throwable) &&
+         exception.is_a?(Java::JavaLang::Throwable)
+        return true
+      end
+
+      return false unless exception.respond_to?(:backtrace)
+
+      (Patterns::JAVA =~ exception.backtrace.first) != nil
+    end
+
+    class << self
+      include Loggable
+
+      private
+
+      def best_regexp_for(exception)
+        if java_exception?(exception)
+          Patterns::JAVA
+        elsif oci_exception?(exception)
+          Patterns::OCI
+        elsif execjs_exception?(exception)
+          Patterns::EXECJS
+        else
+          Patterns::RUBY
+        end
+      end
+
+      def oci_exception?(exception)
+        defined?(OCIError) && exception.is_a?(OCIError)
+      end
+
+      def execjs_exception?(exception)
+        return false unless defined?(ExecJS::RuntimeError)
+        return true if exception.is_a?(ExecJS::RuntimeError)
+        return true if exception.cause && exception.cause.is_a?(ExecJS::RuntimeError)
+
+        false
+      end
+
+      def stack_frame(regexp, stackframe)
+        if (match = match_frame(regexp, stackframe))
+          return {
+            file: match[:file],
+            line: (Integer(match[:line]) if match[:line]),
+            function: match[:function],
+          }
+        end
+
+        logger.error(
+          "can't parse '#{stackframe}' (please file an issue so we can fix " \
+          "it: https://github.com/celerbrake/celerbrake-ruby/issues/new)",
+        )
+        { file: nil, line: nil, function: stackframe }
+      end
+
+      def match_frame(regexp, stackframe)
+        match = regexp.match(stackframe)
+        return match if match
+
+        Patterns::GENERIC.match(stackframe)
+      end
+
+      def parse_backtrace(exception)
+        regexp = best_regexp_for(exception)
+        root_directory = Celerbrake::Config.instance.root_directory.to_s
+
+        exception.backtrace.map.with_index do |stackframe, i|
+          frame = stack_frame(regexp, stackframe)
+          next(frame) if !Celerbrake::Config.instance.code_hunks || frame[:file].nil?
+
+          if !root_directory.empty?
+            populate_code(frame) if frame_in_root?(frame, root_directory)
+          elsif i < CODE_FRAME_LIMIT
+            populate_code(frame)
+          end
+
+          frame
+        end
+      end
+
+      def populate_code(frame)
+        code = Celerbrake::CodeHunk.new.get(frame[:file], frame[:line])
+        frame[:code] = code if code
+      end
+
+      def frame_in_root?(frame, root_directory)
+        frame[:file].start_with?(root_directory) && frame[:file] !~ %r{vendor/bundle}
+      end
+    end
+  end
+end

data/lib/celerbrake-ruby/benchmark.rb

@@ -0,0 +1,39 @@
+module Celerbrake
+  # Benchmark benchmarks Ruby code.
+  #
+  # @since v4.2.4
+  # @api public
+  class Benchmark
+    # Measures monotonic time for the given operation.
+    #
+    # @yieldreturn [void]
+    def self.measure
+      benchmark = new
+
+      yield
+
+      benchmark.stop
+      benchmark.duration
+    end
+
+    # @return [Float]
+    attr_reader :duration
+
+    # @since v4.3.0
+    def initialize
+      @start = MonotonicTime.time_in_ms
+      @duration = 0.0
+    end
+
+    # Stops the benchmark and stores `duration`.
+    #
+    # @since v4.3.0
+    # @return [Boolean] true for the first invocation, false in all other cases
+    def stop
+      return false if @duration > 0.0
+
+      @duration = MonotonicTime.time_in_ms - @start
+      true
+    end
+  end
+end

data/lib/celerbrake-ruby/code_hunk.rb

@@ -0,0 +1,51 @@
+module Celerbrake
+  # Represents a small hunk of code consisting of a base line and a couple lines
+  # around it
+  # @api private
+  class CodeHunk
+    # @return [Integer] the maximum length of a line
+    MAX_LINE_LEN = 200
+
+    # @return [Integer] how many lines should be read around the base line
+    NLINES = 2
+
+    include Loggable
+
+    # @param [String] file The file to read
+    # @param [Integer] line The base line in the file
+    # @return [Hash{Integer=>String}, nil] lines of code around the base line
+    def get(file, line)
+      return unless File.exist?(file)
+      return unless line
+
+      lines = get_lines(file, [line - NLINES, 1].max, line + NLINES) || {}
+      return { 1 => '' } if lines.empty?
+
+      lines
+    end
+
+    private
+
+    def get_from_cache(file)
+      Celerbrake::FileCache[file] ||= File.foreach(file)
+    rescue StandardError => ex
+      logger.error(
+        "#{self.class.name}: can't read code hunk for #{file}: #{ex}",
+      )
+      nil
+    end
+
+    def get_lines(file, start_line, end_line)
+      return unless (cached_file = get_from_cache(file))
+
+      lines = {}
+      cached_file.with_index(1) do |l, i|
+        next if i < start_line
+        break if i > end_line
+
+        lines[i] = l[0...MAX_LINE_LEN].rstrip
+      end
+      lines
+    end
+  end
+end

data/lib/celerbrake-ruby/config/processor.rb

@@ -0,0 +1,77 @@
+module Celerbrake
+  class Config
+    # Processor is a helper class, which is responsible for setting default
+    # config values, default notifier filters and remote configuration changes.
+    #
+    # @since v5.0.0
+    # @api private
+    class Processor
+      # @param [Celerbrake::Config] config
+      # @return [Celerbrake::Config::Processor]
+      def self.process(config)
+        new(config).process
+      end
+
+      # @param [Celerbrake::Config] config
+      def initialize(config)
+        @config = config
+        @blocklist_keys = @config.blocklist_keys
+        @allowlist_keys = @config.allowlist_keys
+        @project_id = @config.project_id
+        @poll_callback = Celerbrake::RemoteSettings::Callback.new(config)
+      end
+
+      # @param [Celerbrake::NoticeNotifier] notifier
+      # @return [void]
+      def process_blocklist(notifier)
+        return if @blocklist_keys.none?
+
+        blocklist = Celerbrake::Filters::KeysBlocklist.new(@blocklist_keys)
+        notifier.add_filter(blocklist)
+      end
+
+      # @param [Celerbrake::NoticeNotifier] notifier
+      # @return [void]
+      def process_allowlist(notifier)
+        return if @allowlist_keys.none?
+
+        allowlist = Celerbrake::Filters::KeysAllowlist.new(@allowlist_keys)
+        notifier.add_filter(allowlist)
+      end
+
+      # @return [Celerbrake::RemoteSettings]
+      def process_remote_configuration
+        return unless @config.remote_config
+        return unless @project_id
+
+        # Never poll remote configuration in the test environment.
+        return if @config.environment == 'test'
+
+        # If the current environment is ignored, don't try to poll remote
+        # configuration.
+        return if @config.ignore_environments.include?(@config.environment)
+
+        RemoteSettings.poll(@project_id, @config.remote_config_host) do |data|
+          @poll_callback.call(data)
+        end
+      end
+
+      # @param [Celerbrake::NoticeNotifier] notifier
+      # @return [void]
+      def add_filters(notifier)
+        return unless @config.root_directory
+
+        [
+          Celerbrake::Filters::RootDirectoryFilter,
+          Celerbrake::Filters::GitRevisionFilter,
+          Celerbrake::Filters::GitRepositoryFilter,
+          Celerbrake::Filters::GitLastCheckoutFilter,
+        ].each do |filter|
+          next if notifier.has_filter?(filter)
+
+          notifier.add_filter(filter.new(@config.root_directory))
+        end
+      end
+    end
+  end
+end

data/lib/celerbrake-ruby/config/validator.rb

@@ -0,0 +1,97 @@
+module Celerbrake
+  class Config
+    # Validator validates values of {Celerbrake::Config} options. A valid config
+    # is a config that guarantees that data can be sent to Celerbrake given its
+    # configuration.
+    #
+    # @api private
+    # @since v1.5.0
+    class Validator
+      # @return [Array<Class>] the list of allowed types to configure the
+      #   environment option
+      VALID_ENV_TYPES = [NilClass, String, Symbol].freeze
+
+      class << self
+        # @param [Celerbrake::Config] config
+        # @since v4.1.0
+        def validate(config)
+          promise = Celerbrake::Promise.new
+
+          unless valid_project_id?(config)
+            return promise.reject(':project_id is required')
+          end
+
+          unless valid_project_key?(config)
+            return promise.reject(':project_key is required')
+          end
+
+          unless valid_environment?(config)
+            return promise.reject(
+              "the 'environment' option must be configured " \
+              "with a Symbol (or String), but '#{config.environment.class}' was " \
+              "provided: #{config.environment}",
+            )
+          end
+
+          promise.resolve(:ok)
+        end
+
+        # Whether the given +config+ allows sending data to Celerbrake. It doesn't
+        # matter if it's valid or invalid.
+        #
+        # @param [Celerbrake::Config] config
+        # @since v4.1.0
+        def check_notify_ability(config)
+          promise = Celerbrake::Promise.new
+
+          unless config.error_notifications
+            return promise.reject('error notifications are disabled')
+          end
+
+          if ignored_environment?(config)
+            return promise.reject(
+              "current environment '#{config.environment}' is ignored",
+            )
+          end
+
+          promise.resolve(:ok)
+        end
+
+        private
+
+        def valid_project_id?(config)
+          return true if config.project_id.to_i > 0
+
+          false
+        end
+
+        def valid_project_key?(config)
+          return false unless config.project_key.is_a?(String)
+          return false if config.project_key.empty?
+
+          true
+        end
+
+        def valid_environment?(config)
+          VALID_ENV_TYPES.any? { |type| config.environment.is_a?(type) }
+        end
+
+        def ignored_environment?(config)
+          if config.ignore_environments.any? && config.environment.nil?
+            config.logger.warn(
+              "#{LOG_LABEL} the 'environment' option is not set, " \
+              "'ignore_environments' has no effect",
+            )
+          end
+
+          return false if config.ignore_environments.none? || !config.environment
+
+          env = config.environment.to_s
+          config.ignore_environments.any? do |pattern|
+            pattern.is_a?(Regexp) ? env.match(pattern) : env == pattern.to_s
+          end
+        end
+      end
+    end
+  end
+end