iron_trail 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d4743b8660d0a3f59c82131213a4e9b85396c0efa83f2a00c2678dcb2a2d57a7
+  data.tar.gz: 6d53fef0dbb300ce504c8065616142ba012cb697647a5f588d4f2bea3935e293
+SHA512:
+  metadata.gz: 7bc826ad0ff24c91b6e7d9bac08fb7c5a0f893142a91315804aafe68a95bc96e3be5b9b98ed83de9f4d293daab9b1bbce3432579116db79fa3c47ca8b184b0a7
+  data.tar.gz: b43255cfbe9833075c44335eaaeb5e2067e942d99f4ff3b8e35aee42c9960cdfe6e1e96cfe5c75fd2b4ae53c8dbef580dae2768cf308f92b2bb2d5a5e06ec667

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright © 2024 Trusted Health
+
+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/lib/generators/iron_trail/migration_generator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module IronTrail
+  class MigrationGenerator < Rails::Generators::Base
+    include ::Rails::Generators::Migration
+
+    source_root File.expand_path('templates', __dir__)
+
+    desc 'Generates a migration adding the iron trail changes table'
+    def create_changes_migration_file
+      migration_template(
+        'create_irontrail_changes.rb.erb',
+        'db/migrate/create_irontrail_changes.rb'
+      )
+
+      migration_template(
+        'create_irontrail_support_tables.rb.erb',
+        'db/migrate/create_irontrail_support_tables.rb'
+      )
+
+      migration_template(
+        'create_irontrail_trigger_function.rb.erb',
+        'db/migrate/create_irontrail_trigger_function.rb'
+      )
+    end
+
+    def self.next_migration_number(dirname)
+      ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+  end
+end

data/lib/generators/iron_trail/templates/create_irontrail_changes.rb.erb

@@ -0,0 +1,25 @@
+class CreateIrontrailChanges < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_range_partition :irontrail_changes, partition_key: :created_at, primary_key: [:id, :created_at] do |t|
+      t.column :id, :bigserial, null: false
+      t.column :actor_type, :text
+      t.column :actor_id, :text
+      t.column :rec_table, :text
+      t.column :rec_id, :text
+      t.column :operation, :text
+
+      t.column :rec_old, :jsonb
+      t.column :rec_new, :jsonb
+      t.column :rec_delta, :jsonb
+      t.column :metadata, :jsonb
+
+      t.column :created_at, :timestamp, null: false
+    end
+
+    add_index :irontrail_changes, :rec_id
+    add_index :irontrail_changes, :rec_table
+    add_index :irontrail_changes, :actor_id
+    add_index :irontrail_changes, :actor_type
+    add_index :irontrail_changes, :created_at, using: :brin
+  end
+end

data/lib/generators/iron_trail/templates/create_irontrail_support_tables.rb.erb

@@ -0,0 +1,18 @@
+class CreateIrontrailSupportTables < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :irontrail_trigger_errors, id: :bigserial do |t|
+      t.column :pg_errcode, :text
+      t.column :pg_message, :text
+      t.column :err_text, :text
+      t.column :ex_detail, :text
+      t.column :ex_hint, :text
+      t.column :ex_ctx, :text
+      t.column :op, :text
+      t.column :table_name, :text
+      t.column :old_data, :jsonb
+      t.column :new_data, :jsonb
+      t.column :query, :text
+      t.column :created_at, :timestamp
+    end
+  end
+end

data/lib/generators/iron_trail/templates/create_irontrail_trigger_function.rb.erb

@@ -0,0 +1,12 @@
+class CreateIrontrailTriggerFunction < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def up
+    IronTrail::DbFunctions.new(connection).tap do |db_fun|
+      db_fun.install_functions
+      db_fun.enable_for_all_missing_tables
+    end
+  end
+
+  def down
+    IronTrail::DbFunctions.new(connection).remove_functions(cascade: true)
+  end
+end

data/lib/iron_trail/association.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module IronTrail
+  class Association < ::ActiveRecord::Associations::HasManyAssociation
+    def association_scope
+      scope = klass.unscoped
+
+      foreign_key = reflection.join_foreign_key
+      pk_value = owner._read_attribute(foreign_key)
+      pk_table = owner.class.arel_table
+
+      scope.where!('rec_id' => pk_value, 'rec_table' => pk_table.name)
+
+      scope
+    end
+
+    def find_target
+      scope.to_a
+    end
+  end
+end

