rails_api_logger 0.9.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f1fb1fae010aa6cf4bdda941fd6ad2ce3ac5583faa690d23680194d2f3eb991
-  data.tar.gz: 0dd85cd48972098af775d7a5feec4d17b8aaaa51641e9a4405244d8ccdd12644
+  metadata.gz: 4959094cde8a80515bac5d15b4bd4f475e7c723b94803a2ecdc00de59aba1995
+  data.tar.gz: 283881fcb6952b5ffab21a816558f8c6ef9c705252d25f183a261e614317db3b
 SHA512:
-  metadata.gz: 4d310658b9bbae0d5406a8df1d7a85e11d161db8405ad970cb422fbd9ad38d2a95c251a8ba3f6acbe30089290b61d94ed8c8cd1b0e601fbbea6f8d2a111b7ae0
-  data.tar.gz: c3c29eaf30dbbb4548b3527ac7220193135a4ca0eb69b5f17b12e0ef88516b8aa91c1b8367dacd4a4ee5988c4722ba493c5e98a28ba7b5c61645db971c36bcdb
+  metadata.gz: 1d727ed904aff3668f16d2bdfdedee5576b30c53819911303f7df0723608344fbe9c30eb7e313cde7c2ca6d33e832c9ac4073baa065331f2cb9e11276975e3f8
+  data.tar.gz: e76f28822d9646a1973f4fb75612c52a0ed0d18d089ae27e9eccc5ac5f1313ee58e5236564b086246a17d6f158d4616a29ebc1419e25484a7a6cb73021529629

data/.gitignore

@@ -6,6 +6,12 @@
 /pkg/
 /spec/reports/
 /tmp/
+/spec/dummy/log
+/spec/dummy/tmp
+/spec/dummy/db/*.sqlite3*
+/spec/dummy/db/schema.rb
+/spec/dummy/db/api_logger_schema.rb
+.env
 
 # rspec failure tracking
 .rspec_status

data/.semaphore/semaphore.yml

@@ -21,12 +21,142 @@ blocks:
           - cache restore
           - bundle config set path 'vendor/bundle'
           - bundle install -j 4
-          - sem-service start postgres 14 --username=semaphore
+
           - cache store
+      env_vars:
+        - name: BUNDLE_GEMFILE
+          value: /home/semaphore/rails_api_logger/gemfiles/rails_8.0.gemfile
       jobs:
-        - name: tests
+        - name: linter
           commands:
             - bundle exec standardrb
+        - name: tests postgres separate db and separate target
+          env_vars:
+            - name: SAME_DB
+              value: "false"
+            - name: SAME_TARGET
+              value: "false"
+            - name: TARGET_DB
+              value: postgres
+            - name: RAILS_ENV
+              value: test
+          commands:
+            - sem-service start postgres 14
+            - bin/rails db:create db:migrate
+            - bundle exec rspec
+        - name: tests postgres separate db and same target
+          env_vars:
+            - name: SAME_DB
+              value: "false"
+            - name: SAME_TARGET
+              value: "true"
+            - name: TARGET_DB
+              value: postgres
+            - name: RAILS_ENV
+              value: test
+          commands:
+            - sem-service start postgres 14
+            - bin/rails db:create db:migrate
+            - bundle exec rspec
+        - name: tests postgres same db and separate target
+          env_vars:
+            - name: SAME_DB
+              value: "true"
+            - name: TARGET_DB
+              value: postgres
+            - name: RAILS_ENV
+              value: test
+          commands:
+            - sem-service start postgres 14
+            - bin/rails db:create db:migrate
+            - bundle exec rspec
+        - name: tests postgres separate db and separate target | rails 6.1
+          env_vars:
+            - name: SAME_DB
+              value: "false"
+            - name: SAME_TARGET
+              value: "false"
+            - name: TARGET_DB
+              value: postgres
+            - name: RAILS_ENV
+              value: test
+            - name: BUNDLE_GEMFILE
+              value: /home/semaphore/rails_api_logger/gemfiles/rails_6.1.gemfile
+          commands:
+            - sem-service start postgres 14
+            - bin/rails db:create db:migrate
+            - bundle exec rspec
+        - name: tests postgres separate db and separate target | rails 7.0
+          env_vars:
+            - name: SAME_DB
+              value: "false"
+            - name: SAME_TARGET
+              value: "false"
+            - name: TARGET_DB
+              value: postgres
+            - name: RAILS_ENV
+              value: test
+            - name: BUNDLE_GEMFILE
+              value: /home/semaphore/rails_api_logger/gemfiles/rails_7.0.gemfile
+          commands:
+            - sem-service start postgres 14
+            - bin/rails db:create db:migrate
+            - bundle exec rspec
+        - name: tests postgres separate db and separate target | rails 7.1
+          env_vars:
+            - name: SAME_DB
+              value: "false"
+            - name: SAME_TARGET
+              value: "false"
+            - name: TARGET_DB
+              value: postgres
+            - name: RAILS_ENV
+              value: test
+            - name: BUNDLE_GEMFILE
+              value: /home/semaphore/rails_api_logger/gemfiles/rails_7.1.gemfile
+          commands:
+            - sem-service start postgres 14
+            - bin/rails db:create db:migrate
+            - bundle exec rspec
+        - name: tests postgres separate db and separate target | rails 7.2
+          env_vars:
+            - name: SAME_DB
+              value: "false"
+            - name: SAME_TARGET
+              value: "false"
+            - name: TARGET_DB
+              value: postgres
+            - name: RAILS_ENV
+              value: test
+            - name: BUNDLE_GEMFILE
+              value: /home/semaphore/rails_api_logger/gemfiles/rails_7.2.gemfile
+          commands:
+            - sem-service start postgres 14
+            - bin/rails db:create db:migrate
+            - bundle exec rspec
+        - name: tests sqlite separate db and separate target
+          env_vars:
+            - name: SAME_DB
+              value: "false"
+            - name: SAME_TARGET
+              value: "false"
+            - name: TARGET_DB
+              value: sqlite
+            - name: RAILS_ENV
+              value: test
+          commands:
+            - bin/rails db:create db:migrate
+            - bundle exec rspec
+        - name: tests sqlite same db
+          env_vars:
+            - name: SAME_DB
+              value: "true"
+            - name: TARGET_DB
+              value: sqlite
+            - name: RAILS_ENV
+              value: test
+          commands:
+            - bin/rails db:create db:migrate
             - bundle exec rspec
 promotions:
   - name: main

data/.standard.yml

@@ -0,0 +1,2 @@
+ignore:
+  - 'gemfiles/**/*'

