allgood 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28b060b89f8c61aa677718b5fb317179709bc8fb41e72e393f4df54c779ad927
-  data.tar.gz: f2c53147cd88aa374d261f5922a33188f6fca0ceed0648c44de320c15ac91ade
+  metadata.gz: 45bac1780ef5cb92516f0a6f02cd7aa7b476213d6595a937252c600dc3e870e0
+  data.tar.gz: b1f8f7e8e30609d67c6c28fb66cd651d13414f9161f74b3e3880f02113408c10
 SHA512:
-  metadata.gz: 2135e908374e1621ad8cddc12605fad50f2b84ac7253c67e32d6ceae02c0d0a805a0a2c682fefe9800a7b49c1d9ae7276059f7473499510de8e59b87f9ba2c9e
-  data.tar.gz: 482317b8650757f64e8a37a15b4f0f9e3789fd61d74dc05e51fcd58eff2710c701f59e7bd42594d724fe107bb39552565179c77d300b0d131a8857955d172f8d
+  metadata.gz: b169c7d38987605312e2e013f645814e12fa23f2b0574793fa560f9f9ec9f97491eea5347c625e8b6d0909f3ec32c912a744925906f9e66b710486eb365cf35f
+  data.tar.gz: 0573a0b4918ec2e6e4a0ce40831d3e57afed34db5e8ada879d0db4450764dd0e72a8ffe4b3e779bf58758cf3d29546728600f9823437cdf1618627a48648fe5a

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.3.0] - 2024-10-27
+
+- Added rate limiting for expensive checks with the `run: "N times per day/hour"` option
+- Added a cache mechanism to store check results and error states, which allows for rate limiting and avoiding redundant runs when checks fail
+- Added automatic cache key expiration
+- Added error handling and feedback for rate-limited checks
+
 ## [0.2.0] - 2024-10-26
 
 - Improved the `allgood` DSL by adding optional conditionals on when individual checks are run

data/README.md

@@ -4,11 +4,13 @@
 
 Add quick, simple, and beautiful health checks to your Rails application via a `/healthcheck` page.
 