data/lib/iron_trail/change_model_concern.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module IronTrail
+  module ChangeModelConcern
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+      def where_object_changes_to(args = {})
+        _where_object_changes(1, args)
+      end
+
+      def where_object_changes_from(args = {})
+        _where_object_changes(0, args)
+      end
+
+      private
+
+      def _where_object_changes(ary_index, args)
+        scope = all
+
+        args.each do |col_name, value|
+          scope.where!(
+            ::Arel::Nodes::SqlLiteral.new("rec_delta->#{connection.quote(col_name)}->>#{Integer(ary_index)}").eq(
+              ::Arel::Nodes::BindParam.new(value)
+            )
+          )
+        end
+
+        scope
+      end
+    end
+  end
+end

data/lib/iron_trail/config.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module IronTrail
+  class Config
+    DEFAULT_IGNORED_TABLES = %w[
+      schema_migrations
+      ar_internal_metadata
+      sessions
+    ].freeze
+
+    include Singleton
+
+    attr_accessor \
+      :track_by_default,
+      :enable,
+      :track_migrations_starting_at_version
+
+    attr_reader :ignored_tables
+
+    def initialize
+      @enable = true
+      @track_by_default = true
+      @ignored_tables = DEFAULT_IGNORED_TABLES.dup
+      @track_migrations_starting_at_version = nil
+    end
+
+    # To prevent ever tracking unintended tables, let's disallow setting this value
+    # directly.
+    # It is possible to call Array#clear to empty the array and remove default
+    # should that be desired.
+    def ignored_tables=(_v)
+      raise 'Overwriting ignored_tables is not allow. Instead, add or remove to it explicitly.'
+    end
+  end
+end

data/lib/iron_trail/db_functions.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module IronTrail
+  class DbFunctions
+    attr_reader :connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # Creates the SQL functions in the DB. It will not run the function or create
+    # any triggers.
+    def install_functions
+      sql = irontrail_log_row_function
+      connection.execute(sql)
+    end
+
+    def irontrail_log_row_function
+      path = File.expand_path('irontrail_log_row_function.sql', __dir__)
+      File.read(path)
+    end
+
+    # Queries the database information schema and returns an array with all
+    # table names that have the "iron_trail_log_changes" trigger enabled.
+    #
+    # This effectively returns all tables which are currently being tracked
+    # by IronTrail.
+    def collect_tracked_table_names
+      stmt = <<~SQL
+        SELECT DISTINCT("event_object_table") AS "table"
+        FROM "information_schema"."triggers"
+        WHERE "trigger_name"='iron_trail_log_changes' AND "event_object_schema"='public'
+        ORDER BY "table" ASC;
+      SQL
+
+      connection.execute(stmt).map { |row| row['table'] }
+    end
+
+    def function_present?(function: 'irontrail_log_row', schema: 'public')
+      stmt = <<~SQL
+        SELECT 1 FROM "pg_proc" p
+        INNER JOIN "pg_namespace" ns
+        ON (ns.oid = p.pronamespace)
+        WHERE p."proname"=#{connection.quote(function)}
+          AND ns."nspname"=#{connection.quote(schema)}
+        LIMIT 1;
+      SQL
+
+      connection.execute(stmt).to_a.count.positive?
+    end
+
+    def remove_functions(cascade:)
+      query = +'DROP FUNCTION irontrail_log_row'
+      query << ' CASCADE' if cascade
+
+      connection.execute(query)
+    end
+
+    def trigger_errors_count
+      stmt = 'SELECT COUNT(*) AS c FROM "irontrail_trigger_errors"'
+      connection.execute(stmt).first['c']
+    end
+
+    def collect_all_tables(schema: 'public')
+      # query pg_class rather than information schema because this way
+      # we can get only regular tables and ignore partitions.
+      stmt = <<~SQL
+        SELECT c.relname AS "table"
+        FROM "pg_class" c INNER JOIN "pg_namespace" ns
+        ON (ns.oid = c.relnamespace)
+        WHERE ns.nspname=#{connection.quote(schema)}
+          AND c.relkind IN ('r', 'p')
+          AND NOT c.relispartition
+        ORDER BY "table" ASC;
+      SQL
+
+      connection.execute(stmt).map { |row| row['table'] }
+    end
+
+    def enable_for_all_missing_tables
+      collect_tables_tracking_status[:missing].each do |table_name|
+        enable_tracking_for_table(table_name)
+      end
+    end
+
+    def collect_tables_tracking_status
+      ignored_tables = OWN_TABLES + (IronTrail.config.ignored_tables || [])
+
+      all_tables = collect_all_tables - ignored_tables
+      tracked_tables = collect_tracked_table_names - ignored_tables
+
+      {
+        tracked: tracked_tables,
+        missing: all_tables - tracked_tables
+      }
+    end
+
+    def disable_tracking_for_table(table_name)
+      # NOTE: will disable even if table is ignored as this allows
+      # one to fix ignored tables mnore easily. Since the table is already
+      # ignored, it is an expected destructive operation.
+
+      stmt = <<~SQL
+        DROP TRIGGER "iron_trail_log_changes" ON
+        #{connection.quote_table_name(table_name)}
+      SQL
+
+      connection.execute(stmt)
+    end
+
+    def enable_tracking_for_table(table_name)
+      return false if IronTrail.ignore_table?(table_name)
+
+      stmt = <<~SQL
+        CREATE TRIGGER "iron_trail_log_changes" AFTER INSERT OR UPDATE OR DELETE ON
+        #{connection.quote_table_name(table_name)}
+        FOR EACH ROW EXECUTE FUNCTION irontrail_log_row();
+      SQL
+
+      connection.execute(stmt)
+    end
+  end
+end

