celerbrake-ruby 0.1.0

data/lib/celerbrake-ruby/performance_breakdown.rb

@@ -0,0 +1,52 @@
+module Celerbrake
+  # PerformanceBreakdown holds data that shows how much time a request spent
+  # doing certaing subtasks such as (DB querying, view rendering, etc).
+  #
+  # @see Celerbrake.notify_breakdown
+  # @api public
+  # @since v4.2.0
+  # rubocop:disable Metrics/ParameterLists
+  class PerformanceBreakdown
+    include HashKeyable
+    include Ignorable
+    include Stashable
+    include Mergeable
+
+    attr_accessor :method, :route, :response_type, :groups, :timing, :time
+
+    def initialize(
+      method:,
+      route:,
+      response_type:,
+      groups:,
+      timing: nil,
+      time: Time.now
+    )
+      @time_utc = TimeTruncate.utc_truncate_minutes(time)
+      @method = method
+      @route = route
+      @response_type = response_type
+      @groups = groups
+      @timing = timing
+      @time = time
+    end
+
+    def destination
+      'routes-breakdowns'
+    end
+
+    def cargo
+      'routes'
+    end
+
+    def to_h
+      {
+        'method' => method,
+        'route' => route,
+        'responseType' => response_type,
+        'time' => @time_utc,
+      }.delete_if { |_key, val| val.nil? }
+    end
+  end
+  # rubocop:enable Metrics/ParameterLists
+end

data/lib/celerbrake-ruby/performance_notifier.rb

@@ -0,0 +1,177 @@
+module Celerbrake
+  # PerformanceNotifier aggregates performance data and periodically sends it to
+  # Celerbrake.
+  #
+  # @api public
+  # @since v3.2.0
+  # rubocop:disable Metrics/ClassLength
+  class PerformanceNotifier
+    include Inspectable
+    include Loggable
+
+    def initialize
+      @config = Celerbrake::Config.instance
+      @flush_period = Celerbrake::Config.instance.performance_stats_flush_period
+      @async_sender = AsyncSender.new(:put, self.class.name)
+      @sync_sender = SyncSender.new(:put)
+      @schedule_flush = nil
+      @filter_chain = FilterChain.new
+
+      @payload = {}.extend(MonitorMixin)
+      @has_payload = @payload.new_cond
+    end
+
+    # @param [Hash] metric
+    # @see Celerbrake.notify_query
+    # @see Celerbrake.notify_request
+    def notify(metric)
+      @payload.synchronize do
+        send_metric(metric, sync: false)
+      end
+    end
+
+    # @param [Hash] metric
+    # @since v4.10.0
+    # @see Celerbrake.notify_queue_sync
+    def notify_sync(metric)
+      send_metric(metric, sync: true).value
+    end
+
+    # @see Celerbrake.add_performance_filter
+    def add_filter(filter = nil, &block)
+      @filter_chain.add_filter(block_given? ? block : filter)
+    end
+
+    # @see Celerbrake.delete_performance_filter
+    def delete_filter(filter_class)
+      @filter_chain.delete_filter(filter_class)
+    end
+
+    def close
+      @payload.synchronize do
+        @schedule_flush.kill if @schedule_flush
+        @sync_sender.close
+        @async_sender.close
+      end
+    end
+
+    private
+
+    def schedule_flush
+      @schedule_flush ||= Thread.new do
+        loop do
+          @payload.synchronize do
+            @last_flush_time ||= MonotonicTime.time_in_s
+
+            while (MonotonicTime.time_in_s - @last_flush_time) < @flush_period
+              @has_payload.wait(@flush_period)
+            end
+
+            if @payload.none?
+              @last_flush_time = nil
+              next
+            end
+
+            send(@async_sender, @payload, Celerbrake::Promise.new)
+            @payload.clear
+          end
+        end
+      end
+    end
+
+    def send_metric(metric, sync:)
+      promise = check_configuration(metric)
+      return promise if promise.rejected?
+
+      @filter_chain.refine(metric)
+      if metric.ignored?
+        return Promise.new.reject("#{metric.class} was ignored by a filter")
+      end
+
+      update_payload(metric)
+      if sync || @flush_period == 0
+        send(@sync_sender, @payload, promise)
+      else
+        @has_payload.signal
+        schedule_flush
+      end
+    end
+
+    def update_payload(metric)
+      if (total_stat = @payload[metric])
+        @payload.key(total_stat).merge(metric)
+      else
+        @payload[metric] = { total: Celerbrake::Stat.new }
+      end
+
+      @payload[metric][:total].increment_ms(metric.timing)
+
+      metric.groups.each do |name, ms|
+        @payload[metric][name] ||= Celerbrake::Stat.new
+        @payload[metric][name].increment_ms(ms)
+      end
+    end
+
+    def check_configuration(metric)
+      promise = @config.check_configuration
+      return promise if promise.rejected?
+
+      promise = @config.check_performance_options(metric)
+      return promise if promise.rejected?
+
+      if metric.timing && metric.timing == 0
+        return Promise.new.reject(':timing cannot be zero')
+      end
+
+      Promise.new
+    end
+
+    def send(sender, payload, promise)
+      raise "payload cannot be empty. Race?" if payload.none?
+
+      with_grouped_payload(payload) do |metric_hash, destination|
+        url = URI.join(
+          @config.apm_host,
+          "api/v5/projects/#{@config.project_id}/#{destination}",
+        )
+
+        logger.debug do
+          "#{LOG_LABEL} #{self.class.name}##{__method__}: #{metric_hash}"
+        end
+        sender.send(metric_hash, promise, url)
+      end
+
+      promise
+    end
+
+    def with_grouped_payload(raw_payload)
+      grouped_payload = raw_payload.group_by do |metric, _stats|
+        [metric.cargo, metric.destination]
+      end
+
+      grouped_payload.each do |(cargo, destination), metrics|
+        payload = {}
+        payload[cargo] = serialize_metrics(metrics)
+        payload['environment'] = @config.environment if @config.environment
+
+        yield(payload, destination)
+      end
+    end
+
+    def serialize_metrics(metrics)
+      metrics.map do |metric, stats|
+        metric_hash = metric.to_h.merge!(stats[:total].to_h)
+
+        if metric.groups.any?
+          group_stats = stats.reject { |name, _stat| name == :total }
+          metric_hash['groups'] = group_stats.merge(group_stats) do |_name, stat|
+            stat.to_h
+          end
+        end
+
+        metric_hash
+      end
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/celerbrake-ruby/promise.rb