data/Appraisals

@@ -0,0 +1,31 @@
+appraise "rails-6.1" do
+  gem "concurrent-ruby", "1.3.4"
+  gem "rails", "~> 6.1.0"
+  gem "rspec-rails", "~> 6.1.0"
+  gem "sqlite3", "~> 1.7.3"
+end
+
+appraise "rails-7.0" do
+  gem "concurrent-ruby", "1.3.4"
+  gem "rails", "~> 7.0.0"
+  gem "rspec-rails", "~> 7.1.0"
+  gem "sqlite3", "~> 1.7.3"
+end
+
+appraise "rails-7.1" do
+  gem "rails", "~> 7.1.0"
+  gem "rspec-rails", "~> 7.1.0"
+  gem "sqlite3", "~> 1.7.3"
+end
+
+appraise "rails-7.2" do
+  gem "rails", "~> 7.2.0"
+  gem "rspec-rails", "~> 7.1.0"
+  gem "sqlite3", "~> 1.7.3"
+end
+
+appraise "rails-8.0" do
+  gem "rails", "~> 8.0.0"
+  gem "rspec-rails", "~> 7.1.0"
+  gem "sqlite3", "~> 2.1.0"
+end

data/CHANGELOG.md

@@ -1,41 +1,98 @@
+# 0.10.1
+
+* Fix a bug introduced in 0.8.1 where we fixed Rails 7.1 warnings. This broke the serialization in Rails < 7.1.
+  We now configure the serializer differently if you are running Rails 7.0 or lower.
+  If you used the gem version 0.8.1 or above in combination with Rails 7.0 or lower this caused the serialization of
+  the request and response body into YML format instead of JSON. This is now fixed and tests run on different rails
+  versions as well.
+
+# 0.10.0
+
+**BREAKING CHANGES**
+
+This version contains many breaking changes. Consider this when upgrading:
+
+* Replace calls to `RailsApiLogger.new` with `RailsApiLogger::Logger.new`. More in general the logger has been renamed.
+* `InboundRequestLog` has been renamed to `RailsApiLogger::InboundRequestLog`. Table name did not change.
+* `OutboundRequestLog` has been renamed to `RailsApiLogger::OutboundRequestLog`. Table name did not change.
+* If you had `has_many :inbound_request_logs` or `has_many :outbound_request_logs` defined, this will break. There's
+  now [three methods](app/models/rails_api_logger/loggable.rb) you can use on your model.
+* `InboundRequestsLoggerMiddleware` has been renamed to `RailsApiLogger::Middleware`
+
+> Do the changes above and then continue with the following steps if you want to connect rails_api_logger to a different
+> database:
+
+* Specify a database called `api_logger`. [Check here](spec/dummy/config/database.yml) for an example.
+* Check that everything still works (also in production!) with the new configuration.
+* Add the migrations in the right folder to create again the necessary tables. Run the migrations that will generate a
+  new schema file.
+* Release and do the same in production. Adapt your build/release steps if you need.
+
+* Add the following line into `production.rb`:
+  `config.rails_api_logger.connects_to = { database: { writing: :api_logger } }` if you want to point to a new database.
+
+> If you are not on SQLite you can point also `api_logger` database to the current database you have, so you benefit
+> from isolated transactions but don't need to create a new database or migrate data.
+
+### List of changes in this version:
+
+* Namespace correctly. Renamed all classes
+* Added tests with a dummy app
+* Use a separate database connection configuration to isolate transactions
+* I acknowledge that there might be issues on mysql. I don't use it so I won't fix them, but PR are welcome.
+* Added `host_regexp` option to the middleware.
+
 # 0.9.0