data/lib/iron_trail/irontrail_log_row_function.sql

@@ -0,0 +1,80 @@
+CREATE OR REPLACE FUNCTION irontrail_log_row()
+RETURNS TRIGGER AS $$
+DECLARE
+  u_changes JSONB;
+  key TEXT;
+  it_meta TEXT;
+  it_meta_obj JSONB;
+  value_a JSONB;
+  value_b JSONB;
+  old_obj JSONB;
+  new_obj JSONB;
+  actor_type TEXT;
+  actor_id TEXT;
+
+  err_text TEXT; err_detail TEXT; err_hint TEXT; err_ctx TEXT;
+BEGIN
+    SELECT split_part(split_part(current_query(), '/*IronTrail ', 2), ' IronTrail*/', 1) INTO it_meta;
+    IF (it_meta <> '') THEN
+      it_meta_obj = it_meta::JSONB;
+
+      IF (it_meta_obj ? '_actor_type') THEN
+        actor_type = it_meta_obj->>'_actor_type';
+        it_meta_obj = it_meta_obj - '_actor_type';
+      END IF;
+      IF (it_meta_obj ? '_actor_id') THEN
+        actor_id = it_meta_obj->>'_actor_id';
+        it_meta_obj = it_meta_obj - '_actor_id';
+      END IF;
+    END IF;
+
+    IF (TG_OP = 'INSERT') THEN
+        INSERT INTO "irontrail_changes" ("actor_id", "actor_type",
+          "rec_table", "operation", "rec_id", "rec_new", "metadata", "created_at")
+        VALUES (actor_id, actor_type,
+          TG_TABLE_NAME, 'i', NEW.id, row_to_json(NEW), it_meta_obj, NOW());
+
+    ELSIF (TG_OP = 'UPDATE') THEN
+        IF (OLD <> NEW) THEN
+          u_changes = jsonb_build_object();
+          old_obj = row_to_json(OLD);
+          new_obj = row_to_json(NEW);
+
+          FOR key IN (SELECT jsonb_object_keys(old_obj) UNION SELECT jsonb_object_keys(new_obj))
+          LOOP
+              value_a := old_obj->key;
+              value_b := new_obj->key;
+              IF value_a IS DISTINCT FROM value_b THEN
+                  u_changes := u_changes || jsonb_build_object(key, jsonb_build_array(value_a, value_b));
+              END IF;
+          END LOOP;
+
+          INSERT INTO "irontrail_changes" ("actor_id", "actor_type", "rec_table", "operation",
+            "rec_id", "rec_old", "rec_new", "rec_delta", "metadata", "created_at")
+          VALUES (actor_id, actor_type, TG_TABLE_NAME, 'u', NEW.id, row_to_json(OLD), row_to_json(NEW),
+          u_changes, it_meta_obj, NOW());
+
+        END IF;
+    ELSIF (TG_OP = 'DELETE') THEN
+        INSERT INTO "irontrail_changes" ("actor_id", "actor_type", "rec_table", "operation",
+          "rec_id", "rec_old", "metadata", "created_at")
+        VALUES (actor_id, actor_type, TG_TABLE_NAME, 'd', OLD.id, row_to_json(OLD), it_meta_obj, NOW());
+
+    END IF;
+    RETURN NULL;
+EXCEPTION
+  WHEN OTHERS THEN
+    GET STACKED DIAGNOSTICS
+      err_text = MESSAGE_TEXT,
+      err_detail = PG_EXCEPTION_DETAIL,
+      err_hint = PG_EXCEPTION_HINT,
+      err_ctx = PG_EXCEPTION_CONTEXT;
+
+    INSERT INTO "irontrail_trigger_errors" ("pg_errcode", "pg_message",
+        "err_text", "ex_detail", "ex_hint", "ex_ctx", "op", "table_name",
+        "old_data", "new_data", "query", "created_at")
+      VALUES (SQLSTATE, SQLERRM, err_text, err_detail, err_hint, err_ctx,
+        TG_OP, TG_TABLE_NAME, row_to_json(OLD), row_to_json(NEW), current_query(), NOW());
+    RETURN NULL;
+END;
+$$ LANGUAGE plpgsql;

