activerecord-health 0.1.0

data/test/unit/extensions_test.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "activerecord/health/extensions"
+
+class ConnectionExtensionTest < ActiveRecord::Health::TestCase
+  def test_healthy_returns_true_when_below_threshold
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.5)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.threshold = 0.75
+      config.cache = cache
+    end
+
+    connection = MockConnectionWithExtension.new("primary")
+    assert connection.healthy?
+  end
+
+  def test_healthy_returns_false_when_above_threshold
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.9)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.threshold = 0.75
+      config.cache = cache
+    end
+
+    connection = MockConnectionWithExtension.new("primary")
+    refute connection.healthy?
+  end
+
+  def test_load_pct_returns_cached_value
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.625)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.cache = cache
+    end
+
+    connection = MockConnectionWithExtension.new("primary")
+    assert_equal 0.625, connection.load_pct
+  end
+end
+
+class ModelExtensionTest < ActiveRecord::Health::TestCase
+  def test_database_healthy_returns_true_when_below_threshold
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.5)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.threshold = 0.75
+      config.cache = cache
+    end
+
+    assert MockModelWithExtension.database_healthy?
+  end
+
+  def test_database_healthy_returns_false_when_above_threshold
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.9)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.threshold = 0.75
+      config.cache = cache
+    end
+
+    refute MockModelWithExtension.database_healthy?
+  end
+end
+
+MockExtensionDbConfig = Struct.new(:name)
+
+class MockConnectionWithExtension
+  include ActiveRecord::Health::ConnectionExtension
+
+  def initialize(db_config_name)
+    @db_config_name = db_config_name
+  end
+
+  def adapter_name
+    "PostgreSQL"
+  end
+
+  def select_value(query)
+    0
+  end
+
+  def pool
+    self
+  end
+
+  def db_config
+    MockExtensionDbConfig.new(@db_config_name)
+  end
+end
+
+class MockModelWithExtension
+  extend ActiveRecord::Health::ModelExtension
+
+  def self.connection_db_config
+    MockExtensionDbConfig.new("primary")
+  end
+
+  def self.connection
+    MockConnectionWithExtension.new("primary")
+  end
+end

data/test/unit/health_test.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HealthTest < ActiveRecord::Health::TestCase
+  def test_ok_returns_true_when_load_below_threshold
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.5)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.threshold = 0.75
+      config.cache = cache
+    end
+
+    mock_model = MockModel.new("primary")
+    assert ActiveRecord::Health.ok?(model: mock_model)
+  end
+
+  def test_ok_returns_false_when_load_above_threshold
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.9)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.threshold = 0.75
+      config.cache = cache
+    end
+
+    mock_model = MockModel.new("primary")
+    refute ActiveRecord::Health.ok?(model: mock_model)
+  end
+
+  def test_ok_returns_true_when_load_equals_threshold
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.75)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.threshold = 0.75
+      config.cache = cache
+    end
+
+    mock_model = MockModel.new("primary")
+    assert ActiveRecord::Health.ok?(model: mock_model)
+  end
+
+  def test_ok_returns_true_when_cache_fails
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.cache = FailingCache.new
+    end
+
+    mock_model = MockModel.new("primary")
+    assert ActiveRecord::Health.ok?(model: mock_model)
+  end
+
+  def test_load_pct_returns_cached_value
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.625)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.cache = cache
+    end
+
+    mock_model = MockModel.new("primary")
+    assert_equal 0.625, ActiveRecord::Health.load_pct(model: mock_model)
+  end
+
+  def test_load_pct_returns_zero_when_cache_fails
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.cache = FailingCache.new
+    end
+
+    mock_model = MockModel.new("primary")
+    assert_equal 0.0, ActiveRecord::Health.load_pct(model: mock_model)
+  end
+
+  def test_load_pct_queries_database_when_not_cached
+    cache = MockCache.new
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.cache = cache
+    end
+
+    connection = MockConnection.new(active_session_count: 8)
+    mock_model = MockModel.new("primary", connection)
+
+    assert_equal 0.5, ActiveRecord::Health.load_pct(model: mock_model)
+    assert_equal 0.5, cache.read("activerecord_health:load_pct:primary")
+  end
+
+  def test_load_pct_returns_1_0_when_database_query_fails
+    cache = MockCache.new
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.cache = cache
+    end
+
+    connection = MockConnection.new(should_fail: true)
+    mock_model = MockModel.new("primary", connection)
+
+    assert_equal 1.0, ActiveRecord::Health.load_pct(model: mock_model)
+  end
+
+  def test_ok_returns_false_when_database_query_fails
+    cache = MockCache.new
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.threshold = 0.75
+      config.cache = cache
+    end
+
+    connection = MockConnection.new(should_fail: true)
+    mock_model = MockModel.new("primary", connection)
+
+    refute ActiveRecord::Health.ok?(model: mock_model)
+  end
+
+  def test_uses_per_model_configuration
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:animals", 0.6)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.threshold = 0.75
+      config.cache = cache
+
+      config.for_model(AnimalsRecord) do |db|
+        db.vcpu_count = 8
+        db.threshold = 0.5
+      end
+    end
+
+    mock_model = MockModel.new("animals")
+    mock_model.define_singleton_method(:class) { AnimalsRecord }
+
+    refute ActiveRecord::Health.ok?(model: mock_model)
+  end
+end
+
+MockDbConfig = Struct.new(:name)
+
+class MockModel
+  attr_reader :connection
+
+  def initialize(db_config_name, connection = nil)
+    @db_config_name = db_config_name
+    @connection = connection || MockConnection.new
+  end
+
+  def connection_db_config
+    MockDbConfig.new(@db_config_name)
+  end
+
+  def class
+    ActiveRecord::Base
+  end
+end
+
+class MockConnection
+  def initialize(active_session_count: 0, should_fail: false)
+    @active_session_count = active_session_count
+    @should_fail = should_fail
+  end
+
+  def adapter_name
+    "PostgreSQL"
+  end
+
+  def select_value(query)
+    raise "Connection failed" if @should_fail
+    @active_session_count
+  end
+
+  def execute(query)
+    raise "Connection failed" if @should_fail
+  end
+
+  def transaction
+    raise "Connection failed" if @should_fail
+    yield
+  end
+end

