rails_api_logger 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f1fb1fae010aa6cf4bdda941fd6ad2ce3ac5583faa690d23680194d2f3eb991
-  data.tar.gz: 0dd85cd48972098af775d7a5feec4d17b8aaaa51641e9a4405244d8ccdd12644
+  metadata.gz: 2fda8a1c76ae8f88f8753f6a24b0e794031f2fe699cf517b2bdc0dc4a9492047
+  data.tar.gz: 6435707109046e2f3444290e8f1c18381a2bbd3b9558602198752c077de3f7ed
 SHA512:
-  metadata.gz: 4d310658b9bbae0d5406a8df1d7a85e11d161db8405ad970cb422fbd9ad38d2a95c251a8ba3f6acbe30089290b61d94ed8c8cd1b0e601fbbea6f8d2a111b7ae0
-  data.tar.gz: c3c29eaf30dbbb4548b3527ac7220193135a4ca0eb69b5f17b12e0ef88516b8aa91c1b8367dacd4a4ee5988c4722ba493c5e98a28ba7b5c61645db971c36bcdb
+  metadata.gz: d8660e1388c86679bc3be3004049b783e96eef9bf18c6c61fb4d885fdd9cf4f2408bb131adf35193652687a3f37b2a7411e3e7953eb919fc468ab99a165e147c
+  data.tar.gz: 53bbe981627e011159acaf23468f1b1bf00b6171ae9f50fc6d577d3461937a871e9955f29e391fdb38027902fd6db42a6a9b20614d6da21d50bacbf0bb2cc980

data/.gitignore

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

data/.semaphore/semaphore.yml

@@ -21,12 +21,63 @@ blocks:
           - cache restore
           - bundle config set path 'vendor/bundle'
           - bundle install -j 4
-          - sem-service start postgres 14 --username=semaphore
+
           - cache store
       jobs:
-        - name: tests
+        - name: linter
           commands:
             - bundle exec standardrb
+        - name: tests sqlite separate db
+          env_vars:
+            - name: TARGET_DB
+              value: sqlite
+            - name: RAILS_ENV
+              value: test
+          commands:
+            - bundle exec rspec
+        - name: tests postgres separate db
+          env_vars:
+            - name: TARGET_DB
+              value: postgres
+            - name: RAILS_ENV
+              value: test
+          commands:
+            - sem-service start postgres 14
+            - bin/rails db:create db:schema:load
+            - 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:
+            - bundle exec rspec
+        - name: tests postgres same db
+          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:schema:load
+            - bundle exec rspec
+        - name: tests postgres same target
+          env_vars:
+            - 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:schema:load
             - bundle exec rspec
 promotions:
   - name: main

data/CHANGELOG.md

@@ -1,41 +1,90 @@
+# 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 +96,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,31 @@ 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.
+
 ## Log Outbound Requests
 
 Given an outbound request in the following format:
@@ -59,7 +76,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 +93,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 +103,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 +111,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 +162,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 +211,22 @@ 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.
+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.
 
-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).
+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

data/app/models/rails_api_logger/loggable.rb

@@ -0,0 +1,27 @@
+module RailsApiLogger
+  module Loggable
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # :nodoc:
+    module ClassMethods
+      def has_many_outbound_request_logs
+        has_many :outbound_request_logs, -> { order(:created_at) },
+          class_name: "RailsApiLogger::OutboundRequestLog",
+          inverse_of: :loggable, dependent: :destroy, as: :loggable
+      end
+
+      def has_many_inbound_request_logs
+        has_many :inbound_request_logs, -> { order(:created_at) },
+          class_name: "RailsApiLogger::InboundRequestLog",
+          inverse_of: :loggable, dependent: :destroy, as: :loggable
+      end
+
+      def has_many_request_logs
+        has_many_inbound_request_logs
+        has_many_outbound_request_logs
+      end
+    end
+  end
+end

data/app/models/rails_api_logger/logger.rb

