celerbrake-ruby 0.1.0

data/lib/celerbrake-ruby/config.rb

@@ -0,0 +1,291 @@
+module Celerbrake
+  # Represents the Celerbrake config. A config contains all the options that you
+  # can use to configure an Celerbrake instance.
+  #
+  # @api public
+  # @since v1.0.0
+  class Config
+    # @return [Integer] the project identificator. This value *must* be set.
+    # @api public
+    attr_accessor :project_id
+
+    # @return [String] the project key. This value *must* be set.
+    # @api public
+    attr_accessor :project_key
+
+    # @return [Hash] the proxy parameters such as (:host, :port, :user and
+    #   :password)
+    # @api public
+    attr_accessor :proxy
+
+    # @return [Logger] the default logger used for debug output
+    # @api public
+    attr_reader :logger
+
+    # @return [String] the version of the user's application
+    # @api public
+    attr_accessor :app_version
+
+    # @return [Hash{String=>String}] arbitrary versions that your app wants to
+    #   track
+    # @api public
+    # @since v2.10.0
+    attr_accessor :versions
+
+    # @return [Integer] the max number of notices that can be queued up
+    # @api public
+    attr_accessor :queue_size
+
+    # @return [Integer] the number of worker threads that process the notice
+    #   queue
+    # @api public
+    attr_accessor :workers
+
+    # @return [String] the host, which provides the API endpoint to which
+    #   exceptions should be sent
+    # @api public
+    # @since v5.0.0
+    attr_accessor :error_host
+
+    # @return [String] the host, which provides the API endpoint to which
+    #   APM data should be sent
+    # @api public
+    # @since v5.0.0
+    attr_accessor :apm_host
+
+    # @return [String, Pathname] the working directory of your project
+    # @api public
+    attr_accessor :root_directory
+
+    # @return [String, Symbol] the environment the application is running in
+    # @api public
+    attr_accessor :environment
+
+    # @return [Array<String,Symbol,Regexp>] the array of environments that
+    #   forbids sending exceptions when the application is running in them.
+    #   Other possible environments not listed in the array will allow sending
+    #   occurring exceptions.
+    # @api public
+    attr_accessor :ignore_environments
+
+    # @return [Integer] The HTTP timeout in seconds.
+    # @api public
+    attr_accessor :timeout
+
+    # @return [Array<String, Symbol, Regexp>] the keys, which should be
+    #   filtered
+    # @api public
+    # @since v4.15.0
+    attr_accessor :allowlist_keys
+
+    # @return [Array<String, Symbol, Regexp>] the keys, which should be
+    #   filtered
+    # @api public
+    # @since v4.15.0
+    attr_accessor :blocklist_keys
+
+    # @return [Boolean] true if the library should attach code hunks to each
+    #   frame in a backtrace, false otherwise
+    # @api public
+    # @since v2.5.0
+    attr_accessor :code_hunks
+
+    # @return [Boolean] true if the library should send route performance stats
+    #   to Celerbrake, false otherwise
+    # @api public
+    # @since v3.2.0
+    attr_accessor :performance_stats
+
+    # @return [Integer] how many seconds to wait before sending collected route
+    #   stats
+    # @api private
+    # @since v3.2.0
+    attr_accessor :performance_stats_flush_period
+
+    # @return [Boolean] true if the library should send SQL stats to Celerbrake,
+    #   false otherwise
+    # @api public
+    # @since v4.6.0
+    attr_accessor :query_stats
+
+    # @return [Boolean] true if the library should send job/queue/worker stats
+    #   to Celerbrake, false otherwise
+    # @api public
+    # @since v4.12.0
+    attr_accessor :job_stats
+
+    # @return [Boolean] true if the library should send error reports to
+    #   Celerbrake, false otherwise
+    # @api public
+    # @since v5.0.0
+    attr_accessor :error_notifications
+
+    # @return [String] the host which should be used for fetching remote
+    #   configuration options
+    # @api public
+    # @since v5.0.0
+    attr_accessor :remote_config_host
+
+    # @return [String] true if notifier should periodically fetch remote
+    #   configuration, false otherwise
+    # @api public
+    # @since v5.2.0
+    attr_accessor :remote_config
+
+    # @return [Boolean] true if the library should keep a backlog of failed
+    #   notices or APM events and retry them after an interval, false otherwise
+    # @api public
+    # @since v6.2.0
+    attr_accessor :backlog
+
+    class << self
+      # @return [Config]
+      attr_writer :instance
+
+      # @return [Config]
+      def instance
+        @instance ||= new
+      end
+    end
+
+    # @param [Hash{Symbol=>Object}] user_config the hash to be used to build the
+    #   config
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def initialize(user_config = {})
+      self.proxy = {}
+      self.queue_size = 100
+      self.workers = 1
+      self.code_hunks = true
+      self.logger = ::Logger.new(File::NULL).tap { |l| l.level = Logger::WARN }
+      self.project_id = user_config[:project_id]
+      self.project_key = user_config[:project_key]
+      self.error_host = self.apm_host = 'https://api.celerbrake.com'
+      self.remote_config_host = 'https://notifier-configs.celerbrake.com'
+
+      self.ignore_environments = []
+
+      self.timeout = user_config[:timeout]
+
+      self.blocklist_keys = []
+      self.allowlist_keys = []
+
+      self.root_directory = File.realpath(
+        (defined?(Bundler) && Bundler.root) ||
+        Dir.pwd,
+      )
+
+      self.versions = {}
+      self.performance_stats = true
+      self.performance_stats_flush_period = 15
+      self.query_stats = true
+      self.job_stats = true
+      self.error_notifications = true
+      # Celerbrake servers do not (yet) serve a remote-config endpoint, so we
+      # default this off to avoid polling a host we don't control. Set it to
+      # +true+ explicitly if your Celerbrake instance grows one.
+      self.remote_config = false
+      self.backlog = true
+
+      merge(user_config)
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    # The full URL to the Celerbrake Notice API. Based on the +:error_host+ option.
+    # @return [URI] the endpoint address
+    def error_endpoint
+      @error_endpoint ||=
+        begin
+          self.error_host = ('https://' << error_host) if error_host !~ %r{\Ahttps?://}
+          api = "api/v3/projects/#{project_id}/notices"
+          URI.join(error_host, api)
+        end
+    end
+
+    # Sets the logger. Never allows to assign `nil` as the logger.
+    # @return [Logger] the logger
+    def logger=(logger)
+      @logger = logger || @logger
+    end
+
+    # Merges the given +config_hash+ with itself.
+    #
+    # @example
+    #   config.merge(host: 'localhost:8080')
+    #
+    # @return [self] the merged config
+    def merge(config_hash)
+      config_hash.each_pair { |option, value| set_option(option, value) }
+      self
+    end
+
+    # @return [Boolean] true if the config meets the requirements, false
+    #   otherwise
+    def valid?
+      validate.resolved?
+    end
+
+    # @return [Promise]
+    # @see Validator.validate
+    def validate
+      Validator.validate(self)
+    end
+
+    # @return [Promise]
+    # @see Validator.check_notify_ability
+    def check_notify_ability
+      Validator.check_notify_ability(self)
+    end
+
+    # @return [Boolean] true if the config ignores current environment, false
+    #   otherwise
+    def ignored_environment?
+      check_notify_ability.rejected?
+    end
+
+    # @return [Promise] resolved promise if config is valid & can notify,
+    #   rejected otherwise
+    def check_configuration
+      promise = validate
+      return promise if promise.rejected?
+
+      check_notify_ability
+    end
+
+    # @return [Promise] resolved promise if neither of the performance options
+    #   reject it, false otherwise
+    def check_performance_options(metric)
+      promise = Celerbrake::Promise.new
+
+      if !performance_stats
+        promise.reject("The Performance Stats feature is disabled")
+      elsif metric.is_a?(Celerbrake::Query) && !query_stats
+        promise.reject("The Query Stats feature is disabled")
+      elsif metric.is_a?(Celerbrake::Queue) && !job_stats
+        promise.reject("The Job Stats feature is disabled")
+      else
+        promise
+      end
+    end
+
+    HOST_DEPRECATION_MSG = "**Celerbrake: the 'host' option is deprecated. Use " \
+      "'error_host' instead".freeze
+
+    def host
+      logger.warn(HOST_DEPRECATION_MSG)
+      @error_host
+    end
+
+    def host=(value)
+      logger.warn(HOST_DEPRECATION_MSG)
+      @error_host = value
+    end
+
+    private
+
+    def set_option(option, value)
+      __send__("#{option}=", value)
+    rescue NoMethodError
+      raise Celerbrake::Error, "unknown option '#{option}'"
+    end
+  end
+end

data/lib/celerbrake-ruby/context.rb

@@ -0,0 +1,51 @@
+module Celerbrake
+  # Represents a thread-safe Celerbrake context object, which carries arbitrary
+  # information added via {Celerbrake.merge_context} calls.
+  #
+  # @example
+  #   Celerbrake::Context.current.merge!(foo: 'bar')
+  #
+  # @api private
+  # @since v5.2.1
+  class Context
+    # Returns current, thread-local, context.
+    # @return [self]
+    def self.current
+      Thread.current[:celerbrake_context] ||= new
+    end
+
+    def initialize
+      @mutex = Mutex.new
+      @context = {}
+    end
+
+    # Merges the given context with the current one.
+    #
+    # @param [Hash{Object=>Object}] other
+    # @return [void]
+    def merge!(other)
+      @mutex.synchronize do
+        @context.merge!(other)
+      end
+    end
+
+    # @return [Hash] duplicated Hash context
+    def to_h
+      @mutex.synchronize do
+        @context.dup
+      end
+    end
+
+    # @return [Hash] clears (resets) the current context
+    def clear
+      @mutex.synchronize do
+        @context.clear
+      end
+    end
+
+    # @return [Boolean] checks whether the context has any data
+    def empty?
+      @context.empty?
+    end
+  end
+end

data/lib/celerbrake-ruby/deploy_notifier.rb

@@ -0,0 +1,36 @@
+module Celerbrake
+  # DeployNotifier sends deploy information to Celerbrake. The information
+  # consists of:
+  # - environment
+  # - username
+  # - repository
+  # - revision
+  # - version
+  #
+  # @api public
+  # @since v3.2.0
+  class DeployNotifier
+    include Inspectable
+
+    def initialize
+      @config = Celerbrake::Config.instance
+      @sender = SyncSender.new
+    end
+
+    # @see Celerbrake.notify_deploy
+    def notify(deploy_info)
+      promise = @config.check_configuration
+      return promise if promise.rejected?
+
+      promise = Celerbrake::Promise.new
+      deploy_info[:environment] ||= @config.environment
+      @sender.send(
+        deploy_info,
+        promise,
+        URI.join(@config.host, "api/v4/projects/#{@config.project_id}/deploys"),
+      )
+
+      promise
+    end
+  end
+end

data/lib/celerbrake-ruby/file_cache.rb

@@ -0,0 +1,54 @@
+module Celerbrake
+  # Extremely simple global cache.
+  #
+  # @api private
+  # @since v2.4.1
+  module FileCache
+    # @return [Integer]
+    MAX_SIZE = 50
+
+    # @return [Mutex]
+    MUTEX = Mutex.new
+
+    # Associates the value given by +value+ with the key given by +key+. Deletes
+    # entries that exceed +MAX_SIZE+.
+    #
+    # @param [Object] key
+    # @param [Object] value
+    # @return [Object] the corresponding value
+    def self.[]=(key, value)
+      MUTEX.synchronize do
+        data[key] = value
+        data.delete(data.keys.first) if data.size > MAX_SIZE
+      end
+    end
+
+    # Retrieve an object from the cache.
+    #
+    # @param [Object] key
+    # @return [Object] the corresponding value
+    def self.[](key)
+      MUTEX.synchronize do
+        data[key]
+      end
+    end
+
+    # Checks whether the cache is empty. Needed only for the test suite.
+    #
+    # @return [Boolean]
+    def self.empty?
+      data.empty?
+    end
+
+    # @since v4.7.0
+    # @return [void]
+    def self.reset
+      @data = {}
+    end
+
+    def self.data
+      @data ||= {}
+    end
+    private_class_method :data
+  end
+end

data/lib/celerbrake-ruby/filter_chain.rb

@@ -0,0 +1,112 @@
+module Celerbrake
+  # FilterChain represents an ordered array of filters.
+  #
+  # A filter is an object that responds to <b>#call</b> (typically a Proc or a
+  # class that implements the call method). The <b>#call</b> method must accept
+  # exactly one argument: an object to be filtered.
+  #
+  # When you add a new filter to the chain, it gets inserted according to its
+  # <b>weight</b>. Smaller weight means the filter will be somewhere in the
+  # beginning of the array. Larger - in the end. If a filter doesn't implement
+  # weight, the chain assumes it's equal to 0.
+  #
+  # @example
+  #   class MyFilter
+  #     attr_reader :weight
+  #
+  #     def initialize
+  #       @weight = 1
+  #     end
+  #
+  #     def call(obj)
+  #       puts 'Filtering...'
+  #       obj[:data] = '[Filtered]'
+  #     end
+  #   end
+  #
+  #   filter_chain = FilterChain.new
+  #   filter_chain.add_filter(MyFilter)
+  #
+  #   filter_chain.refine(obj)
+  #   #=> Filtering...
+  #
+  # @see Celerbrake.add_filter
+  # @api private
+  # @since v1.0.0
+  class FilterChain
+    # @return [Integer]
+    DEFAULT_WEIGHT = 0
+
+    def initialize
+      @filters = []
+    end
+
+    # Adds a filter to the filter chain. Sorts filters by weight.
+    #
+    # @param [#call] filter The filter object (proc, class, module, etc)
+    # @return [void]
+    def add_filter(filter)
+      @filters = (@filters << filter).sort_by do |f|
+        f.respond_to?(:weight) ? f.weight : DEFAULT_WEIGHT
+      end.reverse!
+    end
+
+    # Deletes a filter from the the filter chain.
+    #
+    # @param [Class] filter_class The class of the filter you want to delete
+    # @return [void]
+    # @since v3.1.0
+    def delete_filter(filter_class)
+      # rubocop:disable Style/ClassEqualityComparison
+      index = @filters.index { |f| f.class.name == filter_class.name }
+      # rubocop:enable Style/ClassEqualityComparison
+      @filters.delete_at(index) if index
+    end
+
+    # Applies all the filters in the filter chain to the given notice. Does not
+    # filter ignored notices.
+    #
+    # @param [Celerbrake::Notice] notice The notice to be filtered
+    # @return [void]
+    # @todo Make it work with anything, not only notices
+    def refine(notice)
+      @filters.each do |filter|
+        break if notice.ignored?
+
+        filter.call(notice)
+      end
+    end
+
+    # @return [String] customized inspect to lessen the amount of clutter
+    def inspect
+      filter_classes.to_s
+    end
+
+    # @return [String] {#inspect} for PrettyPrint
+    def pretty_print(q)
+      q.text('[')
+
+      # Make nesting of the first element consistent on JRuby and MRI.
+      q.nest(2) { q.breakable } if @filters.any?
+
+      q.nest(2) do
+        q.seplist(@filters) { |f| q.pp(f.class) }
+      end
+      q.text(']')
+    end
+
+    # @param [Class] filter_class
+    # @return [Boolean] true if the current chain has an instance of the given
+    #   class, false otherwise
+    # @since v4.14.0
+    def includes?(filter_class)
+      filter_classes.include?(filter_class)
+    end
+
+    private
+
+    def filter_classes
+      @filters.map(&:class)
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Celerbrake
+  module Filters
+    # Adds user context to the notice object. Clears the context after it's
+    # attached.
+    #
+    # @api private
+    # @since v2.9.0
+    class ContextFilter
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 119
+        @mutex = Mutex.new
+      end
+
+      # @macro call_filter
+      def call(notice)
+        @mutex.synchronize do
+          return if Celerbrake::Context.current.empty?
+
+          notice[:params][:celerbrake_context] = Celerbrake::Context.current.to_h
+          Celerbrake::Context.current.clear
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Celerbrake
+  module Filters
+    # Attaches loaded dependencies to the notice object.
+    #
+    # @api private
+    # @since v2.10.0
+    class DependencyFilter
+      def initialize
+        @weight = 117
+      end
+
+      # @macro call_filter
+      def call(notice)
+        deps = {}
+        Gem.loaded_specs.map.with_object(deps) do |(name, spec), h|
+          h[name] = "#{spec.version}#{git_version(spec)}"
+        end
+
+        notice[:context][:versions] = {} unless notice[:context].key?(:versions)
+        notice[:context][:versions][:dependencies] = deps
+      end
+
+      private
+
+      def git_version(spec)
+        return unless spec.respond_to?(:git_version) || spec.git_version
+
+        spec.git_version.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Celerbrake
+  module Filters
+    # ExceptionAttributesFilter attempts to call `#to_celerbrake` on the stashed
+    # exception and attaches returned data to the notice object.
+    #
+    # @api private
+    # @since v2.10.0
+    class ExceptionAttributesFilter
+      include Loggable
+
+      def initialize
+        @weight = 118
+      end
+
+      # @macro call_filter
+      def call(notice) # rubocop:disable Metrics/AbcSize
+        exception = notice.stash[:exception]
+        return unless exception.respond_to?(:to_celerbrake)
+
+        attributes = nil
+        begin
+          attributes = exception.to_celerbrake
+        rescue StandardError => ex
+          logger.error(
+            "#{LOG_LABEL} #{exception.class}#to_celerbrake failed. #{ex.class}: #{ex}",
+          )
+        end
+
+        unless attributes.is_a?(Hash)
+          logger.error(
+            "#{LOG_LABEL} #{self.class}: wanted Hash, got #{attributes.class}",
+          )
+          return
+        end
+
+        attributes.each do |key, attrs|
+          if notice[key]
+            notice[key].merge!(attrs)
+          else
+            notice[key] = attrs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Celerbrake
+  module Filters
+    # Replaces paths to gems with a placeholder.
+    # @api private
+    class GemRootFilter
+      # @return [String]
+      GEM_ROOT_LABEL = '/GEM_ROOT'.freeze
+
+      # @return [Integer]
+      attr_reader :weight
+
+      def initialize
+        @weight = 120
+      end
+
+      # @macro call_filter
+      def call(notice)
+        return unless defined?(Gem)
+
+        notice[:errors].each do |error|
+          Gem.path.each do |gem_path|
+            error[:backtrace].each do |frame|
+              # If the frame is unparseable, then 'file' is nil, thus nothing to
+              # filter (all frame's data is in 'function' instead).
+              next unless (file = frame[:file])
+
+              frame[:file] = file.sub(/\A#{gem_path}/, GEM_ROOT_LABEL)
+            end
+          end
+        end
+      end
+    end
+  end
+end