rails_surrogate_key_logging 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4508c5a982897fd625ce7ee7625cedd7a78691b42a6562f9e036e2577f54b91
-  data.tar.gz: 5d5b0395a7cb737fd5f1dc90f0dbbf74a493fcdb91ad8644a9e802584b649e9a
+  metadata.gz: df6c120ebe49e9724f0c2324feefd62dc61c317b87c118e438d3735364193897
+  data.tar.gz: a33a587bdc49075fcf20917797a9a631702ff4b52bd54f021e0088f383e36d3a
 SHA512:
-  metadata.gz: 3201bc7f7e84b36813141a3c9e24883d1fd3a416ec4f05d6e6345fd46d063ebf494bcf39ca333f5292eed7ca845e0604d80f4907064b3db78aac6a496a477a08
-  data.tar.gz: 105d8ed9be27bf5e3f633f230b5836668793c45960628749b09e71570279d7f754207ce4275542fd886129975a6e342da0ac221c32c7ba4b81d27ddc49e12d68
+  metadata.gz: f5020c84352f1dc337ae18b2a8e4f6c8a576bea91ecdaf710fe9d0402fc31f82c6c865a23dee02269e45f7e3faa8e72208f8f64764357b765591a97ae8d5157f
+  data.tar.gz: e7c60aeebd180e87480c3e5857d94cd3926cb945545cc8c0a56f4bc5735dcd4c40b075aae1373e098a8186c3a641d5a3041582f88d42ae5740ebee6ed11c7abc

data/lib/surrogate_key_logging/active_record/log_subscriber.rb

@@ -17,10 +17,11 @@ module SurrogateKeyLogging
         sql   = payload[:sql]
         binds = nil
 
-        name_match = /([A-Za-z]+) (Load|Update|Cache)/.match(payload[:name])
+        name_match = /([A-Za-z:]+) (Load|Create|Update|Cache)/.match(payload[:name])
         model = if name_match && name_match[1] && ::ActiveRecord::Base.descendants.map(&:to_s).include?(name_match[1])
                   name_match[1].safe_constantize
                 end
+        return if !SurrogateKeyLogging.config.debug && SurrogateKeyLogging.key_store.is_a?(SurrogateKeyLogging::KeyStore::ActiveRecord) && SurrogateKeyLogging.key_store.model == model
 
         if payload[:binds]&.any?
           casted_params = type_casted_binds(payload[:type_casted_binds])

data/lib/surrogate_key_logging/active_support.rb

@@ -4,7 +4,7 @@ require 'active_support/parameter_filter'
 
 # Add ability for @mask to be a class/instance/lambda/proc
 module ActiveSupport