@@ -0,0 +1,110 @@
+module Celerbrake
+  # Represents a simplified promise object (similar to promises found in
+  # JavaScript), which allows chaining callbacks that are executed when the
+  # promise is either resolved or rejected.
+  #
+  # @see https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise
+  # @see https://github.com/ruby-concurrency/concurrent-ruby/blob/master/lib/concurrent/promise.rb
+  # @since v1.7.0
+  class Promise
+    def initialize
+      @on_resolved = []
+      @on_rejected = []
+      @value = {}
+      @mutex = Mutex.new
+    end
+
+    # Attaches a callback to be executed when the promise is resolved.
+    #
+    # @example
+    #   Celerbrake::Promise.new.then { |response| puts response }
+    #   #=> {"id"=>"00054415-8201-e9c6-65d6-fc4d231d2871",
+    #   #    "url"=>"http://localhost/locate/00054415-8201-e9c6-65d6-fc4d231d2871"}
+    #
+    # @yield [response]
+    # @yieldparam response [Hash<String,String>] Contains the `id` & `url` keys
+    # @return [self]
+    def then(&block)
+      @mutex.synchronize do
+        if @value.key?('ok')
+          yield(@value['ok'])
+          return self
+        end
+
+        @on_resolved << block
+      end
+
+      self
+    end
+
+    # Attaches a callback to be executed when the promise is rejected.
+    #
+    # @example
+    #   Celerbrake::Promise.new.rescue { |error| raise error }
+    #
+    # @yield [error] The error message from the API
+    # @yieldparam error [String]
+    # @return [self]
+    def rescue(&block)
+      @mutex.synchronize do
+        if @value.key?('error')
+          yield(@value['error'])
+          return self
+        end
+
+        @on_rejected << block
+      end
+
+      self
+    end
+
+    # @example
+    #   Celerbrake::Promise.new.resolve('id' => '123')
+    #
+    # @param reason [Object]
+    # @return [self]
+    def resolve(reason = 'resolved')
+      @mutex.synchronize do
+        @value['ok'] = reason
+        @on_resolved.each { |callback| callback.call(reason) }
+      end
+
+      self
+    end
+
+    # @example
+    #   Celerbrake::Promise.new.reject('Something went wrong')
+    #
+    # @param reason [String]
+    # @return [self]
+    def reject(reason = 'rejected')
+      @mutex.synchronize do
+        @value['error'] = reason
+        @on_rejected.each { |callback| callback.call(reason) }
+      end
+
+      self
+    end
+
+    # @return [Boolean]
+    def rejected?
+      @value.key?('error')
+    end
+
+    # @return [Boolean]
+    def resolved?
+      @value.key?('ok')
+    end
+
+    # @return [Hash<String,String>] either successful response containing the
+    #   +id+ key or unsuccessful response containing the +error+ key
+    # @note This is a non-blocking call!
+    # @todo Get rid of this method and use an accessor. The resolved guard is
+    #   needed for compatibility but it shouldn't exist in the future
+    def value
+      return @value['ok'] if resolved?
+
+      @value
+    end
+  end
+end