data/lib/iron_trail/metadata_store.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module IronTrail
+  class MetadataStore
+    def store_metadata(key, value)
+      RequestStore.store[:irontrail_metadata] ||= {}
+      RequestStore.store[:irontrail_metadata][key] = value
+    end
+
+    def merge_metadata(keys, merge_hash)
+      RequestStore.store[:irontrail_metadata] ||= {}
+      base = RequestStore.store[:irontrail_metadata]
+      keys.each do |key|
+        if base.key?(key)
+          base = base[key]
+        else
+          h = {}
+          base[key] = h
+          base = h
+        end
+      end
+      base.merge!(merge_hash)
+    end
+
+    def current_metadata
+      RequestStore.store[:irontrail_metadata]
+    end
+  end
+end

data/lib/iron_trail/migration.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module IronTrail
+  module Migration
+    def method_missing(method, *args) # rubocop:disable Style/MissingRespondToMissing
+      running_from_schema = is_a?(ActiveRecord::Schema) ||
+        (defined?(ActiveRecord::Schema::Definition) && is_a?(ActiveRecord::Schema::Definition))
+
+      result = super
+
+      return result unless IronTrail.enabled? && method == :create_table
+
+      start_at_version = IronTrail.config.track_migrations_starting_at_version
+      return result if !running_from_schema && start_at_version && version < (Integer(start_at_version))
+
+      table_name = args.first.to_s
+      return result if IronTrail.ignore_table?(table_name)
+
+      if running_from_schema
+        @irontrail_missing_track ||= []
+        @irontrail_missing_track << table_name
+
+        return result
+      end
+
+      db_fun = IronTrail::DbFunctions.new(connection)
+      if db_fun.function_present?
+        db_fun.enable_tracking_for_table(table_name)
+      else
+        Rails.logger.warn(
+          "IronTrail will not create trigger for table #{table_name} " \
+          'because the trigger function does not exist in the database.'
+        )
+      end
+
+      result
+    end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+  end
+end

data/lib/iron_trail/model.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module IronTrail
+  # Including this module will create something akin to:
+  #   has_many :iron_trails
+  #
+  # But a has_many association here wouldn't suffice, so IronTrail has its
+  # own AR reflection and association classes.
+  module Model
+    def self.included(mod)
+      mod.include(ClassMethods)
+
+      ::ActiveRecord::Reflection.add_reflection(
+        mod,
+        :iron_trails,
+        ::IronTrail::Reflection.new(:iron_trails, nil, { class_name: 'IrontrailChange' }, mod)
+      )
+    end
+
+    module ClassMethods
+      def iron_trails
+        association(:iron_trails).reader
+      end
+    end
+  end
+end

data/lib/iron_trail/query_transformer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module IronTrail
+  class QueryTransformer
+    METADATA_MAX_LENGTH = 1_048_576 # 1 MiB
+
+    attr_reader :transformer_proc
+
+    def initialize
+      @transformer_proc = create_query_transformer_proc
+    end
+
+    def setup_active_record
+      ActiveRecord.query_transformers << @transformer_proc
+    end
+
+    private
+
+    def create_query_transformer_proc
+      proc do |query, adapter|
+        current_metadata = IronTrail.current_metadata
+        next query unless adapter.write_query?(query) && (current_metadata.is_a?(Hash) && !current_metadata.empty?)
+
+        metadata = JSON.dump(current_metadata)
+
+        if metadata.length > METADATA_MAX_LENGTH
+          Rails.logger.warn(
+            "IronTrail metadata is longer than maximum length! #{metadata.length} > #{METADATA_MAX_LENGTH}"
+          )
+
+          next query
+        end
+
+        safe_md = metadata.gsub('*/', '\\u002a\\u002f')
+        "/*IronTrail #{safe_md} IronTrail*/ #{query}"
+      end
+    end
+  end
+end