-  module ParameterFilter
+  class ParameterFilter
     class CompiledFilter
 
       def value_for_key(key, value, parents = [], original_params = nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity

data/lib/surrogate_key_logging/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SurrogateKeyLogging
+  class Config < ActiveSupport::OrderedOptions
+  end
+
+  module Configuration
+    extend ActiveSupport::Concern
+
+    def surrogate_key_logging
+      SurrogateKeyLogging.config
+    end
+
+  end
+end

data/lib/surrogate_key_logging/engine.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'rails'
+require 'securerandom'
+
+module SurrogateKeyLogging
+  class Engine < ::Rails::Engine
+    isolate_namespace SurrogateKeyLogging
+
+    config.autoload_paths << root.join('lib')
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.fixture_replacement :factory_bot, dir: 'spec/factories'
+      g.assets false
+      g.helper false
+      g.templates.unshift File.expand_path('lib/templates', root)
+    end
+
+    rake_tasks do
+      load 'tasks/surrogate_key_logging.rake'
+      load 'tasks/key_store/active_record.rake'
+    end
+
+    initializer 'surrogate_key_logging.config' do |app|
+      SurrogateKeyLogging.configure do |config|
+        config.enabled = Rails.env.production? unless config.key?(:enabled)
+        config.debug = !Rails.env.production? unless config.key?(:debug)
+        config.key_prefix = '' unless config.key?(:key_prefix)
+        config.key_for ||= -> (value) { "#{config.key_prefix}#{SecureRandom.uuid}" }
+        config.cache = true unless config.key?(:cache)
+        config.cache_key_for ||= -> (value) { value }
+        config.key_ttl ||= 90.days
+      end
+    end
+
+    initializer 'surrogate_key_logging.filter_parameters' do
+      if SurrogateKeyLogging.config.enabled
+      end
+    end
+
+    initializer 'surrogate_key_logging.logs' do
+      if SurrogateKeyLogging.config.enabled
+        ::ActiveRecord::LogSubscriber.detach_from(:active_record)
+        ::SurrogateKeyLogging::ActiveRecord::LogSubscriber.attach_to(:active_record)
+        ::ActiveSupport::LogSubscriber.detach_from(:action_controller)
+        ::SurrogateKeyLogging::ActionController::LogSubscriber.attach_to(:action_controller)
+        ::ActionDispatch::Request.include SurrogateKeyLogging::ActionDispatch::Request
+      end
+    end
+
+    initializer 'surrogate_key_logging.middleware' do
+      if SurrogateKeyLogging.config.enabled
+        Rails.application.config.middleware.insert_before 0, Middleware
+      end
+    end
+
+  end
+end

data/lib/surrogate_key_logging/key_manager.rb

@@ -3,9 +3,40 @@
 module SurrogateKeyLogging
   class KeyManager
 
-    def call(key, value, _parents = [], _original_params = nil)
-      surrogate = "SK#{Digest::SHA512.hexdigest(value.to_s)}"
-      puts "surrogate for key: `#{key}`, value: `#{value}`, surrogate: `#{surrogate}`"
+    attr_reader :should_cache, :cache_key_for, :cache, :key_for
+
+    delegate :key_store, to: SurrogateKeyLogging
+
+    def initialize
+      @should_cache = SurrogateKeyLogging.config.cache
+      @cache_key_for = SurrogateKeyLogging.config.cache_key_for
+      @cache = {}
+      @key_for = SurrogateKeyLogging.config.key_for
+    end
+
+    def get(value)
+      if should_cache
+        get_cached(value)
+      else
+        get_non_cached(value)
+      end
+    end
+
+    def get_cached(value)
+      @cache[cache_key_for.call(value)] ||= get_non_cached(value)
+    end
+
+    def get_non_cached(value)
+      stored = key_store.surrogate_for_value(value)
+      return stored if stored.present?
+      surrogate = key_for.call(value)
+      key_store.save(surrogate, value)
+      surrogate
+    end
+    
+    def call(_key, value, _parents = [], _original_params = nil)
+      surrogate = get(value)
+      # Rails.logger.tagged('SurrogateKeyLogging') { Rails.logger.info "Surrogate: `#{surrogate}`, value: `#{value}`" } if SurrogateKeyLogging.config.debug
       surrogate
     end
 

data/lib/surrogate_key_logging/key_store/active_record.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module SurrogateKeyLogging
+  module KeyStore
+
+    class ActiveRecord < Base
+
+      attr_reader :model
+
+      def initialize
+        if SurrogateKeyLogging.config.key?(:model) && SurrogateKeyLogging.config.model.present?
+          raise 'SurrogateKeyLogging::KeyStore::ActiveRecord config.model must descend from ActiveRecord::Base' unless SurrogateKeyLogging.config <= ::ActiveRecord::Base
+          @model = SurrogateKeyLogging.config.model
+        else
+          @model = SurrogateKeyLogging::Surrogate
+        end
+      end
+
+      def surrogate_for_value(value)
+        key = model.surrogate_for_value(value)
+        use(key)
+        key
+      end
+
+      def value_for_surrogate(surrogate)
+        model.value_for_surrogate(surrogate)
+      end
+
+      def save(surrogate, value)
+        model.add(surrogate, value)
+      end
+
+      def use(surrogate)
+        model.use(surrogate)
+      end
+
+    end
+
+    add(:active_record, ActiveRecord)
+
+  end
+end

data/lib/surrogate_key_logging/key_store/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SurrogateKeyLogging
+  module KeyStore
+    class Base
+
+      def surrogate_for_value(value)
+        raise NotImplementedError
+      end
+
+      def value_for_surrogate(surrogate)
+        raise NotImplementedError
+      end
+
+      def save(surrogate, value)
+        raise NotImplementedError
+      end
+      
+      def use(surrogate)
+        raise NotImplementedError
+      end
+      
+    end
+  end
+end

data/lib/surrogate_key_logging/key_store.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SurrogateKeyLogging
+  module KeyStore
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Base
+      autoload :ActiveRecord
+    end
+
+    @map = {}.with_indifferent_access
+
+    class << self
+      attr_reader :map
+
+      def get(key_store)
+        map[key_store] || raise("SurrogateKeyLogging unknown key_store: `#{key_store}`")
+      end
+
+      def add(name, klass)
+        map[name] = klass
+      end
+
+    end
+
+  end
+end

data/lib/surrogate_key_logging/middleware.rb

@@ -6,7 +6,6 @@ module SurrogateKeyLogging
 
     def initialize(app)
       @app = app
-      puts 'surrogate new'
     end
 
     def call(env)

data/lib/surrogate_key_logging/version.rb

@@ -4,8 +4,8 @@ module SurrogateKeyLogging
 
   module Version
     MAJOR = 0
-    MINOR = 0
-    PATCH = 1
+    MINOR = 1
+    PATCH = 0
 
   end
 

data/lib/surrogate_key_logging.rb

@@ -6,17 +6,28 @@ require 'active_support'
 module SurrogateKeyLogging
   extend ActiveSupport::Autoload
 
-  autoload :Railtie
-  autoload :Version
   autoload :ActionController
   autoload :ActionDispatch
   autoload :ActiveSupport
   autoload :ActiveRecord
+  autoload :Config, 'surrogate_key_logging/configuration'
+  autoload :Configuration
   autoload :KeyManager
+  autoload :KeyStore
   autoload :Middleware
+  autoload :Engine
+  autoload :Version
+
+  @config = Config.new
 
   class << self
 
+    attr_reader :config
+
+    def configure
+      yield config
+    end
+
     def surrogate_attributes(*attrs)
       @surrogate_attributes ||= []
       attrs.each do |attr|
@@ -26,6 +37,10 @@ module SurrogateKeyLogging
     end
 
     def reset
+      reset! if config.cache
+    end
+    
+    def reset!
       @key_manager = @parameter_filter = nil
     end
 
@@ -37,24 +52,30 @@ module SurrogateKeyLogging
       @parameter_filter ||= ::ActiveSupport::ParameterFilter.new(surrogate_attributes, mask: key_manager)
     end
 
+    def key_store
+      @key_store ||= KeyStore.get(config.key_store).new
+    end
+
     def filter_parameters(params)
       parameter_filter.filter params
     end
 
-    def add_param_to_filter(attr, parent = nil)
-      if parent.nil?
+    def add_param_to_filter(attr, *parents)
+      if parents.empty?
         surrogate_attributes attr.to_s
       else
         surrogate_attributes(
-          "#{parent}.#{attr}",
-          "#{parent}[#{attr}]",
-          "[#{parent}][#{attr}]"
+          "#{parents.join('.')}.#{attr}",
+          "#{parents.first}#{parents[1..-1].map{|x|"[#{x}]"}.join('')}[#{attr}]",
+          "#{parents.map{|x|"[#{x}]"}.join('')}[#{attr}]"
         )
       end
     end
 
   end
 
-end
+  KeyStore.eager_load!
+  ::Rails::Application::Configuration.send(:include, Configuration)
+  require 'surrogate_key_logging/engine'
 
-require 'surrogate_key_logging/railtie'
+end

data/lib/tasks/key_store/active_record.rake

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+namespace :skl do
+  namespace :key_store do
+    namespace :active_record do |ar_ns|
+
+      task clear: :environment do
+        ActiveRecord::Base.connection.truncate(SurrogateKeyLogging.key_store.model.table_name)
+      end
+
+      namespace :clear do
+        task stale: :environment do
+          if SurrogateKeyLogging.config.key_ttl > 0
+            SurrogateKeyLogging.key_store.model.where('updated_at < ?', Time.now - SurrogateKeyLogging.config.key_ttl).destroy_all
+          else
+            puts "SurrogateKeyLogging config.key_ttl is set to 0, which makes keys never go stale."
+          end
+        end
+      end
+
+      namespace :db do |db_ns|
+        %i[drop create setup migrate rollback seed version].each do |task_name|
+          task task_name => :environment do
+            Rake::Task["db:#{task_name}"].invoke
+          end
+        end
+
+        namespace :migrate do
+          %i[up down redo].each do |task_name|
+            task task_name => :environment do
+              Rake::Task["db:migrate:#{task_name}"].invoke
+            end
+          end
+        end
+
+        namespace :schema do
+          %i[load dump].each do |task_name|
+            task task_name => :environment do
+              Rake::Task["db:schema:#{task_name}"].invoke
+            end
+          end
+        end
+
+        namespace :test do
+          task prepare: :environment do
+            Rake::Task['db:test:prepare'].invoke
+          end
+        end
+
+        namespace :environment do
+          task set: :environment do
+            Rake::Task['db:environment:set'].invoke
+          end
+        end
+
+        namespace :__config__ do
+          task set_surrogate_key_logging_db_config: :environment do
+            # save current vars
+            @original_db_config = {
+              env_schema: ENV['SCHEMA'],
+              config: Rails.application.config.dup,
+              ar_config: ActiveRecord::Base.
+                           configurations.
+                           configurations.inject({}) do |memo, db_config|
+                             memo.merge(db_config.env_name => db_config.configuration_hash.stringify_keys)
+                           end,
+            }
+
+            # set config variables for custom database
+            db_dir = SurrogateKeyLogging::Engine.root.join('db')
+            schema_path = Rails.root.join('db', "surrogate_key_logging_schema.#{Rails.application.config.active_record.schema_format}")
+            ENV['SCHEMA'] = schema_path.to_s
+            Rails.application.config.paths['db'] = [db_dir]
+            Rails.application.config.paths['db/migrate'] = [db_dir.join('migrate')]
+            Rails.application.config.paths['db/seeds'] = [db_dir.join('seeds.rb')]
+            Rails.application.config.paths['config/database'] = [SurrogateKeyLogging::Engine.root.join('config', 'database.yml')]
+            ActiveRecord::Base.configurations = ActiveRecord::Base.
+                                                  configurations.
+                                                  configurations.inject({}) do |memo, db_config|
+                                                    next memo unless db_config.env_name.start_with?('surrogate_key_logging_')
+                                                    memo.merge(db_config.env_name.sub(/^surrogate_key_logging_/, '') => db_config.configuration_hash.stringify_keys)
+                                                  end
+            ActiveRecord::Base.establish_connection Rails.application.config.database_configuration[Rails.env]
+          end
+
+          task revert_surrogate_key_logging_db_config: :environment do
+            # reset config variables to original values
+            ENV['SCHEMA'] = @original_db_config[:env_schema]
+            Rails.application.config = @original_db_config[:config]
+            ActiveRecord::Base.configurations = @original_db_config[:ar_config]
+            ActiveRecord::Base.establish_connection Rails.application.config.database_configuration[Rails.env]
+          end
+        end
+
+        db_ns.tasks.each do |task|
+          next if task.scope.first == '__config__'
+          task.enhance ['skl:key_store:active_record:db:__config__:set_surrogate_key_logging_db_config'] do
+            Rake::Task['skl:key_store:active_record:db:__config__:revert_surrogate_key_logging_db_config'].invoke
+            Rake::Task['skl:key_store:active_record:db:__config__:set_surrogate_key_logging_db_config'].reenable
+            Rake::Task['skl:key_store:active_record:db:__config__:revert_surrogate_key_logging_db_config'].reenable
+          end
+        end
+      end
+
+      namespace :__config__ do
+        task check_config: :environment do
+          raise "SurrogateKeyLogging config.key_store must be set to :active_record for this task to function, it is currently set to `#{SurrogateKeyLogging.config.key_store.inspect}`" unless SurrogateKeyLogging.config.key_store == :active_record
+        end
+      end
+
+      ar_ns.tasks.each do |task|
+        next if task.scope.first == '__config__'
+        task.prerequisites.prepend('skl:key_store:active_record:__config__:check_config')
+        task.actions.prepend(&Rake::Task['skl:key_store:active_record:__config__:check_config'].method(:reenable))
+      end
+
+    end
+  end
+end

data/lib/tasks/surrogate_key_logging.rake

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+namespace :skl do
+  task clear: :environment do
+    Rake::Task["skl:key_store:#{SurrogateKeyLogging.config.key_store}:clear"].invoke
+  end
+
+  namespace :clear do
+    task stale: :environment do
+      Rake::Task["skl:key_store:#{SurrogateKeyLogging.config.key_store}:clear:stale"].invoke
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_surrogate_key_logging
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Taylor Yelverton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-13 00:00:00.000000000 Z
+date: 2023-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -83,10 +83,16 @@ files:
 - lib/surrogate_key_logging/active_record/attributes.rb
 - lib/surrogate_key_logging/active_record/log_subscriber.rb
 - lib/surrogate_key_logging/active_support.rb
+- lib/surrogate_key_logging/configuration.rb
+- lib/surrogate_key_logging/engine.rb
 - lib/surrogate_key_logging/key_manager.rb
+- lib/surrogate_key_logging/key_store.rb
+- lib/surrogate_key_logging/key_store/active_record.rb
+- lib/surrogate_key_logging/key_store/base.rb
 - lib/surrogate_key_logging/middleware.rb
-- lib/surrogate_key_logging/railtie.rb
 - lib/surrogate_key_logging/version.rb
+- lib/tasks/key_store/active_record.rake
+- lib/tasks/surrogate_key_logging.rake
 - rails_surrogate_key_logging.gemspec
 homepage: https://github.com/ComplyMD/rails_surrogate_key_logging
 licenses:

data/lib/surrogate_key_logging/railtie.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails'
-
-module SurrogateKeyLogging
-  class Railtie < Rails::Railtie
-    railtie_name :surrogate_key_logging
-
-    initializer 'surrogate_key_logging.filter_parameters' do
-      puts 'surrogate_key_logging.filter_parameters'
-    end
-
-    initializer 'surrogate_key_logging.logs' do
-      puts 'surrogate_key_logging.logs'
-      ::ActiveRecord::LogSubscriber.detach_from(:active_record)
-      ::SurrogateKeyLogging::ActiveRecord::LogSubscriber.attach_to(:active_record)
-      ::ActiveSupport::LogSubscriber.detach_from(:action_controller)
-      ::SurrogateKeyLogging::ActionController::LogSubscriber.attach_to(:action_controller)
-      ::ActionDispatch::Request.include SurrogateKeyLogging::ActionDispatch::Request
-    end
-
-    initializer 'surrogate_key_logging.middleware' do
-      puts 'surrogate_key_logging.middleware'
-      Rails.application.config.middleware.insert_before 0, Middleware
-    end
-
-  end
-end