data/lib/celerbrake-ruby/query.rb

@@ -0,0 +1,59 @@
+module Celerbrake
+  # Query holds SQL query data that powers SQL query collection.
+  #
+  # @see Celerbrake.notify_query
+  # @api public
+  # @since v3.2.0
+  # rubocop:disable Metrics/ParameterLists
+  class Query
+    include HashKeyable
+    include Ignorable
+    include Stashable
+    include Mergeable
+    include Grouppable
+
+    attr_accessor :method, :route, :query, :func, :file, :line, :timing, :time
+
+    def initialize(
+      method:,
+      route:,
+      query:,
+      func: nil,
+      file: nil,
+      line: nil,
+      timing: nil,
+      time: Time.now
+    )
+      @time_utc = TimeTruncate.utc_truncate_minutes(time)
+      @method = method
+      @route = route
+      @query = query
+      @func = func
+      @file = file
+      @line = line
+      @timing = timing
+      @time = time
+    end
+
+    def destination
+      'queries-stats'
+    end
+
+    def cargo
+      'queries'
+    end
+
+    def to_h
+      {
+        'method' => method,
+        'route' => route,
+        'query' => query,
+        'time' => @time_utc,
+        'function' => func,
+        'file' => file,
+        'line' => line,
+      }.delete_if { |_key, val| val.nil? }
+    end
+    # rubocop:enable Metrics/ParameterLists
+  end
+end

data/lib/celerbrake-ruby/queue.rb

@@ -0,0 +1,65 @@
+module Celerbrake
+  # Queue represents a queue (worker).
+  #
+  # @see Celerbrake.notify_queue
+  # @api public
+  # @since v4.9.0
+  class Queue
+    include HashKeyable
+    include Ignorable
+    include Stashable
+
+    attr_accessor :queue, :error_count, :groups, :timing, :time
+
+    def initialize(
+      queue:,
+      error_count:,
+      groups: {},
+      timing: nil,
+      time: Time.now
+    )
+      @time_utc = TimeTruncate.utc_truncate_minutes(time)
+      @queue = queue
+      @error_count = error_count
+      @groups = groups
+      @timing = timing
+      @time = time
+    end
+
+    def destination
+      'queues-stats'
+    end
+
+    def cargo
+      'queues'
+    end
+
+    def to_h
+      {
+        'queue' => queue,
+        'errorCount' => error_count,
+        'time' => @time_utc,
+      }
+    end
+
+    def hash
+      {
+        'queue' => queue,
+        'time' => @time_utc,
+      }.hash
+    end
+
+    def merge(other)
+      self.error_count += other.error_count
+    end
+
+    # Queues don't have routes, but we want to define this to make sure our
+    # filter API is consistent (other models define this property)
+    #
+    # @return [String] empty route
+    # @see https://github.com/celerbrake/celerbrake-ruby/pull/537
+    def route
+      ''
+    end
+  end
+end

data/lib/celerbrake-ruby/remote_settings/callback.rb

