celerbrake-ruby 0.1.0

data/lib/celerbrake-ruby/filters/thread_filter.rb

@@ -0,0 +1,93 @@
+module Celerbrake
+  module Filters
+    # Attaches thread & fiber local variables along with general thread
+    # information.
+    # @api private
+    class ThreadFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      # @return [Array<Class>] the list of classes that can be safely converted
+      #   to JSON
+      SAFE_CLASSES = [
+        NilClass,
+        TrueClass,
+        FalseClass,
+        String,
+        Symbol,
+        Regexp,
+        Numeric,
+      ].freeze
+
+      # Variables starting with this prefix are not attached to a notice.
+      # @see https://github.com/celerbrake/celerbrake-ruby/issues/229
+      # @return [String]
+      IGNORE_PREFIX = '_'.freeze
+
+      def initialize
+        @weight = 110
+      end
+
+      # @macro call_filter
+      def call(notice)
+        th = Thread.current
+        thread_info = {}
+
+        if (vars = thread_variables(th)).any?
+          thread_info[:thread_variables] = vars
+        end
+
+        if (vars = fiber_variables(th)).any?
+          thread_info[:fiber_variables] = vars
+        end
+
+        if (name = th.name)
+          thread_info[:name] = name
+        end
+
+        add_thread_info(th, thread_info)
+
+        notice[:params][:thread] = thread_info
+      end
+
+      private
+
+      def thread_variables(th)
+        th.thread_variables.map.with_object({}) do |var, h|
+          next if var.to_s.start_with?(IGNORE_PREFIX)
+
+          h[var] = sanitize_value(th.thread_variable_get(var))
+        end
+      end
+
+      def fiber_variables(th)
+        th.keys.map.with_object({}) do |key, h|
+          next if key.to_s.start_with?(IGNORE_PREFIX)
+
+          h[key] = sanitize_value(th[key])
+        end
+      end
+
+      def add_thread_info(th, thread_info)
+        thread_info[:self] = th.inspect
+        thread_info[:group] = th.group.list.map(&:inspect)
+        thread_info[:priority] = th.priority
+
+        thread_info[:safe_level] = th.safe_level if Celerbrake::HAS_SAFE_LEVEL
+      end
+
+      def sanitize_value(value)
+        return value if SAFE_CLASSES.any? { |klass| value.is_a?(klass) }
+
+        case value
+        when Array
+          value = value.map { |elem| sanitize_value(elem) }
+        when Hash
+          value.transform_values { |v| sanitize_value(v) }
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/celerbrake-ruby/grouppable.rb

@@ -0,0 +1,12 @@
+module Celerbrake
+  # Grouppable adds the `#groups` method, so that we don't need to define it in
+  # all of performance models every time we add a model without groups.
+  #
+  # @since v4.9.0
+  # @api private
+  module Grouppable
+    def groups
+      {}
+    end
+  end
+end

data/lib/celerbrake-ruby/hash_keyable.rb

@@ -0,0 +1,37 @@
+module Celerbrake
+  # HashKeyable allows instances of the class to be used as a Hash key in a
+  # consistent manner.
+  #
+  # The class that includes it must implement *to_h*, which defines properties
+  # that all of the instances must share in order to produce the same {#hash}.
+  #
+  # @example
+  #   class C
+  #     include Celerbrake::HashKeyable
+  #
+  #     def initialize(key)
+  #       @key = key
+  #     end
+  #
+  #     def to_h
+  #       { 'key' => @key }
+  #     end
+  #   end
+  #
+  #   h = {}
+  #   h[C.new('key1')] = 1
+  #   h[C.new('key1')] #=> 1
+  #   h[C.new('key2')] #=> nil
+  module HashKeyable
+    # @param [Object] other
+    # @return [Boolean]
+    def eql?(other)
+      other.is_a?(self.class) && other.hash == hash
+    end
+
+    # @return [Integer]
+    def hash
+      to_h.hash
+    end
+  end
+end

data/lib/celerbrake-ruby/ignorable.rb

