columns_trace 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd2b5b47e4fa2ca409bf7dd531c8766a6ff6487b50e996f04425577c07a65667
-  data.tar.gz: 28fa32928a82d9c1df876bad8002d677bd7c7e5f0a001f56ad6170b9b87e8f2c
+  metadata.gz: c654a6d0c0772fffa33bb28544ba4e3299272b2673f8f4a138a4526a16a7f036
+  data.tar.gz: f8f2d7914dec1d9b1a39182626ba0f37736bdf2b3a618ade7f9cb1b5b204850a
 SHA512:
-  metadata.gz: df2740562388acd113084e28f50940d2bbf0d0d934abe0b8b4def515158f2bb36ba29179ae317e7cf77665039e5d77d2c15d76ef044b3e4f56f314f046882ba0
-  data.tar.gz: 77fcfa0230679ba9efc329225c6eda32f6ad915bc0bee79df227b724bc1c75ba3cb5e7b51943b1142ba36586f74d94cdeec9bc9873daa807f1e009c4c53f8e4f
+  metadata.gz: 408421ba16b44441a4be3e24c46b0ef7e31bfbcb58d6eacc229c51882c00bd2fbb2956bf16a51572f8d2fab94a9ed515bebb4e8450efdea64b1e849bcffcffb7
+  data.tar.gz: 3ef7b2f0cf92cce13760dd581ef68a59fe833ce1fe646c9c9c5476ed6163f024efad6bf67732c6f4f338bf92a2a50deed2b560c9b923605d68a2d7d482d6c539

data/CHANGELOG.md

@@ -1,3 +1,27 @@
 ## master (unreleased)
 
+## 0.2.0 (2023-10-13)
+
+- Allow to use custom reporters
+
+  ```ruby
+  class MyReporter
+    def report(title, created_records)
+      # do actual reporting
+    end
+  end
+
+  ColumnsTrace.reporter = MyReporter.new
+  ```
+
+  `ColumnsTrace.logger=` setting is removed in favor of using `ColumnsTrace.reporter=`.
+  If you configured custom logger, you should now configure it via:
+
+  ```ruby
+  logger = ActiveSupport::Logger.new("/my/custom/logger.log")
+  ColumnsTrace.reporter = ColumnsTrace::LogReporter.new(logger)
+  ```
+
+## 0.1.0 (2023-10-04)
+
 - First release

data/README.md

@@ -75,10 +75,10 @@ ColumnsTrace.configure do |config|
   #   config.ignored_columns = [:updated_at, { User => :admin }]
   config.ignored_columns = []
 
-  # The logger to log to.
-  # Defaults to logger, that outputs to `log/columns_trace.log` file
-  # when the gem is used in the Rails app.
-  config.logger = nil
+  # The reporter that is used for reporting.
+  # Defaults to log reporter that outputs to `log/columns_trace.log` file
+  # when inside a Rails application.
+  config.reporter = nil
 
   # Controls the contents of the printed backtrace.
   # Is set to the default Rails.backtrace_cleaner when the gem is used in the Rails app.
@@ -94,6 +94,31 @@ end
 ColumnsTrace.enable_sidekiq_tracing!
 ```
 
+### Custom reporters
+
+By default offenses are reported to a log reporter that outputs to `log/columns_trace.log` file
+when inside a Rails application.
+
+You can set your custom reporter by defining a class responding to `#report` method.
+
+```ruby
+class MyReporter
+  def report(title, created_records)
+    title # => "controller#action"
+    created_records # => [#<ColumnsTrace::CreatedRecord>]
+    created_records.each do |record|
+      record.model # class of ActiveRecord model
+      record.accessed_fields  # array of accessed fields
+      record.unused_fields # array of unused fields
+      record.backtrace # array of strings
+      record.record # ActiveRecord model instance
+    end
+  end
+end
+
+ColumnsTrace.reporter = MyReporter.new
+```
+
 ## Development
 
 After checking out the repo, run `bundle install` to install dependencies. Then, run `rake` to run the linter and tests.

