logidze 0.12.0 → 1.0.0.rc1

data/Gemfile

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in logidze.gemspec
-gemspec
-
-gem "pry-byebug", platform: :mri
-
-local_gemfile = "#{File.dirname(__FILE__)}/Gemfile.local"
-
-if File.exist?(local_gemfile)
-  eval(File.read(local_gemfile)) # rubocop:disable Lint/Eval
-else
-  gem 'activerecord', '~> 6.0'
-end

data/Rakefile

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "rspec/core/rake_task"
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-RSpec::Core::RakeTask.new(:spec)
-
-namespace :dummy do
-  require_relative "spec/dummy/config/application"
-  Dummy::Application.load_tasks
-end
-
-task(:spec).clear
-desc "Run specs other than spec/acceptance"
-RSpec::Core::RakeTask.new("spec") do |task|
-  task.exclude_pattern = "spec/acceptance/**/*_spec.rb"
-  task.verbose = false
-end
-
-desc "Run acceptance specs in spec/acceptance"
-RSpec::Core::RakeTask.new("spec:acceptance") do |task|
-  task.pattern = "spec/acceptance/**/*_spec.rb"
-  task.verbose = false
-end
-
-desc "Run the specs and acceptance tests"
-task default: %w[rubocop spec spec:acceptance]

data/bench/performance/README.md

@@ -1,109 +0,0 @@
-# Performance benchmarks: PaperTail vs. Logidze
-
-We want to compare Logidze with the most popular versioning library for Rails – PaperTrail.
-
-
-## Insert ([source](insert_bench.rb))
-
-```
-PaperTrail INSERT    213.148  (± 8.9%) i/s -      1.060k in   5.018504s
-   Logidze INSERT    613.387  (±16.3%) i/s -      2.970k in   5.036127s
-```
-
-
-## Update ([source](update_bench.rb))
-
-When changeset has 2 fields:
-
-```
-PaperTrail UPDATE #1    256.651  (±26.5%) i/s -      1.206k in   5.002300s
-Logidze UPDATE #1    356.932  (±12.6%) i/s -      1.764k in   5.030560s
-```
-
-When changeset has 5 fields:
-
-```
-PaperTrail UPDATE #2    246.281  (±24.0%) i/s -      1.168k in   5.008234s
-Logidze UPDATE #2    331.942  (±16.6%) i/s -      1.593k in   5.028135s
-```
-
-## Getting diff ([source](diff_bench.rb))
-
-PaperTrail doesn't have built-in method to calculate diff between not adjacent versions.
-We add `diff_from(ts)` and `diff_from_joined(ts)` (which uses SQL JOIN) methods to calculate diff from specified version using changesets.
-
-When each record has 10 versions:
-
-```
-       PT DIFF     20.874  (± 4.8%) i/s -    106.000  in   5.091402s
-PT (join) DIFF     20.619  (± 4.8%) i/s -    104.000  in   5.070160s
-  Logidze DIFF    109.482  (±24.7%) i/s -    500.000  in   5.103534s
-```
-
-When each record has 100 versions:
-
-```
-       PT DIFF      2.998  (± 0.0%) i/s -     15.000  in   5.019494s
-PT (join) DIFF      3.193  (± 0.0%) i/s -     16.000  in   5.030155s
-  Logidze DIFF     19.627  (±25.5%) i/s -     88.000  in   5.035555s
-```
-
-And, finally, when each record has 1000 versions:
-
-```
-       PT DIFF      0.270  (± 0.0%) i/s -     17.000  in  63.038374s
-PT (join) DIFF      0.235  (± 0.0%) i/s -     14.000  in  60.350886s
-  Logidze DIFF      2.022  (± 0.0%) i/s -    120.000  in  60.142965s
-```
-
-## Select memory usage ([source](memory_profile.rb))
-
-Logidze loads more data (because it stores log in-place). But how much more?
-We consider two cases for PaperTrail: when we want to calculate diff (and thus loading versions) and when we don't need any history related data.
-
-When each record has 10 versions:
-
-```
-PT records
-Total Allocated:                 27.8 KB
-Total Retained:                  16.59 KB
-Retained memory (per record):    2.14 KB
-
-PT with versions
-Total Allocated:                 228.01 KB
-Total Retained:                  170.78 KB
-Retained memory (per record):    143.13 KB
-
-Logidze records
-Total Allocated:                 46.45 KB
-Total Retained:                  34.73 KB
-Retained memory (per record):    4.11 KB
-```
-
-When each record has 100 versions:
-
-```
-PT with versions
-Total Allocated:                 1.92 MB
-Total Retained:                  1.56 MB
-Retained memory (per record):    1.53 MB
-
-Logidze records
-Total Allocated:                 162.48 KB
-Total Retained:                  150.76 KB
-Retained memory (per record):    15.4 KB
-```
-
-When each record has 1000 versions:
-
-```
-PT with versions
-Total Allocated:                 18.23 MB
-Total Retained:                  14.86 MB
-Retained memory (per record):    14.83 MB
-
-Logidze records
-Total Allocated:                 1.32 MB
-Total Retained:                  1.31 MB
-Retained memory (per record):    131.59 KB
-```