@@ -0,0 +1,43 @@
+module Celerbrake
+  # Ignorable contains methods that allow the includee to be ignored.
+  #
+  # @example
+  #   class A
+  #     include Celerbrake::Ignorable
+  #   end
+  #
+  #   a = A.new
+  #   a.ignore!
+  #   a.ignored? #=> true
+  #
+  # @since v3.2.0
+  # @api private
+  module Ignorable
+    attr_accessor :ignored
+
+    # Checks whether the instance was ignored.
+    # @return [Boolean]
+    # @see #ignore!
+    def ignored?
+      !!ignored
+    end
+
+    # Ignores an instance. Ignored instances must never reach the Celerbrake
+    # dashboard.
+    # @return [void]
+    # @see #ignored?
+    def ignore!
+      self.ignored = true
+    end
+
+    private
+
+    # A method that is meant to be used as a guard.
+    # @raise [Celerbrake::Error] when instance is ignored
+    def raise_if_ignored
+      return unless ignored?
+
+      raise Celerbrake::Error, "cannot access ignored #{self.class}"
+    end
+  end
+end

data/lib/celerbrake-ruby/inspectable.rb

@@ -0,0 +1,39 @@
+module Celerbrake
+  # Inspectable provides custom inspect methods that reduce clutter printed in
+  # REPLs for notifier objects. These custom methods display only essential
+  # information such as project id/key and filters.
+  #
+  # @since v3.2.6
+  # @api private
+  module Inspectable
+    # @return [String] inspect output template
+    INSPECT_TEMPLATE =
+      "#<%<classname>s:0x%<id>s project_id=\"%<project_id>s\" " \
+      "project_key=\"%<project_key>s\" " \
+      "host=\"%<host>s\" filter_chain=%<filter_chain>s>".freeze
+
+    # @return [String] customized inspect to lessen the amount of clutter
+    def inspect
+      format(
+        INSPECT_TEMPLATE,
+        classname: self.class.name,
+        id: (object_id << 1).to_s(16).rjust(16, '0'),
+        project_id: @config.project_id,
+        project_key: @config.project_key,
+        host: @config.host,
+        filter_chain: @filter_chain.inspect,
+      )
+    end
+
+    # @return [String] {#inspect} for PrettyPrint
+    def pretty_print(q)
+      q.text("#<#{self.class}:0x#{(object_id << 1).to_s(16).rjust(16, '0')} ")
+      q.text(
+        "project_id=\"#{@config.project_id}\" project_key=\"#{@config.project_key}\" " \
+        "host=\"#{@config.host}\" filter_chain=",
+      )
+      q.pp(@filter_chain)
+      q.text('>')
+    end
+  end
+end

data/lib/celerbrake-ruby/loggable.rb

@@ -0,0 +1,34 @@
+module Celerbrake
+  # Loggable is included into any class that wants to be able to log.
+  #
+  # By default, Loggable defines a null logger that doesn't do anything. You are
+  # supposed to overwrite it via the {instance} method before calling {logger}.
+  #
+  # @example
+  #   class A
+  #     include Loggable
+  #
+  #     def initialize
+  #       logger.debug('Initialized A')
+  #     end
+  #   end
+  #
+  # @since v4.0.0
+  # @api private
+  module Loggable
+    class << self
+      # @return [Logger]
+      attr_writer :instance
+
+      # @return [Logger]
+      def instance
+        @instance ||= ::Logger.new(File::NULL).tap { |l| l.level = ::Logger::WARN }
+      end
+    end
+
+    # @return [Logger] standard Ruby logger object
+    def logger
+      Loggable.instance
+    end
+  end
+end

data/lib/celerbrake-ruby/mergeable.rb

@@ -0,0 +1,12 @@
+module Celerbrake
+  # Mergeable adds the `#merge` method, so that we don't need to define it in
+  # all of performance models every time we add a model.
+  #
+  # @since v4.9.0
+  # @api private
+  module Mergeable
+    def merge(_other)
+      nil
+    end
+  end
+end

data/lib/celerbrake-ruby/monotonic_time.rb

