code0-zero_track 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05f6505ffccae6a321db55632618e6a624580871f44cc65aba902e4b59094d4c
-  data.tar.gz: bc47bd22bfd34e73f62bc3869b1e6578441712e6eed93d440d8ed57fb0192594
+  metadata.gz: 528e1dc7d30d7cc16b1507b9649429a03196747fe18b27086c23cbdfe9b85147
+  data.tar.gz: ff9eae6c20639f631b0fce5b3de912a73d76bb1f0e77a7e16b32fac2d645cbbc
 SHA512:
-  metadata.gz: f44199c91669e5a544a0eba5a069ff91e46fa1b725d474a4966d6d3ab6633a716ac4cff781d16569529f73f8860926e0cca7a9c0c8256177987634f8d08f624f
-  data.tar.gz: 8798de80e9d97a7c0f5c874c7b9671468f9152a5a445c0ccb8d3d61cbfb3f7479af32ae8587847be31d12ab4ba53433d4d5a41a6690e3a12845a9cb33962411a
+  metadata.gz: 7ee327ee87f60a1d8865d6abb3b1dc322a28bdc57b7a6d31f06a7d1af17425ed8e7d6af4178417d8db5ad9e84cd6794ae4a2612c1ebd65dfb4968f7b3d1e1e35
+  data.tar.gz: eb42c512f19919608444053fb33be11229e7968a1e6bb231b82ec9415d528baabe83051d41ba5a0335afbc0a2ec6b428c4dd420c29a03d4afcf812667b34cad0

data/README.md

@@ -18,3 +18,51 @@ Or install it yourself as:
 ```bash
 $ gem install code0-zero_track
 ```
+
+## Features
+
+### `Code0::ZeroTrack::Context`
+
+Context allows you to save data in a thread local object. Data from the Context is merged into the
+log messages, if `Code0::ZeroTrack::Logs::JsonFormatter` or `Code0::ZeroTrack::Logs::JsonFormatter::Tagged`
+is used.
+
+`.with_context(data, &block)` creates a new context inheriting data from the previous context and adds the
+passed data to it. The new context is dropped after the block finished execution. \
+`.push(data)` creates a new context inheriting data from the previous context and adds the passed data to it. \
+`.current` returns the context from the top of the stack.
+
+### `Code0::ZeroTrack::Memoize`
+
+This module can be included to get access to the `memoize(name, reset_on_change, &block)` method.
+
+This method allows to memoize a value, so it only gets computed once.
+Each memoize is identified by the name. You can pass a proc to `reset_on_change` and the memoization
+will automatically clear every time returned value changes.
+
+`memoized?(name)` allows to check if a value for the given name is currently memoized. \
+Memoizations can be cleared with `clear_memoize(name)` or `clear_memoize!(name)`.
+
+### `config.zero_track.active_record.schema_cleaner`
+
+When using `config.active_record.schema_format = :sql`, Rails produces a `db/structure.sql`.
+This file contains a lot of noise that doesn't provide much value.
+
+This noise can be cleaned out with `config.zero_track.active_record.schema_cleaner = true`.
+
+### `config.zero_track.active_record.timestamps`
+
+Setting `config.zero_track.active_record.timestamps = true` adds `timestamps_with_timezone`
+and `datetime_with_timezone` as methods on the table model when creating tables in migrations.
+
+They behave just like `timestamps` and `datetime`, just including timezones.
+
+### `config.zero_track.active_record.schema_migrations`
+
+Rails uses the `schema_migrations` table to keep track which migrations have been executed.
+This information is also persisted in the `db/structure.sql`, so the `schema_migrations` table
+can be filled with the correct entries when the schema is loaded from the schema file.
+
+This approach is prone to git conflicts, so you can switch to a file based persistence
+with `config.zero_track.active_record.schema_migrations = true`. Instead of an `INSERT INTO` in
+the `db/structure.sql`, this mode creates files in the `db/schema_migrations` directory.

