Use zeitwerk to load gem

grape_logging.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'grape', '>= 2.4.0'
   spec.add_dependency 'rack'
+  spec.add_dependency 'zeitwerk'
 end

lib/grape_logging.rb

@@ -1,17 +1,12 @@
-require 'grape_logging/multi_io'
+require 'grape'
-require 'grape_logging/version'
+require 'rack/utils'
-require 'grape_logging/formatters/default'
+require 'zeitwerk'
-require 'grape_logging/formatters/json'
+
-require 'grape_logging/formatters/lograge'
+# load zeitwerk
-require 'grape_logging/formatters/logstash'
+Zeitwerk::Loader.for_gem.tap do |loader|
-require 'grape_logging/formatters/rails'
+  loader.inflector.inflect 'multi_io' => 'MultiIO'
-require 'grape_logging/loggers/base'
+  loader.setup
-require 'grape_logging/loggers/response'
+end
-require 'grape_logging/loggers/filter_parameters'
+
-require 'grape_logging/loggers/client_env'
+module GrapeLogging
-require 'grape_logging/loggers/request_headers'
+end
-require 'grape_logging/reporters/active_support_reporter'
-require 'grape_logging/reporters/logger_reporter'
-require 'grape_logging/timings'
-require 'grape_logging/middleware/request_logger'
-require 'grape_logging/util/parameter_filter'

lib/grape_logging/formatters/rails.rb

@@ -1,5 +1,3 @@
-require 'rack/utils'
-
 module GrapeLogging
   module Formatters
     class Rails

lib/grape_logging/loggers/filter_parameters.rb

@@ -16,7 +16,7 @@ module GrapeLogging
       private
 
       def parameter_filter
-        @parameter_filter ||= ParameterFilter.new(@replacement, @filter_parameters)
+        @parameter_filter ||= GrapeLogging::Util::ParameterFilter.new(@replacement, @filter_parameters)
       end
 
       def safe_parameters(request)

lib/grape_logging/middleware/request_logger.rb

@@ -1,5 +1,3 @@
-require 'grape'
-
 module GrapeLogging
   module Middleware
     class RequestLogger < Grape::Middleware::Base

lib/grape_logging/reporters/active_support_reporter.rb

@@ -1,11 +1,13 @@
-module Reporters
+module GrapeLogging
-  class ActiveSupportReporter
+  module Reporters
-    def initialize(instrumentation_key)
+    class ActiveSupportReporter
-      @instrumentation_key = instrumentation_key
+      def initialize(instrumentation_key)
-    end
+        @instrumentation_key = instrumentation_key
+      end
 
-    def perform(params)
+      def perform(params)
-      ActiveSupport::Notifications.instrument @instrumentation_key, params
+        ActiveSupport::Notifications.instrument @instrumentation_key, params
+      end
     end
   end
 end

lib/grape_logging/reporters/logger_reporter.rb

@@ -1,13 +1,15 @@
-module Reporters
+module GrapeLogging
-  class LoggerReporter
+  module Reporters
-    def initialize(logger, formatter, log_level)
+    class LoggerReporter
-      @logger = logger.clone || Logger.new(STDOUT)
+      def initialize(logger, formatter, log_level)
-      @log_level = log_level || :info
+        @logger = logger.clone || Logger.new(STDOUT)
-      @logger.formatter = formatter || @logger.formatter || GrapeLogging::Formatters::Default.new if @logger.respond_to?(:formatter=)
+        @log_level = log_level || :info
-    end
+        @logger.formatter = formatter || @logger.formatter || GrapeLogging::Formatters::Default.new if @logger.respond_to?(:formatter=)
+      end
 
-    def perform(params)
+      def perform(params)
-      @logger.send(@log_level, params)
+        @logger.send(@log_level, params)
+      end
     end
   end
 end

lib/grape_logging/util/parameter_filter.rb

@@ -1,101 +1,105 @@
-if defined?(Rails.application)
+module GrapeLogging
-  if Gem::Version.new(Rails.version) < Gem::Version.new('6.0.0')
+  module Util
-    class ParameterFilter < ActionDispatch::Http::ParameterFilter
+    if defined?(Rails.application)
-      def initialize(_replacement, filter_parameters)
+      if Gem::Version.new(Rails.version) < Gem::Version.new('6.0.0')
-        super(filter_parameters)
+        class ParameterFilter < ActionDispatch::Http::ParameterFilter
-      end
+          def initialize(_replacement, filter_parameters)
-    end
+            super(filter_parameters)
-  else
-    require 'active_support/parameter_filter'
-
-    class ParameterFilter < ActiveSupport::ParameterFilter
-      def initialize(_replacement, filter_parameters)
-        super(filter_parameters)
-      end
-    end
-  end
-else
-  #
-  # lifted from https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/http/parameter_filter.rb
-  # we could depend on Rails specifically, but that would us way to hefty!
-  #
-  class ParameterFilter
-    def initialize(replacement, filters = [])
-      @replacement = replacement
-      @filters = filters
-    end
-
-    def filter(params)
-      compiled_filter.call(params)
-    end
-
-    private
-
-    def compiled_filter
-      @compiled_filter ||= CompiledFilter.compile(@replacement, @filters)
-    end
-
-    class CompiledFilter # :nodoc:
-      def self.compile(replacement, filters)
-        return ->(params) { params.dup } if filters.empty?
-
-        strings = []
-        regexps = []
-        blocks = []
-
-        filters.each do |item|
-          case item
-          when Proc
-            blocks << item
-          when Regexp
-            regexps << item
-          else
-            strings << Regexp.escape(item.to_s)
           end
         end