@@ -0,0 +1,22 @@
+module RailsApiLogger
+  class Logger
+    def initialize(loggable = nil, skip_request_body: false, skip_response_body: false)
+      @loggable = loggable
+      @skip_request_body = skip_request_body
+      @skip_response_body = skip_response_body
+    end
+
+    def call(url, request)
+      log = OutboundRequestLog.from_request(request, loggable: @loggable, skip_request_body: @skip_request_body)
+      yield.tap do |response|
+        log.from_response(response, skip_response_body: @skip_response_body)
+      end
+    rescue => e
+      log.response_body = {error: e.message} if log
+      raise
+    ensure
+      log.ended_at = Time.current
+      log.save!
+    end
+  end
+end

data/app/models/rails_api_logger/outbound_request_log.rb

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

data/app/models/rails_api_logger/request_log.rb

@@ -0,0 +1,80 @@
+module RailsApiLogger
+  class RequestLog < ActiveRecord::Base
+    self.abstract_class = true
+
+    connects_to(**RailsApiLogger.connects_to) if RailsApiLogger.connects_to
+
+    serialize :request_body, coder: JSON
+    serialize :response_body, coder: JSON
+
+    belongs_to :loggable, optional: true, polymorphic: true
+
+    scope :failed, -> { where(response_code: 400..599).or(where.not(ended_at: nil).where(response_code: nil)) }
+
+    validates :method, presence: true
+    validates :path, presence: true
+
+    def self.from_request(request, loggable: nil, skip_request_body: false)
+      if skip_request_body
+        body = "[Skipped]"
+      else
+        request_body = (request.body.respond_to?(:read) ? request.body.read : request.body)
+        body = request_body&.dup&.force_encoding("UTF-8")
+        begin
+          body = JSON.parse(body) if body.present?
+        rescue JSON::ParserError
+          body
+        end
+      end
+      create(path: request.path, request_body: body, method: request.method, started_at: Time.current, loggable: loggable)
+    end
+
+    def from_response(response, skip_response_body: false)
+      self.response_code = response.code
+      self.response_body = skip_response_body ? "[Skipped]" : manipulate_body(response.body)
+      self
+    end
+
+    def formatted_request_body
+      formatted_body(request_body)
+    end
+
+    def formatted_response_body
+      formatted_body(response_body)
+    end
+
+    def formatted_body(body)
+      if body.is_a?(String) && body.blank?
+        ""
+      elsif body.is_a?(Hash)
+        JSON.pretty_generate(body)
+      else
+        xml = Nokogiri::XML(body)
+        if xml.errors.any?
+          body
+        else
+          xml.to_xml(indent: 2)
+        end
+      end
+    rescue
+      body
+    end
+
+    def duration
+      return if started_at.nil? || ended_at.nil?
+      ended_at - started_at
+    end
+
+    private
+
+    def manipulate_body(body)
+      body_duplicate = body&.dup&.force_encoding("UTF-8")
+      begin
+        body_duplicate = JSON.parse(body_duplicate) if body_duplicate.present?
+      rescue JSON::ParserError
+        body_duplicate
+      end
+      body_duplicate
+    end
+  end
+end

