aeternitas 0.2.0 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2664ce79ca3661782669c1368fc5fb8c96aff125427ba33041b79c4cd2ce6eb7
-  data.tar.gz: 5027b2dffa4674e800053460d98bef952f26daaea472e616f7fd32a04f994e81
+  metadata.gz: 2c1d90d4cf7395ae79d96e09c0e3ba2ff163d96a31c3283eef8ec516ca2e2645
+  data.tar.gz: 1a245a59727f923ce5e1054e7c043c684f7d14e9b37f4ec65265b30843ff41b1
 SHA512:
-  metadata.gz: c2b538976ad2a42689a43d835830f047ece22b93f47dfdd1ca8edc144a7661656a310e2b36fe07c786aac8260d8d1e23052ee137c4bc1d3a43f3d91b2ef559b6
-  data.tar.gz: 3a0b33ff9da21a20249ab510389d4dd402191dfdb170ec17e11f06747c0e03ef78af7c04da81d7bcf09256c585d52a85ed36c6d00d9d5c6f799418bcdeb62f27
+  metadata.gz: 8764240e6d8e929f4ed351886daf38df7a3d76bb09b41631ee344be52cb8322b600eec8750aeb20b2cb3f3397c819b3b3fdf930dc47641aca9bc57a97597bc80
+  data.tar.gz: fd450bbf6f00ea6341987974741809fcf0a78c6ef7909ac29af9aeae8c87a603e5d36824748bef7f2cce01d9658b14f8d3222aa8d41a3fb5b2f8b70313c9e4bd

data/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

data/.github/workflows/lint.yml

@@ -0,0 +1,25 @@
+name: Lint
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  rspec:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.2
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Code Style Check
+      run: bundle exec standardrb --no-fix

data/.github/workflows/tests.yml

@@ -0,0 +1,28 @@
+name: Tests
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+permissions:
+  contents: read
+
+jobs:
+  rspec:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.2']
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby ${{ matrix.ruby-version }}
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rake

data/.gitignore

@@ -7,8 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
-
-.idea/
-
-## File-based project format:
-*.iws
+/db/test.sqlite3*
+*.gem

data/.ruby-version

@@ -1 +1 @@
-2.5.7
+3.2.8

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [2.0.0] - Unreleased
+
+This is a major rewrite of Æternitas with the primary goals of removing the Redis and Sidekiq dependencies and simplifying the core functionality.
+
+### Changed
+- Updated Core Dependencies: The gem now requires Ruby 3.1+ and ActiveRecord/ActiveJob `>= 7.0`.
+- Complete Backend Overhaul: Æternitas no longer depends on Redis or Sidekiq. It now uses a pure ActiveRecord and ActiveJob backend.
+- Job Uniqueness: Replaced the `sidekiq-unique-jobs` dependency with a built-in, database-backed uniqueness mechanism (`Aeternitas::UniqueJobLock`) to ensure only one `PollJob` per pollable can be enqueued at a time.
+- Job Processing: Replaced Sidekiq-specific workers with a backend-agnostic `Aeternitas::PollJob` that works with any ActiveJob adapter (e.g., SolidQueue, GoodJob).
+- Locking Mechanism: Replaced the Redis-backed Guard with a robust, database-backed distributed lock (`Aeternitas::GuardLock`) using pessimistic locking to prevent race conditions.
+- Metrics System: Replaced the complex, Redis-based `tabstabs` metrics with a simple, database-backed system (`Aeternitas::Metric`). Metrics are now disabled by default.
+- Default Source Storage Path: The default directory for the file storage adapter was changed to `storage/aeternitas/` within a Rails application.
+
+### Added
+- Thundering Herd Prevention: The `PollJob` now intelligently staggers retries when a `GuardIsLocked` error occurs, preventing many jobs from retrying simultaneously and overwhelming a resource.
+- Configurable Metrics: Added `Aeternitas.config.metrics_enabled` and `Aeternitas.config.metric_retention_period` to give users control over metrics collection and data retention.
+- Built-in Maintenance Jobs: Added `Aeternitas::CleanupStaleLocksJob` and `Aeternitas::CleanupOldMetricsJob` to provide a clear, easy way to schedule necessary database cleanup.
+
+### Removed
+- Removed direct gem dependencies on `sidekiq`, `sidekiq-unique-jobs`, `redis`, `connection_pool`, and `tabstabs`.
+- Removed the Sidekiq-specific middleware for handling `GuardIsLocked` errors.
+- Removed the complex, multi-resolution time-series logic from the metrics system.
+
+## [0.2.0 and older] - See legacy repository
+- Initial versions of Æternitas: https://github.com/FHG-IMW/aeternitas
+- Relied on a Sidekiq and Redis backend for job processing, locking, and metrics.