+      else
+        require 'active_support/parameter_filter'
 
-        deep_regexps, regexps = regexps.partition { |r| r.to_s.include?('\\.'.freeze) }
+        class ParameterFilter < ActiveSupport::ParameterFilter
-        deep_strings, strings = strings.partition { |s| s.include?('\\.'.freeze) }
+          def initialize(_replacement, filter_parameters)
-
+            super(filter_parameters)
-        regexps << Regexp.new(strings.join('|'.freeze), true) unless strings.empty?
-        deep_regexps << Regexp.new(deep_strings.join('|'.freeze), true) unless deep_strings.empty?
-
-        new replacement, regexps, deep_regexps, blocks
-      end
-
-      attr_reader :regexps, :deep_regexps, :blocks
-
-      def initialize(replacement, regexps, deep_regexps, blocks)
-        @replacement = replacement
-        @regexps = regexps
-        @deep_regexps = deep_regexps.any? ? deep_regexps : nil
-        @blocks = blocks
-      end
-
-      def call(original_params, parents = [])
-        filtered_params = {}
-
-        original_params.each do |key, value|
-          parents.push(key) if deep_regexps
-          if regexps.any? { |r| key =~ r }
-            value = @replacement
-          elsif deep_regexps && (joined = parents.join('.')) && deep_regexps.any? { |r| joined =~ r }
-            value = @replacement
-          elsif value.is_a?(Hash)
-            value = call(value, parents)
-          elsif value.is_a?(Array)
-            value = value.map { |v| v.is_a?(Hash) ? call(v, parents) : v }
-          elsif blocks.any?
-            key = key.dup if key.duplicable?
-            value = value.dup if value.duplicable?
-            blocks.each { |b| b.call(key, value) }
           end
-          parents.pop if deep_regexps
+        end
-
+      end
-          filtered_params[key] = value
+    else
+      #
+      # lifted from https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/http/parameter_filter.rb
+      # we could depend on Rails specifically, but that would us way to hefty!
+      #
+      class ParameterFilter
+        def initialize(replacement, filters = [])
+          @replacement = replacement
+          @filters = filters
         end
 
-        filtered_params
+        def filter(params)
+          compiled_filter.call(params)
+        end
+
+        private
+
+        def compiled_filter
+          @compiled_filter ||= CompiledFilter.compile(@replacement, @filters)
+        end
+
+        class CompiledFilter # :nodoc:
+          def self.compile(replacement, filters)
+            return ->(params) { params.dup } if filters.empty?
+
+            strings = []
+            regexps = []
+            blocks = []
+
+            filters.each do |item|
+              case item
+              when Proc
+                blocks << item
+              when Regexp
+                regexps << item
+              else
+                strings << Regexp.escape(item.to_s)
+              end
+            end
+
+            deep_regexps, regexps = regexps.partition { |r| r.to_s.include?('\\.'.freeze) }
+            deep_strings, strings = strings.partition { |s| s.include?('\\.'.freeze) }
+
+            regexps << Regexp.new(strings.join('|'.freeze), true) unless strings.empty?
+            deep_regexps << Regexp.new(deep_strings.join('|'.freeze), true) unless deep_strings.empty?
+
+            new replacement, regexps, deep_regexps, blocks
+          end
+
+          attr_reader :regexps, :deep_regexps, :blocks
+
+          def initialize(replacement, regexps, deep_regexps, blocks)
+            @replacement = replacement
+            @regexps = regexps
+            @deep_regexps = deep_regexps.any? ? deep_regexps : nil
+            @blocks = blocks
+          end
+
+          def call(original_params, parents = [])
+            filtered_params = {}
+
+            original_params.each do |key, value|
+              parents.push(key) if deep_regexps
+              if regexps.any? { |r| key =~ r }
+                value = @replacement
+              elsif deep_regexps && (joined = parents.join('.')) && deep_regexps.any? { |r| joined =~ r }
+                value = @replacement
+              elsif value.is_a?(Hash)
+                value = call(value, parents)
+              elsif value.is_a?(Array)
+                value = value.map { |v| v.is_a?(Hash) ? call(v, parents) : v }
+              elsif blocks.any?
+                key = key.dup if key.duplicable?
+                value = value.dup if value.duplicable?
+                blocks.each { |b| b.call(key, value) }
+              end
+              parents.pop if deep_regexps
+
+              filtered_params[key] = value
+            end
+
+            filtered_params
+          end
+        end
       end
     end
   end