@@ -0,0 +1,48 @@
+module Celerbrake
+  # MonotonicTime is a helper for getting monotonic time suitable for
+  # performance measurements. It guarantees that the time is strictly linearly
+  # increasing (unlike realtime).
+  #
+  # @example
+  #   MonotonicTime.time_in_ms #=> 287138801.144576
+  #
+  # @see http://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_getres.html
+  # @since v4.2.4
+  # @api private
+  module MonotonicTime
+    class << self
+      # @return [Integer] current monotonic time in milliseconds
+      def time_in_ms
+        time_in_nanoseconds / (10.0**6)
+      end
+
+      # @return [Integer] current monotonic time in seconds
+      def time_in_s
+        time_in_nanoseconds / (10.0**9)
+      end
+
+      private
+
+      if defined?(Process::CLOCK_MONOTONIC)
+
+        def time_in_nanoseconds
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+        end
+
+      elsif RUBY_ENGINE == 'jruby'
+
+        def time_in_nanoseconds
+          java.lang.System.nanoTime
+        end
+
+      else
+
+        def time_in_nanoseconds
+          time = Time.now
+          (time.to_i * (10**9)) + time.nsec
+        end
+
+      end
+    end
+  end
+end

data/lib/celerbrake-ruby/nested_exception.rb

@@ -0,0 +1,59 @@
+module Celerbrake
+  # A class that is capable of unwinding nested exceptions and representing them
+  # as JSON-like hash.
+  #
+  # @api private
+  # @since v1.0.4
+  class NestedException
+    # @return [Integer] the maximum number of nested exceptions that a notice
+    #   can unwrap. Exceptions that have a longer cause chain will be ignored
+    MAX_NESTED_EXCEPTIONS = 3
+
+    # On Ruby 3.1+, the error highlighting gem can produce messages that can
+    # span multiple lines. We don't display multiline error messages in the
+    # title of the notice in the Celerbrake dashboard. Therefore, we want to strip
+    # out the higlighting part so that the errors look consistent. The full
+    # message with the exception will be attached to the notice body.
+    #
+    # @return [String]
+    RUBY_31_ERROR_HIGHLIGHTING_DIVIDER = "\n\n".freeze
+
+    # @return [Hash] the options for +String#encode+
+    ENCODING_OPTIONS = { invalid: :replace, undef: :replace }.freeze
+
+    def initialize(exception)
+      @exception = exception
+    end
+
+    def as_json
+      unwind_exceptions.map do |exception|
+        { type: exception.class.name,
+          message: message(exception),
+          backtrace: Backtrace.parse(exception) }
+      end
+    end
+
+    private
+
+    def unwind_exceptions
+      exception_list = []
+      exception = @exception
+
+      while exception && exception_list.size < MAX_NESTED_EXCEPTIONS
+        exception_list << exception
+        exception = (exception.cause if exception.respond_to?(:cause))
+      end
+
+      exception_list
+    end
+
+    def message(exception)
+      return unless (msg = exception.message)
+
+      msg
+        .encode(Encoding::UTF_8, **ENCODING_OPTIONS)
+        .split(RUBY_31_ERROR_HIGHLIGHTING_DIVIDER)
+        .first
+    end
+  end
+end

data/lib/celerbrake-ruby/notice.rb

