logidze 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c8113ee63d992fde09019059c1cbd3a6d75ab8914ad365106e954a66c28b633
-  data.tar.gz: e784d849dc188763ada793df28ad134226b2aa21416bbd818ac7e8c496ff1e2c
+  metadata.gz: 0cc10c417605b0f92991c201aeb958a44bc6130b64fd3b278780fb780818ccb3
+  data.tar.gz: 3c06efc69a95294bff75de4c8d91c1528c0cc67f5c0b5753097599a4c9e8fe5b
 SHA512:
-  metadata.gz: d427303c2f7f07f3f0d6964469d124d54dfac17615c881192115a426e9cafe517ad95850753bb6b0676211ffb33b4ed850aa11475ca6753b19c99f07a31421d4
-  data.tar.gz: 837353c8432d3a7c8e43f94949ad3ac45a0ca069d074d2db0e9acdad9abaabd03f04a5a0d9c3427f3ab710abd967a03d92f7eda02b6e15ce2c05fdb2b4e2b9fb
+  metadata.gz: 62d98e00caed7aa2a6f2ccd2be0ed536d2500ef0f195a391f17569c18cf7ce6051ef846abe45d167633100129d7e26555ae3ab4c728f73c05cfaec56dcd5df96
+  data.tar.gz: 56652129cef0c7ca97b2a87dd7a94ff6711b21a43680ba87a4af7f3b253fea7a171a5d2307bd81b8af2ca46a08f4b999929cfedf8dd46db2a75a72c61a8f551d

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## master (unreleased)
 
+## 1.4.0 (2025-05-09) 🎇
+
+- Support Rails 7.2 ([@atomaka][])
+
+- Add `--detached` option to store `log_data` in a separate `logidze_data` table to avoid table bloat.
+
 ## 1.3.1 (2024-10-23)
 
 - Fix `rails destroy logidze:model SomeModel` not deleting the `fx` trigger file file. ([@tylerhunt][])

data/README.md