data/lib/iron_trail/railtie.rb

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

data/lib/iron_trail/reflection.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module IronTrail
+  class Reflection < ::ActiveRecord::Reflection::AssociationReflection
+    def collection? = true
+
+    def association_class
+      ::IronTrail::Association
+    end
+
+    def join_scope(table, foreign_table, _foreign_klass)
+      scope = klass_join_scope(table, nil)
+
+      foreign_key_column_names = Array(join_foreign_key)
+      if foreign_key_column_names.length > 1
+        raise "IronTrail does not support composite foreign keys (got #{foreign_key_column_names})"
+      end
+
+      foreign_key_column_name = foreign_key_column_names.first
+
+      # record_id is always of type text, but the foreign table primary key
+      # could be anything (int, uuid, ...), so let's cast it to text.
+      foreign_value = ::Arel::Nodes::NamedFunction.new(
+        'CAST',
+        [
+          ::Arel::Nodes::As.new(
+            foreign_table[foreign_key_column_name],
+            ::Arel::Nodes::SqlLiteral.new('text')
+          )
+        ]
+      )
+
+      scope.where!(
+        table['rec_id']
+          .eq(foreign_value)
+          .and(
+            table['rec_table']
+            .eq(foreign_table.name)
+          )
+      )
+
+      scope
+    end
+  end
+end

data/lib/iron_trail/sidekiq.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# These are not loaded by default. The user must explicitly require this
+# file in order to integrate IronTrail with Sidekiq.
+
+require 'iron_trail/sidekiq_middleware'

data/lib/iron_trail/sidekiq_middleware.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module IronTrail
+  class SidekiqMiddleware
+    def call(job, _job_hash, queue)
+      md = {
+        jid: job.jid,
+        class: job.class.to_s,
+        queue:
+      }
+
+      # Job batch ID. Requires sidekiq-pro
+      md[:bid] = job.bid if job.respond_to?(:bid) && job.bid.present?
+
+      IronTrail.store_metadata(:job, md)
+
+      yield
+    end
+  end
+end

data/lib/iron_trail/testing/rspec.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'iron_trail'

data/lib/iron_trail/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module IronTrail
+  VERSION = '0.0.1'
+end

data/lib/iron_trail.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'json'
+require 'forwardable'
+require 'request_store'
+
+require 'iron_trail/version'
+require 'iron_trail/config'
+require 'iron_trail/db_functions'
+require 'iron_trail/migration'
+
+require 'iron_trail/metadata_store'
+require 'iron_trail/query_transformer'
+
+require 'iron_trail/association'
+require 'iron_trail/reflection'
+require 'iron_trail/model'
+require 'iron_trail/change_model_concern'
+
+require 'iron_trail/railtie'
+
+module IronTrail
+  # These tables are owned by IronTrail and will be in the default ignore list
+  OWN_TABLES = %w[
+    irontrail_trigger_errors
+    irontrail_changes
+  ].freeze
+
+  module SchemaDumper
+    def trailer(stream)
+      stream.print("\n  IronTrail.post_schema_load(self, missing_tracking: @irontrail_missing_track)\n")
+
+      super
+    end
+  end
+
+  class << self
+    extend Forwardable
+
+    attr_reader :query_transformer
+
+    def config
+      @config ||= IronTrail::Config.instance
+      yield @config if block_given?
+      @config
+    end
+
+    def enabled?
+      config.enable
+    end
+
+    # def test_mode!
+    #   if [ENV['RAILS_ENV'], ENV['RACK_ENV']].include?('production')
+    #     raise "IronTrail test mode cannot be enabled in production!"
+    #   end
+    #   @test_mode = true
+    # end
+    #
+    # def test_mode?
+    #   @test_mode
+    # end
+
+    def ignore_table?(name)
+      (OWN_TABLES + (config.ignored_tables || [])).include?(name)
+    end
+
+    def post_schema_load(context, missing_tracking: nil)
+      df = IronTrail::DbFunctions.new(context.connection)
+      df.install_functions
+
+      missing_tracking.each do |table|
+        df.enable_tracking_for_table(table)
+      end
+    end
+
+    def setup_active_record
+      ActiveRecord::Migration.prepend(IronTrail::Migration)
+      ActiveRecord::SchemaDumper.prepend(IronTrail::SchemaDumper)
+
+      @query_transformer = QueryTransformer.new
+      @query_transformer.setup_active_record
+    end
+
+    def store_instance
+      @store_instance ||= MetadataStore.new
+    end
+
+    def_delegators :store_instance,
+      :store_metadata,
+      :merge_metadata,
+      :current_metadata
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  IronTrail.setup_active_record
+end