data/lib/columns_trace/created_record.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ColumnsTrace
+  # Class that is used to store metadata about created ActiveRecord records.
+  class CreatedRecord
+    # Model class
+    # @return [Class]
+    #
+    attr_reader :model
+
+    # Model instance
+    # @return [ActiveRecord::Base]
+    #
+    attr_reader :record
+
+    # Backtrace where the instance was created
+    # @return [Array<String>]
+    #
+    attr_reader :backtrace
+
+    def initialize(record, backtrace)
+      @model = record.class
+      @record = record
+      @backtrace = backtrace
+    end
+
+    # Get accessed fields on model instance
+    # @return [Array<String>]
+    #
+    def accessed_fields
+      @accessed_fields ||= record.accessed_fields
+    end
+
+    # Get unused fields on model instance
+    # @return [Array<String>]
+    #
+    def unused_fields
+      # We need to store this into local variable, because `record.attributes`
+      # will access all attributes.
+      accessed = accessed_fields
+      record.attributes.keys - accessed
+    end
+  end
+end

data/lib/columns_trace/log_reporter.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ColumnsTrace
+  # Reporter that reports into the provided logger.
+  class LogReporter
+    def initialize(logger)
+      @logger = logger
+    end
+
+    # Main reporter's method
+    #
+    # @param title [String] title of the reporting, e.g. controller action etc
+    # @param created_records [Array<ColumnsTrace::CreatedRecord>] items that hold
+    #   metadata about created records
+    #
+    def report(title, created_records)
+      lines = []
+
+      created_records.group_by(&:model).each do |model, grouped_created_records|
+        lines.concat(lines_for_created_records(model, grouped_created_records))
+      end
+
+      if lines.any?
+        @logger.info("#{title}\n#{lines.join("\n")}")
+      end
+    end
+
+    private
+      def lines_for_created_records(model, created_records)
+        lines = []
+
+        created_records.group_by(&:backtrace).each do |backtrace, grouped_created_records|
+          accessed = accessed_fields(grouped_created_records)
+          unused = grouped_created_records.first.unused_fields - accessed
+          unused.reject! { |column| ColumnsTrace.ignored_column?(model, column) }
+
+          if unused.any?
+            records_text = "record".pluralize(grouped_created_records.size)
+            lines << <<-MSG
+  #{grouped_created_records.size} #{model.name} #{records_text}: unused columns - #{format_columns(unused)}; used columns - #{format_columns(accessed)}
+  ↳ #{backtrace.join("\n  ")}
+            MSG
+          end
+        end
+
+        lines
+      end
+
+      def accessed_fields(created_records)
+        created_records.map(&:accessed_fields).flatten.uniq
+      end
+
+      def format_columns(columns)
+        columns.map(&:inspect).join(", ")
+      end
+  end
+end

data/lib/columns_trace/rails_integration.rb

@@ -15,11 +15,17 @@ module ColumnsTrace
 
   ActiveSupport.on_load(:action_controller) do
     before_action { Registry.clear }
-    after_action { Reporter.report("#{self.class.name}##{action_name}") }
+
+    after_action do
+      ColumnsTrace.reporter.report("#{self.class.name}##{action_name}", Registry.created_records)
+    end
   end
 
   ActiveSupport.on_load(:active_job) do
     before_perform { Registry.clear }
-    after_perform { Reporter.report(self.class.name) }
+
+    after_perform do
+      ColumnsTrace.reporter.report(self.class.name, Registry.created_records)
+    end
   end
 end

data/lib/columns_trace/railtie.rb

@@ -5,7 +5,9 @@ module ColumnsTrace
   class Railtie < Rails::Railtie
     initializer "columns_trace.set_configs" do
       ColumnsTrace.backtrace_cleaner = Rails.backtrace_cleaner
-      ColumnsTrace.logger = ActiveSupport::Logger.new(Rails.root.join("log", "columns_trace.log"))
+
+      logger = ActiveSupport::Logger.new(Rails.root.join("log", "columns_trace.log"))
+      ColumnsTrace.reporter = LogReporter.new(logger)
     end
   end
 end