@@ -37,6 +37,7 @@ Other requirements:
   - [Logs timestamps](#logs-timestamps)
   - [Undoing a Generated Invocation](#undoing-a-generated-invocation)
   - [Using with partitioned tables](#using-with-partitioned-tables)
+  - [Storing history data in a separate table](#storing-history-data-in-a-separate-table)
 - [Usage](#usage)
   - [Basic API](#basic-api)
   - [Track meta information](#track-meta-information)
@@ -203,6 +204,25 @@ bundle exec rails generate logidze:model Post --after-trigger
 
 **IMPORTANT:** Using Logidze for partitioned tables in PostgreSQL 10 is not supported.
 
+### Storing history data in a separate table
+
+By default, Logidze stores history data in the `log_data` column in the origin record table, which might lead to table bloat.
+If it concerns you, you may configure Logidze to store history data in a separate table by providing `--detached` option to the migration:
+
+```sh
+bundle exec rails logidze:model Post --detached
+```
+
+You can also configure Logidze to always store history data in a separate table for all models:
+
+```ruby
+# config/initializers/logidze.rb
+
+Logidze.log_data_placement = :detached
+```
+
+**IMPORTANT:** Using `--detached` mode for storing historic data slightly decreases performance. Check [bench results] for the details.
+
 ## Usage
 
 ### Basic API
@@ -645,3 +665,4 @@ Bug reports and pull requests are welcome on GitHub at [https://github.com/palka
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
 [fx]: https://github.com/teoljungberg/fx
+[bench results]: https://github.com/palkan/logidze/blob/feat-log-data-separate-storage/bench/performance/README.md

data/lib/generators/logidze/install/functions/logidze_logger.sql

@@ -1,5 +1,5 @@
 CREATE OR REPLACE FUNCTION logidze_logger() RETURNS TRIGGER AS $body$
-  -- version: 4
+  -- version: 5
   DECLARE
     changes jsonb;
     version jsonb;
@@ -15,6 +15,15 @@ CREATE OR REPLACE FUNCTION logidze_logger() RETURNS TRIGGER AS $body$
     item record;
     columns text[];
     include_columns boolean;
+    detached_log_data jsonb;
+    -- We use `detached_loggable_type` for:
+    -- 1. Checking if current implementation is `--detached` (`log_data` is stored in a separated table)
+    -- 2. If implementation is `--detached` then we use detached_loggable_type to determine
+    --    to which table current `log_data` record belongs
+    detached_loggable_type text;
+    log_data_table_name text;
+    log_data_is_empty boolean;
+    log_data_ts_key_data text;
     ts timestamp with time zone;
     ts_column text;
     err_sqlstate text;
@@ -30,8 +39,30 @@ CREATE OR REPLACE FUNCTION logidze_logger() RETURNS TRIGGER AS $body$
     ts_column := NULLIF(TG_ARGV[1], 'null');
     columns := NULLIF(TG_ARGV[2], 'null');
     include_columns := NULLIF(TG_ARGV[3], 'null');
+    detached_loggable_type := NULLIF(TG_ARGV[5], 'null');
+    log_data_table_name := NULLIF(TG_ARGV[6], 'null');
 
-    IF NEW.log_data is NULL OR NEW.log_data = '{}'::jsonb
+    -- getting previous log_data if it exists for detached `log_data` storage variant
+    IF detached_loggable_type IS NOT NULL
+    THEN
+      EXECUTE format(
+        'SELECT ldtn.log_data ' ||
+        'FROM %I ldtn ' ||
+        'WHERE ldtn.loggable_type = $1 ' ||
+          'AND ldtn.loggable_id = $2 '  ||
+        'LIMIT 1',
+        log_data_table_name
+      ) USING detached_loggable_type, NEW.id INTO detached_log_data;
+    END IF;
+
+    IF detached_loggable_type IS NULL
+    THEN
+        log_data_is_empty = NEW.log_data is NULL OR NEW.log_data = '{}'::jsonb;
+    ELSE
+        log_data_is_empty = detached_log_data IS NULL OR detached_log_data = '{}'::jsonb;
+    END IF;
+
+    IF log_data_is_empty
     THEN
       IF columns IS NOT NULL THEN
         log_data = logidze_snapshot(to_jsonb(NEW.*), ts_column, columns, include_columns);
@@ -40,7 +71,16 @@ CREATE OR REPLACE FUNCTION logidze_logger() RETURNS TRIGGER AS $body$
       END IF;
 
       IF log_data#>>'{h, -1, c}' != '{}' THEN
-        NEW.log_data := log_data;
+        IF detached_loggable_type IS NULL
+        THEN
+          NEW.log_data := log_data;
+        ELSE
+          EXECUTE format(
+            'INSERT INTO %I(log_data, loggable_type, loggable_id) ' ||
+            'VALUES ($1, $2, $3);',
+            log_data_table_name
+          ) USING log_data, detached_loggable_type, NEW.id;
+        END IF;
       END IF;
 
     ELSE
@@ -52,7 +92,12 @@ CREATE OR REPLACE FUNCTION logidze_logger() RETURNS TRIGGER AS $body$
       history_limit := NULLIF(TG_ARGV[0], 'null');
       debounce_time := NULLIF(TG_ARGV[4], 'null');
 
-      log_data := NEW.log_data;
+      IF detached_loggable_type IS NULL
+      THEN
+          log_data := NEW.log_data;
+      ELSE
+          log_data := detached_log_data;
+      END IF;
 
       current_version := (log_data->>'v')::int;
 
@@ -65,8 +110,16 @@ CREATE OR REPLACE FUNCTION logidze_logger() RETURNS TRIGGER AS $body$
         END IF;
       ELSEIF TG_OP = 'INSERT' THEN
         ts := (to_jsonb(NEW.*) ->> ts_column)::timestamp with time zone;
-        IF ts IS NULL OR (extract(epoch from ts) * 1000)::bigint = (NEW.log_data #>> '{h,-1,ts}')::bigint THEN
-          ts := statement_timestamp();
+
+        IF detached_loggable_type IS NULL
+        THEN
+          log_data_ts_key_data = NEW.log_data #>> '{h,-1,ts}';
+        ELSE
+          log_data_ts_key_data = detached_log_data #>> '{h,-1,ts}';
+        END IF;
+
+        IF ts IS NULL OR (extract(epoch from ts) * 1000)::bigint = log_data_ts_key_data::bigint THEN
+            ts := statement_timestamp();
         END IF;
       END IF;
 
@@ -123,7 +176,12 @@ CREATE OR REPLACE FUNCTION logidze_logger() RETURNS TRIGGER AS $body$
         END;
       END IF;
 
-      changes = changes - 'log_data';
+      -- We store `log_data` in a separate table for the `detached` mode
+      -- So we remove `log_data` only when we store historic data in the record's origin table
+      IF detached_loggable_type IS NULL
+      THEN
+          changes = changes - 'log_data';
+      END IF;
 
       IF columns IS NOT NULL THEN
         changes = logidze_filter_keys(changes, columns, include_columns);
@@ -170,7 +228,21 @@ CREATE OR REPLACE FUNCTION logidze_logger() RETURNS TRIGGER AS $body$
         log_data := logidze_compact_history(log_data, size - history_limit + 1);
       END IF;
 
-      NEW.log_data := log_data;
+      IF detached_loggable_type IS NULL
+      THEN
+        NEW.log_data := log_data;
+      ELSE
+        detached_log_data = log_data;
+        EXECUTE format(
+          'UPDATE %I ' ||
+          'SET log_data = $1 ' ||
+          'WHERE %I.loggable_type = $2 ' ||
+          'AND %I.loggable_id = $3',
+          log_data_table_name,
+          log_data_table_name,
+          log_data_table_name
+        ) USING detached_log_data, detached_loggable_type, NEW.id;
+      END IF;
     END IF;
 
     RETURN NEW; -- result

data/lib/generators/logidze/install/functions/logidze_logger_after.sql

@@ -1,3 +1,3 @@
 CREATE OR REPLACE FUNCTION logidze_logger_after() RETURNS TRIGGER AS $body$
-  -- version: 4
+  -- version: 5
 <%= generate_logidze_logger_after %>

data/lib/generators/logidze/install/install_generator.rb

@@ -87,7 +87,17 @@ module Logidze
           source.sub!(/^CREATE OR REPLACE FUNCTION logidze_logger.*$/, "")
           source.sub!(/^  -- version.*$/, "")
           source.gsub!("RETURN NEW; -- pass", "RETURN NULL;")
-          source.gsub!("RETURN NEW; -- result", "    EXECUTE format('UPDATE %I.%I SET \"log_data\" = $1 WHERE ctid = %L', TG_TABLE_SCHEMA, TG_TABLE_NAME, NEW.CTID) USING NEW.log_data;\n    RETURN NULL;")
+
+          return_condition = <<~SQL
+            IF detached_loggable_type IS NULL
+                THEN
+                  EXECUTE format('UPDATE %I.%I SET "log_data" = $1 WHERE ctid = %L', TG_TABLE_SCHEMA, TG_TABLE_NAME, NEW.CTID) USING NEW.log_data;
+                END IF;
+
+                RETURN NULL;
+          SQL
+          source.gsub!("RETURN NEW; -- result", return_condition)
+
           source
         end
       end

data/lib/generators/logidze/migration/USAGE

@@ -0,0 +1,7 @@
+Description:
+  Generates the necessary migration for running Logidze with Logidze data stored in a separate table
+  
+Examples:
+  rails generate logidze:migration:logs
+
+    This will generate the migration to add separate table for storing Logidze data.

data/lib/generators/logidze/migration/logs_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Logidze
+  module Generators
+    module Migration
+      class LogsGenerator < Rails::Generators::Base
+        include Rails::Generators::Migration
+
+        source_root File.expand_path("templates", __dir__)
+
+        def generate_migration
+          migration_template "migration.rb.erb", "db/migrate/create_logidze_data.rb"
+        end
+
+        def self.next_migration_number(dir)
+          ::ActiveRecord::Generators::Base.next_migration_number(dir)
+        end
+      end
+    end
+  end
+end

data/lib/generators/logidze/migration/templates/migration.rb.erb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class <%= @migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :logidze_data do |t|
+      t.jsonb :log_data
+      t.belongs_to :loggable, polymorphic: true, index: {name: "index_logidze_loggable", unique: true}
+    end
+  end
+end

data/lib/generators/logidze/model/USAGE

@@ -11,3 +11,7 @@ Examples:
 
     This will generate the migration to update existing trigger (drop and create).
 
+  rails generate logidze:Model User --detached
+
+    This will generate migration to add trigger for the <User> model.
+    This will also add `has_logidze detached: true` to the model.

data/lib/generators/logidze/model/model_generator.rb

@@ -14,6 +14,9 @@ module Logidze
       source_root File.expand_path("templates", __dir__)
       source_paths << File.expand_path("triggers", __dir__)
 
+      class_option :detached, type: :boolean, optional: true,
+        desc: "Store history data in a separate table"
+
       class_option :limit, type: :numeric, optional: true, desc: "Specify history size limit"
 
       class_option :debounce_time, type: :numeric, optional: true,
@@ -60,8 +63,11 @@ module Logidze
         return if update?
 
         indents = "  " * (class_name.scan("::").count + 1)
+        macros_name = detached? ? "has_logidze detached: true\n" : "has_logidze\n"
 
-        inject_into_class(model_file_path, class_name.demodulize, "#{indents}has_logidze\n")
+        if File.readlines("#{destination_root}/#{model_file_path}").grep(/has_logidze/).empty?
+          inject_into_class(model_file_path, class_name.demodulize, indents + macros_name)
+        end
       end
 
       no_tasks do
@@ -80,6 +86,10 @@ module Logidze
           "#{config.table_name_prefix}#{table_name}#{config.table_name_suffix}"
         end
 
+        def detached_loggable_type
+          escape_pgsql_string(class_name) if detached?
+        end
+
         def limit
           options[:limit]
         end
@@ -88,6 +98,10 @@ module Logidze
           options[:backfill]
         end
 
+        def detached?
+          options[:detached] || Logidze.detached_log_placement?
+        end
+
         def only_trigger?
           options[:only_trigger]
         end
@@ -116,6 +130,10 @@ module Logidze
           escape_pgsql_string(value)
         end
 
+        def quoted_log_data_table_name
+          Logidze::LogidzeData.quoted_table_name if detached?
+        end
+
         def debounce_time
           options[:debounce_time]
         end
@@ -149,7 +167,8 @@ module Logidze
         end
 
         def logidze_logger_parameters
-          format_pgsql_args(limit, timestamp_column, filtered_columns, include_columns, debounce_time)
+          format_pgsql_args(limit, timestamp_column, filtered_columns, include_columns, debounce_time,
+            detached_loggable_type, quoted_log_data_table_name)
         end
 
         def logidze_snapshot_parameters

data/lib/generators/logidze/model/templates/migration.rb.erb

@@ -1,6 +1,6 @@
 class <%= @migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
   def change
-<%- unless update? || only_trigger? -%>
+<%- unless update? || only_trigger? || detached? -%>
     add_column :<%= table_name %>, :log_data, :jsonb
 <%- end -%>
 
@@ -58,13 +58,23 @@ class <%= @migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::M
     end
 <%- end -%>
 <%- if backfill? -%>
-
     reversible do |dir|
       dir.up do
-        execute <<~SQL
-          UPDATE "<%= full_table_name %>" as t
-          SET log_data = logidze_snapshot(<%= logidze_snapshot_parameters %>);
-        SQL
+        <%- if detached?  %>
+          execute <<~SQL
+            INSERT INTO <%= quoted_log_data_table_name %> (log_data, loggable_type, loggable_id)
+            SELECT logidze_snapshot(<%= logidze_snapshot_parameters %>), <%= detached_loggable_type %>, t.id
+            FROM "<%= full_table_name %>" t
+            ON CONFLICT (loggable_type, loggable_id)
+            DO UPDATE
+            SET log_data = EXCLUDED.log_data;
+          SQL
+        <%- else %>
+          execute <<~SQL
+            UPDATE "<%= full_table_name %>" as t
+            SET log_data = logidze_snapshot(<%= logidze_snapshot_parameters %>);
+          SQL
+        <%- end %>
       end
     end
 <%- end -%>

data/lib/generators/logidze/model/triggers/logidze.sql

@@ -2,5 +2,5 @@ CREATE TRIGGER <%= %Q("logidze_on_#{full_table_name}") %>
 BEFORE UPDATE OR INSERT ON <%= %Q("#{full_table_name}") %> FOR EACH ROW
 WHEN (coalesce(current_setting('logidze.disabled', true), '') <> 'on')
 -- Parameters: history_size_limit (integer), timestamp_column (text), filtered_columns (text[]),
--- include_columns (boolean), debounce_time_ms (integer)
+-- include_columns (boolean), debounce_time_ms (integer), detached_loggable_type(text), log_data_table_name(text)
 EXECUTE PROCEDURE logidze_logger(<%= logidze_logger_parameters %>);

data/lib/generators/logidze/model/triggers/logidze_after.sql

@@ -2,5 +2,5 @@ CREATE TRIGGER <%= %Q("logidze_on_#{full_table_name}") %>
 AFTER UPDATE OR INSERT ON <%= %Q("#{full_table_name}") %> FOR EACH ROW
 WHEN (coalesce(current_setting('logidze.disabled', true), '') <> 'on' AND pg_trigger_depth() < 1)
 -- Parameters: history_size_limit (integer), timestamp_column (text), filtered_columns (text[]),
--- include_columns (boolean), debounce_time_ms (integer)
+-- include_columns (boolean), debounce_time_ms (integer), detached_loggable_type(text), log_data_table_name(text)
 EXECUTE PROCEDURE logidze_logger_after(<%= logidze_logger_parameters %>);

data/lib/logidze/detachable.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Logidze
+  module Detachable
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :logidze_data, as: :loggable, class_name: "::Logidze::LogidzeData", dependent: :destroy, autosave: true
+
+      delegate :log_data, to: :logidze_data, allow_nil: true
+    end
+
+    module ClassMethods # :nodoc:
+      # Nullify log_data column for a association
+      #
+      # @return [Integer] number of deleted +Logidze::LogidzeData+ records
+      def reset_log_data
+        Logidze::LogidzeData.where(loggable_id: ids, loggable_type: name).delete_all
+      end
+
+      # Initialize log_data with the current state if it's null
+      def create_logidze_snapshot(timestamp: nil, only: nil, except: nil, sql_filter: nil)
+        ActiveRecord::Base.connection.execute <<~SQL.squish
+          INSERT INTO #{Logidze::LogidzeData.quoted_table_name} (log_data, loggable_type, loggable_id)
+          SELECT logidze_snapshot(
+              to_jsonb(#{quoted_table_name}),
+              #{snapshot_query_args(timestamp: timestamp, only: only, except: except)}
+            ),
+            '#{name}',
+            #{quoted_table_name}.id
+          FROM #{quoted_table_name}
+          #{sql_filter}
+          ON CONFLICT (loggable_type, loggable_id)
+          DO UPDATE
+          SET log_data = EXCLUDED.log_data;
+        SQL
+      end
+
+      private
+
+      def initial_scope
+        includes(:logidze_data)
+      end
+    end
+
+    # Loads log_data field from the database, stores to the attributes hash and returns it
+    def reload_log_data
+      reload_logidze_data.log_data
+    end
+
+    # Nullify log_data column for a single record
+    def reset_log_data
+      tap { logidze_data.delete }.reload_logidze_data
+    end
+
+    # Initialize log_data with the current state if it's null for a single record
+    def create_logidze_snapshot!(timestamp: nil, only: nil, except: nil)
+      id_filter = "WHERE #{self.class.quoted_table_name}.id = #{id}"
+      self.class.create_logidze_snapshot(timestamp: timestamp, only: only, except: except, sql_filter: id_filter)
+
+      reload_log_data
+    end
+
+    def raw_log_data
+      logidze_data&.read_attribute_before_type_cast(:log_data)
+    end
+
+    def log_data=(v)
+      logidze_data&.assign_attributes(log_data: v) || build_logidze_data(log_data: v)
+      v # rubocop:disable Lint/Void
+    end
+
+    def dup
+      super.tap { _1.logidze_data = logidze_data.dup }
+    end
+
+    protected
+
+    # rubocop: disable Lint/ShadowedArgument
+    def build_dup(log_entry, requested_ts = log_entry.time, object_at: nil)
+      object_at = dup
+      object_at.logidze_data = logidze_data.dup
+      super
+    end
+    # rubocop: enable Lint/ShadowedArgument
+  end
+end

data/lib/logidze/has_logidze.rb

@@ -9,10 +9,14 @@ module Logidze
 
     module ClassMethods # :nodoc:
       # Include methods to work with history.
-      #
-      def has_logidze(ignore_log_data: Logidze.ignore_log_data_by_default)
+      def has_logidze(ignore_log_data: Logidze.ignore_log_data_by_default, detached: Logidze.detached_log_placement?)
         include Logidze::IgnoreLogData
         include Logidze::Model
+        if detached && !Logidze.inline_log_placement?
+          # Adds needed behavior to models and alters behavior of some methods from +Logidze::Model+ to
+          # work with detached table for `log_data`
+          include Logidze::Detachable
+        end
 
         @ignore_log_data = ignore_log_data
 

data/lib/logidze/history/type.rb

@@ -36,6 +36,10 @@ module Logidze
       def changed_in_place?(raw_old_value, new_value)
         cast_value(raw_old_value) != new_value
       end
+
+      def mutable?
+        true
+      end
     end
   end
 end

data/lib/logidze/model.rb

@@ -18,12 +18,12 @@ module Logidze
     module ClassMethods # :nodoc:
       # Return records reverted to specified time
       def at(time: nil, version: nil)
-        all.to_a.filter_map { |record| record.at(time: time, version: version) }
+        initial_scope.all.to_a.filter_map { |record| record.at(time: time, version: version) }
       end
 
       # Return changes made to records since specified time
       def diff_from(time: nil, version: nil)
-        all.map { |record| record.diff_from(time: time, version: version) }
+        initial_scope.all.map { |record| record.diff_from(time: time, version: version) }
       end
 
       # Alias for Logidze.without_logging
@@ -44,6 +44,26 @@ module Logidze
 
       # Initialize log_data with the current state if it's null
       def create_logidze_snapshot(timestamp: nil, only: nil, except: nil)
+        without_logging do
+          where(log_data: nil).update_all(
+            <<~SQL.squish
+              log_data = logidze_snapshot(
+                to_jsonb(#{quoted_table_name}),
+                #{snapshot_query_args(timestamp: timestamp, only: only, except: except)}
+              )
+            SQL
+          )
+        end
+      end
+
+      private
+
+      def initial_scope
+        all
+      end
+
+      # Computes args for creating initializing snapshots in +.create_logidze_snapshot+ and +#create_logidze_snapshot!+
+      def snapshot_query_args(timestamp: nil, only: nil, except: nil)
         args = ["'null'"]
 
         args[0] = "'#{timestamp}'" if timestamp
@@ -55,13 +75,7 @@ module Logidze
           args[2] = only ? "true" : "false"
         end
 
-        without_logging do
-          where(log_data: nil).update_all(
-            <<~SQL
-              log_data = logidze_snapshot(to_jsonb(#{quoted_table_name}), #{args.join(", ")})
-            SQL
-          )
-        end
+        args.join(", ")
       end
     end
 
@@ -244,6 +258,10 @@ module Logidze
       reload_log_data
     end
 
+    def raw_log_data
+      read_attribute_before_type_cast(:log_data)
+    end
+
     protected
 
     def apply_diff(version, diff)
@@ -261,14 +279,16 @@ module Logidze
       write_attribute column, deserialize_value(column, value)
     end
 
-    def build_dup(log_entry, requested_ts = log_entry.time)
-      object_at = dup
+    # rubocop: disable Lint/ShadowedArgument
+    def build_dup(log_entry, requested_ts = log_entry.time, object_at: nil)
+      object_at ||= dup
       object_at.apply_diff(log_entry.version, log_data.changes_to(version: log_entry.version))
       object_at.id = id
       object_at.logidze_requested_ts = requested_ts
 
       object_at
     end
+    # rubocop: enable Lint/ShadowedArgument
 
     def deserialize_value(column, value)
       @attributes[column].type.deserialize(value)

data/lib/logidze/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Logidze
-  VERSION = "1.3.1"
+  VERSION = "1.4.0"
 end

data/lib/logidze.rb

@@ -11,6 +11,7 @@ module Logidze
   require "logidze/ignore_log_data"
   require "logidze/has_logidze"
   require "logidze/meta"
+  require "logidze/detachable"
 
   extend Logidze::Meta
 
@@ -29,6 +30,12 @@ module Logidze
     attr_accessor :sort_triggers_by_name
     # Determines what Logidze should do when upgrade is needed (:raise | :warn | :ignore)
     attr_reader :on_pending_upgrade
+    # Determines where to store +log_data+:
+    # - +:inline+ - force Logidze to store it in the origin table in the +log_data+ column
+    # - +:detached+ - force Logidze to  store it in the +logidze_data+ table in the +log_data+ column
+    #
+    # By default we do not set +log_data_placement+ value and rely on `has_logidze` macros
+    attr_accessor :log_data_placement
 
     # Temporary disable DB triggers.
     #
@@ -53,6 +60,14 @@ module Logidze
       @on_pending_upgrade = mode
     end
 
+    def detached_log_placement?
+      @log_data_placement == :detached
+    end
+
+    def inline_log_placement?
+      @log_data_placement == :inline
+    end
+
     private
 
     def with_logidze_setting(name, value)
@@ -71,4 +86,5 @@ module Logidze
   self.return_self_if_log_data_is_empty = true
   self.on_pending_upgrade = :ignore
   self.sort_triggers_by_name = false
+  self.log_data_placement = nil
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logidze
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.0
 platform: ruby
 authors:
 - palkan
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-23 00:00:00.000000000 Z
+date: 2025-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -136,6 +136,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.4
 description: PostgreSQL JSONB-based model changes tracking
 email:
 - dementiev.vm@gmail.com
@@ -160,12 +174,16 @@ files:
 - lib/generators/logidze/install/templates/hstore.rb.erb
 - lib/generators/logidze/install/templates/migration.rb.erb
 - lib/generators/logidze/install/templates/migration_fx.rb.erb
+- lib/generators/logidze/migration/USAGE
+- lib/generators/logidze/migration/logs_generator.rb
+- lib/generators/logidze/migration/templates/migration.rb.erb
 - lib/generators/logidze/model/USAGE
 - lib/generators/logidze/model/model_generator.rb
 - lib/generators/logidze/model/templates/migration.rb.erb
 - lib/generators/logidze/model/triggers/logidze.sql
 - lib/generators/logidze/model/triggers/logidze_after.sql
 - lib/logidze.rb
+- lib/logidze/detachable.rb
 - lib/logidze/engine.rb
 - lib/logidze/has_logidze.rb
 - lib/logidze/history.rb
@@ -188,7 +206,7 @@ metadata:
   documentation_uri: http://github.com/palkan/logidze
   homepage_uri: http://github.com/palkan/logidze
   source_code_uri: http://github.com/palkan/logidze
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -204,7 +222,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.4.19
-signing_key: 
+signing_key:
 specification_version: 4
 summary: PostgreSQL JSONB-based model changes tracking
 test_files: []