data/test/unit/sheddable_test.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class SheddableTest < ActiveRecord::Health::TestCase
+  def test_sheddable_executes_block_and_returns_true_when_healthy
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.5)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.threshold = 0.75
+      config.cache = cache
+    end
+
+    mock_model = MockModel.new("primary")
+    executed = false
+    result = ActiveRecord::Health.sheddable(model: mock_model) { executed = true }
+
+    assert executed
+    assert result
+  end
+
+  def test_sheddable_returns_false_and_skips_block_when_overloaded
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.9)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.threshold = 0.75
+      config.cache = cache
+    end
+
+    mock_model = MockModel.new("primary")
+    executed = false
+    result = ActiveRecord::Health.sheddable(model: mock_model) { executed = true }
+
+    refute executed
+    refute result
+  end
+
+  def test_sheddable_pct_executes_block_and_returns_true_when_below_threshold
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.4)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.cache = cache
+    end
+
+    mock_model = MockModel.new("primary")
+    executed = false
+    result = ActiveRecord::Health.sheddable_pct(pct: 0.5, model: mock_model) { executed = true }
+
+    assert executed
+    assert result
+  end
+
+  def test_sheddable_pct_returns_false_and_skips_block_when_above_threshold
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.6)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.cache = cache
+    end
+
+    mock_model = MockModel.new("primary")
+    executed = false
+    result = ActiveRecord::Health.sheddable_pct(pct: 0.5, model: mock_model) { executed = true }
+
+    refute executed
+    refute result
+  end
+
+  def test_sheddable_pct_executes_block_and_returns_true_when_at_threshold
+    cache = MockCache.new
+    cache.write("activerecord_health:load_pct:primary", 0.5)
+
+    ActiveRecord::Health.configure do |config|
+      config.vcpu_count = 16
+      config.cache = cache
+    end
+
+    mock_model = MockModel.new("primary")
+    executed = false
+    result = ActiveRecord::Health.sheddable_pct(pct: 0.5, model: mock_model) { executed = true }
+
+    assert executed
+    assert result
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-health
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nate Berkopec
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+description: A gem that checks database health by monitoring active session count
+  relative to available vCPUs. Intended for automatic load shedding.
+email:
+- nate.berkopec@speedshop.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CONTRIBUTING.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- docker-compose.yml
+- lib/activerecord-health.rb
+- lib/activerecord/health.rb
+- lib/activerecord/health/adapters/mysql_adapter.rb
+- lib/activerecord/health/adapters/postgresql_adapter.rb
+- lib/activerecord/health/configuration.rb
+- lib/activerecord/health/extensions.rb
+- lib/activerecord/health/railtie.rb
+- lib/activerecord/health/version.rb
+- test/integration/mysql_integration_test.rb
+- test/integration/postgresql_integration_test.rb
+- test/test_helper.rb
+- test/unit/adapters/mysql_adapter_test.rb
+- test/unit/adapters/postgresql_adapter_test.rb
+- test/unit/configuration_test.rb
+- test/unit/extensions_test.rb
+- test/unit/health_test.rb
+- test/unit/sheddable_test.rb
+homepage: https://github.com/nateberkopec/activerecord-health
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/nateberkopec/activerecord-health
+  source_code_uri: https://github.com/nateberkopec/activerecord-health
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Database health monitoring for ActiveRecord with automatic load shedding
+test_files: []