-* Add option skip_request_body to skip the request body. Use this option when you don't want to persist the request body. `[Skipped]` will be persisted instead.
+
+* Add option skip_request_body to skip the request body. Use this option when you don't want to persist the request
+  body. `[Skipped]` will be persisted instead.
 * Add option skip_request_body_regexp to skip logging the body of requests matching a regexp.
 * Renamed the option skip_body into skip_response_body. This is a breaking change!
 * Renamed the option skip_body_regexp into skip_response_body_regexp. This is a breaking change!
 
 # 0.8.1
+
 * Fix Rails 7.1 warnings.
 
 # 0.8.0
-* Add option skip_body to skip the body for request responses. Use this option when you don't want to persist the response body. `[Skipped]` will be persisted instead. This is not a breaking change.
+
+* Add option skip_body to skip the body for request responses. Use this option when you don't want to persist the
+  response body. `[Skipped]` will be persisted instead. This is not a breaking change.
 
 # 0.7.0
+
 * Fix an issue in the middleware where the request body was not read correctly if there were encoding issues.
 * Improved documentation about outboud request logging.
 * Add option skip_body_regexp to skip logging the body of requests matching a regexp.
 
 # 0.6.3
+
 * Fix the CHANGELOG path in gemspec.
 
 # 0.6.2
+
 * Fixes Zeitwerk warning.
 
 # 0.6.1
+
 * Fixes the loading of concern into controllers.
 
 # 0.6.0
+
 * Fixes an important concurrency issue by removing instance variables in the rack middleware.
 
 # 0.5.0
+
 * Started using Zeitwerk.
 * Removed RailsAdmin specific code.
 * Improved RailsApiLogger class.
 
 # 0.4.1
+
 * Fixed the `.failed` scope.
 
 # 0.4.0
+
 * Added `started_at`, `ended_at` and `duration` methods.
 
 Migrate your tables with:
