mercy 1.3.0

data/lib/bidu/mercy/report/multiple.rb

@@ -0,0 +1,29 @@
+module Bidu::Mercy::Report::Multiple
+  def as_json
+    {
+      status: status
+    }.merge(sub_reports_hash)
+  end
+
+  def error?
+    sub_reports.any?(&:error?)
+  end
+
+  private
+
+  def sub_reports_hash
+    sub_reports.map(&:as_json).as_hash(reports_ids.map(&:to_s))
+  end
+
+  def sub_reports
+    @sub_reports ||= reports_ids.map do |id|
+      build_sub_report(id)
+    end
+  end
+
+  def build_sub_report(id)
+    sub_report_class.new(json.merge(key => id))
+  end
+end
+
+

data/lib/bidu/mercy/report/range.rb

@@ -0,0 +1,54 @@
+module Bidu
+  module Mercy
+    class Report
+      class Range < Report::ActiveRecord
+        ALLOWED_PARAMETERS=[:period, :maximum, :minimum]
+        DEFAULT_OPTION = {
+          period: 1.day,
+          scope: :all,
+          minimum: nil,
+          maximum: nil
+        }
+
+        json_parse :scope
+        json_parse :minimum, :maximum, type: :integer
+
+        def initialize(options)
+          super(DEFAULT_OPTION.merge(options))
+        end
+
+        def scoped
+          @scoped ||= fetch_scoped(last_entries, scope)
+        end
+
+        def error?
+          @error ||= !count_in_range?
+        end
+
+        def as_json
+          {
+            status: status,
+            count: count
+          }
+        end
+
+        def count
+          scoped.count
+        end
+
+        private
+
+        def range
+          (minimum..maximum)
+        end
+
+        def count_in_range?
+          return range.include?(count) unless (maximum.nil? || minimum.nil?)
+          return count >= minimum unless minimum.nil?
+          return count <= maximum unless maximum.nil?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/bidu/mercy/report_builder.rb

@@ -0,0 +1,24 @@
+module Bidu
+  module Mercy
+    class ReportBuilder
+      def build(key, parameters = {})
+        config = config_for(key)
+        config.build(parameters)
+      end
+
+      def add_config(key, config)
+        configs[key] = Bidu::Mercy::ReportConfig.new(config)
+      end
+
+      private
+
+      def config_for(key)
+        configs[key]
+      end
+
+      def configs
+        @configs ||= {}
+      end
+    end
+  end
+end

data/lib/bidu/mercy/report_config.rb

@@ -0,0 +1,37 @@
+module Bidu
+  module Mercy
+    class ReportConfig
+      attr_accessor :config
+
+      delegate :[], :[]=, :merge, to: :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      def build(parameters)
+        params = slice_parameters(parameters)
+        report_class.new(config.merge(params))
+      end
+
+      private
+
+      def type
+        self[:type] ||= :error
+      end
+
+      def report_class
+        return type if type.is_a?(Class)
+        @report_class ||= Bidu::Mercy::Report.const_get(type.to_s.camelize)
+      end
+
+      def slice_parameters(parameters)
+        parameters.slice(*allowed_parameters)
+      end
+
+      def allowed_parameters
+        report_class::ALLOWED_PARAMETERS
+      end
+    end
+  end
+end

data/lib/bidu/mercy/status.rb

@@ -0,0 +1,27 @@
+module Bidu
+  module Mercy
+    class Status
+      attr_reader :reports
+
+      def initialize(reports)
+        @reports = reports
+      end
+
+      def status
+        reports.any? { |r| r.error? } ? :error : :ok
+      end
+
+      def as_json
+        {
+          status: status
+        }.merge(reports_jsons)
+      end
+
+      private
+
+      def reports_jsons
+        reports.map(&:as_json).as_hash(reports.map(&:id))
+      end
+    end
+  end
+end

data/lib/bidu/mercy/status_builder.rb

@@ -0,0 +1,35 @@
+module Bidu
+  module Mercy
+    class StatusBuilder
+      def build(key, parameters = {})
+        Bidu::Mercy::Status.new(reports_for(key, parameters))
+      end
+
+      def add_report_config(key, config)
+        status_key = config.delete(:on) || :default
+        report_builder.add_config(key, config)
+        config_for(status_key) << key
+      end
+
+      private
+
+      def report_builder
+        @report_builder ||= Bidu::Mercy::ReportBuilder.new
+      end
+
+      def reports_for(key, parameters)
+        config_for(key).map do |report_key|
+          report_builder.build(report_key, parameters)
+        end
+      end
+
+      def configs
+        @configs ||= {}
+      end
+
+      def config_for(key)
+        configs[key] ||= []
+      end
+    end
+  end
+end

