grape_rails_logger 1.2.2 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4483b69705ac60afc5e74a55a4b1d865ba08c6569e449cb2e7fcc9b82e8e449
-  data.tar.gz: d54444fd7424e615b480ca6bf85346eb3afef76d07f57991b5f342a8b7d79f39
+  metadata.gz: 1309874132392d9a8663be8cdbcb56a4ce095d1e99773ba1ec520e8efa1f85e3
+  data.tar.gz: c831b29fd58a6a7128c351ea6cc99031a3ef24129c57d1ec03620fcd92628ba9
 SHA512:
-  metadata.gz: 9c92013348863f50c25ed04f6c1c0141dc1b0b2fe6f73d4713cc2ba3ae0476beda731d5a8e0f9daa7fe7937f98fd07570483a3d9bdf1f30828b80c4a13496f7b
-  data.tar.gz: 4b95fcc595e37b91076965409651fc453cd112d16414c328ac20ab5daab090cade361f3836199ec351c9de1fddd091d4c05a7800dbde06f4ca26e1b79b2a378a
+  metadata.gz: 739fb2ea500a4dcd09361b109a6c40812c4b986ab4025892d9413460f63eb92f62c28b57537337a4eacbb0b783a79a224ea47f281623d5452c0f2fcbd30ed839
+  data.tar.gz: 20a22a11f028bf57eaeb8463906ecc5628baa59e8a059a58099b94a5ef5a4bc0a72b23187d115b06f572c86a17952ce8d9e45d979b4dd28d422c3af2b947031a

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # CHANGELOG
 
+## 1.2.4 (2026-11-07)
+
+- Cache `ActiveSupport::ParameterFilter` (and legacy `ParameterFilter`) per `filter_parameters` configuration
+- Use shallow param copy for flat hashes before in-place filtering; keep `deep_dup` when nested structures are present
+- Speed request log build: `nested_param_structure?` fast path, frozen downcased filter tokens, `PARAM_EXCEPTIONS` hash lookup, local `payload` in `build_log_data`
+- In `Timings.record_sql_notification`, derive duration from notification args without allocating `Event` when the payload matches the usual five-argument AS::Notifications shape
+
+## 1.2.3 (2026-11-03)
+
+- Keep tracing and request instrumentation from dispatching a failed request more than once
+- Return false from `safe_log` / `log_data` when the logger write fails or no logger exists
+- Filter manual params by key only; expand key patterns toward Rails `filter_parameters` defaults
+- Prefer `#status` over `#to_a` when reading a non-Array Rack response status
+- Skip `ActiveSupport::Notifications::Event` allocation for SQL outside an active Grape request
+- Fail closed when release confirmation input reaches EOF
+- Require a CHANGELOG version heading before release; run tests on pull requests to `main`
+
 ## 1.2.2 (2026-09-15)
 
 - Allow grape 4.x by expanding the runtime dependency to `< 5.0`

data/README.md

@@ -1,15 +1,9 @@
 # grape_rails_logger
 