@@ -47,12 +104,14 @@ add_column :outbound_request_logs, :started_at, :timestamp
 add_column :outbound_request_logs, :ended_at, :timestamp
 ```
 
-
 # 0.3.0
+
 * Added `formatted_request_body` and `formatted_response_body` methods.
 
 # 0.2.0
+
 * Switch to a middleware solution.
 
 # 0.1.0
+
 * Initial release.

data/README.md

@@ -1,23 +1,23 @@
 # Rails API Logger
 
-The simplest way to log API requests of your Rails application in your database.
+The simplest way to log API requests in your database.
 
 The Rails API logger gem introduces a set of tools to log and debug API requests.
+
 It works on two sides:
 
 * **Inbound requests**: API exposed by your application
-* **Outbound requests**: API invoked by your application  
+* **Outbound requests**: API invoked by your application
 
-This gem has been extracted from various Renuo projects, where we implemented this
-technique multiple times successfully.
+This gem has been extracted from various [Renuo](https://www.renuo.ch) projects.
 
 This gem creates two database tables to log the following information:
 
 * **path** the path/url invoked
 * **method** the method used to invoke the API (get, post, put, etc...)
 * **request_body** what was included in the request body
-* **response_body** what was included in the response body 
-* **response_code** the HTTP response code of the request 
+* **response_body** what was included in the response body
+* **response_code** the HTTP response code of the request
 * **started_at** when the request started
 * **ended_at** when the request finished
 
@@ -33,14 +33,34 @@ And then execute:
 
 ```bash
 bundle install
-spring stop # if it's running. otherwise it does not see the new generator 
-bundle exec rails generate rails_api_logger:install
-bundle exec rails db:migrate
+bin/rails g rails_api_logger:install
+bin/rails db:migrate
 ```
 
 This will generate two tables `inbound_request_logs` and `outbound_request_logs`.
 These tables will contain the logs.
 
+## Ensure logging of data
+
+RailsApiLogger can use a separate database, to ensure that the logs are written in the database even if a
+surrounding database transaction is rolled back.
+
+Make sure to add the following in your `config/environments/production.rb`:
+
+```ruby
+config.rails_api_logger.connects_to = { database: { writing: :api_logger } }
+```
+
+and [configure a new database](spec/dummy/config/database.yml) accordingly.
+
+> ⚠️ If you skip this step, rails_api_logger will use your primary database but a rollback will also rollback the
+> writing of logs
+> If you are not on SQLite you can point also `api_logger` to the same database! By doing so you can use a single
+> database but still guarantee the writing of logs in an isolated transaction:
+> ```
+> config.rails_api_logger.connects_to = { database: { writing: :primary } }
+> ```
+
 ## Log Outbound Requests
 
 Given an outbound request in the following format:
@@ -59,7 +79,7 @@ uri = URI('http://example.com/some_path?query=string')
 http = Net::HTTP.start(uri.host, uri.port)
 request = Net::HTTP::Get.new(uri)
 
-log = OutboundRequestLog.from_request(request)
+log = RailsApiLogger::OutboundRequestLog.from_request(request)
 
 response = http.request(request)
 
@@ -76,7 +96,7 @@ request = Net::HTTP::Post.new(uri)
 request.body = { answer: 42 }.to_json
 request.content_type = 'application/json'
 
-response = RailsApiLogger.new.call(nil, request) do
+response = RailsApiLogger::Logger.new.call(nil, request) do
   Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(request) }
 end
 ``` 
@@ -86,25 +106,7 @@ This will guarantee that the log is always persisted, even in case of errors.
 ### Database Transactions Caveats
 
 If you log your outbound requests inside of parent app transactions, your logs will not be persisted if
