code0-zero_track 0.0.0 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05f6505ffccae6a321db55632618e6a624580871f44cc65aba902e4b59094d4c
-  data.tar.gz: bc47bd22bfd34e73f62bc3869b1e6578441712e6eed93d440d8ed57fb0192594
+  metadata.gz: 6d7131b86c5135e76e99a0b4edb22b76c5fdcc765ef7d00160ce6e85dc8f3ea4
+  data.tar.gz: ab601c8af299d5679e16a57748977b0762a71aab0802470acb2a43873109c892
 SHA512:
-  metadata.gz: f44199c91669e5a544a0eba5a069ff91e46fa1b725d474a4966d6d3ab6633a716ac4cff781d16569529f73f8860926e0cca7a9c0c8256177987634f8d08f624f
-  data.tar.gz: 8798de80e9d97a7c0f5c874c7b9671468f9152a5a445c0ccb8d3d61cbfb3f7479af32ae8587847be31d12ab4ba53433d4d5a41a6690e3a12845a9cb33962411a
+  metadata.gz: 18fb171af0b27a2d1cf48a690a3d4529ad8daa95bb4d192e2ac6c0a7a5a2c501b922fa5ce48effee6ebced6ec545522b8ef9008587fd6b24d1115b21628ffd16
+  data.tar.gz: 5c6e8f01a01d2427aa75265260ea603eb902480e29b4342fa8c6d6ff9e7103da7c3a2be93d4b5b0ee739248de50e4c83d848c1701c8232e5d267e132b39da8a4

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