data/lib/tasks/tracking.rake

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+namespace :iron_trail do
+  namespace :tracking do
+    desc 'Enables tracking for all missing tables.'
+    task enable: :environment do
+      tables = db_functions.collect_tables_tracking_status[:missing]
+      unless tables.length.positive?
+        puts 'All tables are being tracked already (no missing tables found).'
+        puts 'If you think this is wrong, check your ignored_tables list.'
+        return
+      end
+
+      puts "Will start tracking #{tables.length} tables."
+      tables.each do |table_name|
+        db_functions.enable_tracking_for_table(table_name)
+      end
+    end
+
+    desc 'Disables tracking all tables. Dangerous!'
+    task disable: :environment do
+      abort_when_unsafe!
+
+      tables = db_functions.collect_tables_tracking_status[:tracked]
+      puts "Will stop tracking #{tables.length} tables."
+      tables.each do |table_name|
+        db_functions.disable_tracking_for_table(table_name)
+      end
+
+      tables = db_functions.collect_tables_tracking_status[:tracked]
+      if tables.length.positive?
+        puts "WARNING: Something went wrong. There are still #{tables.length} " \
+             'tables being tracked.'
+      else
+        puts 'Done!'
+      end
+    end
+
+    desc 'Shows which tables are tracking, missing and ignored.'
+    task status: :environment do
+      status = db_functions.collect_tables_tracking_status
+      ignored = IronTrail.config.ignored_tables || []
+
+      # We likely want to keep this structure of text untouched as someone
+      # could use it to perform automation (e.g. monitoring).
+      puts "Tracking #{status[:tracked].length} tables."
+      puts "Missing #{status[:missing].length} tables."
+      puts "There are #{ignored.length} ignored tables."
+
+      puts 'Tracked tables:'
+      status[:tracked].sort.each do |table_name|
+        puts "\t#{table_name}"
+      end
+
+      puts 'Missing tables:'
+      status[:missing].sort.each do |table_name|
+        puts "\t#{table_name}"
+      end
+
+      puts 'Ignored tables:'
+      ignored.sort.each do |table_name|
+        puts "\t#{table_name}"
+      end
+    end
+
+    private
+
+    def db_functions
+      @db_functions ||= IronTrail::DbFunctions.new(ActiveRecord::Base.connection)
+    end
+
+    def abort_when_unsafe!
+      run_unsafe = %w[true 1 yes].include?(ENV['IRONTRAIL_RUN_UNSAFE'])
+      return unless Rails.env.production? && !run_unsafe
+
+      puts 'Aborting: operation is dangerous in a production environment. ' \
+           'Override this behavior by setting the IRONTRAIL_RUN_UNSAFE=1 env var.'
+
+      exit(1)
+    end
+  end
+end

metadata

@@ -0,0 +1,219 @@
+--- !ruby/object:Gem::Specification
+name: iron_trail
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- André Diego Piske
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: request_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.69'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.69'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg_party
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.2'
+description:
+email: andrepiske@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/generators/iron_trail/migration_generator.rb
+- lib/generators/iron_trail/templates/create_irontrail_changes.rb.erb
+- lib/generators/iron_trail/templates/create_irontrail_support_tables.rb.erb
+- lib/generators/iron_trail/templates/create_irontrail_trigger_function.rb.erb
+- lib/iron_trail.rb
+- lib/iron_trail/association.rb
+- lib/iron_trail/change_model_concern.rb
+- lib/iron_trail/config.rb
+- lib/iron_trail/db_functions.rb
+- lib/iron_trail/irontrail_log_row_function.sql
+- lib/iron_trail/metadata_store.rb
+- lib/iron_trail/migration.rb
+- lib/iron_trail/model.rb
+- lib/iron_trail/query_transformer.rb
+- lib/iron_trail/railtie.rb
+- lib/iron_trail/reflection.rb
+- lib/iron_trail/sidekiq.rb
+- lib/iron_trail/sidekiq_middleware.rb
+- lib/iron_trail/testing/rspec.rb
+- lib/iron_trail/version.rb
+- lib/tasks/tracking.rake
+homepage: https://github.com/trusted/iron_trail
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key:
+specification_version: 4
+summary: Creates a trail strong as iron
+test_files: []