data/bench/performance/diff_bench.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "benchmark/ips"
-require "./setup"
-
-# How many records do you want?
-N = (ENV["N"] || "100").to_i
-
-# How many version each record has?
-V = (ENV["V"] || "10").to_i
-
-# Benchmark run time
-BM_TIME = (ENV["BM_TIME"] || 5).to_i
-
-BM_WARMUP = [(BM_TIME / 10), 2].max
-
-LogidzeBench.cleanup
-LogidzeBench.populate(N)
-
-ts1 = LogidzeBench.generate_versions(V / 2)
-
-LogidzeBench.generate_versions(V / 2)
-
-Benchmark.ips do |x|
-  x.config(time: BM_TIME, warmup: BM_WARMUP)
-
-  x.report("PT DIFF") do
-    User.random(N / 2).diff_from(ts1)
-  end
-
-  x.report("PT (join) DIFF") do
-    User.random(N / 2).diff_from_joined(ts1)
-  end
-
-  x.report("Logidze DIFF") do
-    LogidzeUser.random(N / 2).diff_from(ts1)
-  end
-end

data/bench/performance/insert_bench.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "benchmark/ips"
-require "./setup"
-
-params = {
-  email: Faker::Internet.email,
-  position: Faker::Number.number(3),
-  name: Faker::Name.name,
-  age: Faker::Number.number(2),
-  bio: Faker::Lorem.paragraph
-}
-
-Benchmark.ips do |x|
-  x.report("PaperTrail INSERT") do
-    User.create!(params)
-  end
-
-  x.report("Logidze INSERT") do
-    LogidzeUser.create!(params)
-  end
-end

data/bench/performance/memory_profile.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require "./setup"
-require "active_support/core_ext"
-require "memory_profiler"
-
-# How many records do you want?
-N = (ENV["N"] || "10").to_i
-
-# How many version each record has?
-V = (ENV["V"] || "10").to_i
-
-LogidzeBench.cleanup
-LogidzeBench.populate(N)
-LogidzeBench.generate_versions(V)
-
-module MemoryReport
-  KILO_BYTE = 1024
-  MEGA_BYTE = 1024 * 1024
-
-  module_function
-
-  def call(msg, relation)
-    buffer = nil
-    delta = N / 10
-    r0 = MemoryProfiler.report do
-      buffer = relation.random(N - delta).to_a
-    end
-
-    buffer = nil
-    r1 = MemoryProfiler.report do
-      buffer = relation.to_a
-    end
-
-    $stdout.puts msg
-    $stdout.puts "Total Allocated:\t\t\t\t#{to_human_size(r1.total_allocated_memsize)}"
-    $stdout.puts "Total Retained:\t\t\t\t\t#{to_human_size(r1.total_retained_memsize)}"
-    $stdout.puts "Retained_memsize memory (per record):\t\t#{to_human_size((r1.total_retained_memsize - r0.total_retained_memsize) / delta)}"
-  end
-
-  module_function
-
-  def to_human_size(size)
-    if size > MEGA_BYTE
-      "#{(size.to_f / MEGA_BYTE).round(2)} MB"
-    elsif size > KILO_BYTE
-      "#{(size.to_f / KILO_BYTE).round(2)} KB"
-    else
-      "#{size} B"
-    end
-  end
-end
-
-MemoryReport.call("PT records", User.all)
-MemoryReport.call("PT with versions", User.joins(:versions).all)
-MemoryReport.call("Logidze records", LogidzeUser.all)