@@ -0,0 +1,157 @@
+module Celerbrake
+  # Represents a chunk of information that is meant to be either sent to
+  # Celerbrake or ignored completely.
+  #
+  # @since v1.0.0
+  class Notice
+    # @return [Hash{Symbol=>String,Hash}] the information to be displayed in the
+    #   Context tab in the dashboard
+    CONTEXT = {
+      os: RUBY_PLATFORM,
+      language: "#{RUBY_ENGINE}/#{RUBY_VERSION}".freeze,
+      notifier: Celerbrake::NOTIFIER_INFO,
+    }.freeze
+
+    # @return [Integer] the maxium size of the JSON payload in bytes
+    MAX_NOTICE_SIZE = 64000
+
+    # @return [Integer] the maximum size of hashes, arrays and strings in the
+    #   notice.
+    PAYLOAD_MAX_SIZE = 10000
+
+    # @return [Array<StandardError>] the list of possible exceptions that might
+    #   be raised when an object is converted to JSON
+    JSON_EXCEPTIONS = [
+      IOError,
+      NotImplementedError,
+      JSON::GeneratorError,
+      Encoding::UndefinedConversionError,
+    ].freeze
+
+    # @return [Array<Symbol>] the list of keys that can be be overwritten with
+    #   {Celerbrake::Notice#[]=}
+    WRITABLE_KEYS = %i[notifier context environment session params].freeze
+
+    # @return [Array<Symbol>] parts of a Notice's payload that can be modified
+    #   by the truncator
+    TRUNCATABLE_KEYS = %i[errors environment session params].freeze
+
+    # @return [String] the name of the host machine
+    HOSTNAME = Socket.gethostname.freeze
+
+    # @return [String]
+    DEFAULT_SEVERITY = 'error'.freeze
+
+    include Ignorable
+    include Loggable
+    include Stashable
+
+    # @api private
+    def initialize(exception, params = {})
+      @config = Celerbrake::Config.instance
+      @truncator = Celerbrake::Truncator.new(PAYLOAD_MAX_SIZE)
+
+      @payload = {
+        errors: NestedException.new(exception).as_json,
+        context: context(exception),
+        environment: {
+          program_name: $PROGRAM_NAME,
+        },
+        session: {},
+        params: params,
+      }
+
+      stash[:exception] = exception
+    end
+
+    # Converts the notice to JSON. Calls +to_json+ on each object inside
+    # notice's payload. Truncates notices, JSON representation of which is
+    # bigger than {MAX_NOTICE_SIZE}.
+    #
+    # @return [Hash{String=>String}, nil]
+    # @api private
+    def to_json(*_args)
+      loop do
+        begin
+          json = @payload.to_json
+        rescue *JSON_EXCEPTIONS => ex
+          logger.debug("#{LOG_LABEL} `notice.to_json` failed: #{ex.class}: #{ex}")
+        else
+          return json if json && json.bytesize <= MAX_NOTICE_SIZE
+        end
+
+        break if truncate == 0
+      end
+    end
+
+    # Reads a value from notice's payload.
+    #
+    # @return [Object]
+    # @raise [Celerbrake::Error] if the notice is ignored
+    def [](key)
+      raise_if_ignored
+      @payload[key]
+    end
+
+    # Writes a value to the payload hash. Restricts unrecognized writes.
+    #
+    # @example
+    #   notice[:params][:my_param] = 'foobar'
+    #
+    # @return [void]
+    # @raise [Celerbrake::Error] if the notice is ignored
+    # @raise [Celerbrake::Error] if the +key+ is not recognized
+    # @raise [Celerbrake::Error] if the root value is not a Hash
+    def []=(key, value)
+      raise_if_ignored
+
+      unless WRITABLE_KEYS.include?(key)
+        raise Celerbrake::Error,
+              ":#{key} is not recognized among #{WRITABLE_KEYS}"
+      end
+
+      unless value.respond_to?(:to_hash)
+        raise Celerbrake::Error, "Got #{value.class} value, wanted a Hash"
+      end
+
+      @payload[key] = value.to_hash
+    end
+
+    private
+
+    def context(exception)
+      {
+        version: @config.app_version,
+        versions: @config.versions,
+        # We ensure that root_directory is always a String, so it can always be
+        # converted to JSON in a predictable manner (when it's a Pathname and in
+        # Rails environment, it converts to unexpected JSON).
+        rootDirectory: @config.root_directory.to_s,
+        environment: @config.environment,
+
+        # Make sure we always send hostname.
+        hostname: HOSTNAME,
+
+        severity: DEFAULT_SEVERITY,
+        error_message: @truncator.truncate(exception.message),
+      }.merge(CONTEXT).delete_if { |_key, val| val.nil? || val.empty? }
+    end
+
+    def truncate
+      TRUNCATABLE_KEYS.each do |key|
+        @payload[key] = @truncator.truncate(@payload[key])
+      end
+
+      new_max_size = @truncator.reduce_max_size
+      if new_max_size == 0
+        logger.error(
+          "#{LOG_LABEL} truncation failed. File an issue at " \
+          "https://github.com/celerbrake/celerbrake-ruby " \
+          "and attach the following payload: #{@payload}",
+        )
+      end
+
+      new_max_size
+    end
+  end
+end

data/lib/celerbrake-ruby/notice_notifier.rb