data/Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in aeternitas.gemspec
 gemspec

data/README.md

@@ -1,16 +1,16 @@
-![Aeternitas](https://github.com/FHG-IMW/aeternitas/blob/master/logo.png?raw=true)
+# Æternitas
 
-[![Build Status](https://travis-ci.org/FHG-IMW/aeternitas.svg?branch=master)](https://travis-ci.org/FHG-IMW/aeternitas)
+[![Tests](https://github.com/Dietech-Group/aeternitas/actions/workflows/tests.yml/badge.svg)](https://github.com/Dietech-Group/aeternitas/actions/workflows/tests.yml)
+[![Lint](https://github.com/Dietech-Group/aeternitas/actions/workflows/lint.yml/badge.svg)](https://github.com/Dietech-Group/aeternitas/actions/workflows/lint.yml)
 
-A ruby gem for continuous source retrieval and data integration.
+A Ruby gem for continuous source retrieval and data integration.
 
-Aeternitas provides means to regularly "poll" resources (i.e. a website, twitter feed or API) and to permanently store retrieved results.
-By default it avoids putting too much load on external servers and stores raw results as compressed files on disk.
-Aeternitas can be configured to a wide variety of polling strategies (e.g. frequencies, cooldown periods, ignoring exceptions, deactivating resources, ...).
+Æternitas provides means to regularly "poll" resources (i.e. a website, twitter feed or API) and to permanently store the retrieved results.
+By default, it avoids putting too much load on external servers and stores raw results as compressed files on disk.
+ Aeternitas can be configured to a wide variety of polling strategies (e.g. frequencies, cooldown periods, error handling, deactivation on failure).
 
-Aeternitas is meant to be included in a rails application and expects a working sidekiq/redis setup and any kind of database backend.
-All meta-data is stored in two database tables (aeternitas_pollable_meta_data and aeternitas_sources) while metrics are stored in Redis
-and raw data as compressed files on disk.
+Æternitas is meant to be included in a Rails application and uses a pure ActiveJob and ActiveRecord backend.
+ All metadata, locks, and metrics are stored in your application's database, while raw source data is stored as compressed files on disk by default.
 
 ## Installation
 
@@ -22,22 +22,32 @@ gem 'aeternitas'
 
 And then execute:
 
-    $ bundle install
-    $ rails generate aeternitas:install
-    $ rake db:migrate
+```bash
+$ bundle install
+$ rails generate aeternitas:install
+$ rails db:migrate
+```
 
-to install gem and generate tables and initializers needed for aeternitas.
+This will install the gem, generate the necessary database tables, and create a configuration initializer.
 
-## Quickstart
+### Maintenance
+
+Æternitas creates lock and metric records in your database. To prevent this data from growing indefinitely, you should schedule periodic cleanup jobs. The two key maintenance jobs are:
 
-Aeternitas expects you wanting to store single pollables as ActiveRecord Objects. For instance you might want to
-monitor several Websites for the usage of the word æternitas and store the websites old states for later analysis.
-Using Aeternitas you would create your website model and tables
+- **`Aeternitas::CleanupStaleLocksJob`**: Removes old, expired lock records from crashed workers.
+- **`Aeternitas::CleanupOldMetricsJob`**: Prunes metric data older than the configured `metric_retention_period`.
+
+You should schedule these jobs to run periodically (e.g. weekly).
+
+## Quickstart
 
-    $ rails generate model Website url:string aeternitas_word_count:integer
+Let's say you want to monitor several websites for the usage of a keyword, e.g. 'aeternitas'. First, create your model:
 
-And then include Aeternitas
+```bash
+$ rails generate model Website url:string keyword_count:integer
+```
 
+Then, include `Aeternitas::Pollable` in your model and define your polling logic.
 
 ```ruby
 class Website < ApplicationRecord
@@ -46,61 +56,49 @@ class Website < ApplicationRecord
   polling_options do
     polling_frequency :weekly
   end
-end
-```
 
-For now we are satisfied with aeternitas default setting [TODO:link] except for the polling_frequency. We only want to 
-check once a week.
-Next up we have to implement the websites `poll` method.
-
-```ruby
   def poll
     page_content = Net::HTTP.get(URI.parse(self.url))
-    add_source(page_content) #store the retrieved page permanently
-    aeternitas_word_count = page_content.scan('aeternitas').size
-    update(aeternitas_word_count: aeternitas_word_count)
+    add_source(page_content) # Store the retrieved page content permanently
+    count = page_content.scan('aeternitas').size
+    update(keyword_count: count)
   end
+end
 ```
 
-The poll method is called every time a pollable is good to go. In our example this would be once a week. The time at which
-aeternitas will execute the poll method is determined by the pollable metadata stored in a separate table and may be
-checked using the `next_polling` method on a website (note: there are several advanced error states which may or may not
-allow a pollable to be polled).
+The `poll` method is called each time Æternitas processes the job for this resource. In our example, this would be once a week.
 
-Assuming you have already setup sidekiq the only thing left is to regularly run `Aeternitas.enqueue_due_pollables`
-and have a worker consuming the "polling" queue.
+ To start the polling process, you need to regularly run `Aeternitas.enqueue_due_pollables` and have an ActiveJob backend (like SolidQueue, GoodJob, etc.) running to process the jobs.
 
-In most cases it makes sense to store polling results as sources to allow further work to be done in separate jobs.
-In above example we already added the `page_content`as a source to the website. Aeternitas thereby only stores a new source
-if the sources fingerprint does not yet exist (i.e. MD5 Hash of the page_content). If we wanted to process the word count in 
-a separate job the following implementation would allow to do so.
+In most cases it makes sense to store polling results as sources to allow further work to be done in separate jobs. In above example we already added the `page_content` as a source to the website with `add_source`.
+Aeternitas only stores a new source if the source's fingerprint (MD5 Hash of the content) does not exist yet. If we wanted to process the word count in a separate job the following implementation would allow to do so:
 
 ```ruby
+# app/models/website.rb
 class Website < ApplicationRecord
   include Aeternitas::Pollable
 
   polling_options do
     polling_frequency :weekly
   end
-  
+
   def poll
     page_content = Net::HTTP.get(URI.parse(self.url))
-    new_source = add_source(page_content) #returns nil if source already exists
-    CountWordJob.perform_async(new_source.id) if new_source
-    
-    
+    new_source = add_source(page_content) # returns nil if source already exists
+    CountKeywordJob.perform_later(new_source.id) if new_source
   end
 end
 
-class CountWordJob
-  include Sidekiq::Worker
-  
+# app/jobs/count_keyword_job.rb
+class CountKeywordJob < ApplicationJob
+  queue_as :default
+
   def perform(source_id)
     source = Aeternitas::Source.find(source_id)
     page_content = source.raw_content
-    aeternitas_word_count = page_content.scan('aeternitas').size
+    keyword_count = page_content.scan('aeternitas').size
     website = source.pollable
-    website.update(aeternitas_word_count: aeternitas_word_count)
+    website.update(keyword_count: keyword_count)
   end
 end
 ```
@@ -109,57 +107,45 @@ end
 
 ### Global Configuration
 
-In this configuration you can specify the global settings for Æternitas. The configuration should be stored in
-`config/initializers/aeternitas.rb`
-
-#### redis
+Global settings can be configured in `config/initializers/aeternitas.rb`.
 
-This option specifies the redis connection details. Æternitas uses redis to for resource locking and to store statistics.
+#### Metrics
+You can enable or disable metrics collection. By default, metrics are disabled.
 
 ```ruby
-Aeternitas.configure do |config| 
-  config.redis = {host: localhost, port: 6379}
-end
-```    
-
-For configuration options you can have a look here: [redis-rb](https://github.com/redis/redis-rb)
-
-#### storage_adapter
-_Default: Aeternitas::StorageAdapter::File_
+Aeternitas.configure do |config|
+  # Set to true to enable logging metrics to the database.
+  config.metrics_enabled = true
 
-Æternitas by default stores source file in compressed files on disk. If you however want to store them in another way you 
-can do so easily by implementing the `Aeternitas::StorageAdapter` interface. For an example you can have a look at 
-`Aeternitas::StorageAdapter::File`.
-To specify which storage adapter Æternitas should use, just pass the class name to this option:
-
-```ruby
-Aeternitas.configure do |config| 
-  config.storage_adapter = Aeternitas::StorageAdapter::File
+  # Configure how long to keep metric data.
+  config.metric_retention_period = 180.days
 end
 ```
 
-#### storage_adapter_options
-
-Some storage adapter need some extra configuration. The file adapter for example needs to now where to store the files:
+#### Storage Adapter
+By default, Æternitas stores source files as compressed files on disk. You can change this behavior by implementing a custom storage adapter. For an example you can have a look at `Aeternitas::StorageAdapter::File`.
 
 ```ruby
-Aeternitas.configure do |config| 
-  config.storage_adapter_options = {
+Aeternitas.configure do |config|
+  # To change the storage directory for the default File adapter:
+  config.storage_adapter_config = {
     directory: File.join(Rails.root, 'public', 'sources')
   }
+
+  # To use a custom adapter:
+  config.storage_adapter = Aeternitas::StorageAdapter::MyCustomAdapter
 end
 ```
 
 ### Pollable Configuration
 
-Pollables can be configured on a per class base using the `polling_options` block.
-
+Pollables can be configured on a per-model basis using the `polling_options` block.
 
 #### polling_frequency
 _Default: :daily_
 
 This option controls how often a pollable is polled and can be configured in two different ways.
-Either use one of the presets specified in `Aeternitas::PollingFrequency` by specifiey the presets name as a symbol
+Either use one of the presets specified in `Aeternitas::PollingFrequency` by specifying the presets name as a symbol:
 
 ```ruby
 polling_options do
@@ -167,111 +153,67 @@ polling_options do
 end
 ```
 
-If want to specify a more complex polling schema you can also us a custom method which returns the time and date of the
-next polling. For example if you want to increase the frequency depending on the pollables age you could use the
-following method:
+Or, if you want to specify a more complex polling schema you can do so by using a custom lambda for dynamic frequency:
 
 ```ruby
 polling_options do
   # set frequency depending elements age (+ 1 month for every 3 months)
-  polling_frequency ->(context) { 1.month + (Time.now - context.created_at).to_i / 3.month * 1.month }
-end
-```
-
-#### before_polling
-_Default: []_
-
-Specifies methods that are run before the polling is executed. You can either specify a method name or a lamba
-```ruby
-polling_options do
-  # run the pollables `foo` and `bar` methods
-  before_polling :foo, :bar 
-  # run a custom block
-  before_polling ->(pollable) { puts "About to poll #{pollable.id}"}
+  polling_frequency ->(context) { 1.month.from_now + (Time.now - context.created_at).to_i / 3.months * 1.month }
 end
 ```
 
-#### after_polling
-
-Specify methods run after polling was successful. See __before_polling__
-
-#### deactivation_errors
+#### before_polling / after_polling
 _Default: []_
 
-Specify error clases which, once they occur, will instantly deactivate the pollable. This can be useful for example if 
-the error implied that the resource does not exist any more.
+Specify methods to run before each poll or after each successful poll. You can either specify a method name or a lambda:
 
 ```ruby
 polling_options do
-  # deactivate the pollable if the tweet was not found
-  deactivation_errors Twitter::Error::NotFound
+  before_polling :log_start
+  after_polling ->(pollable) { puts "Finished polling #{pollable.id}" }
 end
 ```
 
-#### ignore_error
+#### deactivate_on / ignore_error
 _Default: []_
 
-Errors specified as ignored errors are wrapped within `Aeternitas::Errors::Ignored`. which is then raised instead.
-This is supposed to be used in combination with error tracking systems like Airbrake. Instead globally telling Airbrake which errors to 
-ignore, you can do this on a per pollable basis
+Define custom error handling rules.
+
+ `deactivate_on` will stop polling a resource permanently if a specified error occurs. This can be useful if the error implied that the resource does not exist anymore.
+ 
+ `ignore_error` will wrap the error within `Aeternitas::Errors::Ignored` which is then raised instead. This can be useful for filtering in exception tracking services like Airbrake.
 
 ```ruby
 polling_options do
-  # don't log an error if the twitter api is down
+  deactivate_on Twitter::Error::NotFound
   ignore_error Twitter::Error::ServiceUnavailable
 end
 ```
 
-#### sleep_on_guard_lock
-_Default: true
+#### sleep_on_guard_locked
+_Default: false_
+
+Controls behavior when a guard lock cannot be acquired.
+- **`false`:** The job will be retried with a smart, staggered backoff delay to prevent a "thundering herd." This is the recommended and most scalable option.
+- **`true`:** The job will cause the ActiveJob worker thread to `sleep` until the lock is expected to be free, blocking that thread from processing other jobs. This is an aggressive strategy and should *only* be used in specific cases where you intend to pause a dedicated worker.
 
-With this option set to true, if a pollable can't acquire the lock, it will sleep until the guard_timeout expires, 
-effectively blocking the Sidekiq queue from processing any other jobs. 
-This should *only* be used, if you know that all the jobs within this queue will try to access the same resource and you want to pause the entire queue.  
- 
 #### queue
 _Default: 'polling'_
 
-This option specifies the Sidekiq queue into which the poll job will be enqueued.
+This option specifies the ActiveJob queue for the poll job.
 
 #### guard_key
-_Default: "#{obj.class.name}"_
+_Default: obj.class.name.to_s_
 
-This option specifies the guard key. This can be done by either specifying a method name or a custom block. 
-Default is to lock on pollable class level. Therefor only one job at a time per pollable class will be executed to
-avoid DDOSing by accident.
+Defines the key used for resource locking. By default, all instances of a model share the same lock. The default is to lock on pollable class level, but you can also provide a block for more granular locking (e.g. per-instance or per-API-host):
 
 ```ruby
 polling_options do
-  # use the urls host as lock key
-  guard ->(website) { URI.parse(website.url).host }
+  # Lock based on the instance's URL host
+  guard_key ->(website) { URI.parse(website.url).host }
 end
 ```
 
-## Web UI
-
-Æternitas also has a monitoring interface which can be integrated with a rail application.
-
-To use it add this line to your application's Gemfile:
-
-```ruby
-gem 'aeternitas_web_ui'
-```
-
-Then run 
-
-    $ bundle install
-    
-And mount the engine
-   
-```ruby
-# config/routes.rb
-   
-mount Aeternitas::WebUi::Engine => '/aeternitas'
-```
-
-For more information head over to the project page: [https://github.com/FHG-IMW/aeternitas_web_ui](https://github.com/FHG-IMW/aeternitas_web_ui)
-
 ## Development
 
 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.
@@ -280,10 +222,13 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and spec backed pull requests are welcome on GitHub at https://github.com/FHG-IMW/aeternitas. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and spec backed pull requests are welcome on GitHub at https://github.com/Dietech-Group/aeternitas. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
+## History
+
+This gem was originally developed under [FHG-IMW/aeternitas](https://github.com/FHG-IMW/aeternitas) and named "æternitas - A ruby gem for continuous source retrieval and data integration". It's core was based upon Sidekiq and Redis which both were removed as dependencies for this gem.

data/Rakefile

@@ -3,4 +3,4 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/aeternitas.gemspec

@@ -1,44 +1,33 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'aeternitas/version'
+require "aeternitas/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'aeternitas'
-  spec.version       = Aeternitas::VERSION
-  spec.authors       = ['Michael Prilop', 'Max Kießling', 'Robert Terbach']
-  spec.email         = ['max@kopfueber.org', 'michael.prilop@imw.fraunhofer.de']
+  spec.name = "aeternitas"
+  spec.version = Aeternitas::VERSION
+  spec.authors = ["Michael Prilop", "Max Kießling", "Louis Franzke"]
+  spec.email = ["prilop@infai.org"]
 
-  spec.summary       = "æternitas - A ruby gem for continuous source retrieval and data integration"
-  spec.description   = <<-EOF
-    Æternitas provides means to regularly 'poll' resources (i.e. a website, twitter feed or API) and to permanently
-    store retrieved results. By default æternitas avoids putting too much load on external servers and stores raw
-    results as compressed files on disk. It can be configured to a wide variety of polling strategies (e.g. frequencies,
-    cooldown periods, ignoring exceptions, deactivating resources, ...)."
-  EOF
-  spec.homepage      = "https://github.com/FHG-IMW/aeternitas"
-  spec.license       = "MIT"
+  spec.summary = "æternitas - version 2"
+  spec.description = "æternitas is a tool support polling resources (webpages, APIs)."
+  spec.homepage = "https://github.com/Dietech-Group/aeternitas"
+  spec.license = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
 
-  spec.add_dependency 'activerecord', '>= 5'
-  spec.add_dependency 'redis'
-  spec.add_dependency 'connection_pool'
-  spec.add_dependency 'aasm'
-  spec.add_dependency 'sidekiq', '> 4', '< 6'
-  spec.add_dependency 'sidekiq-unique-jobs', '~> 5.0'
-  spec.add_dependency 'tabstabs'
+  spec.add_dependency "activerecord", ">= 7.0"
+  spec.add_dependency "activejob", ">= 7.0"
+  spec.add_dependency "aasm"
 
-  spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'sqlite3'
-  spec.add_development_dependency 'database_cleaner', '~> 1.5'
-  spec.add_development_dependency 'rspec-sidekiq'
-  spec.add_development_dependency 'mock_redis'
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec-rails", "~> 7.0"
+  spec.add_development_dependency "sqlite3", "~> 2.1"
+  spec.add_development_dependency "database_cleaner", "~> 2.0"
+  spec.add_development_dependency "standard"
 end

data/lib/aeternitas/aeternitas_job.rb

@@ -0,0 +1,7 @@
+require "active_job"
+
+module Aeternitas
+  # Base class for Aeternitas ActiveJobs
+  class AeternitasJob < ActiveJob::Base
+  end
+end

data/lib/aeternitas/cleanup_old_metrics_job.rb

@@ -0,0 +1,12 @@
+require_relative "aeternitas_job"
+
+module Aeternitas
+  # An ActiveJob for cleaning up old metric records.
+  class CleanupOldMetricsJob < AeternitasJob
+    queue_as :maintenance
+
+    def perform
+      Aeternitas::Maintenance.cleanup_old_metrics
+    end
+  end
+end

data/lib/aeternitas/cleanup_stale_locks_job.rb

@@ -0,0 +1,12 @@
+require_relative "aeternitas_job"
+
+module Aeternitas
+  # An ActiveJob for cleaning up stale lock records.
+  class CleanupStaleLocksJob < AeternitasJob
+    queue_as :maintenance
+
+    def perform
+      Aeternitas::Maintenance.cleanup_stale_locks
+    end
+  end
+end

data/lib/aeternitas/errors.rb

@@ -14,7 +14,6 @@ module Aeternitas
         @original_error = original_error
         super("#{original_error.class} - #{original_error.message}")
       end
-
     end
 
     # Raised when a source data already exists.
@@ -45,4 +44,4 @@ module Aeternitas
       end
     end
   end
-end
+end