data/bench/performance/setup.rb

@@ -1,315 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "bundler/inline"
-rescue LoadError => e
-  warn "Bundler version 1.10 or later is required. Please update your Bundler"
-  raise e
-end
-
-gemfile(true) do
-  source "https://rubygems.org"
-  gem "activerecord", "~>4.2"
-  gem "pg"
-  gem "paper_trail", "~>4.2", require: false
-  gem "pry-byebug"
-  gem "faker"
-  gem "benchmark-ips"
-  gem "memory_profiler"
-end
-
-DB_NAME = ENV["DB_NAME"] || "logidze_query_bench"
-
-begin
-  system("createdb #{DB_NAME}")
-rescue
-  $stdout.puts "DB already exists"
-end
-
-$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
-
-require "active_record"
-require "logger"
-require "logidze"
-
-ActiveRecord::Base.send :include, Logidze::HasLogidze
-
-ActiveRecord::Base.establish_connection(adapter: "postgresql", database: DB_NAME)
-
-at_exit do
-  ActiveRecord::Base.connection.disconnect!
-end
-
-require "paper_trail"
-
-module LogidzeBench
-  module_function
-
-  def setup_db
-    ActiveRecord::Schema.define do
-      # PaperTrail setup
-      create_table :versions, force: true do |t|
-        t.string :item_type, null: false
-        t.integer :item_id, null: false
-        t.string :event, null: false
-        t.string :whodunnit
-        t.text :object
-        t.jsonb :object_changes
-
-        t.datetime :created_at
-      end
-
-      add_index :versions, [:item_type, :item_id]
-
-      # Logidze setup
-      enable_extension :hstore
-
-      execute <<~SQL
-        DO $$
-          BEGIN
-          EXECUTE 'ALTER DATABASE ' || current_database() || ' SET logidze.disabled TO off';
-          END;
-        $$
-        LANGUAGE plpgsql;
-      SQL
-
-      execute <<~SQL
-        CREATE OR REPLACE FUNCTION logidze_logger() RETURNS TRIGGER AS $body$
-          DECLARE
-            changes jsonb;
-            new_v integer;
-            ts bigint;
-            size integer;
-            history_limit integer;
-            current_version integer;
-            merged jsonb;
-            iterator integer;
-            item record;
-          BEGIN
-            ts := (extract(epoch from now()) * 1000)::bigint;
-
-            IF TG_OP = 'INSERT' THEN
-              changes := to_jsonb(NEW.*) - 'log_data';
-              new_v := 1;
-
-              NEW.log_data := json_build_object(
-                'v',
-                1,
-                'h',
-                jsonb_build_array(
-                  jsonb_build_object(
-                    'ts',
-                    ts,
-                    'v',
-                    new_v,
-                    'c',
-                    changes
-                  )
-                )
-              );
-            ELSIF TG_OP = 'UPDATE' THEN
-              history_limit := TG_ARGV[0];
-              current_version := (NEW.log_data->>'v')::int;
-
-              IF NEW = OLD THEN
-                RETURN NEW;
-              END IF;
-
-              IF current_version < (NEW.log_data#>>'{h,-1,v}')::int THEN
-                iterator := 0;
-                FOR item in SELECT * FROM jsonb_array_elements(NEW.log_data->'h')
-                LOOP
-                  IF (item.value->>'v')::int > current_version THEN
-                    NEW.log_data := jsonb_set(
-                      NEW.log_data,
-                      '{h}',
-                      (NEW.log_data->'h') - iterator
-                    );
-                  END IF;
-                  iterator := iterator + 1;
-                END LOOP;
-              END IF;
-
-              changes := hstore_to_jsonb_loose(
-                hstore(NEW.*) - hstore(OLD.*)
-              ) - 'log_data';
-
-              new_v := (NEW.log_data#>>'{h,-1,v}')::int + 1;
-
-              size := jsonb_array_length(NEW.log_data->'h');
-
-              NEW.log_data := jsonb_set(
-                NEW.log_data,
-                ARRAY['h', size::text],
-                jsonb_build_object(
-                  'ts',
-                  ts,
-                  'v',
-                  new_v,
-                  'c',
-                  changes
-                ),
-                true
-              );
-
-              NEW.log_data := jsonb_set(
-                NEW.log_data,
-                '{v}',
-                to_jsonb(new_v)
-              );
-
-              IF history_limit IS NOT NULL AND history_limit = size THEN
-                merged := jsonb_build_object(
-                  'ts',
-                  NEW.log_data#>'{h,1,ts}',
-                  'v',
-                  NEW.log_data#>'{h,1,v}',
-                  'c',
-                  (NEW.log_data#>'{h,0,c}') || (NEW.log_data#>'{h,1,c}')
-                );
-
-                NEW.log_data := jsonb_set(
-                  NEW.log_data,
-                  '{h}',
-                  jsonb_set(
-                    NEW.log_data->'h',
-                    '{1}',
-                    merged
-                  ) - 0
-                );
-              END IF;
-            END IF;
-
-            return NEW;
-          END;
-          $body$
-          LANGUAGE plpgsql;
-      SQL
-
-      create_table :users, force: true do |t|
-        t.string :email
-        t.integer :position
-        t.string :name
-        t.text :bio
-        t.integer :age
-        t.timestamps
-      end
-
-      create_table :logidze_users, force: true do |t|
-        t.string :email
-        t.integer :position
-        t.string :name
-        t.text :bio
-        t.integer :age
-        t.jsonb :log_data, default: "{}", null: false
-        t.timestamps
-      end
-
-      execute <<~SQL
-        CREATE TRIGGER logidze_on_logidze_users
-        BEFORE UPDATE OR INSERT ON logidze_users FOR EACH ROW
-        WHEN (current_setting('logidze.disabled') <> 'on')
-        EXECUTE PROCEDURE logidze_logger();
-      SQL
-    end
-  end
-
-  module_function
-
-  def populate(n = 1_000)
-    n.times do
-      params = fake_params
-      User.create!(params)
-      LogidzeUser.create!(params)
-    end
-  end
-
-  module_function
-
-  def cleanup
-    LogidzeUser.delete_all
-    User.delete_all
-    PaperTrail::Version.delete_all
-  end
-
-  module_function
-
-  def generate_versions(num = 1)
-    num.times do
-      User.find_each do |u|
-        u.update!(fake_params(sample: true))
-      end
-
-      LogidzeUser.find_each do |u|
-        u.update!(fake_params(sample: true))
-      end
-
-      # make at least 1 second between versions
-      sleep 1
-    end
-    Time.now
-  end
-
-  module_function
-
-  def fake_params(sample: false)
-    params = {
-      email: Faker::Internet.email,
-      position: Faker::Number.number(3),
-      name: Faker::Name.name,
-      age: Faker::Number.number(2),
-      bio: Faker::Lorem.paragraph
-    }
-
-    return params.slice(%i[email position name age bio].sample) if sample
-    params
-  end
-end
-
-module ARandom
-  def random(num = 1)
-    rel = order("random()")
-    num == 1 ? rel.first : rel.limit(num)
-  end
-end
-
-class User < ActiveRecord::Base
-  extend ARandom
-  has_paper_trail
-
-  def self.diff_from(ts)
-    includes(:versions).map { |u| {"id" => u.id, "changes" => u.diff_from(ts)} }
-  end
-
-  def self.diff_from_joined(ts)
-    eager_load(:versions).map { |u| {"id" => u.id, "changes" => u.diff_from(ts)} }
-  end
-
-  def diff_from(ts)
-    changes = {}
-    versions.each do |v|
-      next if v.created_at < ts
-      merge_changeset(changes, v.changeset)
-    end
-    changes
-  end
-
-  private
-
-  def merge_changeset(acc, data)
-    data.each do |k, v|
-      unless acc.key?(k)
-        acc[k] = {"old" => v[0]}
-      end
-      acc[k]["new"] = v[1]
-    end
-  end
-end
-
-class LogidzeUser < ActiveRecord::Base
-  extend ARandom
-  has_logidze
-end
-
-# Run migration only if neccessary
-LogidzeBench.setup_db if ENV["FORCE"].present? || !ActiveRecord::Base.connection.tables.include?("logidze_users")