@@ -0,0 +1,142 @@
+module Celerbrake
+  # NoticeNotifier is reponsible for sending notices to Celerbrake. It supports
+  # synchronous and asynchronous delivery.
+  #
+  # @see Celerbrake::Config The list of options
+  # @since v1.0.0
+  # @api public
+  class NoticeNotifier
+    # @return [Array<Class>] filters to be executed first
+    DEFAULT_FILTERS = [
+      Celerbrake::Filters::SystemExitFilter,
+      Celerbrake::Filters::GemRootFilter,
+
+      # Optional filters (must be included by users):
+      # Celerbrake::Filters::ThreadFilter
+    ].freeze
+
+    include Inspectable
+    include Loggable
+
+    def initialize
+      @config = Celerbrake::Config.instance
+      @filter_chain = FilterChain.new
+      @async_sender = AsyncSender.new(:post, self.class.name)
+      @sync_sender = SyncSender.new
+
+      DEFAULT_FILTERS.each { |filter| add_filter(filter.new) }
+
+      add_filter(Celerbrake::Filters::ContextFilter.new)
+      add_filter(Celerbrake::Filters::ExceptionAttributesFilter.new)
+    end
+
+    # @see Celerbrake.notify
+    def notify(exception, params = {}, &block)
+      send_notice(exception, params, default_sender, &block)
+    end
+
+    # @see Celerbrake.notify_sync
+    def notify_sync(exception, params = {}, &block)
+      send_notice(exception, params, @sync_sender, &block).value
+    end
+
+    # @see Celerbrake.add_filte
+    def add_filter(filter = nil, &block)
+      @filter_chain.add_filter(block_given? ? block : filter)
+    end
+
+    # @see Celerbrake.delete_filter
+    def delete_filter(filter_class)
+      @filter_chain.delete_filter(filter_class)
+    end
+
+    # @see Celerbrake.build_notice
+    def build_notice(exception, params = {})
+      if @async_sender.closed?
+        raise Celerbrake::Error,
+              "Celerbrake is closed; can't build exception: " \
+              "#{exception.class}: #{exception}"
+      end
+
+      if exception.is_a?(Celerbrake::Notice)
+        exception[:params].merge!(params)
+        exception
+      else
+        Notice.new(convert_to_exception(exception), params.dup)
+      end
+    end
+
+    # @see Celerbrake.close
+    def close
+      @sync_sender.close
+      @async_sender.close
+    end
+
+    # @see Celerbrake.configured?
+    def configured?
+      @config.valid?
+    end
+
+    # @see Celerbrake.merge_context
+    def merge_context(context)
+      Celerbrake::Context.current.merge!(context)
+    end
+
+    # @return [Boolean]
+    # @since v4.14.0
+    def has_filter?(filter_class) # rubocop:disable Naming/PredicateName
+      @filter_chain.includes?(filter_class)
+    end
+
+    private
+
+    def convert_to_exception(ex)
+      if ex.is_a?(Exception) || Backtrace.java_exception?(ex)
+        # Manually created exceptions don't have backtraces, so we create a fake
+        # one, whose first frame points to the place where Celerbrake was called
+        # (normally via `notify`).
+        ex.set_backtrace(clean_backtrace) unless ex.backtrace
+        return ex
+      end
+
+      e = RuntimeError.new(ex.to_s)
+      e.set_backtrace(clean_backtrace)
+      e
+    end
+
+    def send_notice(exception, params, sender)
+      promise = @config.check_configuration
+      return promise if promise.rejected?
+
+      notice = build_notice(exception, params)
+      yield notice if block_given?
+      @filter_chain.refine(notice)
+
+      promise = Celerbrake::Promise.new
+      return promise.reject("#{notice} was marked as ignored") if notice.ignored?
+
+      sender.send(notice, promise)
+    end
+
+    def default_sender
+      return @async_sender if @async_sender.has_workers?
+
+      logger.warn(
+        "#{LOG_LABEL} falling back to sync delivery because there are no " \
+        "running async workers",
+      )
+      @sync_sender
+    end
+
+    def clean_backtrace
+      caller_copy = Kernel.caller
+      clean_bt = caller_copy.drop_while { |frame| frame.include?('/lib/celerbrake') }
+
+      # If true, then it's likely an internal library error. In this case return
+      # at least some backtrace to simplify debugging.
+      return caller_copy if clean_bt.empty?
+
+      clean_bt
+    end
+  end
+end