+Use it for smoke testing, to make sure your app is healthy and functioning as expected.
+
 ![Example dashboard of the Allgood health check page](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.
+`allgood` allows you to define custom health checks / smoke tests (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.
 
@@ -180,6 +182,26 @@ check "Complex check",
 end
 ```
 
+### Rate Limiting Expensive Checks
+
+For expensive operations (like testing paid APIs), you can limit how often checks run:
+
+```ruby
+# Run expensive checks a limited number of times
+check "OpenAI is responding with a valid LLM message", run: "2 times per day" do
+  # expensive API call
+end
+
+check "Analytics can be processed", run: "4 times per hour" do
+  # expensive operation
+end
+```
+
+Important notes:
+- Rate limits reset at the start of each period (hour/day)
+- The error state persists between rate-limited runs
+- Rate-limited checks show clear feedback about remaining runs and next reset time
+
 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.
 
 ![Example dashboard of the Allgood health check page with skipped checks](allgood_skipped.webp)

data/app/controllers/allgood/healthcheck_controller.rb

@@ -44,20 +44,62 @@ module Allgood
     end
 
     def run_single_check(check)
+      last_result_key = "allgood:last_result:#{check[:name].parameterize}"
+      last_result = Allgood::CacheStore.instance.read(last_result_key)
+
+      unless Allgood.configuration.should_run_check?(check)
+        message = check[:skip_reason]
+        if last_result
+          status_info = "Last check #{last_result[:success] ? 'passed' : 'failed'} #{time_ago_in_words(last_result[:time])} ago: #{last_result[:message]}"
+          message = "#{message}. #{status_info}"
+        end
+
+        return {
+          name: check[:name],
+          success: last_result ? last_result[:success] : true,
+          skipped: true,
+          message: message,
+          duration: 0
+        }
+      end
+
       start_time = Time.now
       result = { success: false, message: "Check timed out after #{check[:timeout]} seconds" }
+      error_key = "allgood:error:#{check[:name].parameterize}"
 
       begin
         Timeout.timeout(check[:timeout]) do
           check_result = Allgood.configuration.run_check(&check[:block])
           result = { success: check_result[:success], message: check_result[:message] }
+
+          if result[:success]
+            # Clear error state and store successful result
+            Allgood::CacheStore.instance.write(error_key, nil)
+            Allgood::CacheStore.instance.write(last_result_key, {
+              success: true,
+              message: result[:message],
+              time: Time.current
+            })
+          end
+        end
+      rescue Timeout::Error, Allgood::CheckFailedError, StandardError => e
+        error_message = case e
+        when Timeout::Error
+          "Check timed out after #{check[:timeout]} seconds"
+        when Allgood::CheckFailedError
+          e.message
+        else
+          "Error: #{e.message}"
         end
-      rescue Timeout::Error
-        # The result is already set to a timeout message
-      rescue Allgood::CheckFailedError => e
-        result = { success: false, message: e.message }
-      rescue StandardError => e
-        result = { success: false, message: "Error: #{e.message}" }
+
+        # Store error state and failed result
+        Allgood::CacheStore.instance.write(error_key, error_message)
+        Allgood::CacheStore.instance.write(last_result_key, {
+          success: false,
+          message: error_message,
+          time: Time.current
+        })
+        result = { success: false, message: error_message }
       end
 
       {

data/examples/allgood.rb

@@ -106,7 +106,10 @@ 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}"
+  blob_key = blob.key
+  make_sure blob.persisted? && blob.service.exist?(blob_key)
+  blob.purge
+  make_sure !blob.service.exist?(blob_key), "Image needs to be successfully stored, retrieved, and purged from #{ActiveStorage::Blob.service.name} (#{ActiveStorage::Blob.service.class.name})"
 end
 
 # --- CACHE ---
@@ -143,18 +146,65 @@ check "The percentage of failed jobs in the last 24 hours is less than 1%", only
   end
 end
 
+# --- ACTION CABLE ---
+
+check "ActionCable is configured and running" do
+  make_sure ActionCable.server.present?, "ActionCable server should be running"
+end
+
+check "ActionCable is configured to accept connections with a valid adapter" do
+  make_sure ActionCable.server.config.allow_same_origin_as_host, "ActionCable server should be configured to accept connections"
+
+  adapter = ActionCable.server.config.cable["adapter"]
+
+  if Rails.env.production?
+    make_sure adapter.in?(["solid_cable", "redis"]), "ActionCable running #{adapter} adapter in #{Rails.env.to_s}"
+  else
+    make_sure adapter.in?(["solid_cable", "async"]), "ActionCable running #{adapter} adapter in #{Rails.env.to_s}"
+  end
+end
+
+check "ActionCable can broadcast messages and store them in SolidCable" do
+  test_message = "allgood_test_#{Time.now.to_i}"
+
+  begin
+    ActionCable.server.broadcast("allgood_test_channel", { message: test_message })
+
+    # Verify message was stored in SolidCable
+    message = SolidCable::Message.where(channel: "allgood_test_channel")
+                                .order(created_at: :desc)
+                                .first
+
+    make_sure message.present?, "Message should be stored in SolidCable"
+    make_sure message.payload.include?(test_message) && message.destroy, "Message payload should contain our test message"
+  rescue => e
+    make_sure false, "Failed to broadcast/verify message: #{e.message}"
+  end
+end
+
 # --- SYSTEM ---
 
-check "Disk space usage is below 90%" do
+check "Disk space usage is below 90%", only: :production 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
+check "Memory usage is below 90%", only: :production do
   usage = `free | grep Mem | awk '{print $3/$2 * 100.0}' | cut -d. -f1`.to_i
   expect(usage).to_be_less_than(90)
 end
 
+# --- SITEMAP ---
+
+check "The sitemap generator is available" do
+  make_sure SitemapGenerator.present?
+end
+
+check "sitemap.xml.gz exists", only: :production do
+  make_sure File.exist?(Rails.public_path.join("sitemap.xml.gz"))
+end
+
+
 # --- USAGE-DEPENDENT CHECKS ---
 
 check "SolidQueue has processed jobs in the last 24 hours", only: :production do

data/lib/allgood/cache_store.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Allgood
+  class CacheStore
+    def self.instance
+      @instance ||= new
+    end
+
+    def initialize
+      @memory_store = {}
+    end
+
+    def read(key)
+      if rails_cache_available?
+        Rails.cache.read(key)
+      else
+        @memory_store[key]
+      end
+    end
+
+    def write(key, value)
+      if rails_cache_available?
+        expiry = key.include?('day') ? 1.day : 1.hour
+        Rails.cache.write(key, value, expires_in: expiry)
+      else
+        @memory_store[key] = value
+      end
+    end
+
+    def cleanup_old_keys
+      return unless rails_cache_available?
+
+      keys_pattern = "allgood:*"
+      if Rails.cache.respond_to?(:delete_matched)
+        Rails.cache.delete_matched("#{keys_pattern}:*:#{(Time.current - 2.days).strftime('%Y-%m-%d')}*")
+      end
+    rescue StandardError => e
+      Rails.logger.warn "Allgood: Failed to cleanup old cache keys: #{e.message}"
+    end
+
+    private
+
+    def rails_cache_available?
+      Rails.cache && Rails.cache.respond_to?(:read) && Rails.cache.respond_to?(:write) &&
+        Rails.cache.write("allgood_rails_cache_test_ok", "true") &&
+        Rails.cache.read("allgood_rails_cache_test_ok") == "true"
+    rescue StandardError => e
+      Rails.logger.warn "Allgood: Rails.cache not available (#{e.message}), falling back to memory store"
+      false
+    end
+  end
+end

data/lib/allgood/configuration.rb

@@ -17,6 +17,18 @@ module Allgood
         status: :pending
       }
 
+      # Handle rate limiting
+      if options[:run]
+        begin
+          check_info[:rate] = parse_run_frequency(options[:run])
+        rescue ArgumentError => e
+          check_info[:status] = :skipped
+          check_info[:skip_reason] = "Invalid run frequency: #{e.message}"
+          @checks << check_info
+          return
+        end
+      end
+
       # Handle environment-specific options
       if options[:only]
         environments = Array(options[:only])
@@ -66,6 +78,97 @@ module Allgood
     def run_check(&block)
       CheckRunner.new.instance_eval(&block)
     end
+
+    def should_run_check?(check)
+      return true unless check[:rate]
+
+      cache_key = "allgood:last_run:#{check[:name].parameterize}"
+      runs_key = "allgood:runs_count:#{check[:name].parameterize}:#{current_period(check[:rate])}"
+      error_key = "allgood:error:#{check[:name].parameterize}"
+      last_result_key = "allgood:last_result:#{check[:name].parameterize}"
+
+      last_run = Allgood::CacheStore.instance.read(cache_key)
+      period_runs = Allgood::CacheStore.instance.read(runs_key).to_i
+      last_result = Allgood::CacheStore.instance.read(last_result_key)
+
+      current_period_key = current_period(check[:rate])
+      stored_period = Allgood::CacheStore.instance.read("allgood:current_period:#{check[:name].parameterize}")
+
+      # If we're in a new period, reset the counter
+      if stored_period != current_period_key
+        period_runs = 0
+        Allgood::CacheStore.instance.write("allgood:current_period:#{check[:name].parameterize}", current_period_key)
+        Allgood::CacheStore.instance.write(runs_key, 0)
+      end
+
+      # If there's an error, wait until next period
+      if previous_error = Allgood::CacheStore.instance.read(error_key)
+        next_period = next_period_start(check[:rate])
+        rate_info = "Rate limited (#{period_runs}/#{check[:rate][:max_runs]} runs this #{check[:rate][:period]})"
+        check[:skip_reason] = "#{rate_info}. Waiting until #{next_period.strftime('%H:%M:%S %Z')} to retry failed check"
+        return false
+      end
+
+      # If we haven't exceeded the max runs for this period
+      if period_runs < check[:rate][:max_runs]
+        Allgood::CacheStore.instance.write(cache_key, Time.current)
+        Allgood::CacheStore.instance.write(runs_key, period_runs + 1)
+        true
+      else
+        next_period = next_period_start(check[:rate])
+        rate_info = "Rate limited (#{period_runs}/#{check[:rate][:max_runs]} runs this #{check[:rate][:period]})"
+        next_run = "Next check at #{next_period.strftime('%H:%M:%S %Z')}"
+        check[:skip_reason] = "#{rate_info}. #{next_run}"
+        false
+      end
+    end
+
+    private
+
+    def parse_run_frequency(frequency)
+      case frequency.to_s.downcase
+      when /(\d+)\s+times?\s+per\s+(day|hour)/i
+        max_runs, period = $1.to_i, $2
+        if max_runs <= 0
+          raise ArgumentError, "Number of runs must be positive"
+        end
+        if max_runs > 1000
+          raise ArgumentError, "Maximum 1000 runs per period allowed"
+        end
+        { max_runs: max_runs, period: period }
+      else
+        raise ArgumentError, "Unsupported frequency format. Use 'N times per day' or 'N times per hour'"
+      end
+    end
+
+    def current_period(rate)
+      case rate[:period]
+      when 'day'
+        Time.current.strftime('%Y-%m-%d')
+      when 'hour'
+        Time.current.strftime('%Y-%m-%d-%H')
+      end
+    end
+
+    def new_period?(last_run, rate)
+      case rate[:period]
+      when 'day'
+        !last_run.to_date.equal?(Time.current.to_date)
+      when 'hour'
+        last_run.strftime('%Y-%m-%d-%H') != Time.current.strftime('%Y-%m-%d-%H')
+      end
+    end
+
+    def next_period_start(rate)
+      case rate[:period]
+      when 'day'
+        Time.current.beginning_of_day + 1.day
+      when 'hour'
+        Time.current.beginning_of_hour + 1.hour
+      else
+        raise ArgumentError, "Unsupported period: #{rate[:period]}"
+      end
+    end
   end
 
   class CheckRunner

data/lib/allgood/version.rb

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

data/lib/allgood.rb

@@ -3,6 +3,7 @@
 require_relative "allgood/version"
 require_relative "allgood/engine"
 require_relative "allgood/configuration"
+require_relative "allgood/cache_store"
 
 module Allgood
   class Error < StandardError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: allgood
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - rameerez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-26 00:00:00.000000000 Z
+date: 2024-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -48,6 +48,7 @@ files:
 - config/routes.rb
 - examples/allgood.rb
 - lib/allgood.rb
+- lib/allgood/cache_store.rb
 - lib/allgood/configuration.rb
 - lib/allgood/engine.rb
 - lib/allgood/version.rb
@@ -75,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Add quick, simple, and beautiful health checks to your Rails application.