data/lib/code0/zero_track/context.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    class Context
+      LOG_KEY = 'meta'
+      CORRELATION_ID_KEY = 'correlation_id'
+      RAW_KEYS = [CORRELATION_ID_KEY].freeze
+
+      class << self
+        def with_context(attributes = {})
+          context = push(attributes)
+
+          begin
+            yield(context)
+          ensure
+            pop(context)
+          end
+        end
+
+        def push(new_attributes = {})
+          new_context = current&.merge(new_attributes) || new(new_attributes)
+
+          contexts.push(new_context)
+
+          new_context
+        end
+
+        def pop(context)
+          contexts.pop while contexts.include?(context)
+        end
+
+        def correlation_id
+          current&.correlation_id
+        end
+
+        def current
+          contexts.last
+        end
+
+        def log_key(key)
+          key = key.to_s
+          return key if RAW_KEYS.include?(key)
+          return key if key.start_with?("#{LOG_KEY}.")
+
+          "#{LOG_KEY}.#{key}"
+        end
+
+        private
+
+        def contexts
+          Thread.current[:labkit_contexts] ||= []
+        end
+      end
+
+      def initialize(values = {})
+        @data = {}
+
+        assign_attributes(values)
+      end
+
+      def merge(new_attributes)
+        new_context = self.class.new(data.dup)
+        new_context.assign_attributes(new_attributes)
+
+        new_context
+      end
+
+      def to_h
+        expand_data
+      end
+
+      def [](key)
+        to_h[log_key(key)]
+      end
+
+      def correlation_id
+        data[CORRELATION_ID_KEY]
+      end
+
+      def get_attribute(attribute)
+        raw = call_or_value(data[log_key(attribute)])
+
+        call_or_value(raw)
+      end
+
+      protected
+
+      def assign_attributes(attributes)
+        attributes = attributes.transform_keys(&method(:log_key))
+
+        data.merge!(attributes)
+
+        # Remove keys that had their values set to `nil` in the new attributes
+        data.keep_if { |_, value| valid_data?(value) }
+
+        # Assign a correlation if it was missing in the first context or when
+        # explicitly removed
+        data[CORRELATION_ID_KEY] ||= new_id
+
+        data
+      end
+
+      private
+
+      attr_reader :data
+
+      def log_key(key)
+        self.class.log_key(key)
+      end
+
+      def call_or_value(value)
+        value.respond_to?(:call) ? value.call : value
+      end
+
+      def expand_data
+        data.transform_values do |value|
+          value = call_or_value(value)
+
+          value if valid_data?(value)
+        end.compact
+      end
+
+      def new_id
+        SecureRandom.hex
+      end
+
+      def valid_data?(value)
+        value == false || value.present?
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/column_methods.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module ColumnMethods
+        module Timestamps
+          # Appends columns `created_at` and `updated_at` to a table.
+          #
+          # It is used in table creation like:
+          # create_table 'users' do |t|
+          #   t.timestamps_with_timezone
+          # end
+          def timestamps_with_timezone(**options)
+            options[:null] = false if options[:null].nil?
+
+            %i[created_at updated_at].each do |column_name|
+              column(column_name, :datetime_with_timezone, **options)
+            end
+          end
+
+          # Adds specified column with appropriate timestamp type
+          #
+          # It is used in table creation like:
+          # create_table 'users' do |t|
+          #   t.datetime_with_timezone :did_something_at
+          # end
+          def datetime_with_timezone(column_name, **options)
+            column(column_name, :datetime_with_timezone, **options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/migration.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      class Migration
+        # rubocop:disable Naming/ClassAndModuleCamelCase
+        class V1_0 < ::ActiveRecord::Migration[7.1]
+          include Database::MigrationHelpers::AddColumnEnhancements
+          include Database::MigrationHelpers::ConstraintHelpers
+          include Database::MigrationHelpers::IndexHelpers
+          include Database::MigrationHelpers::TableEnhancements
+        end
+        # rubocop:enable Naming/ClassAndModuleCamelCase
+
+        def self.[](version)
+          version = version.to_s
+          name = "V#{version.tr('.', '_')}"
+          raise ArgumentError, "Invalid migration version: #{version}" unless const_defined?(name, false)
+
+          const_get(name, false)
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/migration_helpers/add_column_enhancements.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module MigrationHelpers
+        module AddColumnEnhancements
+          def add_column(table_name, column_name, type, *args, **kwargs, &block)
+            helper_context = self
+
+            limit = kwargs.delete(:limit)
+            unique = kwargs.delete(:unique)
+
+            super
+
+            return unless type == :text
+
+            quoted_column_name = helper_context.quote_column_name(column_name)
+
+            if limit
+              name = helper_context.send(:text_limit_name, table_name, column_name)
+
+              definition = "char_length(#{quoted_column_name}) <= #{limit}"
+
+              add_check_constraint(table_name, definition, name: name)
+            end
+
+            if unique.is_a?(Hash)
+              unique[:where] = "#{column_name} IS NOT NULL" if unique.delete(:allow_nil_duplicate)
+              column_name = "LOWER(#{quoted_column_name})" if unique.delete(:case_insensitive)
+
+              add_index table_name, column_name, unique: true, **unique
+            elsif unique
+              add_index table_name, column_name, unique: unique
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/migration_helpers/constraint_helpers.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module MigrationHelpers
+        module ConstraintHelpers
+          def text_limit_name(table, column, name: nil)
+            name.presence || check_constraint_name(table, column, 'max_length')
+          end
+
+          def check_constraint_name(table, column, type)
+            identifier = "#{table}_#{column}_check_#{type}"
+            hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
+
+            "check_#{hashed_identifier}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/migration_helpers/index_helpers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module MigrationHelpers
+        module IndexHelpers
+          def index_name(table, column, type)
+            identifier = "#{table}_#{column}_index_#{type}"
+            hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
+
+            "index_#{hashed_identifier}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/migration_helpers/table_enhancements.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Database
+      module MigrationHelpers
+        module TableEnhancements
+          def create_table(table_name, *args, **kwargs, &block)
+            helper_context = self
+
+            super do |t|
+              enhance(t, table_name, helper_context, &block)
+            end
+          end
+
+          def change_table(table_name, *args, **kwargs, &block)
+            helper_context = self
+
+            super do |t|
+              enhance(t, table_name, helper_context, &block)
+            end
+          end
+
+          private
+
+          def enhance(t, table_name, helper_context, &block)
+            t.define_singleton_method(:text) do |column_name, **inner_kwargs|
+              limit = inner_kwargs.delete(:limit)
+              unique = inner_kwargs.delete(:unique)
+
+              super(column_name, **inner_kwargs)
+
+              quoted_column_name = helper_context.quote_column_name(column_name)
+
+              if limit
+                name = helper_context.send(:text_limit_name, table_name, column_name)
+
+                definition = "char_length(#{quoted_column_name}) <= #{limit}"
+
+                t.check_constraint(definition, name: name)
+              end
+
+              if unique.is_a?(Hash)
+                index_definition = column_name
+                unique[:where] = "#{column_name} IS NOT NULL" if unique.delete(:allow_nil_duplicate)
+                index_definition = "LOWER(#{quoted_column_name})" if unique.delete(:case_insensitive)
+
+                t.index index_definition, unique: true, **unique
+              elsif unique
+                t.index column_name, unique: unique
+              end
+            end
+
+            t.define_singleton_method(:integer) do |column_name, **inner_kwargs|
+              unique = inner_kwargs.delete(:unique)
+
+              super(column_name, **inner_kwargs)
+
+              t.index column_name, unique: unique unless unique.nil?
+            end
+
+            return if block.nil?
+
+            t.instance_eval do |obj|
+              if block.arity == 1
+                block.call(obj)
+              elsif block.arity == 2
+                block.call(obj, helper_context)
+              else
+                raise ArgumentError, "Unsupported arity of #{block.arity}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/postgresql_adapter/dump_schema_versions_mixin.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Heavily inspired by the implementation of GitLab
+# (https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/lib/gitlab/database/postgresql_adapter/dump_schema_versions_mixin.rb)
+# which is licensed under a modified version of the MIT license which can be found at
+# https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/LICENSE
+#
+# The code might have been modified to accommodate for the needs of this project
+
+module Code0
+  module ZeroTrack
+    module Database
+      module PostgresqlAdapter
+        module DumpSchemaVersionsMixin
+          extend ActiveSupport::Concern
+
+          def dump_schema_information
+            # rubocop:disable Rails/SkipsModelValidations -- not an active record object
+            Database::SchemaMigrations.touch_all(self) unless Rails.env.production?
+            # rubocop:enable Rails/SkipsModelValidations
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/postgresql_database_tasks/load_schema_versions_mixin.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Heavily inspired by the implementation of GitLab
+# (https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/lib/gitlab/database/postgresql_database_tasks/load_schema_versions_mixin.rb)
+# which is licensed under a modified version of the MIT license which can be found at
+# https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/LICENSE
+#
+# The code might have been modified to accommodate for the needs of this project
+
+module Code0
+  module ZeroTrack
+    module Database
+      module PostgresqlDatabaseTasks
+        module LoadSchemaVersionsMixin
+          extend ActiveSupport::Concern
+
+          def structure_load(...)
+            super
+
+            Database::SchemaMigrations.load_all(connection)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/schema_cleaner.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Heavily inspired by the implementation of GitLab
+# (https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/lib/gitlab/database/schema_cleaner.rb)
+# which is licensed under a modified version of the MIT license which can be found at
+# https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/LICENSE
+#
+# The code might have been modified to accommodate for the needs of this project
+
+module Code0
+  module ZeroTrack
+    module Database
+      class SchemaCleaner
+        attr_reader :original_schema
+
+        def initialize(original_schema)
+          @original_schema = original_schema
+        end
+
+        def clean(io)
+          structure = original_schema.dup
+
+          # Remove noise
+          structure.gsub!(/^COMMENT ON EXTENSION.*/, '')
+          structure.gsub!(/^SET.+/, '')
+          structure.gsub!(/^SELECT pg_catalog\.set_config\('search_path'.+/, '')
+          structure.gsub!(/^--.*/, "\n")
+
+          # We typically don't assume we're working with the public schema.
+          # pg_dump uses fully qualified object names though, since we have multiple schemas
+          # in the database.
+          #
+          # The intention here is to not introduce an assumption about the standard schema,
+          # unless we have a good reason to do so.
+          structure.gsub!(/public\.(\w+)/, '\1')
+          structure.gsub!(
+            /CREATE EXTENSION IF NOT EXISTS (\w+) WITH SCHEMA public;/,
+            'CREATE EXTENSION IF NOT EXISTS \1;'
+          )
+
+          structure.gsub!(/\n{3,}/, "\n\n")
+
+          io << structure.strip
+          io << "\n"
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/schema_migrations/context.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Heavily inspired by the implementation of GitLab
+# (https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/lib/gitlab/database/schema_migrations/context.rb)
+# which is licensed under a modified version of the MIT license which can be found at
+# https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/LICENSE
+#
+# The code might have been modified to accommodate for the needs of this project
+
+module Code0
+  module ZeroTrack
+    module Database
+      module SchemaMigrations
+        class Context
+          attr_reader :connection
+
+          class_attribute :default_schema_migrations_path, default: 'db/schema_migrations'
+
+          def initialize(connection)
+            @connection = connection
+          end
+
+          def schema_directory
+            @schema_directory ||= Rails.root.join(database_schema_migrations_path).to_s
+          end
+
+          def versions_to_create
+            versions_from_database = @connection.pool.schema_migration.versions
+            versions_from_migration_files = @connection.pool.migration_context.migrations.map { |m| m.version.to_s }
+
+            versions_from_database & versions_from_migration_files
+          end
+
+          private
+
+          def database_name
+            @database_name ||= @connection.pool.db_config.name
+          end
+
+          def database_schema_migrations_path
+            @connection.pool.db_config.configuration_hash[:schema_migrations_path] ||
+              self.class.default_schema_migrations_path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/schema_migrations/migrations.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Heavily inspired by the implementation of GitLab
+# (https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/lib/gitlab/database/schema_migrations/migrations.rb)
+# which is licensed under a modified version of the MIT license which can be found at
+# https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/LICENSE
+#
+# The code might have been modified to accommodate for the needs of this project
+
+module Code0
+  module ZeroTrack
+    module Database
+      module SchemaMigrations
+        class Migrations
+          MIGRATION_VERSION_GLOB = '20[0-9][0-9]*'
+
+          def initialize(context)
+            @context = context
+          end
+
+          def touch_all
+            return unless @context.versions_to_create.any?
+
+            version_filepaths = version_filenames.map { |f| File.join(schema_directory, f) }
+            FileUtils.rm(version_filepaths)
+
+            @context.versions_to_create.each do |version|
+              version_filepath = File.join(schema_directory, version)
+
+              File.open(version_filepath, 'w') do |file|
+                file << Digest::SHA256.hexdigest(version)
+              end
+            end
+          end
+
+          def load_all
+            return if version_filenames.empty?
+            return unless @context.connection.pool.schema_migration.table_exists?
+
+            values = version_filenames.map { |vf| "('#{@context.connection.quote_string(vf)}')" }
+
+            @context.connection.execute(<<~SQL.squish)
+              INSERT INTO schema_migrations (version)
+              VALUES #{values.join(',')}
+              ON CONFLICT DO NOTHING
+            SQL
+          end
+
+          private
+
+          def schema_directory
+            @context.schema_directory
+          end
+
+          def version_filenames
+            @version_filenames ||= Dir.glob(MIGRATION_VERSION_GLOB, base: schema_directory)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/database/schema_migrations.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Heavily inspired by the implementation of GitLab
+# (https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/lib/gitlab/database/schema_migrations.rb)
+# which is licensed under a modified version of the MIT license which can be found at
+# https://gitlab.com/gitlab-org/gitlab/-/blob/7983d2a2203aff265fae479d7c1b7066858d1265/LICENSE
+#
+# The code might have been modified to accommodate for the needs of this project
+
+module Code0
+  module ZeroTrack
+    module Database
+      module SchemaMigrations
+        module_function
+
+        def touch_all(connection)
+          context = Database::SchemaMigrations::Context.new(connection)
+
+          # rubocop:disable Rails/SkipsModelValidations -- not an active record object
+          Database::SchemaMigrations::Migrations.new(context).touch_all
+          # rubocop:enable Rails/SkipsModelValidations
+        end
+
+        def load_all(connection)
+          context = Database::SchemaMigrations::Context.new(connection)
+
+          Database::SchemaMigrations::Migrations.new(context).load_all
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/injectors/active_record_schema_migrations.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Injectors
+      class ActiveRecordSchemaMigrations
+        def self.inject!
+          # Patch to write version information as empty files under the db/schema_migrations directory
+          # This is intended to reduce potential for merge conflicts in db/structure.sql
+          ActiveSupport.on_load(:active_record_postgresqladapter) do
+            prepend Database::PostgresqlAdapter::DumpSchemaVersionsMixin
+          end
+          # Patch to load version information from empty files under the db/schema_migrations directory
+          ActiveRecord::Tasks::PostgreSQLDatabaseTasks
+            .prepend Database::PostgresqlDatabaseTasks::LoadSchemaVersionsMixin
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/injectors/active_record_timestamps.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Injectors
+      class ActiveRecordTimestamps
+        def self.inject!
+          ActiveSupport.on_load(:active_record_postgresqladapter) do
+            self::NATIVE_DATABASE_TYPES[:datetime_with_timezone] = { name: 'timestamptz' }
+          end
+
+          ActiveSupport.on_load(:active_record) do
+            ActiveRecord::Base.time_zone_aware_types += [:datetime_with_timezone]
+          end
+
+          ActiveRecord::ConnectionAdapters::ColumnMethods.include ZeroTrack::Database::ColumnMethods::Timestamps
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/loggable.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Loggable
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def logger
+          Logger.new(Rails.logger, name || '<Anonymous>')
+        end
+      end
+
+      def logger
+        Logger.new(Rails.logger, self.class.name || '<Anonymous>')
+      end
+
+      class Logger
+        def initialize(log, clazz)
+          @log = log
+          @clazz = clazz
+        end
+
+        delegate :debug?, :info?, :warn?, :error?, :fatal?, :formatter, :level, to: :@log
+
+        def with_context(&block)
+          Code0::ZeroTrack::Context.with_context(class: @clazz, &block)
+        end
+
+        def debug(message)
+          with_context { @log.debug(message) }
+        end
+
+        def error(message)
+          with_context { @log.error(message) }
+        end
+
+        def warn(message)
+          with_context { @log.warn(message) }
+        end
+
+        def info(message)
+          with_context { @log.info(message) }
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/logs/json_formatter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Logs
+      class JsonFormatter < ::Logger::Formatter
+        def call(severity, datetime, _progname, message)
+          JSON.generate(data(severity, datetime, message)) << "\n"
+        end
+
+        def data(severity, datetime, message)
+          data = {}
+          data[:severity] = severity
+          data[:time] = datetime.utc.iso8601(3)
+
+          case message
+          when String
+            data[:message] = chomp message
+          when Hash
+            data.merge!(message)
+          end
+
+          data.merge!(Code0::ZeroTrack::Context.current.to_h)
+        end
+
+        def chomp(message)
+          message.chomp! until message.chomp == message
+
+          message.strip
+        end
+
+        class Tagged < JsonFormatter
+          include ActiveSupport::TaggedLogging::Formatter
+
+          def tagged(*_args)
+            yield self # Ignore tags, they break the json layout as they are prepended to the log line
+          end
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/memoize.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Code0
+  module ZeroTrack
+    module Memoize
+      def memoize(name, reset_on_change: nil)
+        unless reset_on_change.nil?
+          reset_trigger = reset_on_change.call
+          reset_memoize = memoize("#{name}_reset_on_change") { reset_trigger }
+
+          if reset_trigger != reset_memoize
+            clear_memoize(name)
+            clear_memoize("#{name}_reset_on_change")
+          end
+        end
+
+        if memoized?(name)
+          instance_variable_get(ivar(name))
+        else
+          instance_variable_set(ivar(name), yield)
+        end
+      end
+
+      def memoized?(name)
+        instance_variable_defined?(ivar(name))
+      end
+
+      def clear_memoize(name)
+        clear_memoize!(name) if memoized?(name)
+      end
+
+      def clear_memoize!(name)
+        remove_instance_variable(ivar(name))
+      end
+
+      private
+
+      def ivar(name)
+        case name
+        when Symbol
+          name.to_s.prepend('@').to_sym
+        when String
+          :"@#{name}"
+        else
+          raise ArgumentError, "Invalid type of '#{name}'"
+        end
+      end
+    end
+  end
+end

data/lib/code0/zero_track/railtie.rb

@@ -3,6 +3,21 @@
 module Code0
   module ZeroTrack
     class Railtie < ::Rails::Railtie
+      config.zero_track = ActiveSupport::OrderedOptions.new
+      config.zero_track.active_record = ActiveSupport::OrderedOptions.new
+      config.zero_track.active_record.timestamps = false
+      config.zero_track.active_record.schema_migrations = false
+      config.zero_track.active_record.schema_cleaner = false
+
+      rake_tasks do
+        path = File.expand_path(__dir__)
+        Dir.glob("#{path}/../../tasks/**/*.rake").each { |f| load f }
+      end
+
+      config.after_initialize do
+        Injectors::ActiveRecordTimestamps.inject! if config.zero_track.active_record.timestamps
+        Injectors::ActiveRecordSchemaMigrations.inject! if config.zero_track.active_record.schema_migrations
+      end
     end
   end
 end

data/lib/code0/zero_track/version.rb

@@ -2,6 +2,6 @@
 
 module Code0
   module ZeroTrack
-    VERSION = '0.0.0'
+    VERSION = '0.0.1'
   end
 end

data/lib/code0/zero_track.rb

@@ -1,10 +1,18 @@
 # frozen_string_literal: true
 
-require 'code0/zero_track/version'
-require 'code0/zero_track/railtie'
+require 'rails/railtie'
+
+require 'zeitwerk'
+loader = Zeitwerk::Loader.new
+loader.tag = File.basename(__FILE__, '.rb')
+loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
+loader.push_dir(File.expand_path(File.join(__dir__, '..')))
+loader.setup
 
 module Code0
   module ZeroTrack
     # Your code goes here...
   end
 end
+
+Code0::ZeroTrack::Railtie # eager load the railtie

data/lib/tasks/code0/zero_track_tasks.rake

@@ -1,6 +1,35 @@
 # frozen_string_literal: true
 
-# desc "Explaining what the task does"
-# task :code0_zero_track do
-#   # Task goes here
-# end
+namespace :code0 do
+  namespace :zero_track do
+    namespace :db do
+      desc 'This adjusts and cleans db/structure.sql - it runs after db:schema:dump'
+      task clean_structure_sql: :environment do |task_name|
+        # Allow this task to be called multiple times, as happens when running db:migrate:redo
+        Rake::Task[task_name].reenable
+
+        next unless Rails.application.config.zero_track.active_record.schema_cleaner
+
+        ActiveRecord::Base.configurations
+                          .configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
+                          .each do |db_config|
+          structure_file = ActiveRecord::Tasks::DatabaseTasks.schema_dump_path(db_config)
+
+          schema = File.read(structure_file)
+
+          File.open(structure_file, 'wb+') do |io|
+            Code0::ZeroTrack::Database::SchemaCleaner.new(schema).clean(io)
+          end
+        end
+      end
+
+      # Inform Rake that custom tasks should be run every time rake db:schema:dump is run
+      Rake::Task['db:schema:dump'].enhance do
+        Rake::Task['code0:zero_track:db:clean_structure_sql'].invoke
+      end
+      Rake::Task['db:prepare'].enhance do
+        Rake::Task['code0:zero_track:db:clean_structure_sql'].invoke
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: code0-zero_track
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Niklas van Schrick
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-02-16 00:00:00.000000000 Z
+date: 2025-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 8.0.1
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-parameterized
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -122,7 +150,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.30'
-description: 
+description:
 email:
 - mc.taucher2003@gmail.com
 executables: []
@@ -133,6 +161,24 @@ files:
 - README.md
 - Rakefile
 - lib/code0/zero_track.rb
+- lib/code0/zero_track/context.rb
+- lib/code0/zero_track/database/column_methods.rb
+- lib/code0/zero_track/database/migration.rb
+- lib/code0/zero_track/database/migration_helpers/add_column_enhancements.rb
+- lib/code0/zero_track/database/migration_helpers/constraint_helpers.rb
+- lib/code0/zero_track/database/migration_helpers/index_helpers.rb
+- lib/code0/zero_track/database/migration_helpers/table_enhancements.rb
+- lib/code0/zero_track/database/postgresql_adapter/dump_schema_versions_mixin.rb
+- lib/code0/zero_track/database/postgresql_database_tasks/load_schema_versions_mixin.rb
+- lib/code0/zero_track/database/schema_cleaner.rb
+- lib/code0/zero_track/database/schema_migrations.rb
+- lib/code0/zero_track/database/schema_migrations/context.rb
+- lib/code0/zero_track/database/schema_migrations/migrations.rb
+- lib/code0/zero_track/injectors/active_record_schema_migrations.rb
+- lib/code0/zero_track/injectors/active_record_timestamps.rb
+- lib/code0/zero_track/loggable.rb
+- lib/code0/zero_track/logs/json_formatter.rb
+- lib/code0/zero_track/memoize.rb
 - lib/code0/zero_track/railtie.rb
 - lib/code0/zero_track/version.rb
 - lib/tasks/code0/zero_track_tasks.rake
@@ -144,7 +190,7 @@ metadata:
   source_code_uri: https://github.com/code0-tech/code0-zero_track
   changelog_uri: https://github.com/code0-tech/code0-zero_track/releases
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -152,7 +198,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -160,7 +206,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.4.10
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Common helpers for Code0 rails applications
 test_files: []