pig-ci-rails 0.1.0

data/lib/pig_ci/api.rb

@@ -0,0 +1,14 @@
+require 'httparty'
+
+class PigCI::Api
+  include HTTParty
+
+  def headers
+    {
+      'Content-Type': 'application/json',
+      'X-ApiKey': PigCI.api_key
+    }
+  end
+end
+
+require 'pig_ci/api/reports'

data/lib/pig_ci/api/reports.rb

@@ -0,0 +1,36 @@
+class PigCI::Api::Reports < PigCI::Api
+  def initialize(reports: [])
+    @reports = reports
+  end
+
+  def share!
+    response = post_payload
+    return if response.success?
+
+    puts I18n.t('pig_ci.api.reports.error', error: JSON.parse(response.parsed_response || '{}')['error'])
+  rescue Net::OpenTimeout => e
+    puts I18n.t('pig_ci.api.reports.error', error: e.inspect)
+  end
+
+  private
+
+  def post_payload
+    self.class.post(
+      '/v1/reports',
+      base_uri: PigCI.api_base_uri,
+      verify: PigCI.api_verify_ssl?,
+      body: payload,
+      headers: headers
+    )
+  end
+
+  def payload
+    {
+      library: 'pig-ci-rails',
+      library_version: PigCI::VERSION,
+      commit_sha1: PigCI.commit_sha1,
+      head_branch: PigCI.head_branch,
+      reports: @reports.collect { |report| report.to_payload_for(PigCI.run_timestamp) }
+    }.to_json
+  end
+end

data/lib/pig_ci/decorator.rb

@@ -0,0 +1,9 @@
+class PigCI::Decorator
+  attr_accessor :object
+
+  def initialize(object)
+    @object = object
+  end
+end
+
+require 'pig_ci/decorator/report_terminal_decorator'

data/lib/pig_ci/decorator/report_terminal_decorator.rb

@@ -0,0 +1,19 @@
+require 'colorized_string'
+
+class PigCI::Decorator::ReportTerminalDecorator < PigCI::Decorator
+  %i[key max min mean number_of_requests].each do |field|
+    define_method(field) do
+      @object[field]
+    end
+  end
+
+  def max_change_percentage
+    if @object[:max_change_percentage].start_with?('-')
+      ColorizedString[@object[:max_change_percentage]].colorize(:green)
+    elsif @object[:max_change_percentage].start_with?('0.0')
+      @object[:max_change_percentage]
+    else
+      ColorizedString[@object[:max_change_percentage]].colorize(:red)
+    end
+  end
+end

data/lib/pig_ci/metric.rb

@@ -0,0 +1,4 @@
+class PigCI::Metric; end
+
+require 'pig_ci/metric/current'
+require 'pig_ci/metric/historical'

data/lib/pig_ci/metric/current.rb

@@ -0,0 +1,30 @@
+class PigCI::Metric::Current
+  def initialize(log_file:)
+    @log_file = log_file
+  end
+
+  def to_h
+    @to_h = {}
+
+    File.foreach(@log_file) do |f|
+      key, value = f.strip.split('|')
+      value = value.to_i
+
+      @to_h[key] ||= {
+        key: key,
+        max: value,
+        min: value,
+        mean: 0,
+        total: 0,
+        number_of_requests: 0
+      }
+      @to_h[key][:max] = value if value > @to_h[key][:max]
+      @to_h[key][:min] = value if value < @to_h[key][:min]
+      @to_h[key][:total] += value
+      @to_h[key][:number_of_requests] += 1
+      @to_h[key][:mean] = @to_h[key][:total] / @to_h[key][:number_of_requests]
+    end
+
+    @to_h.collect { |_k, d| d }
+  end
+end

data/lib/pig_ci/metric/historial/change_percentage.rb

@@ -0,0 +1,37 @@
+class PigCI::Metric::Historical::ChangePercentage
+  def initialize(previous_data:, data:)
+    @previous_data = previous_data
+    @data = data
+    @timestamp = @data.keys.first
+    @profiler = @data[@timestamp].keys.first
+  end
+
+  def updated_data
+    @data[@timestamp][@profiler].collect do |data|
+      previous_run_data = previous_run_data_for_key(data[:key]) || data
+
+      data[:max_change_percentage] = (((BigDecimal(data[:max]) - BigDecimal(previous_run_data[:max])) / BigDecimal(previous_run_data[:max])) * 100).round(PigCI.max_change_percentage_precision)
+      data[:max_change_percentage] = BigDecimal('0') if data[:max_change_percentage].to_s == 'NaN' || data[:max_change_percentage] == BigDecimal('-0.0')
+      data[:max_change_percentage] = data[:max_change_percentage].to_f
+
+      data
+    end
+
+    @data
+  end
+
+  private
+
+  def previous_run_data_for_key(key)
+    previous_data_keys.each do |previous_run_key|
+      @previous_data[previous_run_key][@profiler.to_sym].each do |raw_previous_run_data|
+        return raw_previous_run_data if raw_previous_run_data[:key] == key
+      end
+    end
+    nil
+  end
+
+  def previous_data_keys
+    @previous_data_keys ||= @previous_data.keys.sort.reverse
+  end
+end