data/lib/bidu/mercy/version.rb

@@ -0,0 +1,5 @@
+module Bidu
+  module Mercy
+    VERSION = '1.3.0'
+  end
+end

data/lib/bidu/period_parser.rb

@@ -0,0 +1,32 @@
+module Bidu
+  class PeriodParser
+    class << self
+      def parse(period)
+        return unless period
+        return period if period.is_a?(Integer)
+        new(period).to_seconds
+      end
+    end
+
+    def initialize(period)
+      @period = period
+    end
+
+    def to_seconds
+      return unless period.match(/^\d+(years|months|days|hours|minutes|seconds)?/)
+      type.blank? ? value.seconds : value.public_send(type)
+    end
+
+    private
+
+    attr_reader :period
+
+    def value
+      @period_value ||= period.gsub(/\D+/, '').to_i
+    end
+
+    def type
+      @period_type ||= period.gsub(/\d+/, '')
+    end
+  end
+end

data/lib/json_parser/type_cast_ext.rb

@@ -0,0 +1,7 @@
+module JsonParser
+  module TypeCast
+    def to_period(value)
+      Bidu::PeriodParser.parse(value)
+    end
+  end
+end

data/mercy.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bidu/mercy/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'mercy'
+  gem.version       = Bidu::Mercy::VERSION
+  gem.authors       = ["Bidu Dev's Team"]
+  gem.email         = ["dev@bidu.com.br"]
+  gem.homepage      = 'https://github.com/Bidu/mercy'
+  gem.description   = 'Gem for easy health check'
+  gem.summary       = gem.description
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f)  }
+  gem.test_files    = gem.files.grep(%r{^(test|gem|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_runtime_dependency 'activesupport'
+  gem.add_runtime_dependency 'concern_builder'
+  gem.add_runtime_dependency 'darthjee-active_ext'
+  gem.add_runtime_dependency 'json_parser', '~> 1.1'
+
+  gem.add_development_dependency "activerecord"
+  gem.add_development_dependency "sqlite3"
+
+  gem.add_development_dependency "bundler"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency 'pry-nav'
+  gem.add_development_dependency 'simplecov'
+end

data/spec/lib/bidu/mercy/report/error_spec.rb

@@ -0,0 +1,385 @@
+require 'spec_helper'
+
+describe Bidu::Mercy::Report::Error do
+  let(:errors) { 1 }
+  let(:successes) { 1 }
+  let(:old_errors) { 2 }
+  let(:threshold) { 0.02 }
+  let(:period) { 1.day }
+  let(:external_key) { :external_id }
+  let(:scope) { :with_error }
+  let(:base_scope) { :all }
+  let(:options) do
+    {
+      period: period,
+      threshold: threshold,
+      scope: scope,
+      base_scope: base_scope,
+      clazz: Document,
+      external_key: external_key
+    }
+  end
+  let(:subject) { described_class.new(options) }
+  let(:types) { [:a] }
+  before do
+    Document.all.each(&:destroy)
+    types.each do |type|
+      successes.times { Document.create status: :success, doc_type: type }
+      errors.times do |i|
+        Document.create status: :error, external_id: 10 * successes + i, outter_external_id: i, doc_type: type
+      end
+      old_errors.times do
+        Document.create status: :error, created_at: 2.days.ago, updated_at: 2.days.ago, doc_type: type
+      end
+    end
+  end
+
+  describe '#status' do
+    context 'when are more errors than the allowed by the threshold' do
+      let(:errors) { 1 }
+      let(:successes) { 3 }
+      it { expect(subject.status).to eq(:error) }
+    end
+
+    context 'when the threshold is 0 and there are no errors' do
+      let(:errors) { 0 }
+      let(:threshold) { 0 }
+      it { expect(subject.status).to eq(:ok) }
+    end
+
+    context 'when the threshold is 100% and there is 100% error' do
+      let(:successes) { 0 }
+      let(:threshold) { 1 }
+      it { expect(subject.status).to eq(:ok) }
+    end
+
+    context 'when there are no documents' do
+      let(:successes) { 0 }
+      let(:errors) { 0 }
+      it { expect(subject.status).to eq(:ok) }
+    end
+
+    context 'when there are older errors out of the period' do
+      let(:threshold) { 0.6 }
+
+      it 'ignores the older errros' do
+        expect(subject.status).to eq(:ok)
+      end
+
+      context 'when passing a bigger period' do
+        let(:period) { 3.days }
+
+        it 'consider the older errros' do
+          expect(subject.status).to eq(:error)
+        end
+      end
+    end
+  end
+
+  describe 'percentage' do
+    context 'when there are 25% erros' do
+      let(:errors) { 1 }
+      let(:successes) { 3 }
+      it { expect(subject.percentage).to eq(0.25) }
+    end
+
+    context 'when there are no errors' do
+      let(:errors) { 0 }
+      let(:threshold) { 0 }
+      it { expect(subject.percentage).to eq(0) }
+    end
+
+    context 'when there is 100% error' do
+      let(:successes) { 0 }
+      let(:threshold) { 1 }
+      it { expect(subject.percentage).to eq(1) }
+    end
+
+    context 'when there are no documents' do
+      let(:successes) { 0 }
+      let(:errors) { 0 }
+      it { expect(subject.percentage).to eq(0) }
+    end
+
+    context 'when there are older errors out of the period' do
+      let(:old_errors) { 2 }
+
+      it 'ignores the older errros' do
+        expect(subject.percentage).to eq(0.5)
+      end
+
+      context 'when passing a bigger period' do
+        let(:period) { 3.days }
+
+        it 'consider the older errros' do
+          expect(subject.percentage).to eq(0.75)
+        end
+      end
+    end
+
+    context 'when configuring with a complex scope' do
+      let(:types) { [:a, :b] }
+      let(:old_errors) { 0 }
+      let(:scope) { :'with_error.type_b' }
+      let(:errors) { 1 }
+      let(:successes) { 3 }
+      context 'as symbol' do
+        let(:scope) { :'with_error.type_b' }
+
+        it 'fetches from each scope in order' do
+          expect(subject.percentage).to eq(0.125)
+        end
+      end
+
+      context 'as string where scope' do
+        let(:scope) { "status = 'error' and doc_type = 'b'" }
+
+        it 'fetches from each scope in order' do
+          expect(subject.percentage).to eq(0.125)
+        end
+      end
+
+      context 'as hash where scope' do
+        let(:scope) { { status: :error, doc_type: :b } }
+
+        it 'fetches from each scope in order' do
+          expect(subject.percentage).to eq(0.125)
+        end
+      end
+    end
+
+    context 'when using a base scope' do
+      let(:types) { [:a, :b, :b, :b] }
+      let(:old_errors) { 0 }
+      let(:errors) { 1 }
+      let(:successes) { 3 }
+
+      context 'as symbol' do
+        let(:base_scope) { :type_b }
+
+        it 'fetches from each scope in order' do
+          expect(subject.percentage).to eq(0.25)
+        end
+      end
+
+      context 'as where clause' do
+        let(:base_scope) { "doc_type = 'b'" }
+
+        it 'fetches from each scope in order' do
+          expect(subject.percentage).to eq(0.25)
+        end
+      end
+
+      context 'as hash' do
+        let(:base_scope) { { doc_type: :b } }
+
+        it 'fetches from each scope in order' do
+          expect(subject.percentage).to eq(0.25)
+        end
+      end
+    end
+  end
+
+  describe '#scoped' do
+    context 'when there are 25% erros' do
+      let(:errors) { 1 }
+      let(:successes) { 3 }
+      it 'returns only the scoped documents' do
+        expect(subject.scoped.count).to eq(1)
+      end
+    end
+
+    context 'when there are no errors' do
+      let(:errors) { 0 }
+      let(:threshold) { 0 }
+      it { expect(subject.scoped).to be_empty }
+    end
+
+    context 'when there are no documents' do
+      let(:successes) { 0 }
+      let(:errors) { 0 }
+      it { expect(subject.scoped).to be_empty }
+    end
+
+    context 'when there are older errors out of the period' do
+      let(:old_errors) { 2 }
+
+      it 'ignores the older errros' do
+        expect(subject.scoped.count).to eq(1)
+      end
+
+      context 'when passing a bigger period' do
+        let(:period) { 3.days }
+
+        it 'consider the older errros' do
+          expect(subject.scoped.count).to eq(3)
+        end
+      end
+    end
+
+    context 'when configured with a complex scope' do
+      let(:types) { [:a, :b, :b] }
+      let(:old_errors) { 0 }
+
+      context 'as symbol' do
+        let(:scope) { :'with_error.type_b' }
+
+        it 'fetches from each scope in order' do
+          expect(subject.scoped.count).to eq(Document.with_error.type_b.count)
+          expect(subject.scoped.count).to eq(2 * Document.with_error.type_a.count)
+        end
+      end
+
+      context 'as hash' do
+        let(:scope) { { status: :error, doc_type: :b } }
+
+        it 'fetches from each scope in order' do
+          expect(subject.scoped.count).to eq(Document.with_error.type_b.count)
+          expect(subject.scoped.count).to eq(2 * Document.with_error.type_a.count)
+        end
+      end
+
+      context 'as string where scope' do
+        let(:scope) { "status = 'error' and doc_type = 'b'" }
+
+        it 'fetches from each scope in order' do
+          expect(subject.scoped.count).to eq(Document.with_error.type_b.count)
+          expect(subject.scoped.count).to eq(2 * Document.with_error.type_a.count)
+        end
+      end
+    end
+
+    context 'when using a base scope' do
+      let(:types) { [:a, :b, :b, :b] }
+      let(:old_errors) { 0 }
+
+      context 'as symbol' do
+        let(:base_scope) { :type_b }
+
+        it 'fetches from each scope in order' do
+          expect(subject.scoped.count).to eq(Document.with_error.type_b.count)
+          expect(subject.scoped.count).to eq(3 * Document.with_error.type_a.count)
+        end
+      end
+
+      context 'as where clause' do
+        let(:base_scope) { "doc_type = 'b'" }
+
+        it 'fetches from each scope in order' do
+          expect(subject.scoped.count).to eq(Document.with_error.type_b.count)
+          expect(subject.scoped.count).to eq(3 * Document.with_error.type_a.count)
+        end
+      end
+
+      context 'as hash' do
+        let(:base_scope) { { doc_type: :b } }
+
+        it 'fetches from each scope in order' do
+          expect(subject.scoped.count).to eq(Document.with_error.type_b.count)
+          expect(subject.scoped.count).to eq(3 * Document.with_error.type_a.count)
+        end
+      end
+    end
+  end
+
+  describe '#error?' do
+    context 'when errors percentage overcames threshold' do
+      it { expect(subject.error?).to be_truthy }
+    end
+
+    context 'when errors percentage does not overcames threshold' do
+      let(:errors) { 0 }
+      it { expect(subject.error?).to be_falsey }
+    end
+  end
+
+  describe '#status' do
+    context 'when errors percentage overcames threshold' do
+      it { expect(subject.status).to eq(:error) }
+    end
+
+    context 'when errors percentage does not overcames threshold' do
+      let(:errors) { 0 }
+      it { expect(subject.status).to eq(:ok) }
+    end
+  end
+
+  describe '#as_json' do
+    let(:expected) do
+      { ids: ids_expected, percentage: percentage_expected, status: status_expected }
+    end
+
+    context 'when everything is ok' do
+      let(:errors) { 1 }
+      let(:successes) { 9 }
+      let(:ids_expected) { [90] }
+      let(:status_expected) { :ok }
+      let(:percentage_expected) { 0.1 }
+      let(:threshold) { 0.5 }
+
+      it 'returns the external keys, status and error percentage' do
+        expect(subject.as_json).to eq(expected)
+      end
+
+    end
+
+    context 'when there are 75% erros' do
+      let(:status_expected) { :error }
+      let(:percentage_expected) { 0.75 }
+      let(:errors) { 3 }
+      let(:successes) { 1 }
+      let(:ids_expected) { [10, 11, 12] }
+
+      it 'returns the external keys, status and error percentage' do
+        expect(subject.as_json).to eq(expected)
+      end
+
+      context 'when configurated with different external key' do
+        let(:external_key) { :outter_external_id }
+        let(:ids_expected) { [0, 1, 2] }
+
+        it 'returns the correct external keys' do
+          expect(subject.as_json).to eq(expected)
+        end
+
+        context 'when some external ids are the same' do
+          let(:ids_expected) { [10, 10, 10] }
+          before do
+            Document.update_all(outter_external_id: 10)
+          end
+
+          it 'returns the correct external keys' do
+            expect(subject.as_json).to eq(expected)
+          end
+
+          context 'and passing uniq option' do
+            before { options[:uniq] = true }
+            let(:ids_expected) { [10] }
+
+            it 'returns the correct external keys only once' do
+              expect(subject.as_json).to eq(expected)
+            end
+          end
+        end
+
+        context 'with a limit' do
+          before { options[:limit] = 2 }
+          let(:ids_expected) { [0, 1] }
+
+          it 'returns only the limited ids' do
+            expect(subject.as_json).to eq(expected)
+          end
+        end
+      end
+
+      context 'when configurated without external key' do
+        before { options.delete(:external_key) }
+        let(:ids_expected) { Document.with_error.where('created_at > ?', 30.hours.ago).map(&:id) }
+
+        it 'returns the ids as default id' do
+          expect(subject.as_json).to eq(expected)
+        end
+      end
+    end
+  end
+end