allgood 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe79d04db962fcfc50cb094c0b122506d09f903b7ee02e2ee7ae0c3930c78557
-  data.tar.gz: fb9a69be909db1c10d5019dfadbdbee5b7da514913d8a907933cd2873e73f2f0
+  metadata.gz: 28b060b89f8c61aa677718b5fb317179709bc8fb41e72e393f4df54c779ad927
+  data.tar.gz: f2c53147cd88aa374d261f5922a33188f6fca0ceed0648c44de320c15ac91ade
 SHA512:
-  metadata.gz: fc26bbc3685f38fbfa49e05047987537c64e06c55356c28d0c8a0a50b73b6981c10d66c96996ca44057720402f4f5ed1319309a33402b25a39d0bdf472518496
-  data.tar.gz: ea88c1027193b356560b2361e65a28c42d3b10683df7e777796ff5de10c0c6e3aa93f7bb42fa70ef6ce9699d288e4efa74ceaa82667a5208ec006aa41506e6ea
+  metadata.gz: 2135e908374e1621ad8cddc12605fad50f2b84ac7253c67e32d6ceae02c0d0a805a0a2c682fefe9800a7b49c1d9ae7276059f7473499510de8e59b87f9ba2c9e
+  data.tar.gz: 482317b8650757f64e8a37a15b4f0f9e3789fd61d74dc05e51fcd58eff2710c701f59e7bd42594d724fe107bb39552565179c77d300b0d131a8857955d172f8d

data/CHANGELOG.md