data/lib/pig_ci/metric/historical.rb

@@ -0,0 +1,52 @@
+class PigCI::Metric::Historical
+  def initialize(historical_log_file:)
+    @historical_log_file = historical_log_file
+  end
+
+  def to_h
+    @to_h ||= read_historical_log_file.sort_by { |timestamp, _data| timestamp.to_s.to_i * -1 }.to_h
+  end
+
+  # In future this might honour some limit.
+  def append!(timestamp:, metric:, data:)
+    to_h
+    @to_h[timestamp] ||= {}
+    @to_h[timestamp][metric] = data
+    remove_old_historical_data!
+    save!
+  end
+
+  def add_change_percentage_and_append!(timestamp:, metric:, data:)
+    max_change_percentage_data = {}
+    max_change_percentage_data[timestamp] = {}
+    max_change_percentage_data[timestamp][metric] = data
+
+    data = PigCI::Metric::Historical::ChangePercentage.new(previous_data: to_h, data: max_change_percentage_data).updated_data
+    append!(timestamp: timestamp, metric: metric, data: data[timestamp][metric])
+  end
+
+  private
+
+  def remove_old_historical_data!
+    new_historical_data = @to_h
+                          .sort_by { |timestamp, _data| timestamp.to_s.to_i * -1 }[0..(PigCI.historical_data_run_limit - 1)]
+                          .to_h
+                          .sort_by { |timestamp, _data| timestamp.to_s.to_i * -1 }.to_h
+    @to_h = new_historical_data
+  end
+
+  def read_historical_log_file
+    if File.exist?(@historical_log_file)
+      JSON.parse(File.open(@historical_log_file, 'r').read, symbolize_names: true)
+    else
+      {}
+    end
+  end
+
+  def save!
+    File.write(@historical_log_file, @to_h.to_json)
+    @to_h = nil
+  end
+end
+
+require 'pig_ci/metric/historial/change_percentage'

data/lib/pig_ci/profiler.rb

@@ -0,0 +1,41 @@
+class PigCI::Profiler
+  attr_accessor :log_value, :log_file, :historical_log_file, :i18n_key
+
+  def initialize(i18n_key: nil, log_file: nil, historical_log_file: nil)
+    @i18n_key = i18n_key || self.class.name.underscore.split('/').last
+    @log_file = log_file || PigCI.tmp_directory.join("#{@i18n_key}.txt")
+    @historical_log_file = historical_log_file || PigCI.tmp_directory.join("#{@i18n_key}.json")
+    @log_value = 0
+  end
+
+  def setup!
+    File.open(log_file, 'w') { |file| file.truncate(0) }
+  end
+
+  def reset!
+    @log_value = 0
+  end
+
+  def log_request!(request_key)
+    File.open(log_file, 'a+') do |f|
+      f.puts([request_key, log_value].join('|'))
+    end
+  end
+
+  def save!
+    historical_data = PigCI::Metric::Historical.new(historical_log_file: @historical_log_file)
+    historical_data.add_change_percentage_and_append!(
+      timestamp: PigCI.run_timestamp,
+      metric: i18n_key,
+      data: PigCI::Metric::Current.new(log_file: log_file).to_h
+    )
+  end
+
+  def increment!(*)
+    raise NotImplementedError
+  end
+end
+
+require 'pig_ci/profiler/memory'
+require 'pig_ci/profiler/request_time'
+require 'pig_ci/profiler/database_request'

data/lib/pig_ci/profiler/database_request.rb

@@ -0,0 +1,5 @@
+class PigCI::Profiler::DatabaseRequest < PigCI::Profiler
+  def increment!(by: 1)
+    @log_value += by
+  end
+end

data/lib/pig_ci/profiler/memory.rb

@@ -0,0 +1,16 @@
+require 'get_process_mem'
+
+class PigCI::Profiler::Memory < PigCI::Profiler
+  def reset!
+    GC.disable
+  end
+
+  def log_request!(request_key)
+    GC.enable
+    super
+  end
+
+  def log_value
+    ::GetProcessMem.new.bytes
+  end
+end

data/lib/pig_ci/profiler/request_time.rb

@@ -0,0 +1,17 @@
+class PigCI::Profiler::RequestTime < PigCI::Profiler
+  attr_accessor :start_time, :end_time
+
+  def reset!
+    super
+    @start_time = Time.now.utc
+  end
+
+  def log_request!(request_key)
+    @end_time = Time.now.utc
+    super
+  end
+
+  def log_value
+    (@end_time - @start_time) * 1000.0
+  end
+end

data/lib/pig_ci/profiler_engine.rb