-[![Gem Version](https://badge.fury.io/rb/grape_rails_logger.svg?v=1.1.0)](https://badge.fury.io/rb/grape_rails_logger) [![Test Status](https://github.com/amkisko/grape_rails_logger.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/grape_rails_logger.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/grape_rails_logger.rb/graph/badge.svg?token=RC5T0Y2Z5A)](https://app.codecov.io/github/amkisko/grape_rails_logger.rb)
+[![Gem Version](https://badge.fury.io/rb/grape_rails_logger.svg?v=1.2.4)](https://badge.fury.io/rb/grape_rails_logger) [![Test Status](https://github.com/amkisko/grape_rails_logger.rb/actions/workflows/test.yml/badge.svg)](https://github.com/amkisko/grape_rails_logger.rb/actions/workflows/test.yml) [![codecov](https://codecov.io/gh/amkisko/grape_rails_logger.rb/graph/badge.svg?token=RC5T0Y2Z5A)](https://app.codecov.io/github/amkisko/grape_rails_logger.rb)
 
 Rails-compatible structured logging for Grape APIs with ActiveRecord timing, parameter filtering, and exception tracking.
 
-Sponsored by [Kisko Labs](https://www.kiskolabs.com).
-
-<a href="https://www.kiskolabs.com">
-  <img src="kisko.svg" width="200" alt="Sponsored by Kisko Labs" />
-</a>
-
 ## Installation
 
 Add to your Gemfile:
@@ -22,7 +16,7 @@ Run `bundle install` or `gem install grape_rails_logger`.
 
 ## Usage
 
-The gem works automatically in Rails applications. No configuration needed. It automatically patches `Grape::Endpoint#build_stack` to instrument requests and subscribes to `grape.request` notifications, logging structured data via `Rails.logger`. Works with any Rails logger or integrates with `activesupport-json_logging` for JSON output.
+In a Rails app, adding the gem is enough. The Railtie patches `Grape::Endpoint#build_stack`, subscribes to `grape.request`, and writes structured data through `Rails.logger`. Any Rails logger works; pair with `activesupport-json_logging` for JSON lines.
 
 ## What gets logged
 
@@ -30,7 +24,7 @@ Each request logs structured data with:
 - Request metadata: `method`, `path`, `status`, `duration`, `host`, `remote_addr`, `request_id`
 - Route information: `controller`, `action`, `source_location` (file:line)
 - Performance metrics: `duration` (ms), `db` (ActiveRecord query time in ms), `db_calls` (SQL query count)
-- Parameters: `params` (automatically filtered using Rails `filter_parameters`)
+- Parameters: `params` (filtered with Rails `filter_parameters`)
 - Exceptions: `exception` object with `class`, `message`, and `backtrace` (non-production only)
 
 ## Configuration
@@ -43,11 +37,11 @@ Rails.application.config.filter_parameters += [
 ]
 ```
 
-When Rails `ParameterFilter` is not available, the gem falls back to manual filtering that detects sensitive patterns (password, secret, token, key) in parameter keys.
+When Rails `ParameterFilter` is not available, the gem falls back to manual key filtering with patterns aligned to those defaults (`passw`, `secret`, `token`, `_key`, `crypt`, `salt`, `certificate`, `otp`, `ssn`, `authorization`).
 
 ## Debug tracing
 
-Optional `DebugTracer` middleware provides detailed request tracing when the `debug` gem is installed and `TRACE` environment variable is set:
+Optional `DebugTracer` middleware traces requests when the `debug` gem is present and `TRACE` is set:
 
 ```ruby
 class API < Grape::API
@@ -55,22 +49,22 @@ class API < Grape::API
 end
 ```
 
-Enable tracing: `TRACE=1 rails server`. The middleware gracefully degrades if the `debug` gem is not installed.
+Enable tracing: `TRACE=1 rails server`. Without the `debug` gem, the middleware does not start a tracer.
 
 ## Compatibility
 
-- Rails 6.0, 6.1, 7.0, 7.1, 7.2, 8.0+
-- Grape >= 1.6
-- Ruby >= 2.7
+- Rails 7.0, 7.1, 7.2, 8.0+
+- Grape >= 1.6, < 5.0
+- Ruby >= 3.4
 
-In Rails 7.1+, the gem uses `ActiveSupport::IsolatedExecutionState` for improved thread/Fiber safety. In Rails 6-7.0, it falls back to `Thread.current`.
+In Rails 7.1+, request state uses `ActiveSupport::IsolatedExecutionState`. On Rails 7.0, it uses `Thread.current`.
 
 ## Development
 
 ```bash
 bundle install
 bundle exec appraisal generate
-bundle exec rspec
+bundle exec polyrun parallel-rspec --workers 5 --merge-failures
 bin/appraisals
 bundle exec standardrb --fix
 ```
@@ -120,3 +114,11 @@ usr/bin/release.rb
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Sponsors
+
+Sponsored by [Kisko Labs](https://www.kiskolabs.com).
+
+<a href="https://www.kiskolabs.com">
+  <img src="kisko.svg" width="200" alt="Sponsored by Kisko Labs" />
+</a>

data/lib/grape_rails_logger/debug_tracer.rb

@@ -20,11 +20,6 @@ module GrapeRailsLogger
       trace_request(env) do
         @app.call(env)
       end
-    rescue => e
-      # If tracing fails for any reason, log and pass through
-      # Never break the request flow
-      log_trace_error(e)
-      @app.call(env)
     end
 
     private
@@ -41,19 +36,31 @@ module GrapeRailsLogger
       file_prefix = sanitize_file_prefix(request_method, request_path)
       context = [request_method, request_path].compact.join(" ")
 
-      Debug.new(
-        with_sql: true,
-        with_stack: false,
-        store_file: true,
-        file_prefix: file_prefix,
-        context: context
-      ).trace do
+      downstream_started = false
+      downstream_completed = false
+      downstream_response = nil
+
+      begin
+        Debug.new(
+          with_sql: true,
+          with_stack: false,
+          store_file: true,
+          file_prefix: file_prefix,
+          context: context
+        ).trace do
+          downstream_started = true
+          downstream_response = yield
+          downstream_completed = true
+          downstream_response
+        end
+        downstream_response
+      rescue => e
+        log_trace_error(e)
+        raise if downstream_started && !downstream_completed
+        return downstream_response if downstream_completed
+
         yield
       end
-    rescue => e
-      # If Debug.new or trace fails, log and continue without tracing
-      log_trace_error(e)
-      yield
     end
 
     def sanitize_file_prefix(method, path)

data/lib/grape_rails_logger/endpoint_wrapper.rb

@@ -20,6 +20,8 @@ module GrapeRailsLogger
 
       logger = resolve_logger
       downstream_response = nil
+      downstream_started = false
+      downstream_completed = false
 
       Timings.track_grape_request do
         # Wrap the entire request in ActiveSupport::Notifications
@@ -28,7 +30,9 @@ module GrapeRailsLogger
           # Call the wrapped app - Error middleware will process exceptions and return final response
           # NOTE: We do NOT read the body here - Grape will process it and parse params
           # We'll extract params later from already-parsed sources (endpoint.request.params)
+          downstream_started = true
           downstream_response = @app.call(env)
+          downstream_completed = true
 
           # NOW collect all data AFTER Error middleware has processed exceptions
           # At this point, response contains the final Rack response with correct status
@@ -41,7 +45,8 @@ module GrapeRailsLogger
       end
     rescue => e
       handle_instrumentation_error(e)
-      return downstream_response if downstream_response
+      return downstream_response if downstream_completed
+      raise if downstream_started
 
       @app.call(env)
     end
@@ -86,11 +91,11 @@ module GrapeRailsLogger
 
       if response.is_a?(Array) && response[0].is_a?(Integer)
         response[0]
+      elsif response.respond_to?(:status) && response.status.is_a?(Integer)
+        response.status
       elsif response.respond_to?(:to_a)
         array = response.to_a
         array[0] if array.is_a?(Array) && array[0].is_a?(Integer)
-      elsif response.respond_to?(:status) && response.status.is_a?(Integer)
-        response.status
       end
     end
 

data/lib/grape_rails_logger/railtie.rb

@@ -20,7 +20,7 @@ if defined?(Rails) && defined?(Rails::Railtie)
         # Only subscribe if ActiveRecord is loaded (optional dependency)
         if defined?(ActiveRecord)
           ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-            GrapeRailsLogger::Timings.append_db_runtime(ActiveSupport::Notifications::Event.new(*args))
+            GrapeRailsLogger::Timings.record_sql_notification(*args)
           rescue => e
             # Never let DB timing errors break anything
             # Only warn in development to avoid noise in production

data/lib/grape_rails_logger/subscriber.rb

@@ -7,6 +7,9 @@ module GrapeRailsLogger
   # This class is designed to be exception-safe: any error in logging
   # is caught and logged separately, never breaking the request flow.
   class GrapeRequestLogSubscriber
+    API_ENDPOINT_ENV_KEY = Grape::Env::API_ENDPOINT
+    EMPTY_HASH = {}.freeze
+
     # Custom error class to distinguish logging errors from other errors
     class LoggingError < StandardError
       attr_reader :original_error
@@ -17,26 +20,35 @@ module GrapeRailsLogger
       end
     end
 
-    FILTERED_PARAMS = %w[password secret token key].freeze
+    # Key substrings aligned with Rails filter_parameters defaults (key-only; values pass through).
+    FILTERED_PARAMS = %w[passw secret token _key crypt salt certificate otp ssn authorization].freeze
+    FILTERED_PARAMS_LOWER = FILTERED_PARAMS.map(&:downcase).freeze
     PARAM_EXCEPTIONS = %w[controller action format].freeze
+    PARAM_EXCEPTIONS_EXCLUDE = PARAM_EXCEPTIONS.each_with_object({}) { |k, h| h[k] = true }.freeze
+
+    def initialize
+      super
+      @parameter_filter_config = nil
+      @parameter_filter = nil
+    end
 
     def grape_request(event)
       return unless event.is_a?(ActiveSupport::Notifications::Event)
 
-      env = event.payload[:env]
+      payload = event.payload
+      env = payload[:env]
       return unless env.is_a?(Hash)
 
-      # Get logger from event payload (passed from middleware)
-      logger = event.payload[:logger]
+      logger = payload[:logger]
 
       logged_successfully = false
       begin
-        endpoint = env[Grape::Env::API_ENDPOINT] if env.is_a?(Hash)
+        endpoint = env[API_ENDPOINT_ENV_KEY]
         request = (endpoint&.respond_to?(:request) && endpoint.request) ? endpoint.request : nil
 
         data = build_log_data(event, request, env)
-        logged_successfully = log_data(data, event.payload[:exception_object], logger)
-        event.payload[:logged_successfully] = true if logged_successfully
+        logged_successfully = log_data(data, payload[:exception_object], logger)
+        payload[:logged_successfully] = true if logged_successfully
       rescue LoggingError
         # If logging itself failed, don't try to log again (would cause infinite loop or duplicates)
         # The error was already logged in safe_log's rescue block
@@ -59,18 +71,22 @@ module GrapeRailsLogger
     end
 
     def build_log_data(event, request, env)
-      db_runtime = event.payload[:db_runtime] || 0
-      db_calls = event.payload[:db_calls] || 0
+      payload = event.payload
+      db_runtime = payload[:db_runtime] || 0
+      db_calls = payload[:db_calls] || 0
       total_runtime = begin
         event.duration || 0
       rescue
         0
       end
 
-      status = extract_status(event) || (event.payload[:exception_object] ? 500 : 200)
+      exception_object = payload[:exception_object]
+      status = extract_status(event) || (exception_object ? 500 : 200)
       rails_request = rails_request_for(env)
       method = request ? safe_string(request.request_method) : safe_string(env["REQUEST_METHOD"])
       path = request ? safe_string(request.path) : safe_string(env["PATH_INFO"] || env["REQUEST_URI"])
+      duration_q = total_runtime.round(2)
+      db_q = db_runtime.round(2)
 
       {
         method: method,
@@ -83,9 +99,9 @@ module GrapeRailsLogger
         host: extract_host(rails_request, request),
         remote_addr: extract_remote_addr(rails_request, request),
         request_id: extract_request_id(rails_request, env),
-        duration: total_runtime.round(2),
-        db: db_runtime.round(2),
-        db_calls: db_calls,
+        duration: duration_q,
+        db: db_q,
+        db_calls: Integer(db_calls),
         params: filter_params(extract_params(request, env))
       }
     end
@@ -134,12 +150,6 @@ module GrapeRailsLogger
       else
         safe_log(:info, data, logger)
       end
-      # Mark that we successfully logged to prevent fallback from duplicating
-      true
-    rescue => e
-      # If logging itself fails, don't log again in fallback
-      # Mark that we tried to log so fallback knows not to duplicate
-      raise LoggingError.new(e)
     end
 
     def build_exception_data(exception)
@@ -157,11 +167,9 @@ module GrapeRailsLogger
     end
 
     def safe_log(level, data, logger = nil)
-      # Get logger from parameter, config, or default to Rails.logger
       effective_logger = logger || resolve_effective_logger
-      return unless effective_logger
+      return false unless effective_logger
 
-      # Get tag from config
       tag = resolve_tag
 
       if effective_logger.respond_to?(:tagged) && tag
@@ -171,12 +179,12 @@ module GrapeRailsLogger
       else
         effective_logger.public_send(level, data)
       end
+      true
     rescue => e
-      # Fallback to stderr if logging fails - never raise
-      # Only warn in development to avoid noise in production
       if defined?(Rails) && Rails.respond_to?(:env) && Rails.env.development?
         Rails.logger&.warn("GrapeRailsLogger log error: #{e.message}")
       end
+      false
     end
 
     def resolve_tag
@@ -585,13 +593,13 @@ module GrapeRailsLogger
     end
 
     def extract_params(request, env = nil)
-      return {} unless env.is_a?(Hash)
+      return EMPTY_HASH unless env.is_a?(Hash)
 
-      endpoint = env[Grape::Env::API_ENDPOINT]
+      endpoint = env[API_ENDPOINT_ENV_KEY]
       return {} unless endpoint&.respond_to?(:request) && endpoint.request
 
       endpoint_params = endpoint.request.params
-      return {} if endpoint_params.blank?
+      return EMPTY_HASH if endpoint_params.blank?
 
       params_hash = if endpoint_params.respond_to?(:to_unsafe_h)
         endpoint_params.to_unsafe_h
@@ -735,22 +743,27 @@ module GrapeRailsLogger
     end
 
     def filter_params(params)
-      return {} unless params
+      return EMPTY_HASH unless params
       return {} unless params.is_a?(Hash)
 
       cleaned = if (filter = rails_parameter_filter)
         # Create a deep copy since filter modifies in place (Rails 6+)
-        params_copy = params.respond_to?(:deep_dup) ? params.deep_dup : params.dup
+        params_copy =
+          if nested_param_structure?(params)
+            params.respond_to?(:deep_dup) ? params.deep_dup : params.dup
+          else
+            params.dup
+          end
         filter.filter(params_copy)
       else
         filter_parameters_manually(params)
       end
 
-      cleaned.is_a?(Hash) ? cleaned.reject { |key, _| PARAM_EXCEPTIONS.include?(key.to_s) } : {}
+      cleaned.is_a?(Hash) ? cleaned.reject { |key, _| PARAM_EXCEPTIONS_EXCLUDE[key.to_s] } : {}
     rescue
       # Don't log - just fallback to manual filtering
       # Logging happens only in subscriber
-      filter_parameters_manually(params).reject { |key, _| PARAM_EXCEPTIONS.include?(key.to_s) }
+      filter_parameters_manually(params).reject { |key, _| PARAM_EXCEPTIONS_EXCLUDE[key.to_s] }
     end
 
     def rails_parameter_filter
@@ -761,14 +774,23 @@ module GrapeRailsLogger
       filter_parameters = Rails.application.config.filter_parameters
       return nil if filter_parameters.blank?
 
+      if filter_parameters.equal?(@parameter_filter_config) && @parameter_filter
+        return @parameter_filter
+      end
+
       # Prefer ActiveSupport::ParameterFilter (Rails 6.1+)
       # This is the Rails-native parameter filtering system
-      if defined?(ActiveSupport::ParameterFilter)
-        ActiveSupport::ParameterFilter.new(filter_parameters)
-      # Fall back to ActionDispatch::Http::ParameterFilter (Rails 6.0 and earlier)
-      elsif defined?(ActionDispatch::Http::ParameterFilter)
-        ActionDispatch::Http::ParameterFilter.new(filter_parameters)
-      end
+      built =
+        if defined?(ActiveSupport::ParameterFilter)
+          ActiveSupport::ParameterFilter.new(filter_parameters)
+        # Fall back to ActionDispatch::Http::ParameterFilter (Rails 6.0 and earlier)
+        elsif defined?(ActionDispatch::Http::ParameterFilter)
+          ActionDispatch::Http::ParameterFilter.new(filter_parameters)
+        end
+      return nil if built.nil?
+
+      @parameter_filter_config = filter_parameters
+      @parameter_filter = built
     rescue
       # Log but don't fail - fall back to manual filtering
       # Don't log - just return nil
@@ -776,6 +798,33 @@ module GrapeRailsLogger
       nil
     end
 
+    def nested_param_structure?(params)
+      return false unless params.is_a?(Hash)
+      return false if params.empty?
+
+      return true if params.any? { |_, v| v.is_a?(Hash) }
+
+      params.each_value do |value|
+        next unless value.is_a?(Array)
+
+        return true if value.any? { |el| el.is_a?(Hash) }
+      end
+
+      stack = [params]
+      until stack.empty?
+        h = stack.pop
+        h.each_value do |value|
+          case value
+          when Hash
+            return true
+          when Array
+            value.each { |el| stack.push(el) if el.is_a?(Hash) }
+          end
+        end
+      end
+      false
+    end
+
     def filter_parameters_manually(params, depth = 0)
       return {} unless params
       return {"[FILTERED]" => "[max_depth_exceeded]"} if depth > 10
@@ -793,9 +842,9 @@ module GrapeRailsLogger
           when Hash
             filter_parameters_manually(value, depth + 1)
           when Array
-            value.first(100).map { |v| v.is_a?(Hash) ? filter_parameters_manually(v, depth + 1) : filter_value(v) }
+            value.first(100).map { |v| v.is_a?(Hash) ? filter_parameters_manually(v, depth + 1) : v }
           else
-            filter_value(value)
+            value
           end
         end
       end
@@ -805,17 +854,14 @@ module GrapeRailsLogger
       {}
     end
 
-    def filter_value(value)
-      return value unless value.is_a?(String)
-      value_lower = value.downcase
-      return "[FILTERED]" if FILTERED_PARAMS.any? { |param| value_lower.include?(param.downcase) }
-
-      value
-    end
-
     def should_filter_key?(key)
-      key_lower = key.to_s.downcase
-      FILTERED_PARAMS.any? { |param| key_lower.include?(param.downcase) }
+      key_lower =
+        if key.is_a?(String)
+          key.downcase
+        else
+          key.to_s.downcase
+        end
+      FILTERED_PARAMS_LOWER.any? { |param| key_lower.include?(param) }
     end
   end
 end

data/lib/grape_rails_logger/timings.rb

@@ -15,7 +15,7 @@ module GrapeRailsLogger
 
     def self.reset_db_runtime
       state = execution_state
-      state[:grape_db_runtime] = 0
+      state[:grape_db_runtime] = 0.0
       state[:grape_db_calls] = 0
     end
 
@@ -41,12 +41,41 @@ module GrapeRailsLogger
       execution_state[:grape_db_calls] ||= 0
     end
 
-    def self.append_db_runtime(event)
+    def self.append_db_runtime(event_or_duration)
       state = execution_state
       return unless state[:grape_db_tracking]
 
-      state[:grape_db_runtime] = (state[:grape_db_runtime] || 0) + event.duration
+      duration =
+        if event_or_duration.is_a?(Numeric)
+          event_or_duration
+        else
+          event_or_duration.duration
+        end
+      duration = duration.to_f if duration.is_a?(Numeric)
+      state[:grape_db_runtime] = (state[:grape_db_runtime] || 0) + duration
       state[:grape_db_calls] = (state[:grape_db_calls] || 0) + 1
     end
+
+    # Railtie SQL subscribe entry: skip Event allocation when no Grape request is tracked.
+    def self.record_sql_notification(*args)
+      state = execution_state
+      return unless state[:grape_db_tracking]
+
+      duration = sql_notification_duration(args)
+      append_db_runtime(duration.nil? ? ActiveSupport::Notifications::Event.new(*args) : duration)
+    end
+
+    def self.sql_notification_duration(args)
+      case args.length
+      when 5
+        d = args[2] - args[1]
+        d.is_a?(Numeric) ? d.to_f : d
+      when 1
+        arg = args.first
+        d = arg.duration if arg.respond_to?(:duration)
+        d.is_a?(Numeric) ? d.to_f : d
+      end
+    end
+    private_class_method :sql_notification_duration
   end
 end

data/lib/grape_rails_logger/version.rb

@@ -1,3 +1,3 @@
 module GrapeRailsLogger
-  VERSION = "1.2.2"
+  VERSION = "1.2.4"
 end

data/sig/grape_rails_logger.rbs

@@ -22,7 +22,8 @@ module GrapeRailsLogger
     def self.grape_request_active?: () -> bool
     def self.db_runtime: () -> Float
     def self.db_calls: () -> Integer
-    def self.append_db_runtime: (ActiveSupport::Notifications::Event event) -> void
+    def self.append_db_runtime: (ActiveSupport::Notifications::Event | Float | Integer event_or_duration) -> void
+    def self.record_sql_notification: (*untyped args) -> void
   end
 
   module StatusExtractor
@@ -34,6 +35,8 @@ module GrapeRailsLogger
   end
 
   class GrapeRequestLogSubscriber
+    EMPTY_HASH: Hash[untyped, untyped]
+
     def initialize: () -> void
     def grape_request: (ActiveSupport::Notifications::Event event) -> void
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grape_rails_logger
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.2.4
 platform: ruby
 authors:
 - Andrei Makarov
@@ -89,14 +89,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.2.9
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.2.9
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -125,20 +125,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13'
-- !ruby/object:Gem::Dependency
-  name: rspec_junit_formatter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
@@ -307,8 +293,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
-description: Rails-compatible, ActiveSupport-integrated logging for Grape APIs, including
-  request context and ActiveRecord timings.
+description: Rails and ActiveSupport request logging for Grape APIs, with request
+  context and ActiveRecord timings.
 email:
 - contact@kiskolabs.com
 executables: []
@@ -351,5 +337,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.6
 specification_version: 4
-summary: Unified JSON request logging for Grape on Rails with DB timing.
+summary: Structured request logging for Grape on Rails with ActiveRecord timing.
 test_files: []