data/bin/rails

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/rails_api_logger/engine', __dir__)
+APP_PATH = File.expand_path('../spec/dummy/config/application', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/lib/generators/rails_api_logger/install_generator.rb

@@ -3,7 +3,7 @@
 require "rails/generators/base"
 require "rails/generators/migration"
 
-class RailsApiLogger
+module RailsApiLogger
   module Generators
     class InstallGenerator < Rails::Generators::Base
       include Rails::Generators::Migration

data/lib/rails_api_logger/engine.rb

@@ -0,0 +1,25 @@
+module RailsApiLogger
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsApiLogger
+
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    config.rails_api_logger = ActiveSupport::OrderedOptions.new
+
+    initializer "rails_api_logger.config" do
+      config.rails_api_logger.each do |name, value|
+        RailsApiLogger.public_send(:"#{name}=", value)
+      end
+    end
+
+    ActiveSupport.on_load(:action_controller) do
+      include InboundRequestsLogger
+    end
+
+    ActiveSupport.on_load(:active_record) do
+      include RailsApiLogger::Loggable
+    end
+  end
+end

data/lib/rails_api_logger/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsApiLogger
+  VERSION = "0.10.0"
+end

data/lib/rails_api_logger.rb

@@ -1,35 +1,17 @@
-require "active_record"
+require "rails_api_logger/version"
+require "rails_api_logger/engine"
+require_relative "../app/models/rails_api_logger/loggable"
+require_relative "../app/middlewares/rails_api_logger/middleware"
+
+require "rails"
 require "nokogiri"
+
 require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem
-loader.collapse("#{__dir__}/rails_api_logger")
 loader.ignore("#{__dir__}/generators")
 loader.setup
 
-class RailsApiLogger
-  class Error < StandardError; end
-
-  def initialize(loggable = nil, skip_request_body: false, skip_response_body: false)
-    @loggable = loggable
-    @skip_request_body = skip_request_body
-    @skip_response_body = skip_response_body
-  end
-
-  def call(url, request)
-    log = OutboundRequestLog.from_request(request, loggable: @loggable, skip_request_body: @skip_request_body)
-    yield.tap do |response|
-      log.from_response(response, skip_response_body: @skip_response_body)
-    end
-  rescue => e
-    log.response_body = {error: e.message}
-    raise
-  ensure
-    log.ended_at = Time.current
-    log.save!
-  end
-end
-
-ActiveSupport.on_load(:action_controller) do
-  include InboundRequestsLogger
+module RailsApiLogger
+  mattr_accessor :connects_to
 end

data/rails_api_logger.gemspec

@@ -1,6 +1,8 @@
+require_relative "lib/rails_api_logger/version"
+
 Gem::Specification.new do |spec|
   spec.name = "rails_api_logger"
-  spec.version = "0.9.0"
+  spec.version = RailsApiLogger::VERSION
   spec.authors = ["Alessandro Rodi"]
   spec.email = ["alessandro.rodi@renuo.ch"]
 
@@ -23,16 +25,19 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "railties", ">= 4.1.0"
-  spec.add_dependency "activerecord", ">= 4.1.0"
-  spec.add_dependency "actionpack", ">= 4.1.0"
+  rails_version = ">= 7.1"
+  spec.add_dependency "activerecord", rails_version
+  spec.add_dependency "activejob", rails_version
+  spec.add_dependency "railties", rails_version
   spec.add_dependency "nokogiri"
   spec.add_dependency "zeitwerk", ">= 2.0.0"
 
-  spec.add_development_dependency "sqlite3", "~> 1.4.0"
+  spec.add_development_dependency "sqlite3", "~> 2.1.0"
   spec.add_development_dependency "pg", "~> 1.5.4"
+  spec.add_development_dependency "mysql2", "~> 0.5.6"
   spec.add_development_dependency "standard", "~> 1.31"
   spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec-rails", "~> 7.1.0"
   spec.add_development_dependency "rack"
 end

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: rails_api_logger
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Alessandro Rodi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-12 00:00:00.000000000 Z
+date: 2024-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: railties
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: '7.1'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: activejob
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: '7.1'
 - !ruby/object:Gem::Dependency
-  name: actionpack
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 2.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.5.4
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.6
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +164,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.1.0
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -177,21 +205,25 @@ files:
 - ".semaphore/main-deploy.yml"
 - ".semaphore/semaphore.yml"
 - CHANGELOG.md
-- CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- app/controllers/inbound_requests_logger.rb
+- app/middlewares/rails_api_logger/middleware.rb
+- app/models/rails_api_logger/inbound_request_log.rb
+- app/models/rails_api_logger/loggable.rb
+- app/models/rails_api_logger/logger.rb
+- app/models/rails_api_logger/outbound_request_log.rb
+- app/models/rails_api_logger/request_log.rb
 - bin/console
+- bin/rails
 - bin/setup
 - lib/generators/rails_api_logger/install_generator.rb
 - lib/generators/templates/create_rails_api_logger_table.rb.tt
 - lib/rails_api_logger.rb
-- lib/rails_api_logger/inbound_request_log.rb
-- lib/rails_api_logger/inbound_requests_logger.rb
-- lib/rails_api_logger/inbound_requests_logger_middleware.rb
-- lib/rails_api_logger/outbound_request_log.rb
-- lib/rails_api_logger/request_log.rb
+- lib/rails_api_logger/engine.rb
+- lib/rails_api_logger/version.rb
 - rails_api_logger.gemspec
 homepage: https://github.com/renuo/rails_api_logger
 licenses:

data/CODE_OF_CONDUCT.md

@@ -1,74 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, gender identity and expression, level of experience,
-nationality, personal appearance, race, religion, or sexual identity and
-orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at alessandro.rodi@renuo.ch. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at [https://contributor-covenant.org/version/1/4][version]
-
-[homepage]: https://contributor-covenant.org
-[version]: https://contributor-covenant.org/version/1/4/

data/lib/rails_api_logger/inbound_request_log.rb

@@ -1,2 +0,0 @@
-class InboundRequestLog < RequestLog
-end

data/lib/rails_api_logger/inbound_requests_logger_middleware.rb

@@ -1,71 +0,0 @@
-class InboundRequestsLoggerMiddleware
-  attr_accessor :only_state_change, :path_regexp, :skip_request_body_regexp, :skip_response_body_regexp
-
-  def initialize(app, only_state_change: true,
-    path_regexp: /.*/,
-    skip_request_body_regexp: nil,
-    skip_response_body_regexp: nil)
-    @app = app
-    self.only_state_change = only_state_change
-    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
-    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)
-    env["PATH_INFO"] =~ 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

data/lib/rails_api_logger/outbound_request_log.rb

@@ -1,2 +0,0 @@
-class OutboundRequestLog < RequestLog
-end

data/lib/rails_api_logger/request_log.rb

@@ -1,76 +0,0 @@
-class RequestLog < ActiveRecord::Base
-  self.abstract_class = true
-
-  serialize :request_body, coder: JSON
-  serialize :response_body, coder: JSON
-
-  belongs_to :loggable, optional: true, polymorphic: true
-
-  scope :failed, -> { where(response_code: 400..599).or(where.not(ended_at: nil).where(response_code: nil)) }
-
-  validates :method, presence: true
-  validates :path, presence: true
-
-  def self.from_request(request, loggable: nil, skip_request_body: false)
-    if skip_request_body
-      body = "[Skipped]"
-    else
-      request_body = (request.body.respond_to?(:read) ? request.body.read : request.body)
-      body = request_body&.dup&.force_encoding("UTF-8")
-      begin
-        body = JSON.parse(body) if body.present?
-      rescue JSON::ParserError
-        body
-      end
-    end
-    create(path: request.path, request_body: body, method: request.method, started_at: Time.current, loggable: loggable)
-  end
-
-  def from_response(response, skip_response_body: false)
-    self.response_code = response.code
-    self.response_body = skip_response_body ? "[Skipped]" : manipulate_body(response.body)
-    self
-  end
-
-  def formatted_request_body
-    formatted_body(request_body)
-  end
-
-  def formatted_response_body
-    formatted_body(response_body)
-  end
-
-  def formatted_body(body)
-    if body.is_a?(String) && body.blank?
-      ""
-    elsif body.is_a?(Hash)
-      JSON.pretty_generate(body)
-    else
-      xml = Nokogiri::XML(body)
-      if xml.errors.any?
-        body
-      else
-        xml.to_xml(indent: 2)
-      end
-    end
-  rescue
-    body
-  end
-
-  def duration
-    return if started_at.nil? || ended_at.nil?
-    ended_at - started_at
-  end
-
-  private
-
-  def manipulate_body(body)
-    body_duplicate = body&.dup&.force_encoding("UTF-8")
-    begin
-      body_duplicate = JSON.parse(body_duplicate) if body_duplicate.present?
-    rescue JSON::ParserError
-      body_duplicate
-    end
-    body_duplicate
-  end
-end