data_checks 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 76f3628c85ded9452a6825695726c6814153051c3345812f6e411f447b9114fb
+  data.tar.gz: 04bca1e6301d41a901e73432ad98b062e508a40e0156fa8a803e0c3fdb765f2d
+SHA512:
+  metadata.gz: 2133d07d50f683647d055aaf877169dadbd62bde6cde8bab24ed785e660c99f844ff80c2be0cd2f3bfec30ec8fba9d902d3ca85ef8dd877f89b54bfd1580d59c
+  data.tar.gz: 8c14320fbeaf09ca1a789f7c4232e5908849ede96b645b13a8f12a1922e07902f700a8c6ae36221d47f485d15a72be1f499789a58f4c0a62e4219ee94a65347c

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## master (unreleased)
+
+## 0.1.0 (2022-04-21)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 fatkodima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,213 @@
+# DataChecks
+
+This gem provides a small DSL to check your data for inconsistencies and anomalies.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "data_checks"
+```
+
+    $ bundle install
+    $ bin/rails generate data_checks:install
+
+## Motivation
+
+Making sure that data stays valid is not a trivial task. For simple requirements, like "this column is not null" or "this column is unique", you of course just use the database constraints and that's it. Same goes for type validation or reference integrity.
+
+However, when you want to check for something more complex, then it all changes. Depending on your DBMS, you can use stored procedures, but this is often harder to write, version and maintain.
+
+You could also assume that your data will never get corrupted, and validations directly in the code can do the trick ... but that'd be way too optimistic. Bugs happen all the time, and it's best to plan for the worst.
+
+This gem doesn't aim to replace those tools, but provides something else that could serve a close purpose: *ensure that you work with the data you expect*.
+
+This gem help you to schedule some verifications on your data and get alerts when something is unexpected.
+
+## Usage
+
+A small DSL is provided to help express predicates and an easy way to configure notifications.
+
+You will be notified when a check starts failing, and when it starts passing again.
+
+### Checking for inconsistencies
+
+For example, we expect every image attachment to have previews in 3 sizes. It is possible, that when a new image was attached, some previews were not generated because of some failure. What we would like to ensure is that no image ends up without a full set of previews. We could write something like:
+
+```ruby
+DataChecks.configure do
+  ensure_no :images_without_previews, tag: "hourly" do
+    Attachment.images.joins(:previews).having("COUNT(*) < 3").group(:attachment_id)
+  end
+
+  notifier :email,
+    from: "production@company.com",
+    to: "developer@company.com"
+end
+```
+
+### Checking for anomalies
+
+This gem can be also used to detect anomalies in the data. For example, you expect to have some number of new orders in the system in some period of time. Otherwise, this can hint at some bug in the order placing system worth investigating.
+
+```ruby
+ensure_more :new_orders_per_hour, than: 10, tag: "hourly" do
+  Order.where("created_at >= ?", 1.hour.ago).count
+end
+```
+
+## Configuration
+
+Custom configurations should be placed in a `data_checks.rb` initializer.
+
+```ruby
+# config/initializers/data_checks.rb
+
+DataChecks.configure do
+  # ...
+end
+```
+
+### Notifiers
+
+Currently, the following notifiers are supported:
+
+- `:email`: Uses `ActionMailer` to send emails. You can pass it any `ActionMailer` options.
+- `:slack`: Sends notifications to Slack. Accepts the following options:
+  - `webhook_url`: The webhook url to send notifications to
+- `:logger`: Uses `Logger` to output notifications to the log. Accepts the following params:
+  - `logdev`: The log device. This is a filename (String) or IO object (typically STDOUT, STDERR, or an open file).
+  - `level`: Logging severity threshold (e.g. Logger::INFO)
+
+Each of them accepts a `formatter_class` config to configure the used formatter when generating a notification.
+
+You can create custom notifiers by creating a subclass of [Notifier](https://github.com/fatkodima/data_checks/blob/master/lib/data_checks/notifiers/notifier.rb).
+
+Create a notifier:
+
+```ruby
+notifier :email,
+  from: "production@company.com",
+  to: "developer@company.com"
+```
+
+Create multiple notifiers of the same type:
+
+```ruby
+notifier "developers",
+  type: :email,
+  from: "production@company.com",
+  to: ["developer1@company.com", "developer2@company.com"]
+
+notifier "tester",
+  type: :email,
+  from: "production@company.com",
+  to: "tester@company.com"
+
+ensure_no :images_without_previews, notify: "developers" do # notify only developers
+  # ...
+end
+```
+
+### Checks
+
+* `ensure_no` will check that the result of a given block is `zero?`, `empty?` or `false`
+* `ensure_any` will check that the result of a given block is `> 0`
+* `ensure_more` will check that the result of a given block is `>` than a given number or that it contains more than a given number of items
+* `ensure_less` will check that the result of a given block is `<` than a given number or that it contains less than a given number of items
+
+```ruby
+ensure_no :images_without_previews do
+  # ...
+end
+
+ensure_any :facebook_logins_per_hour do
+  # ...
+end
+
+ensure_more :new_orders_per_hour, than: 10 do
+  # ...
+end
+```
+
+### Customizing the error handler
+
+Exceptions raised while a check runs are rescued and information about the error is persisted in the database.
+
+If you want to integrate with an exception monitoring service (e.g. Bugsnag), you can define an error handler:
+
+```ruby
+# config/initializers/data_checks.rb
+
+DataChecks.config.error_handler = ->(error, check_context) do
+  Bugsnag.notify(error) do |notification|
+    notification.add_metadata(:data_checks, check_context)
+  end
+end
+```
+
+The error handler should be a lambda that accepts 2 arguments:
+
+* `error`: The exception that was raised.
+* `check_context`: A hash with additional information about the check:
+  * `check_name`: The name of the check that errored
+  * `ran_at`: The time when the check ran
+
+### Customizing the backtrace cleaner
+
+`DataChecks.config.backtrace_cleaner` can be configured to specify a backtrace cleaner to use when a check errors and the backtrace is cleaned and persisted. An `ActiveSupport::BacktraceCleaner` should be used.
+
+```ruby
+# config/initializers/data_checks.rb
+
+cleaner = ActiveSupport::BacktraceCleaner.new
+cleaner.add_silencer { |line| line =~ /ignore_this_dir/ }
+
+DataChecks.config.backtrace_cleaner = cleaner
+```
+
+If none is specified, the default `Rails.backtrace_cleaner` will be used to clean backtraces.
+
+### Schedule checks
+
+Schedule checks to run (with cron, [Heroku Scheduler](https://elements.heroku.com/addons/scheduler), etc).
+
+```sh
+rake data_checks:run_checks TAG="5 minutes"  # run checks with tag="5 minutes"
+rake data_checks:run_checks TAG="hourly"     # run checks with tag="hourly"
+rake data_checks:run_checks TAG="daily"      # run checks with tag="daily"
+rake data_checks:run_checks                  # run all checks
+```
+
+Here's what it looks like with cron.
+
+```
+*/5 * * * * rake data_checks:run_checks TAG="5 minutes"
+0   * * * * rake data_checks:run_checks TAG="hourly"
+30  7 * * * rake data_checks:run_checks TAG="daily"
+```
+
+You can also manually get a status of all the checks by running:
+
+```sh
+rake data_checks:status
+```
+
+## Credits
+
+Thanks to [checker_jobs gem](https://github.com/drivy/checker_jobs) for the original idea.
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/fatkodima/data_checks.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/data_checks/check.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module DataChecks
+  class Check
+    attr_reader :name, :options, :tag, :block
+
+    def initialize(name, options, block)
+      @name = name.to_s
+      @options = options
+      @tag = options[:tag]&.to_s
+      @block = block
+    end
+
+    def run
+      result = block.call
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      error_result(e)
+    else
+      handle_result(result)
+    end
+
+    def check_run
+      @check_run ||= CheckRun.find_by(name: name)
+    end
+
+    def notifiers
+      configured_notifiers = DataChecks.config.notifier_options
+      notifiers = Array(options[:notify] || configured_notifiers.keys).map(&:to_s)
+
+      notifiers.map do |notifier|
+        raise "Unknown notifier: '#{notifier}'" unless configured_notifiers.key?(notifier)
+
+        type = configured_notifiers[notifier][:type]
+        klass = Notifiers.lookup(type)
+        klass.new(configured_notifiers[notifier])
+      end
+    end
+
+    private
+      def handle_result(_result)
+        raise NotImplementedError, "#{self.class.name} must implement a 'handle_result' method"
+      end
+
+      def error_result(error)
+        CheckResult.new(check: self, error: error)
+      end
+  end
+end

data/lib/data_checks/check_result.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DataChecks
+  class CheckResult
+    attr_reader :check, :passing, :count, :entries, :error
+
+    def initialize(check:, passing: false, count: nil, entries: nil, error: nil)
+      @check = check
+      @passing = passing
+      @count = count
+      @entries = entries
+      @error = error
+    end
+
+    def passing?
+      passing
+    end
+
+    def failing?
+      !passing && error.nil?
+    end
+
+    def error?
+      error
+    end
+  end
+end

data/lib/data_checks/check_run.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DataChecks
+  class CheckRun < ActiveRecord::Base
+    self.table_name = :data_checks_runs
+
+    STATUSES = [:passing, :failing, :error]
+    enum status: STATUSES.map { |status| [status, status.to_s] }.to_h
+
+    serialize :backtrace
+
+    validates :name, :status, :last_run_at, presence: true
+  end
+end

data/lib/data_checks/config.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module DataChecks
+  class Config
+    attr_reader :checks, :notifier_options
+    attr_accessor :error_handler, :backtrace_cleaner
+
+    def initialize
+      @checks = []
+      @notifier_options = {}
+    end
+
+    def ensure_no(name, **options, &block)
+      add_check(EnsureNo, name, options, block)
+    end
+
+    def ensure_any(name, **options, &block)
+      add_check(EnsureMore, name, options.merge(than: 0), block)
+    end
+
+    def ensure_more(name, **options, &block)
+      add_check(EnsureMore, name, options, block)
+    end
+
+    def ensure_less(name, **options, &block)
+      add_check(EnsureLess, name, options, block)
+    end
+
+    def notifier(name, **options)
+      name = name.to_s
+
+      if notifier_options.key?(name)
+        raise ArgumentError, "Duplicate notifier: '#{name}'"
+      else
+        options[:type] ||= name
+        notifier_options[name] = options
+      end
+    end
+
+    private
+      def add_check(klass, name, options, block)
+        name = name.to_s
+
+        if checks.any? { |check| check.name == name }
+          raise ArgumentError, "Duplicate check: '#{name}'"
+        else
+          checks << klass.new(name, options, block)
+        end
+      end
+  end
+end

data/lib/data_checks/ensure_less.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module DataChecks
+  class EnsureLess < Check
+    private
+      def handle_result(result)
+        expected = options.fetch(:than)
+        passing = true
+
+        case result
+        when Numeric
+          count = result
+          if result >= expected
+            passing = false
+          end
+        when Enumerable, ActiveRecord::Relation
+          count = result.count
+          if count >= expected
+            passing = false
+          end
+        else
+          raise ArgumentError, "Unsupported result: '#{result.class.name}' for 'ensure_less'"
+        end
+
+        CheckResult.new(check: self, passing: passing, count: count)
+      end
+  end
+end

data/lib/data_checks/ensure_more.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module DataChecks
+  class EnsureMore < Check
+    private
+      def handle_result(result)
+        expected = options.fetch(:than)
+        passing = true
+
+        case result
+        when Numeric
+          count = result
+          if result <= expected
+            passing = false
+          end
+        when Enumerable, ActiveRecord::Relation
+          count = result.count
+          if count <= expected
+            passing = false
+          end
+        else
+          raise ArgumentError, "Unsupported result: '#{result.class.name}' for 'ensure_more'"
+        end
+
+        CheckResult.new(check: self, passing: passing, count: count)
+      end
+  end
+end

data/lib/data_checks/ensure_no.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DataChecks
+  class EnsureNo < Check
+    private
+      def handle_result(result)
+        passing = true
+        count = 0
+
+        case result
+        when Numeric
+          if result != 0
+            passing = false
+            count = result
+          end
+        # In ActiveRecord <= 4.2 ActiveRecord::Relation is not an Enumerable!
+        when Enumerable, ActiveRecord::Relation
+          unless result.empty?
+            passing = false
+            count = result.size
+            entries = result
+          end
+        when true
+          passing = false
+          count = 1
+        when false
+          # ok
+        else
+          raise ArgumentError, "Unsupported result: '#{result.class.name}' for 'ensure_no'"
+        end
+
+        CheckResult.new(check: self, passing: passing, count: count, entries: entries)
+      end
+  end
+end

data/lib/data_checks/notifiers/email_default_formatter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DataChecks
+  module Notifiers
+    class EmailDefaultFormatter
+      def initialize(check_result)
+        @check_run = check_result.check.check_run
+        @check_result = check_result
+      end
+
+      def subject
+        "Check #{@check_run.status.titleize}: #{@check_run.name}"
+      end
+
+      def body
+        error = @check_run.error_message
+        count = @check_result.count
+        entries = @check_result.entries&.map { |entry| format_entry(entry) }
+
+        if error
+          "<p>#{error}</p>"
+        else
+          body = "<p>Checker found #{count} element(s).</p>"
+          if entries
+            if count > 10
+              body += "<p>Showing 10 of #{count} entries</p>"
+            end
+
+            body += format("<ul>%s</ul>", entries.map { |entry| "<li>#{entry}</li>" }.join)
+          end
+          body
+        end
+      end
+
+      private
+        def format_entry(entry)
+          entry.respond_to?(:id) ? entry.id : entry.to_s
+        end
+    end
+  end
+end

data/lib/data_checks/notifiers/email_notifier.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DataChecks
+  module Notifiers
+    class EmailNotifier < Notifier
+      def initialize(options)
+        super
+        @formatter_class = options.delete(:formatter_class) || EmailDefaultFormatter
+      end
+
+      def notify(check_result)
+        formatter = @formatter_class.new(check_result)
+
+        body = formatter.body
+        email_options = { subject: formatter.subject }.merge(options)
+        Mailer.notify(body, email_options).deliver_now
+      end
+
+      class Mailer < ::ActionMailer::Base
+        layout false
+
+        def notify(body, options)
+          mail(options) do |format|
+            format.html { render html: body.html_safe }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/data_checks/notifiers/logger_default_formatter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DataChecks
+  module Notifiers
+    class LoggerDefaultFormatter
+      def initialize(check_result)
+        @check_run = check_result.check.check_run
+      end
+
+      def message
+        "[data_checks] Check #{@check_run.status.titleize}: #{@check_run.name}"
+      end
+    end
+  end
+end

data/lib/data_checks/notifiers/logger_notifier.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_support/logger"
+
+module DataChecks
+  module Notifiers
+    class LoggerNotifier < Notifier
+      def initialize(options)
+        super
+
+        logdev = options[:logdev] || $stdout
+        level = options[:level] || Logger::INFO
+        @logger = ActiveSupport::Logger.new(logdev, level: level)
+        @formatter_class = options.delete(:formatter_class) || LoggerDefaultFormatter
+      end
+
+      def notify(check_result)
+        formatter = @formatter_class.new(check_result)
+        @logger.add(@logger.level, formatter.message)
+      end
+    end
+  end
+end

data/lib/data_checks/notifiers/notifier.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module DataChecks
+  module Notifiers
+    class Notifier
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+
+      def notify(check_result)
+        raise NotImplementedError, "#{self.class.name} must implement a 'notify' method"
+      end
+    end
+  end
+end

data/lib/data_checks/notifiers/slack_default_formatter.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module DataChecks
+  module Notifiers
+    class SlackDefaultFormatter
+      def initialize(check_result)
+        @check_run = check_result.check.check_run
+        @check_result = check_result
+      end
+
+      def title
+        escape("Check #{@check_run.status.titleize}: #{@check_run.name}")
+      end
+
+      def text
+        error = @check_run.error_message
+        count = @check_result.count
+        entries = @check_result.entries&.map { |entry| format_entry(entry) }
+
+        if error
+          escape(error)
+        else
+          text = ["Checker found #{count} element(s)."]
+          if entries
+            if count > 10
+              text << "Showing 10 of #{count} entries"
+            end
+
+            text += entries.first(10).map { |entry| "- #{entry}" }
+          end
+
+          escape(text.join("\n"))
+        end
+      end
+
+      def color
+        if @check_run.status == CheckRun.statuses[:passing]
+          "good"
+        else
+          "danger"
+        end
+      end
+
+      private
+        # https://api.slack.com/docs/message-formatting#how_to_escape_characters
+        def escape(str)
+          str.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+        end
+
+        def format_entry(entry)
+          entry.respond_to?(:id) ? entry.id : entry.to_s
+        end
+    end
+  end
+end

data/lib/data_checks/notifiers/slack_notifier.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module DataChecks
+  module Notifiers
+    class SlackNotifier < Notifier
+      def initialize(options)
+        super
+        @formatter_class = options.delete(:formatter_class) || SlackDefaultFormatter
+        @webhook_url = options.fetch(:webhook_url) { raise ArgumentError, "webhook_url must be configured" }
+      end
+
+      def notify(check_result)
+        formatter = @formatter_class.new(check_result)
+
+        payload = {
+          attachments: [
+            {
+              title: formatter.title,
+              text: formatter.text,
+              color: formatter.color,
+            },
+          ],
+        }
+
+        response = post(payload)
+        unless response.is_a?(Net::HTTPSuccess) && response.body == "ok"
+          raise "Failed to notify slack: #{response.body.inspect}"
+        end
+      end
+
+      private
+        def post(payload)
+          uri = URI.parse(@webhook_url)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.open_timeout = 3
+          http.read_timeout = 5
+          http.post(uri.request_uri, payload.to_json)
+        end
+    end
+  end
+end

data/lib/data_checks/notifiers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DataChecks
+  module Notifiers
+    extend ActiveSupport::Autoload
+
+    autoload :Notifier
+    autoload :EmailDefaultFormatter
+    autoload :EmailNotifier
+    autoload :SlackDefaultFormatter
+    autoload :SlackNotifier
+    autoload :LoggerDefaultFormatter
+    autoload :LoggerNotifier
+
+    def self.lookup(name)
+      const_get("#{name.to_s.camelize}Notifier")
+    end
+  end
+end

data/lib/data_checks/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DataChecks
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/data_checks.rake"
+    end
+  end
+end

data/lib/data_checks/runner.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module DataChecks
+  class Runner
+    def run_checks(tag: nil)
+      checks = DataChecks.config.checks
+      checks = checks.select { |check| check.tag == tag.to_s } if tag
+
+      checks.each do |check|
+        run_one(check)
+      end
+    end
+
+    def run_check(name)
+      checks = DataChecks.config.checks
+      check = checks.find { |c| c.name == name.to_s }
+      raise "Check #{name} not found" unless check
+
+      run_one(check)
+    end
+
+    private
+      def run_one(check)
+        previous_check_run = check.check_run
+        previous_status = previous_check_run&.status
+
+        check_result = check.run
+
+        if check_result.error?
+          check_run = mark_check_as_errored(check, check_result.error)
+
+          check_context = { check_name: check.name, run_at: Time.current }
+          handle_exception(check_result.error, context: check_context)
+        else
+          check_run = mark_check_as_completed(check, check_result.passing?)
+        end
+
+        # Notify if not passing or the status changed
+        if !check_result.passing? ||
+           (previous_status && previous_status != check_run.status)
+          notify(check.notifiers, check_result)
+        end
+
+        check_result
+      end
+
+      def mark_check_as_errored(check, error)
+        backtrace_cleaner = DataChecks.config.backtrace_cleaner
+
+        run = check.check_run || CheckRun.new(name: check.name)
+        run.status = :error
+        run.error_class = error.class.name
+        run.error_message = error.message
+        run.backtrace = backtrace_cleaner ? backtrace_cleaner.clean(error.backtrace) : error.backtrace
+        run.last_run_at = Time.current
+        run.save!
+        run
+      end
+
+      def mark_check_as_completed(check, passing)
+        run = check.check_run || CheckRun.new(name: check.name)
+        run.status = (passing ? :passing : :failing)
+        run.error_class = nil
+        run.error_message = nil
+        run.backtrace = nil
+        run.last_run_at = Time.current
+        run.save!
+        run
+      end
+
+      def notify(notifiers, check_result)
+        notifiers.each do |notifier|
+          safely { notifier.notify(check_result) }
+        end
+      end
+
+      def safely
+        yield
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        handle_exception(e)
+      end
+
+      def handle_exception(exception, context: {})
+        if (error_handler = DataChecks.config.error_handler)
+          error_handler.call(exception, context)
+        else
+          raise exception
+        end
+      end
+  end
+end

data/lib/data_checks/status_printer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DataChecks
+  class StatusPrinter
+    def initialize(io = $stdout)
+      @io = io
+    end
+
+    def print
+      runs = DataChecks::CheckRun.all.to_a
+      counts = Hash.new { |h, k| h[k] = 0 }
+
+      DataChecks.config.checks.each do |check|
+        run = runs.find { |r| r.name == check.name }
+
+        if run
+          counts[run.status] += 1
+
+          formatted_time = run.last_run_at.to_formatted_s(:db)
+          @io.puts("Check #{check.name} (at #{formatted_time}) - #{run.status.titleize}")
+        else
+          counts["not_ran"] += 1
+          @io.puts("Check #{check.name} - Not ran yet")
+        end
+      end
+
+      @io.puts
+      print_summary(counts)
+    end
+
+    private
+      def print_summary(counts)
+        statuses = DataChecks::CheckRun.statuses
+        summary = "Error: #{counts[statuses[:error]]}, "\
+                  "Failing: #{counts[statuses[:failing]]}, "\
+                  "Passing: #{counts[statuses[:passing]]}"
+        summary += ", Not Ran: #{counts['not_ran']}" if counts["not_ran"] > 0
+        @io.puts(summary)
+      end
+  end
+end

data/lib/data_checks/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DataChecks
+  VERSION = "0.1.0"
+end

data/lib/data_checks.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "data_checks/check_run"
+require "data_checks/check_result"
+require "data_checks/check"
+require "data_checks/ensure_less"
+require "data_checks/ensure_more"
+require "data_checks/ensure_no"
+require "data_checks/notifiers"
+require "data_checks/config"
+require "data_checks/runner"
+require "data_checks/status_printer"
+require "data_checks/version"
+
+require "data_checks/railtie" if defined?(Rails)
+
+module DataChecks
+  class << self
+    def config
+      @config ||= Config.new
+    end
+
+    def configure(&block)
+      config.instance_exec(&block)
+    end
+  end
+end

data/lib/generators/data_checks/install_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record/migration"
+
+module DataChecks
+  class InstallGenerator < Rails::Generators::Base
+    include ActiveRecord::Generators::Migration
+
+    source_root File.expand_path("templates", __dir__)
+
+    def create_migration_file
+      migration_template("migration.rb", File.join(migrations_dir, "install_data_checks.rb"))
+    end
+
+    def copy_initializer_file
+      template("initializer.rb", "config/initializers/data_checks.rb")
+    end
+
+    private
+      def start_after
+        self.class.next_migration_number(migrations_dir)
+      end
+
+      def migrations_dir
+        ar_version >= 5.1 ? db_migrate_path : "db/migrate"
+      end
+
+      def ar_version
+        ActiveRecord.version.to_s.to_f
+      end
+  end
+end

data/lib/generators/data_checks/templates/initializer.rb.tt

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+DataChecks.configure do
+  # ==> Configure notifiers
+  #
+  # Predefined notifiers are :email, :slack, and :logger.
+  #
+  # notifier :email,
+  #   from: "production@company.com",
+  #   to: "developer@company.com",
+  #   formatter_class: DataChecks::Notifiers::EmailDefaultFormatter # default
+
+  # ==> Configure checks
+  #
+  # Available checks are :ensure_no, :ensure_any, :ensure_more, and :ensure_less.
+  #
+  # ensure_no :users_without_emails do
+  #   User.where(email: nil).count
+  # end
+
+  # The Active Support backtrace cleaner that will be used to clean the
+  # backtrace of a check that errors.
+  self.backtrace_cleaner = Rails.backtrace_cleaner
+
+  # The callback to perform when an error occurs in the check.
+  # self.error_handler = ->(error, check_context) do
+  #   Bugsnag.notify(error) do |notification|
+  #     notification.add_metadata(:data_checks, check_context)
+  #   end
+  # end
+end

data/lib/generators/data_checks/templates/migration.rb.tt

@@ -0,0 +1,17 @@
+class InstallDataChecks < ActiveRecord::Migration[<%= ar_version %>]
+  def change
+    create_table :data_checks_runs do |t|
+      t.string :name, null: false
+      t.string :status, null: false
+      t.datetime :last_run_at, null: false
+
+      t.string :error_class
+      t.string :error_message
+      t.text :backtrace
+
+      t.timestamps
+
+      t.index :name, unique: true
+    end
+  end
+end

data/lib/tasks/data_checks.rake

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+namespace :data_checks do
+  desc "Run checks"
+  task :run_checks, [:tag] => :environment do |_, args|
+    runner = DataChecks::Runner.new
+    runner.run_checks(tag: args[:tag] || ENV["TAG"])
+  end
+
+  desc "Show statuses of all checks"
+  task status: :environment do
+    printer = DataChecks::StatusPrinter.new
+    printer.print
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: data_checks
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- fatkodima
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-04-21 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- fatkodima123@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/data_checks.rb
+- lib/data_checks/check.rb
+- lib/data_checks/check_result.rb
+- lib/data_checks/check_run.rb
+- lib/data_checks/config.rb
+- lib/data_checks/ensure_less.rb
+- lib/data_checks/ensure_more.rb
+- lib/data_checks/ensure_no.rb
+- lib/data_checks/notifiers.rb
+- lib/data_checks/notifiers/email_default_formatter.rb
+- lib/data_checks/notifiers/email_notifier.rb
+- lib/data_checks/notifiers/logger_default_formatter.rb
+- lib/data_checks/notifiers/logger_notifier.rb
+- lib/data_checks/notifiers/notifier.rb
+- lib/data_checks/notifiers/slack_default_formatter.rb
+- lib/data_checks/notifiers/slack_notifier.rb
+- lib/data_checks/railtie.rb
+- lib/data_checks/runner.rb
+- lib/data_checks/status_printer.rb
+- lib/data_checks/version.rb
+- lib/generators/data_checks/install_generator.rb
+- lib/generators/data_checks/templates/initializer.rb.tt
+- lib/generators/data_checks/templates/migration.rb.tt
+- lib/tasks/data_checks.rake
+homepage: https://github.com/fatkodima/data_checks
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/fatkodima/data_checks
+  source_code_uri: https://github.com/fatkodima/data_checks
+  changelog_uri: https://github.com/fatkodima/data_checks/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Regression testing for data
+test_files: []