grape_logging 1.8.4 → 3.0.0

data/RELEASING.md

@@ -0,0 +1,113 @@
+# Releasing grape_logging
+
+There're no particular rules about when to release grape_logging. Release bug fixes frequently, features not so frequently and breaking API changes rarely.
+
+### Pre-flight Checks
+
+Run tests, check that all tests succeed locally.
+
+```
+bundle install
+rake
+```
+
+Check that the last build succeeded in [GitHub Actions](https://github.com/aserafin/grape_logging/actions) for all supported platforms.
+
+### Update Changelog
+
+Change "Unreleased" in [CHANGELOG.md](https://github.com/aserafin/grape_logging/blob/master/CHANGELOG.md) to the new version and date:
+
+```
+## [1.8.5] - 2024-06-28
+
+### Changed
+- Description of changes
+
+### Fixed
+- Description of fixes
+
+### Added
+- Description of additions
+
+[1.8.5]: https://github.com/aserafin/grape_logging/compare/v1.8.4...v1.8.5
+```
+
+Remove the line with "Your contribution here.", since there will be no more contributions to this release.
+
+Only include the sections (Changed, Fixed, Added, etc.) that have actual changes.
+
+Commit your changes.
+
+```shell
+git add CHANGELOG.md lib/grape_logging/version.rb
+git commit -m "Preparing for release, 1.8.5."
+git push
+```
+
+### Release on RubyGems and GitHub
+
+#### Option 1: Automated (Recommended)
+
+Use the combined task that releases the gem and creates a GitHub release:
+
+```shell
+rake github_release
+```
+
+This will:
+1. Build and push the gem to RubyGems
+2. Create and push the git tag
+3. Create a GitHub release with auto-generated changelog
+
+#### Option 2: Manual
+
+First, release the gem:
+
+```shell
+rake release
+```
+
+Output will look something like:
+```
+grape_logging 1.8.5 built to pkg/grape_logging-1.8.5.gem.
+Tagged v1.8.5.
+Pushed git commits and tags.
+Pushed grape_logging 1.8.5 to rubygems.org.
+```
+
+Then create the GitHub release on the web or using `gh`:
+
+```
+gh release create v1.8.5 --generate-notes --verify-tag
+```
+
+This uses GitHub's automatic changelog generation feature to create release notes from merged pull requests and commits since the last release.
+
+### Prepare for the Next Version
+
+Modify `lib/grape_logging/version.rb`, increment the version number (eg. change `1.8.5` to `1.8.6`).
+
+```ruby
+module GrapeLogging
+  VERSION = '1.8.6'.freeze
+end
+```
+
+Add the next release to [CHANGELOG.md](https://github.com/aserafin/grape_logging/blob/master/CHANGELOG.md).
+
+```
+## [1.8.6] - Unreleased
+
+### Changed or Fixed or Added
+- Your contribution here.
+
+[1.8.6]: https://github.com/aserafin/grape_logging/compare/v1.8.5...master
+```
+
+Commit your changes.
+
+```
+git add CHANGELOG.md lib/grape_logging/version.rb
+git commit -m "Bump version to 1.8.6."
+git push
+```

data/Rakefile

@@ -1,2 +1,43 @@
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = ['-fd -c']
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RuboCop::RakeTask.new(:rubocop) do |t|
+  t.patterns = ['lib/**/*.rb', 'spec/**/*.rb', 'Rakefile', 'Gemfile', 'grape_logging.gemspec']
+end
+
+task default: %i[spec rubocop]
+
+desc 'Release gem and create GitHub release'
+task github_release: :release do
+  require 'grape_logging/version'
+
+  version = "v#{GrapeLogging::VERSION}"
+
+  # Check if gh CLI is available
+  unless system('which gh > /dev/null 2>&1')
+    puts "\n⚠️  GitHub CLI (gh) not found"
+    puts 'To create a GitHub release with auto-generated changelog, install gh:'
+    puts '  brew install gh  # macOS with Homebrew'
+    puts '  # or visit: https://github.com/cli/cli#installation'
+    puts "\nYou can manually create the release with:"
+    puts "  gh release create v#{GrapeLogging::VERSION} --generate-notes"
+    next
+  end
+
+  # Create GitHub release
+  puts "\nCreating GitHub release #{version}..."
+
+  if system('gh', 'release', 'create', version, '--generate-notes', '--verify-tag')
+    puts "✅ GitHub release #{version} created successfully"
+  else
+    puts '❌ Failed to create GitHub release'
+    puts 'You can manually create it with:'
+    puts "  gh release create '#{version}' --generate-notes --verify-tag"
+  end
+end

data/grape_logging.gemspec

@@ -1,29 +1,32 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'grape_logging/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'grape_logging'
   spec.version       = GrapeLogging::VERSION
-  spec.authors       = ['aserafin']
-  spec.email         = ['adrian@softmad.pl']
+  spec.authors       = ['aserafin', 'Sami Samhuri']
+  spec.email         = ['adrian@softmad.pl', 'sami@samhuri.net']
 
-  spec.summary       = %q{Out of the box request logging for Grape!}
-  spec.description   = %q{This gem provides simple request logging for Grape with just few lines of code you have to put in your project! In return you will get response codes, paths, parameters and more!}
+  spec.summary       = 'Out of the box request logging for Grape!'
+  spec.description   = 'This gem provides simple request logging for Grape with just few lines ' \
+                       'of code you have to put in your project! In return you will get response ' \
+                       'codes, paths, parameters and more!'
   spec.homepage      = 'http://github.com/aserafin/grape_logging'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'grape'
+  spec.add_dependency 'grape', '>= 2.4.0'
   spec.add_dependency 'rack'
 
-  spec.add_development_dependency 'bundler', '~> 1.8'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 13.3'
   spec.add_development_dependency 'rspec', '~> 3.5'
-  spec.add_development_dependency 'pry-byebug', '~> 3.4.2'
+
+  # This is pinned to an exact version otherwise we can't know which rules
+  # are in play at any given time in different environments.
+  spec.add_development_dependency 'rubocop', '1.77.0'
 end

data/lib/grape_logging/formatters/default.rb

@@ -18,6 +18,7 @@ module GrapeLogging
       end
 
       private
+
       def format_hash(hash)
         hash.keys.sort.map { |key| "#{key}=#{hash[key]}" }.join(' ')
       end

data/lib/grape_logging/formatters/logstash.rb

@@ -3,9 +3,9 @@ module GrapeLogging
     class Logstash
       def call(severity, datetime, _, data)
         {
-          :'@timestamp' => datetime.iso8601,
-          :'@version' => '1',
-          :severity => severity
+          '@timestamp': datetime.iso8601,
+          '@version': '1',
+          severity: severity
         }.merge!(format(data)).to_json + "\n"
       end
 

data/lib/grape_logging/formatters/rails.rb

@@ -3,7 +3,6 @@ require 'rack/utils'
 module GrapeLogging
   module Formatters
     class Rails
-
       def call(severity, datetime, _, data)
         if data.is_a?(String)
           "#{severity[0..0]} [#{datetime}] #{severity} -- : #{data}\n"
@@ -24,7 +23,7 @@ module GrapeLogging
         [
           "#{exception.message} (#{exception.class})",
           backtrace_array.join("\n")
-        ].reject{|line| line == ""}.join("\n")
+        ].reject { |line| line == '' }.join("\n")
       end
 
       def format_hash(hash)
@@ -32,7 +31,7 @@ module GrapeLogging
         # Completed 200 OK in 958ms (Views: 951.1ms | ActiveRecord: 3.8ms)
         # See: actionpack/lib/action_controller/log_subscriber.rb
 
-        message = ""
+        message = ''
         additions = []
         status = hash.delete(:status)
         params = hash.delete(:params)
@@ -47,13 +46,12 @@ module GrapeLogging
         message << "  Parameters: #{params.inspect}\n" if params
 
         message << "Completed #{status} #{::Rack::Utils::HTTP_STATUS_CODES[status]} in #{total_time}ms"
-        message << " (#{additions.join(" | ".freeze)})" if additions.size > 0
+        message << " (#{additions.join(' | '.freeze)})" unless additions.empty?
         message << "\n"
         message << "\n" if defined?(::Rails.env) && ::Rails.env.development?
 
         message
       end
-
     end
   end
 end

data/lib/grape_logging/loggers/base.rb

@@ -1,7 +1,7 @@
 module GrapeLogging
   module Loggers
     class Base
-      def parameters(request, response)
+      def parameters(_request, _response)
         {}
       end
     end

data/lib/grape_logging/loggers/client_env.rb

@@ -2,7 +2,7 @@ module GrapeLogging
   module Loggers
     class ClientEnv < GrapeLogging::Loggers::Base
       def parameters(request, _)
-        { ip: request.env["HTTP_X_FORWARDED_FOR"] || request.env["REMOTE_ADDR"], ua: request.env["HTTP_USER_AGENT"] }
+        { ip: request.env['HTTP_X_FORWARDED_FOR'] || request.env['REMOTE_ADDR'], ua: request.env['HTTP_USER_AGENT'] }
       end
     end
   end

data/lib/grape_logging/loggers/filter_parameters.rb

@@ -3,7 +3,7 @@ module GrapeLogging
     class FilterParameters < GrapeLogging::Loggers::Base
       AD_PARAMS = 'action_dispatch.request.parameters'.freeze
 
-      def initialize(filter_parameters = nil, replacement = nil, exceptions = %w(controller action format))
+      def initialize(filter_parameters = nil, replacement = nil, exceptions = %w[controller action format])
         @filter_parameters = filter_parameters || (defined?(::Rails.application) ? ::Rails.application.config.filter_parameters : [])
         @replacement = replacement || '[FILTERED]'
         @exceptions = exceptions
@@ -29,7 +29,25 @@ module GrapeLogging
       end
 
       def clean_parameters(parameters)
-        parameter_filter.filter(parameters).reject{ |key, _value| @exceptions.include?(key) }
+        original_encoding_map = build_encoding_map(parameters)
+        params = transform_key_encoding(parameters, Hash.new { |h, _| [Encoding::ASCII_8BIT, h] })
+        cleaned_params = parameter_filter.filter(params).reject { |key, _value| @exceptions.include?(key) }
+        transform_key_encoding(cleaned_params, original_encoding_map)
+      end
+
+      def build_encoding_map(parameters)
+        parameters.each_with_object({}) do |(k, v), h|
+          key_str = k.to_s
+          h[key_str.dup.force_encoding(Encoding::ASCII_8BIT)] = [key_str.encoding, v.is_a?(Hash) ? build_encoding_map(v) : nil]
+        end
+      end
+
+      def transform_key_encoding(parameters, encoding_map)
+        parameters.each_with_object({}) do |(k, v), h|
+          key_str = k.to_s
+          encoding, children_encoding_map = encoding_map[key_str]
+          h[key_str.dup.force_encoding(encoding)] = v.is_a?(Hash) ? transform_key_encoding(v, children_encoding_map) : v
+        end
       end
     end
   end

data/lib/grape_logging/loggers/request_headers.rb

@@ -1,7 +1,6 @@
 module GrapeLogging
   module Loggers
     class RequestHeaders < GrapeLogging::Loggers::Base
-
       HTTP_PREFIX = 'HTTP_'.freeze
 
       def parameters(request, _)
@@ -16,7 +15,6 @@ module GrapeLogging
 
         { headers: headers }
       end
-
     end
   end
 end

data/lib/grape_logging/loggers/response.rb

@@ -9,14 +9,13 @@ module GrapeLogging
 
       # In some cases, response.body is not parseable by JSON.
       # For example, if you POST on a PUT endpoint, response.body is egal to """".
-      # It's strange but it's the Grape behavior...
+      # It's strange, but it's the Grape behavior...
       def serialized_response_body(response)
-
         if response.respond_to?(:body)
           # Rack responses
           begin
-            response.body.map{ |body| JSON.parse(body.to_s) }
-          rescue # No reason to have "=> e" here when we don't use it..
+            response.body.map { |body| JSON.parse(body.to_s) }
+          rescue StandardError # No reason to have "=> e" here when we don't use it..
             response.body
           end
         else

data/lib/grape_logging/middleware/request_logger.rb

@@ -1,27 +1,29 @@
-require 'grape/middleware/base'
+require 'grape'
 
 module GrapeLogging
   module Middleware
     class RequestLogger < Grape::Middleware::Base
-
-      ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
-        event = ActiveSupport::Notifications::Event.new(*args)
-        GrapeLogging::Timings.append_db_runtime(event)
-      end if defined?(ActiveRecord)
+      if defined?(ActiveRecord)
+        ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
+          event = ActiveSupport::Notifications::Event.new(*args)
+          GrapeLogging::Timings.append_db_runtime(event)
+        end
+      end
 
       # Persist response status & response (body)
       # to use int in parameters
       attr_accessor :response_status, :response_body
 
-      def initialize(app, options = {})
+      def initialize(app, **options)
         super
 
         @included_loggers = @options[:include] || []
-        @reporter = if options[:instrumentation_key]
-          Reporters::ActiveSupportReporter.new(@options[:instrumentation_key])
-        else
-          Reporters::LoggerReporter.new(@options[:logger], @options[:formatter], @options[:log_level])
-        end
+        @reporter =
+          if options[:instrumentation_key]
+            Reporters::ActiveSupportReporter.new(@options[:instrumentation_key])
+          else
+            Reporters::LoggerReporter.new(@options[:logger], @options[:formatter], @options[:log_level])
+          end
       end
 
       def before
@@ -37,7 +39,7 @@ module GrapeLogging
         @response_status = status
         @response_body   = response
 
-        # Perform repotters
+        # Perform reporters
         @reporter.perform(collect_parameters)
 
         # Invoke loggers
@@ -56,20 +58,18 @@ module GrapeLogging
 
         # Catch error
         error = catch(:error) do
-          begin
-            @app_response = @app.call(@env)
-          rescue => e
-            # Log as 500 + message
-            after(e.respond_to?(:status) ? e.status : 500, e.message)
-
-            # Re-raise exception
-            raise e
-          end
+          @app_response = @app.call(@env)
           nil
+        rescue StandardError => e
+          # Log as 500 + message
+          after(e.respond_to?(:status) ? e.status : 500, e.message)
+
+          # Re-raise exception
+          raise e
         end
 
         # Get status & response from app_response
-        # when no error occures.
+        # when no error occurs.
         if error
           # Call with error & response
           after(error[:status], error[:message])
@@ -100,7 +100,8 @@ module GrapeLogging
           method: request.request_method,
           path: request.path,
           params: request.params,
-          host: request.host
+          host: request.host,
+          request_id: env['action_dispatch.request_id']
         }
       end
 
@@ -115,7 +116,7 @@ module GrapeLogging
       end
 
       def view_runtime
-        total_runtime - db_runtime
+        (total_runtime - db_runtime).round(2)
       end
 
       def db_runtime

data/lib/grape_logging/multi_io.rb

@@ -5,11 +5,11 @@ module GrapeLogging
     end
 
     def write(*args)
-      @targets.each {|t| t.write(*args)}
+      @targets.each { |t| t.write(*args) }
     end
 
     def close
       @targets.each(&:close)
     end
   end
-end
+end

data/lib/grape_logging/reporters/active_support_reporter.rb

@@ -8,4 +8,4 @@ module Reporters
       ActiveSupport::Notifications.instrument @instrumentation_key, params
     end
   end
-end
+end

data/lib/grape_logging/reporters/logger_reporter.rb

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

data/lib/grape_logging/timings.rb

@@ -1,21 +1,19 @@
 module GrapeLogging
   module Timings
-    extend self
-
-    def db_runtime=(value)
+    def self.db_runtime=(value)
       Thread.current[:grape_db_runtime] = value
     end
 
-    def db_runtime
+    def self.db_runtime
       Thread.current[:grape_db_runtime] ||= 0
     end
 
-    def reset_db_runtime
+    def self.reset_db_runtime
       self.db_runtime = 0
     end
 
-    def append_db_runtime(event)
+    def self.append_db_runtime(event)
       self.db_runtime += event.duration
     end
   end
-end
+end

data/lib/grape_logging/util/parameter_filter.rb

@@ -1,4 +1,4 @@
-if defined?(::Rails.application)
+if defined?(Rails.application)
   if Gem::Version.new(Rails.version) < Gem::Version.new('6.0.0')
     class ParameterFilter < ActionDispatch::Http::ParameterFilter
       def initialize(_replacement, filter_parameters)
@@ -6,7 +6,7 @@ if defined?(::Rails.application)
       end
     end
   else
-    require "active_support/parameter_filter"
+    require 'active_support/parameter_filter'
 
     class ParameterFilter < ActiveSupport::ParameterFilter
       def initialize(_replacement, filter_parameters)
@@ -37,9 +37,11 @@ else
 
     class CompiledFilter # :nodoc:
       def self.compile(replacement, filters)
-        return lambda { |params| params.dup } if filters.empty?
+        return ->(params) { params.dup } if filters.empty?
 
-        strings, regexps, blocks = [], [], []
+        strings = []
+        regexps = []
+        blocks = []
 
         filters.each do |item|
           case item
@@ -52,8 +54,8 @@ else
           end
         end
 
-        deep_regexps, regexps = regexps.partition { |r| r.to_s.include?("\\.".freeze) }
-        deep_strings, strings = strings.partition { |s| s.include?("\\.".freeze) }
+        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?
@@ -67,7 +69,7 @@ else
         @replacement = replacement
         @regexps = regexps
         @deep_regexps = deep_regexps.any? ? deep_regexps : nil
-        @blocks  = blocks
+        @blocks = blocks
       end
 
       def call(original_params, parents = [])

data/lib/grape_logging/version.rb

@@ -1,3 +1,3 @@
 module GrapeLogging
-  VERSION = '1.8.4'
+  VERSION = '3.0.0'
 end