-the transaction is rolled-back. You can circumvent that by opening another database connection
-to the same (or another database if you're into that stuff) when logging.
-
-```
-# config/initializers/outbound_request_log_patch.rb
-
-module OutboundRequestLogTransactionPatch
-  extend ActiveSupport::Concern
-
-  included do
-    connects_to database: { writing: :primary, reading: :primary }
-  end
-end
-
-OutboundRequestLog.include(OutboundRequestLogTransactionPatch)
-```
-
-You can also log the request in a separate thread to provoke the checkout of a separate database connection.
-Have a look at [this example here](https://github.com/renuo/rails_api_logger/blob/28d4ced88fea5a5f4fd72f5a1db42ad4734eb547/spec/outbound_request_log_spec.rb#L28-L30).
+the transaction is rolled-back. Use a separate database to prevent this.
 
 ## Log Inbound Requests
 
@@ -112,36 +114,41 @@ If you are exposing some API you might be interested in logging the requests you
 You can do so by adding this middleware in `config/application.rb`
 
 ```ruby
-config.middleware.insert_before Rails::Rack::Logger, InboundRequestsLoggerMiddleware
+config.middleware.insert_before Rails::Rack::Logger, RailsApiLogger::Middleware
 ``` 
 
 this will by default only log requests that have an impact in your system (POST, PUT, and PATCH calls).
 If you want to log all requests (also GET ones) use
 
 ```ruby
-config.middleware.insert_before Rails::Rack::Logger, InboundRequestsLoggerMiddleware, only_state_change: false
+config.middleware.insert_before Rails::Rack::Logger, RailsApiLogger::Middleware, only_state_change: false
 ```
 
 If you want to log only requests on a certain path, you can pass a regular expression:
 
 ```ruby
-config.middleware.insert_before Rails::Rack::Logger, InboundRequestsLoggerMiddleware, path_regexp: /api/
+config.middleware.insert_before Rails::Rack::Logger, RailsApiLogger::Middleware, path_regexp: /api/
 ```
 
-If you want to skip logging the response or request body of certain requests, you can pass a regular expression:
+If you want to log only requests on a certain host, you can also use a regular expression:
 
 ```ruby
-config.middleware.insert_before Rails::Rack::Logger, InboundRequestsLoggerMiddleware,
-                                skip_request_body_regexp: /api/books/,
-                                skip_response_body_regexp: /api/letters/
+config.middleware.insert_before Rails::Rack::Logger, RailsApiLogger::Middleware, host_regexp: /api.example.com/
 ```
 
+If you want to skip logging the response or request body of certain requests, you can pass a regular expression:
+
+```ruby
+config.middleware.insert_before Rails::Rack::Logger, RailsApiLogger::Middleware,
+                                skip_request_body_regexp: /api\/books/,
+                                skip_response_body_regexp: /api\/letters/
+```
 
 In the implementation of your API, you can call any time `attach_inbound_request_loggable(model)`
 to attach an already persisted model to the log record.
 
-
 For example:
+
 ```ruby
 
 def create
@@ -158,18 +165,21 @@ end
 in the User model you can define:
 
 ```ruby
-has_many :inbound_request_logs, inverse_of: :loggable, dependent: :destroy, as: :loggable
+has_many_inbound_request_logs
 ```
 
-to be able to access the logs attached to the model.
+to be able to access the inbound logs attached to the model.
+
+You also have `has_many_outbound_request_logs` and `has_many_request_logs` that includes both.
 
 ## RailsAdmin integration
 
 We provide here some code samples to integrate the models in [RailsAdmin](https://github.com/sferik/rails_admin).
 
-This configuration will give you some nice views, and searches to work with the logs efficiently. 
+This configuration will give you some nice views, and searches to work with the logs efficiently.
+
 ```ruby
-%w[InboundRequestLog OutboundRequestLog].each do |logging_model|
+%w[RailsApiLogger::InboundRequestLog RailsApiLogger::OutboundRequestLog].each do |logging_model|
   config.model logging_model do
     list do
       filters %i[method path response_code request_body response_body created_at]
@@ -204,24 +214,51 @@ This configuration will give you some nice views, and searches to work with the
 end
 ```
 
-
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+We use Appraisals to un on different Rails versions. This is a run example:
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+```bash
+export SAME_TARGET=false 
+export SAME_DB=false 
+export TARGET_DB=postgres 
+export BUNDLE_GEMFILE=/Users/alessandrorodi/RenuoWorkspace/rails_api_logger/gemfiles/rails_6.1.gemfile 
+bundle exec rails db:create db:migrate
+bundle exec rspec
+```
+
+These are the possible ENV variables:
+
+* `SAME_TARGET` if true, the api_logger database is the same as the primary one. It will still use two separate
+  connection pools, but they'll point to the same database. This cannot be set to true if TARGET_DB is sqlite because
+  sqlite does not support multiple connection pools to the same database.
+* `SAME_DB` if true, the api_logger uses the primary database. In this case SAME_TARGET is ignored.
+* `TARGET_DB` the database to use. Can be `postgres`, `mysql`, or `sqlite`.
+* `BUNDLE_GEMFILE` the gemfile to use. This is used to run the tests on different Rails versions.
+
+Possible combinations:
+
+| SAME_DB | SAME_TARGET | TARGET_DB | Description                                                          |
+|---------|-------------|-----------|----------------------------------------------------------------------|
+| false   | false       | postgres  | Separate database, separate connection pool.                         |
+| false   | true        | postgres  | Same database, separate connection pool.                             |
+| true    | -           | postgres  | Same connection pool so the separate target is ignored.              |
+| false   | false       | sqlite    | Separate database, separate connection pool.                         |
+| false   | true        | sqlite    | Not allowed. sqlite cannot have two connection pools to the same db. |
+| true    | -           | sqlite    | Same connection pool so the separate target is ignored.              |
+
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the
+version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version,
+push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/renuo/rails_api_logger. 
-This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to 
-the [code of conduct](https://github.com/renuo/rails_api_logger/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/renuo/rails_api_logger.
+This project is intended to be a safe, welcoming space for collaboration.
+
+Try to be a decent human being while interacting with other people.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Code of Conduct
-
-Everyone interacting in the RailsApiLogger project's codebases, issue trackers, chat rooms and mailing lists is 
-expected to follow the [code of conduct](https://github.com/renuo/rails_api_logger/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -1,6 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require "rake/testtask"
 
-RSpec::Core::RakeTask.new(:spec)
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+load "rails/tasks/statistics.rake"
 
 task default: :spec

data/app/middlewares/rails_api_logger/middleware.rb

@@ -0,0 +1,80 @@
+module RailsApiLogger
+  class Middleware
+    attr_accessor :only_state_change, :host_regexp, :path_regexp, :skip_request_body_regexp, :skip_response_body_regexp
+
+    def initialize(app, only_state_change: true,
+      host_regexp: /.*/,
+      path_regexp: /.*/,
+      skip_request_body_regexp: nil,
+      skip_response_body_regexp: nil)
+      @app = app
+      self.only_state_change = only_state_change
+      self.host_regexp = host_regexp
+      self.path_regexp = path_regexp
+      self.skip_request_body_regexp = skip_request_body_regexp
+      self.skip_response_body_regexp = skip_response_body_regexp
+    end
+
+    def call(env)
+      request = ActionDispatch::Request.new(env)
+      logging = log?(env, request)
+      if logging
+        env["INBOUND_REQUEST_LOG"] = InboundRequestLog.from_request(request, skip_request_body: skip_request_body?(env))
+        request.body.rewind if request.body.respond_to?(:read)
+      end
+      status, headers, body = @app.call(env)
+      if logging
+        updates = {response_code: status, ended_at: Time.current}
+        updates[:response_body] = if skip_response_body?(env)
+          "[Skipped]"
+        else
+          parsed_body(body)
+        end
+        # this usually works. let's be optimistic.
+        begin
+          env["INBOUND_REQUEST_LOG"].update_columns(updates)
+        rescue JSON::GeneratorError => _e # this can be raised by activerecord if the string is not UTF-8.
+          env["INBOUND_REQUEST_LOG"].update_columns(updates.except(:response_body))
+        end
+      end
+      [status, headers, body]
+    end
+
+    private
+
+    def skip_request_body?(env)
+      skip_request_body_regexp && env["PATH_INFO"] =~ skip_request_body_regexp
+    end
+
+    def skip_response_body?(env)
+      skip_response_body_regexp && env["PATH_INFO"] =~ skip_response_body_regexp
+    end
+
+    def log?(env, request)
+      # The HTTP_HOST header is preferred to the SERVER_NAME header per the Rack spec: https://github.com/rack/rack/blob/main/SPEC.rdoc#label-The+Environment
+      host = env["HTTP_HOST"] || env["SERVER_NAME"]
+      path = env["PATH_INFO"]
+      (host =~ host_regexp) &&
+        (path =~ path_regexp) &&
+        (!only_state_change || request_with_state_change?(request))
+    end
+
+    def parsed_body(body)
+      return unless body.present?
+
+      if body.respond_to?(:to_ary)
+        JSON.parse(body.to_ary[0])
+      elsif body.respond_to?(:body)
+        JSON.parse(body.body)
+      else
+        body
+      end
+    rescue JSON::ParserError, ArgumentError
+      body
+    end
+
+    def request_with_state_change?(request)
+      request.post? || request.put? || request.patch? || request.delete?
+    end
+  end
+end

data/app/models/rails_api_logger/inbound_request_log.rb

@@ -0,0 +1,5 @@
+module RailsApiLogger
+  class InboundRequestLog < RequestLog
+    self.table_name = "inbound_request_logs"
+  end
+end