@@ -0,0 +1,44 @@
+module Celerbrake
+  class RemoteSettings
+    # Callback is a class that provides a callback for the config poller, which
+    # updates the local config according to the data.
+    #
+    # @api private
+    # @since v5.0.2
+    class Callback
+      def initialize(config)
+        @config = config
+        @orig_error_notifications = config.error_notifications
+        @orig_performance_stats = config.performance_stats
+      end
+
+      # @param [Celerbrake::RemoteSettings::SettingsData] data
+      # @return [void]
+      def call(data)
+        @config.logger.debug do
+          "#{LOG_LABEL} applying remote settings: #{data.to_h}"
+        end
+
+        @config.error_host = data.error_host if data.error_host
+        @config.apm_host = data.apm_host if data.apm_host
+
+        process_error_notifications(data)
+        process_performance_stats(data)
+      end
+
+      private
+
+      def process_error_notifications(data)
+        return unless @orig_error_notifications
+
+        @config.error_notifications = data.error_notifications?
+      end
+
+      def process_performance_stats(data)
+        return unless @orig_performance_stats
+
+        @config.performance_stats = data.performance_stats?
+      end
+    end
+  end
+end

data/lib/celerbrake-ruby/remote_settings/settings_data.rb

@@ -0,0 +1,116 @@
+module Celerbrake
+  class RemoteSettings
+    # SettingsData is a container, which wraps JSON payload returned by the
+    # remote settings API. It exposes the payload via convenient methods and
+    # also ensures that in case some data from the payload is missing, a default
+    # value would be returned instead.
+    #
+    # @example
+    #   # Create the object and pass initial data (empty hash).
+    #   settings_data = SettingsData.new({})
+    #
+    #   settings_data.interval #=> 600
+    #
+    # @since v5.0.0
+    # @api private
+    class SettingsData
+      # @return [Integer] how frequently we should poll the config API
+      DEFAULT_INTERVAL = 600
+
+      # @return [String] API version of the S3 API to poll
+      API_VER = '2020-06-18'.freeze
+
+      # @return [String] what path to poll
+      CONFIG_ROUTE_PATTERN =
+        "%<host>s/#{API_VER}/config/%<project_id>s/config.json".freeze
+
+      # @return [Hash{Symbol=>String}] the hash of all supported settings where
+      #   the value is the name of the setting returned by the API
+      SETTINGS = {
+        errors: 'errors'.freeze,
+        apm: 'apm'.freeze,
+      }.freeze
+
+      # @param [Integer] project_id
+      # @param [Hash{String=>Object}] data
+      def initialize(project_id, data)
+        @project_id = project_id
+        @data = data
+      end
+
+      # Merges the given +hash+ with internal data.
+      #
+      # @param [Hash{String=>Object}] hash
+      # @return [self]
+      def merge!(hash)
+        @data.merge!(hash)
+
+        self
+      end
+
+      # @return [Integer] how frequently we should poll for the config
+      def interval
+        return DEFAULT_INTERVAL if !@data.key?('poll_sec') || !@data['poll_sec']
+
+        @data['poll_sec'] > 0 ? @data['poll_sec'] : DEFAULT_INTERVAL
+      end
+
+      # @param [String] remote_config_host
+      # @return [String] where the config is stored on S3.
+      def config_route(remote_config_host)
+        if @data['config_route'] && !@data['config_route'].empty?
+          return "#{remote_config_host.chomp('/')}/#{@data['config_route']}"
+        end
+
+        format(
+          CONFIG_ROUTE_PATTERN,
+          host: remote_config_host.chomp('/'),
+          project_id: @project_id,
+        )
+      end
+
+      # @return [Boolean] whether error notifications are enabled
+      def error_notifications?
+        return true unless (s = find_setting(SETTINGS[:errors]))
+
+        s['enabled']
+      end
+
+      # @return [Boolean] whether APM is enabled
+      def performance_stats?
+        return true unless (s = find_setting(SETTINGS[:apm]))
+
+        s['enabled']
+      end
+
+      # @return [String, nil] the host, which provides the API endpoint to which
+      #   exceptions should be sent
+      def error_host
+        return unless (s = find_setting(SETTINGS[:errors]))
+
+        s['endpoint']
+      end
+
+      # @return [String, nil] the host, which provides the API endpoint to which
+      #   APM data should be sent
+      def apm_host
+        return unless (s = find_setting(SETTINGS[:apm]))
+
+        s['endpoint']
+      end
+
+      # @return [Hash{String=>Object}] raw representation of JSON payload
+      def to_h
+        @data.dup
+      end
+
+      private
+
+      def find_setting(name)
+        return unless @data.key?('settings')
+
+        @data['settings'].find { |s| s['name'] == name }
+      end
+    end
+  end
+end