data/lib/columns_trace/registry.rb

@@ -4,18 +4,16 @@ module ColumnsTrace
   # @private
   # Note: can use ActiveSupport::IsolatedExecutionState instead of this module for rails 7.0+.
   module Registry
-    Entry = Struct.new(:model, :record, :backtrace)
-
     class << self
       def register(record, backtrace)
-        state << Entry.new(record.class, record, backtrace)
+        state << CreatedRecord.new(record, backtrace)
       end
 
       def clear
         state.clear
       end
 
-      def entries
+      def created_records
         state
       end
 

data/lib/columns_trace/sidekiq_integration.rb

@@ -6,7 +6,7 @@ module ColumnsTrace
     def call(worker, _job, _queue)
       Registry.clear
       yield
-      Reporter.report(worker.class.name)
+      ColumnsTrace.reporter.report(worker.class.name, Registry.created_records)
     end
   end
 end

data/lib/columns_trace/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ColumnsTrace
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/columns_trace.rb

@@ -2,9 +2,10 @@
 
 require "active_record"
 
+require_relative "columns_trace/created_record"
 require_relative "columns_trace/registry"
 require_relative "columns_trace/rails_integration"
-require_relative "columns_trace/reporter"
+require_relative "columns_trace/log_reporter"
 require_relative "columns_trace/version"
 require_relative "columns_trace/railtie" if defined?(Rails)
 
@@ -54,11 +55,11 @@ module ColumnsTrace
       end
     end
 
-    # Allows to set the logger.
-    # Defaults to logger, that outputs to `log/columns_trace.log` file
+    # Allows to set the reporter.
+    # Defaults to log reporter that outputs to `log/columns_trace.log` file
     # when inside a rails application.
     #
-    attr_accessor :logger
+    attr_accessor :reporter
 
     # @private
     attr_reader :backtrace_cleaner

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: columns_trace
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - fatkodima
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-04 00:00:00.000000000 Z
+date: 2023-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -35,10 +35,11 @@ files:
 - LICENSE.txt
 - README.md
 - lib/columns_trace.rb
+- lib/columns_trace/created_record.rb
+- lib/columns_trace/log_reporter.rb
 - lib/columns_trace/rails_integration.rb
 - lib/columns_trace/railtie.rb
 - lib/columns_trace/registry.rb
-- lib/columns_trace/reporter.rb
 - lib/columns_trace/sidekiq_integration.rb
 - lib/columns_trace/version.rb
 - test/dummy/tmp/development_secret.txt

data/lib/columns_trace/reporter.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module ColumnsTrace
-  # @private
-  class Reporter
-    def self.report(title)
-      new.report(title)
-    end
-
-    def report(title)
-      lines = []
-
-      Registry.entries.group_by(&:model).each do |model, entries|
-        lines.concat(lines_for_entries(model, entries))
-      end
-
-      if lines.any?
-        ColumnsTrace.logger.info("#{title}\n#{lines.join("\n")}")
-      end
-    end
-
-    private
-      def lines_for_entries(model, entries)
-        lines = []
-
-        entries.group_by(&:backtrace).each do |backtrace, grouped_entries|
-          records = grouped_entries.map(&:record)
-
-          accessed = accessed_fields(records)
-          unused = records.first.attributes.keys - accessed
-          unused.reject! { |column| ColumnsTrace.ignored_column?(model, column) }
-
-          if unused.any?
-            records_text = "record".pluralize(records.size)
-            lines << <<-MSG
-  #{records.size} #{model.name} #{records_text}: unused columns - #{format_columns(unused)}; used columns - #{format_columns(accessed)}
-  ↳ #{backtrace.join("\n  ")}
-            MSG
-          end
-        end
-
-        lines
-      end
-
-      def accessed_fields(records)
-        records.map(&:accessed_fields).flatten.uniq
-      end
-
-      def format_columns(columns)
-        columns.map(&:inspect).join(", ")
-      end
-  end
-end