@@ -1,4 +1,12 @@
-## [Unreleased]
+## [0.2.0] - 2024-10-26
+
+- Improved the `allgood` DSL by adding optional conditionals on when individual checks are run
+- Allow for environment-specific checks with `only` and `except` options (`check "Test Check", only: [:development, :test]`)
+- Allow for conditional checks with `if` and `unless` options, which can be procs or any other condition (`check "Test Check", if: -> { condition }`)
+- Added visual indication of skipped checks in the healthcheck page
+- Improved developer experience by showing why checks were skipped (didn't meet conditions, environment-specific, etc.)
+- New DSL changes are fully backward compatible with the previous version (new options are optional, and checks will run normally if they are not specified), so the new version won't break existing configurations
+- Changed configuration loading to happen after Rails initialization so we fix the segfault that could occur when requiring gems in the `allgood.rb` configuration file before Rails was initialized
 
 ## [0.1.0] - 2024-08-22
 

data/README.md

@@ -1,12 +1,20 @@
 # ✅ Allgood - Rails gem for health checks
 
-Add quick, simple, and beautiful health checks to your Rails application.
+[![Gem Version](https://badge.fury.io/rb/allgood.svg)](https://badge.fury.io/rb/allgood)
 
-`allgood` allows you to define custom, business-oriented health checks (as in: are there any new users in the past 24 hours, are they actually using the app, does the last record have all the attributes we expect, etc.) in a very intuitive way that reads just like English – and provides a `/healthcheck` endpoint that displays the results in a beautiful page.
+Add quick, simple, and beautiful health checks to your Rails application via a `/healthcheck` page.
 
-You can then use that endpoint to monitor the health of your application via UptimeRobot, Pingdom, etc. These services will load your `/healthcheck` page every few minutes, so all checks will be run when UptimeRobot fetches the page.
+![Example dashboard of the Allgood health check page](allgood.jpeg)
 
-![alt text](allgood.jpeg)
+## How it works
+
+`allgood` allows you to define custom health checks (as in: can the Rails app connect to the DB, are there any new users in the past 24 hours, are they actually using the app, etc.) in a very intuitive way that reads just like English.
+
+It provides a `/healthcheck` endpoint that displays the results in a beautiful page.
+
+You can then [use that endpoint to monitor the health of your application via UptimeRobot](https://uptimerobot.com/?rid=854006b5fe82e4), Pingdom, etc. These services will load your `/healthcheck` page every few minutes, so all checks will be run when UptimeRobot fetches the page.
+
+`allgood` aims to provide developers with peace of mind by answering the question "is production okay?" at a glance.
 
 ## Installation
 
@@ -17,9 +25,10 @@ gem 'allgood'
 
 Then run `bundle install`.
 
-## Usage
+After installing the gem, you need to mount the `/healthcheck` route and define your health checks in a `config/allgood.rb` file.
+
 
-### Mounting the Engine
+## Mount the `/healthcheck` route
 
 In your `config/routes.rb` file, mount the Allgood engine:
 ```ruby
@@ -28,50 +37,39 @@ mount Allgood::Engine => '/healthcheck'
 
 You can now navigate to `/healthcheck` to see the health check results.
 
-The `/healthcheck` page returns a `200` HTTP code if all checks are successful – and error `503 Service Unavailable` otherwise.
+The `/healthcheck` page returns HTTP codes:
+ - `200 OK` if all checks are successful
+ - `503 Service Unavailable` error otherwise
 
-`allgood` is also a nice replacement for the default `/up` Rails action, so Kamal to also checks things like if the database connection is good. Just change the mounting route to `/up` instead of `/healthcheck`
+Services like UptimeRobot pick up these HTTP codes, which makes monitoring easy.
 
+**Kamal**: `allgood` can also be used as a replacement for the default `/up` Rails action, to make [Kamal](https://github.com/basecamp/kamal) check things like if the database connection is healthy when deploying your app's containers. Just change `allgood`'s mounting route to `/up` instead of `/healthcheck`, or configure Kamal to use the `allgood` route.
 
-### Configuring Health Checks
+> [!TIP]
+> If you're using Kamal with `allgood`, container deployment will fail if any defined checks fail, [without feedback from Kamal](https://github.com/rameerez/allgood/issues/1) on what went wrong. Your containers will just not start, and you'll get a generic error message. To avoid this, you can either keep the `allgood.rb` file very minimal (e.g., only check for active DB connection, migrations up to date, etc.) so the app deployment is likely to succeed, or you can use the default `/up` route for Kamal, and then mount `allgood` on another route for more advanced business-oriented checks. What you want to avoid is your app deployment failing because of usage-dependent or business-oriented checks, like your app not deploying because it didn't get any users in the past hour, or something like that.
 
-Create a file `config/allgood.rb` in your Rails application. This is where you'll define your health checks:
+## Configure your health checks
+
+Create a file `config/allgood.rb` in your Rails application. This is where you'll define your health checks. Here's a simple example:
 ```ruby
 # config/allgood.rb
 
 check "We have an active database connection" do
-  make_sure ActiveRecord::Base.connection.active?
-end
-```
-
-This will run the check upon page load, and will show "Check passed" or "Check failed" next to it. You can also specify a custom human-readable success / error message for each check, so you don't go crazy when things fail and you can't figure out what the check expected output was:
-```ruby
-check "Cache is accessible and functioning" do
-  Rails.cache.write('health_check_test', 'ok')
-  make_sure Rails.cache.read('health_check_test') == 'ok', "The `health_check_test` key in the cache should contain `'ok'`"
+  make_sure ActiveRecord::Base.connection.connect!.active?
 end
 ```
 
-As you can see, there's a very simple DSL (Domain-Specific Language) you can use to define health checks. It reads almost like natural English, and allows you to define powerful yet simple checks to make sure your app is healthy.
+`allgood` will run all checks upon page load, and will show "Check passed" or "Check failed" next to it. That's it – add as many health checks as you want!
 
-Other than checking for an active database connection, it's useful to check for business-oriented metrics, such as whether your app has gotten any new users in the past 24 hours (to make sure your signup flow is not broken), check whether there have been any new posts / records created recently (to make sure your users are performing the actions you'd expect them to do in your app), check for recent purchases, check for external API connections, check whether new records contain values within expected range, etc.
+Here's my default `config/allgood.rb` file that should work for most Rails applications, feel free to use it as a starting point:
 
-Some business health check examples that you'd need to adapt to the specifics of your particular app:
 ```ruby
-check "There's been new signups in the past 24 hours" do
-  count = User.where(created_at: 24.hours.ago..Time.now).count
-  expect(count).to_be_greater_than(0)
-end
+# config/allgood.rb
 
-check "The last created Purchase has a valid total" do
-  last_purchase = Purchase.order(created_at: :desc).limit(1).first
-  make_sure last_purchase.total.is_a?(Numeric), "Purchase total should be a number"
-  expect(last_purchase.total).to_be_greater_than(0)
+check "We have an active database connection" do
+  make_sure ActiveRecord::Base.connection.connect!.active?
 end
-```
 
-Other nice checks to have:
-```ruby
 check "Database can perform a simple query" do
   make_sure ActiveRecord::Base.connection.execute("SELECT 1").any?
 end
@@ -80,11 +78,6 @@ check "Database migrations are up to date" do
   make_sure ActiveRecord::Migration.check_all_pending! == nil
 end
 
-check "Cache is accessible and functioning" do
-  Rails.cache.write('health_check_test', 'ok')
-  make_sure Rails.cache.read('health_check_test') == 'ok', "The `health_check_test` key in the cache should contain `'ok'`"
-end
-
 check "Disk space usage is below 90%" do
   usage = `df -h / | tail -1 | awk '{print $5}' | sed 's/%//'`.to_i
   expect(usage).to_be_less_than(90)
@@ -96,12 +89,44 @@ check "Memory usage is below 90%" do
 end
 ```
 
-If you have other nice default checks, please open a PR! I'd love to provide a good default `config/allgood.rb` file.
+I've also added an example [`config/allgood.rb`](examples/allgood.rb) file in the `examples` folder, with very comprehensive checks for a Rails 8+ app, that you can use as a starting point.
+
+> [!IMPORTANT]
+> Make sure you restart the Rails server (`bin/rails s`) every time you modify the `config/allgood.rb` file for the changes to apply – the `allgood` config is only loaded once when the Rails server starts.
 
-> ⚠️ Make sure to restart the Rails server every time you modify the `config/allgood.rb` file for the config to reload and the changes to apply.
+### The `allgood` DSL
 
+As you can see, there's a very simple DSL (Domain-Specific Language) you can use to define health checks.
 
-### Available Check Methods
+It reads almost like natural English, and allows you to define powerful yet simple checks to make sure your app is healthy.
+
+For example, you can specify a custom human-readable success / error message for each check, so you don't go crazy when things fail and you can't figure out what the check expected output was:
+```ruby
+check "Cache is accessible and functioning" do
+  Rails.cache.write('allgood_test', 'ok')
+  make_sure Rails.cache.read('allgood_test') == 'ok', "The `allgood_test` key in the cache should contain `'ok'`"
+end
+```
+
+Other than checking for an active database connection, it's useful to check for business-oriented metrics, such as whether your app has gotten any new users in the past 24 hours (to make sure your signup flow is not broken), check whether there have been any new posts / records created recently (to make sure your users are performing the actions you'd expect them to do in your app), check for recent purchases, check for external API connections, check whether new records contain values within expected range, etc.
+
+Some business health check examples that you'd need to adapt to the specifics of your particular app:
+```ruby
+# Adapt these to your app specifics
+
+check "There's been new signups in the past 24 hours" do
+  count = User.where(created_at: 24.hours.ago..Time.now).count
+  expect(count).to_be_greater_than(0)
+end
+
+check "The last created Purchase has a valid total" do
+  last_purchase = Purchase.order(created_at: :desc).limit(1).first
+  make_sure last_purchase.total.is_a?(Numeric), "Purchase total should be a number"
+  expect(last_purchase.total).to_be_greater_than(0)
+end
+```
+
+### Available check methods
 
 - `make_sure(condition, message = nil)`: Ensures that the given condition is true.
 - `expect(actual).to_eq(expected)`: Checks if the actual value equals the expected value.
@@ -110,23 +135,67 @@ If you have other nice default checks, please open a PR! I'd love to provide a g
 
 Please help us develop by adding more expectation methods in the `Expectation` class!
 
-## Customization
+### Run checks only in specific environments or under certain conditions
+
+You can also make certain checks run only in specific environments or under certain conditions. Some examples:
+
+```ruby
+# Only run in production
+check "There have been new user signups in the past hour", only: :production do
+  make_sure User.where(created_at: 1.hour.ago..Time.now).count.positive?
+end
+
+# Run in both staging and production
+check "External API is responsive", only: [:staging, :production] do
+  # ...
+end
+
+# Run everywhere except development
+check "A SolidCable connection is active and healthy", except: :development do
+  # ...
+end
+
+# Using if with a direct boolean
+check "Feature flag is enabled", if: ENV['FEATURE_ENABLED'] == 'true' do
+  # ...
+end
+
+# Using if with a Proc for more complex conditions
+check "Complex condition", if: -> { User.count > 1000 && User.last.created_at < 10.minutes.ago } do
+  # ...
+end
+
+# Override default timeout (in seconds) for specific checks
+# By default, each check has a timeout of 10 seconds
+check "Slow external API", timeout: 30 do
+  # ...
+end
+
+# Combine multiple conditions
+check "Complex check",
+      only: :production,
+      if: -> { User.count > 1000 },
+      timeout: 15 do
+  # ...
+end
+```
 
-### Timeout
+When a check is skipped due to its conditions not being met, it will appear in the healthcheck page with a skip emoji (⏭️) and a clear explanation of why it was skipped.
 
-By default, each check has a timeout of 10 seconds.
+![Example dashboard of the Allgood health check page with skipped checks](allgood_skipped.webp)
 
+_Note: the `allgood` health check dashboard has an automatic dark mode, based on the system's appearance settings._
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-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 the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/rameerez/allgood Our code of conduct is: just be nice and make your mom proud of what you do and post online.
+Bug reports and pull requests are welcome on GitHub at https://github.com/rameerez/allgood. Our code of conduct is: just be nice and make your mom proud of what you do and post online.
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/app/controllers/allgood/healthcheck_controller.rb

@@ -29,7 +29,17 @@ module Allgood
 
     def run_checks
       Allgood.configuration.checks.map do |check|
-        run_single_check(check)
+        if check[:status] == :skipped
+          {
+            name: check[:name],
+            success: true,
+            skipped: true,
+            message: check[:skip_reason],
+            duration: 0
+          }
+        else
+          run_single_check(check)
+        end
       end
     end
 

data/app/views/allgood/healthcheck/index.html.erb

@@ -14,6 +14,10 @@
   .check {
     margin: 0.5em 0;
   }
+
+  .skipped {
+    opacity: 0.6;
+  }
 </style>
 
 <header>
@@ -22,11 +26,18 @@
 
 <% if @results.any? %>
   <% @results.each do |result| %>
-    <div class="check">
-      <%= result[:success] ? "✅" : "❌" %>
-      <b><%= result[:name] %></b>: <i><%= result[:message] %></i> <code>[<%= result[:duration] %>ms]</code>
+    <div class="check <%= 'skipped' if result[:skipped] %>">
+      <% if result[:skipped] %>
+        ⏭️
+      <% else %>
+        <%= result[:success] ? "✅" : "❌" %>
+      <% end %>
+      <b><%= result[:name] %></b>: <i><%= result[:message] %></i> 
+      <% unless result[:skipped] %>
+        <code>[<%= result[:duration] %>ms]</code>
+      <% end %>
     </div>
   <% end %>
 <% else %>
   <p>No health checks were run. Please check your configuration.</p>
-<% end %>
+<% end %>

data/examples/allgood.rb

@@ -0,0 +1,166 @@
+require 'open-uri'
+TEST_IMAGE = URI.open("https://picsum.photos/id/237/536/354").read
+
+# --- ACTIVE RECORD ---
+
+check "We have an active database connection" do
+  make_sure ActiveRecord::Base.connection.connect!.active?
+end
+
+check "The database can perform a simple query" do
+  make_sure ActiveRecord::Base.connection.execute("SELECT 1 LIMIT 1").any?
+end
+
+check "The database can perform writes" do
+  table_name = "allgood_health_check_#{Time.now.to_i}"
+  random_id = rand(1..999999)
+
+  result = ActiveRecord::Base.connection.execute(<<~SQL)
+    DROP TABLE IF EXISTS #{table_name};
+    CREATE TEMPORARY TABLE #{table_name} (id integer);
+    INSERT INTO #{table_name} (id) VALUES (#{random_id});
+    SELECT id FROM #{table_name} LIMIT 1;
+  SQL
+
+  ActiveRecord::Base.connection.execute("DROP TABLE #{table_name}")
+
+  make_sure result.present? && result.first["id"] == random_id, "Able to write to temporary table"
+end
+
+check "The database connection pool is healthy" do
+  pool = ActiveRecord::Base.connection_pool
+
+  used_connections = pool.connections.count
+  max_connections = pool.size
+  usage_percentage = (used_connections.to_f / max_connections * 100).round
+
+  make_sure usage_percentage < 90, "Pool usage at #{usage_percentage}% (#{used_connections}/#{max_connections})"
+end
+
+check "Database migrations are up to date" do
+  make_sure ActiveRecord::Migration.check_all_pending! == nil
+end
+
+# --- IMAGE PROCESSING ---
+
+check "Vips (libvips) is installed on Linux", except: :development do
+  output = `ldconfig -p | grep libvips`
+  make_sure output.present? && output.include?("libvips.so") && output.include?("libvips-cpp.so"), "libvips is found in the Linux system's library cache"
+end
+
+check "Vips is available to Rails" do
+  throw "ImageProcessing::Vips is not available" if !ImageProcessing::Vips.present? # Need this line to load `Vips`
+
+  make_sure Vips::VERSION.present?, "Vips available with version #{Vips::VERSION}"
+end
+
+check "Vips can perform operations on images" do
+  throw "ImageProcessing::Vips is not available" if !ImageProcessing::Vips.present? # Need this line to load `Vips`
+
+  image = Vips::Image.new_from_buffer(TEST_IMAGE, "")
+  processed_image = image
+    .gaussblur(10)                   # Apply Gaussian blur with sigma 10
+    .linear([1.2], [0])              # Increase brightness
+    .invert                          # Invert colors for a wild effect
+    .sharpen                         # Apply sharpening
+    .resize(0.5)
+
+  make_sure processed_image.present? && processed_image.width == 268 && processed_image.height == 177, "If we input an image of 536x354px, and we apply filters and a 0.5 resize, we should get an image of 268x177px"
+end
+
+check "ImageProcessing::Vips is available to Rails" do
+  make_sure ImageProcessing::Vips.present?
+end
+
+check "ImageProcessing can perform operations on images" do
+  image_processing_image = ImageProcessing::Vips
+    .source(Vips::Image.new_from_buffer(TEST_IMAGE, ""))
+    .resize_to_limit(123, 123)        # Resize to fit within 500x500
+    .convert("webp")                  # Convert to webp format
+    .call
+  processed_image = Vips::Image.new_from_file(image_processing_image.path)
+
+  make_sure processed_image.present? && processed_image.width == 123 && processed_image.get("vips-loader") == "webpload", "ImageProcessing can resize and convert to webp"
+end
+
+# --- ACTIVE STORAGE ---
+
+check "Active Storage is available to Rails" do
+  make_sure ActiveStorage.present?
+end
+
+check "Active Storage tables are present in the database" do
+  make_sure ActiveRecord::Base.connection.table_exists?("active_storage_attachments") && ActiveRecord::Base.connection.table_exists?("active_storage_blobs")
+end
+
+check "Active Storage has a valid client configured" do
+  service = ActiveStorage::Blob.service
+  service_name = service&.class&.name&.split("::")&.last&.split("Service")&.first
+
+  if !service_name.downcase.include?("disk")
+    make_sure service.present? && service.respond_to?(:client) && service.client.present?, "Active Storage service has a valid #{service_name} client configured"
+  else
+    make_sure !Rails.env.production? && service.present?, "Active Storage using #{service_name} service in #{Rails.env.to_s}"
+  end
+end
+
+check "ActiveStorage can store images, retrieve them, and purge them" do
+  blob = ActiveStorage::Blob.create_and_upload!(io: StringIO.new(TEST_IMAGE), filename: "allgood-test-image-#{Time.now.to_i}.jpg", content_type: "image/jpeg")
+  make_sure blob.persisted? && blob.service.exist?(blob.key) && blob.purge, "Image was successfully stored, retrieved, and purged from #{ActiveStorage::Blob.service.class.name}"
+end
+
+# --- CACHE ---
+
+check "Cache is accessible and functioning" do
+  cache_value = "allgood_#{Time.now.to_i}"
+  Rails.cache.write("allgood_health_check_test", cache_value, expires_in: 1.minute)
+  make_sure Rails.cache.read("allgood_health_check_test") == cache_value, "The `allgood_health_check_test` key in the cache should return the string `#{cache_value}`"
+end
+
+# --- SOLID QUEUE ---
+
+check "SolidQueue is available to Rails" do
+  make_sure SolidQueue.present?
+end
+
+check "We have an active SolidQueue connection to the database" do
+  make_sure SolidQueue::Job.connection.connect!.active?
+end
+
+check "SolidQueue tables are present in the database" do
+  make_sure SolidQueue::Job.connection.table_exists?("solid_queue_jobs") && SolidQueue::Job.connection.table_exists?("solid_queue_failed_executions") && SolidQueue::Job.connection.table_exists?("solid_queue_semaphores")
+end
+
+check "The percentage of failed jobs in the last 24 hours is less than 1%", only: :production do
+  failed_jobs = SolidQueue::FailedExecution.where(created_at: 24.hours.ago..Time.now).count
+  all_jobs = SolidQueue::Job.where(created_at: 24.hours.ago..Time.now).count
+
+  if all_jobs > 10
+    percentage = all_jobs > 0 ? (failed_jobs.to_f / all_jobs.to_f * 100) : 0
+    make_sure percentage < 1, "#{percentage.round(2)}% of jobs are failing"
+  else
+    make_sure true, "Not enough jobs to calculate meaningful failure rate (only #{all_jobs} jobs in last 24h)"
+  end
+end
+
+# --- SYSTEM ---
+
+check "Disk space usage is below 90%" do
+  usage = `df -h / | tail -1 | awk '{print $5}' | sed 's/%//'`.to_i
+  expect(usage).to_be_less_than(90)
+end
+
+check "Memory usage is below 90%" do
+  usage = `free | grep Mem | awk '{print $3/$2 * 100.0}' | cut -d. -f1`.to_i
+  expect(usage).to_be_less_than(90)
+end
+
+# --- USAGE-DEPENDENT CHECKS ---
+
+check "SolidQueue has processed jobs in the last 24 hours", only: :production do
+  make_sure SolidQueue::Job.where(created_at: 24.hours.ago..Time.now).order(created_at: :desc).limit(1).any?
+end
+
+# --- PAY / STRIPE ---
+
+# TODO: no error webhooks in the past 24 hours, new sales in the past few hours, etc.

data/lib/allgood/configuration.rb

@@ -8,8 +8,59 @@ module Allgood
       @default_timeout = 10 # Default timeout of 10 seconds
     end
 
-    def check(name, &block)
-      @checks << { name: name, block: block, timeout: @default_timeout }
+    def check(name, **options, &block)
+      check_info = {
+        name: name,
+        block: block,
+        timeout: options[:timeout] || @default_timeout,
+        options: options,
+        status: :pending
+      }
+
+      # Handle environment-specific options
+      if options[:only]
+        environments = Array(options[:only])
+        unless environments.include?(Rails.env.to_sym)
+          check_info[:status] = :skipped
+          check_info[:skip_reason] = "Only runs in #{environments.join(', ')}"
+          @checks << check_info
+          return
+        end
+      end
+
+      if options[:except]
+        environments = Array(options[:except])
+        if environments.include?(Rails.env.to_sym)
+          check_info[:status] = :skipped
+          check_info[:skip_reason] = "This check doesn't run in #{environments.join(', ')}"
+          @checks << check_info
+          return
+        end
+      end
+
+      # Handle conditional checks
+      if options[:if]
+        condition = options[:if]
+        unless condition.is_a?(Proc) ? condition.call : condition
+          check_info[:status] = :skipped
+          check_info[:skip_reason] = "Check condition not met"
+          @checks << check_info
+          return
+        end
+      end
+
+      if options[:unless]
+        condition = options[:unless]
+        if condition.is_a?(Proc) ? condition.call : condition
+          check_info[:status] = :skipped
+          check_info[:skip_reason] = "Check `unless` condition met"
+          @checks << check_info
+          return
+        end
+      end
+
+      check_info[:status] = :active
+      @checks << check_info
     end
 
     def run_check(&block)

data/lib/allgood/engine.rb

@@ -2,7 +2,7 @@ module Allgood
   class Engine < ::Rails::Engine
     isolate_namespace Allgood
 
-    initializer "allgood.load_configuration" do
+    config.after_initialize do
       config_file = Rails.root.join("config", "allgood.rb")
       if File.exist?(config_file)
         Allgood.configure do |config|

data/lib/allgood/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: allgood
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - rameerez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-23 00:00:00.000000000 Z
+date: 2024-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,12 +24,13 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.0.0
-description: 'Define custom, business-oriented health checks for your app (as in:
-  are there any new users in the past 24 hours) and see the results in a simple /healthcheck
-  page that you can use to monitor your app with UptimeRobot, Pingdom, or other monitoring
-  services.'
+description: 'Define custom health checks for your app (as in: are there any new users
+  in the past 24 hours) and see the results in a simple /healthcheck page that you
+  can use to monitor your production app with UptimeRobot, Pingdom, or other monitoring
+  services. It''s also useful as a drop-in replacement for the default `/up` health
+  check endpoint for Kamal deployments.'
 email:
-- allgood@rameerez.com
+- rubygems@rameerez.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -39,11 +40,13 @@ files:
 - README.md
 - Rakefile
 - allgood.jpeg
+- allgood_skipped.webp
 - app/controllers/allgood/base_controller.rb
 - app/controllers/allgood/healthcheck_controller.rb
 - app/views/allgood/healthcheck/index.html.erb
 - app/views/layouts/allgood/application.html.erb
 - config/routes.rb
+- examples/allgood.rb
 - lib/allgood.rb
 - lib/allgood/configuration.rb
 - lib/allgood/engine.rb
@@ -56,7 +59,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/rameerez/allgood
   source_code_uri: https://github.com/rameerez/allgood
-  changelog_uri: https://github.com/rameerez/allgood
+  changelog_uri: https://github.com/rameerez/allgood/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -72,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.17
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: Add quick, simple, and beautiful health checks to your Rails application.