@@ -0,0 +1,40 @@
+class PigCI::ProfilerEngine
+  attr_accessor :request_key, :profilers, :reports, :request_captured
+
+  def initialize(profilers: nil, reports: nil)
+    @profilers = profilers || []
+    @reports = reports || []
+    @request_captured = false
+  end
+
+  def request_key?
+    !@request_key.nil? && @request_key != ''
+  end
+
+  def request_captured?
+    @request_captured
+  end
+
+  def request_captured!
+    @request_captured = true
+  end
+
+  def setup!
+    Dir.mkdir(PigCI.tmp_directory) unless File.exist?(PigCI.tmp_directory)
+
+    yield if block_given?
+
+    profilers.collect(&:setup!)
+
+    # Attach listeners to the rails events.
+    attach_listeners!
+  end
+
+  private
+
+  def attach_listeners!
+    raise NotImplementedError
+  end
+end
+
+require 'pig_ci/profiler_engine/rails'

data/lib/pig_ci/profiler_engine/rails.rb

@@ -0,0 +1,61 @@
+# This subscribes to the ActiveSupport::Notifications and passes it onto our profilers.
+class PigCI::ProfilerEngine::Rails < ::PigCI::ProfilerEngine
+  def initialize(profilers: nil, reports: nil)
+    @profilers = profilers || [
+      PigCI::Profiler::Memory.new,
+      PigCI::Profiler::RequestTime.new,
+      PigCI::Profiler::DatabaseRequest.new
+    ]
+    @reports = reports || [
+      PigCI::Report::Memory.new,
+      PigCI::Report::RequestTime.new,
+      PigCI::Report::DatabaseRequest.new
+    ]
+    @request_captured = false
+  end
+
+  def request_key_from_payload!(payload)
+    @request_key = "#{payload[:method]} #{payload[:controller]}##{payload[:action]}{format:#{payload[:format]}}"
+  end
+
+  def setup!
+    super do
+      eager_load_rails!
+    end
+  end
+
+  private
+
+  def eager_load_rails!
+    # Eager load rails to give more accurate memory levels.
+    ::Rails.application.eager_load!
+    ::Rails::Engine.subclasses.map(&:instance).each(&:eager_load!)
+    ::ActiveRecord::Base.descendants
+
+    # Make a call to the root path to load up as much of rails as possible
+    ::Rails.application.call(::Rack::MockRequest.env_for('/'))
+  end
+
+  def attach_listeners!
+    ::ActiveSupport::Notifications.subscribe 'start_processing.action_controller' do |_name, _started, _finished, _unique_id, payload|
+      request_key_from_payload!(payload)
+
+      profilers.each(&:reset!)
+    end
+
+    ::ActiveSupport::Notifications.subscribe 'sql.active_record' do |_name, _started, _finished, _unique_id, _payload|
+      if request_key?
+        profilers.select { |profiler| profiler.class == PigCI::Profiler::DatabaseRequest }.each(&:increment!)
+      end
+    end
+
+    ::ActiveSupport::Notifications.subscribe 'process_action.action_controller' do |_name, _started, _finished, _unique_id, _payload|
+      profilers.each do |profiler|
+        profiler.log_request!(request_key)
+      end
+
+      request_captured!
+      self.request_key = nil
+    end
+  end
+end

data/lib/pig_ci/report.rb

@@ -0,0 +1,64 @@
+class PigCI::Report
+  attr_accessor :historical_log_file, :i18n_key
+
+  def initialize(historical_log_file: nil, i18n_key: nil, timestamp: nil)
+    @i18n_key = i18n_key || self.class.name.underscore.split('/').last
+    @historical_log_file = historical_log_file || PigCI.tmp_directory.join("#{@i18n_key}.json")
+    @timestamp = timestamp || PigCI.run_timestamp
+  end
+
+  def headings
+    column_keys.collect { |key| I18n.t(".attributes.#{key}", scope: i18n_scope, locale: PigCI.locale) }
+  end
+
+  def i18n_name
+    I18n.t('.name', scope: i18n_scope, locale: PigCI.locale)
+  end
+
+  def sorted_and_formatted_data_for(timestamp)
+    data_for(timestamp)[@i18n_key.to_sym].sort_by do |data|
+      PigCI.report_row_sort_by(data)
+    end.collect do |data|
+      self.class.format_row(data)
+    end
+  end
+
+  def to_payload_for(timestamp)
+    {
+      profiler: @i18n_key.to_sym,
+      data: data_for(timestamp)[@i18n_key.to_sym]
+    }
+  end
+
+  def historical_data
+    @historical_data ||= PigCI::Metric::Historical.new(historical_log_file: @historical_log_file).to_h
+  end
+
+  def timestamps
+    historical_data.keys
+  end
+
+  def column_keys
+    %i[key max min mean number_of_requests max_change_percentage]
+  end
+
+  def i18n_scope
+    @i18n_scope ||= "pig_ci.report.#{i18n_key}"
+  end
+
+  def self.format_row(row)
+    row = row.dup
+    row[:max_change_percentage] = "#{row[:max_change_percentage]}%"
+    row
+  end
+
+  private
+
+  def data_for(timestamp)
+    historical_data[timestamp.to_sym]
+  end
+end
+
+require 'pig_ci/report/memory'
+require 'pig_ci/report/request_time'
+require 'pig_ci/report/database_request'