logcraft 1.0.0.rc → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cebda0be923bafa1e3409178e92baa0c0161540b94655c1ccf0cc756ff7dbc2f
-  data.tar.gz: 35bcecda73c4bca768c4178fa5a0f1fe478d142b93f91f63ef8c8835dbc7d3f0
+  metadata.gz: 1553a9ab5e60ffb3beab51543cefcca10632c655fafa559ed18fe123dad9243a
+  data.tar.gz: 673ea0771ff8846f9b191f1ab745233cc6002dc2b454b92b97a4e5a8088dea33
 SHA512:
-  metadata.gz: 4ee4ea6eafd4e3b4ca5ff71b542baf38a58685ae639e083ece215a7e3f27d8c4b4fd08569f07e62d96602a5f37d7495478be90b7844adfa28b8caf3c6df7c829
-  data.tar.gz: 16f1d50ab12098b2e2ab341b4ff659f0504ff8282e8b78fe8cfe8a1ab8d8413e6d413b1ac4912e9e3af76080d7cc7407174a1b9a713b1922785180b562911f6a
+  metadata.gz: d440d1fb9a136f36e30911912ec79fff375ad4086b87697399e6530422d92e8749307ac043acdec270a04d507281e009d5f2bf86f5c01ab00192e40de34149d8
+  data.tar.gz: 5a207a0a5ed398a1ecd95db4252cd0455c265f8a93b4b3b22ab7a60f852d2b8b072ee59366117665476fd35730c134aac958b16d2f1c3670bcf538f08773ea97

data/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.1] - 2022-10-07
+### Fixed
+- Fixed a bug where request log tracing didn't work with the DataDog integration. Had to move up logging
+  the request to the point where the middleware is done processing instead of where we originally had it;
+  at the time when the response body was closed. We lost some precision in terms of measuring request duration
+  but some context (e.g. DataDog active trace) would not be available otherwise.
+
+## [2.0.0] - 2022-07-31
+### Added
+- Added the option to change the log level or suppress logging of unhandled errors which are, in fact,
+  handled by Rails (e.g. 404 Not Found).
+
+### Changed
+- The initial context is now fully dynamic; it can be either a Hash or a lambda/Proc returning a Hash.
+  Using a Hash with lambda values is no longer supported.
+- Renamed `initial_context` configuration setting to `global_context` everywhere.
+
+### Fixed
+- Fixed a bug where the request ID was missing from the access log.
+
+### Added
+- The provided RSpec matchers can now take other matchers as part of the log expectation.
+
 ## [1.0.0.rc] - 2022-06-26
 ### Added
-- Logcraft was rewritten from the ground up, based on its predecessor: [Ezlog](https://github.com/emartech/ezlog)
+- Logcraft was rewritten from the ground up, based on its predecessor: [Ezlog](https://github.com/emartech/ezlog).

data/Gemfile

@@ -6,7 +6,7 @@ source "https://rubygems.org"
 gemspec
 
 group :test do
-  gem 'rails', '~> 6.1'
+  gem 'rails', '~> 7.0.0'
   gem 'rspec-rails', '~> 4.0'
   gem 'sqlite3', '~> 1.4'
   gem 'net-smtp', require: false

data/README.md

@@ -1,36 +1,66 @@
 # Logcraft
 
 [![Build Status](https://github.com/zormandi/logcraft/actions/workflows/main.yml/badge.svg)](https://github.com/zormandi/logcraft/actions/workflows/main.yml)
+[![Gem Version](https://badge.fury.io/rb/logcraft.svg)](https://badge.fury.io/rb/logcraft)
 
-Logcraft is a zero-configuration structured logging library for pure Ruby or [Ruby on Rails](https://rubyonrails.org/) applications.
-It is the successor to [Ezlog](https://github.com/emartech/ezlog) with which it shares its ideals but is reimagined and
-reimplemented to be more versatile and much more thoroughly tested.
+Logcraft is a zero-configuration structured logging library for pure Ruby or [Ruby on Rails](https://rubyonrails.org/)
+applications. It is the successor to [Ezlog](https://github.com/emartech/ezlog) with which it shares its ideals but is
+reimagined and reimplemented to be more versatile and much more thoroughly tested.
 
 Logcraft's purpose is threefold:
+
 1. Make sure that our applications are logging in a concise and sensible manner; emitting no unnecessary "noise" but
    containing all relevant and necessary information (like timing or a request ID).
 2. Make sure that all log messages are written to STDOUT in a machine-processable format (JSON).
 3. Achieving the above goals should require no configuration in the projects where the library is used.
 
 Logcraft supports:
-* [Ruby](https://www.ruby-lang.org) 2.6 and up (tested with 2.6, 2.7, 3.0 and 3.1)
-* [Rails](https://rubyonrails.org/) 5 and up (tested with 5.2, 6.0 and 6.1)
-* [Sidekiq](https://github.com/mperham/sidekiq) support is coming soon via a separate gem (_logcraft-sidekiq_)
 
-Logcraft uses Tim Pease's wonderful [Logging](https://github.com/TwP/logging) gem under the hood for an all-purpose structured logging solution.
+* [Ruby](https://www.ruby-lang.org) 2.6 and up (tested with 2.6, 2.7, 3.0 and 3.1)
+* [Rails](https://rubyonrails.org/) 5 and up (tested with 5.2, 6.0, 6.1 and 7.0)
+* [Sidekiq](https://github.com/mperham/sidekiq) integration is provided via
+  the [Logcraft::Sidekiq](https://github.com/zormandi/logcraft-sidekiq) gem
+
+Logcraft uses Tim Pease's wonderful [Logging](https://github.com/TwP/logging) gem under the hood for an all-purpose
+structured logging solution.
+
+## Table of contents
+
+* [Installation](#installation)
+  * [Rails](#rails)
+  * [Non-Rails applications](#non-rails-applications)
+* [Usage](#usage)
+  * [Structured logging](#structured-logging)
+    * [Adding context information to log messages](#adding-context-information-to-log-messages)
+  * [Rails logging](#rails-logging)
+    * [The log level](#the-log-level)
+    * [JSON serialization](#json-serialization)
+* [Configuration options](#configuration-options)
+  * [Rails configuration](#rails-configuration)
+  * [Non-Rails configuration](#non-rails-configuration)
+* [Integration with DataDog](#integration-with-datadog)
+* [RSpec support](#rspec-support)
+* [Development](#development)
+* [Contributing](#contributing)
+* [Disclaimer](#disclaimer)
+* [License](#license)
+* [Code of Conduct](#code-of-conduct)
 
 ## Installation
 
 ### Rails
 
 Add this line to your application's Gemfile:
+
 ```ruby
 gem 'logcraft'
+gem 'oj' # Optional, but recommended; see the "JSON serialization" section in the README
 ```
 
-Although Logcraft sets up sensible defaults for all logging configuration settings, it leaves you the option to override these
-settings manually in the way you're used to; via Rails's configuration mechanism. Unfortunately the Rails new project generator
-automatically generates code for the production environment configuration that overrides some of these default settings.
+Although Logcraft sets up sensible defaults for all logging configuration settings, it leaves you the option to override
+these settings manually in the way you're used to; via Rails's configuration mechanism. Unfortunately the Rails new
+project generator automatically generates code for the production environment configuration that overrides some of these
+default settings.
 
 For Logcraft to work properly, you need to delete or comment out the logging configuration options in the generated
 `config/environments/production.rb` file.
@@ -38,13 +68,17 @@ For Logcraft to work properly, you need to delete or comment out the logging con
 ### Non-Rails applications
 
 Add this line to your application's Gemfile:
+
 ```ruby
 gem 'logcraft'
 ```
+
 and call
+
 ```ruby
 Logcraft.initialize
 ```
+
 any time during your application's startup.
 
 ## Usage
@@ -60,6 +94,7 @@ messages in JSON format to the standard output. These loggers can handle a varie
 * any other object that can be coerced into a String
 
 The logger also automatically adds some basic information to all messages, such as:
+
 * name of the logger
 * timestamp
 * log level (as string)
@@ -67,20 +102,21 @@ The logger also automatically adds some basic information to all messages, such
 * PID
 
 Examples:
+
 ```ruby
 logger = Logcraft.logger 'Application'
 
 logger.info 'Log message'
-# => {"timestamp":"2022-06-26T17:52:57.845+02:00","level":"INFO","logger":"Application","hostname":"Zoltans-iPro","pid":80422,"message":"Log message"}
+# => {"timestamp":"2022-06-26T17:52:57.845+02:00","level":"INFO","logger":"Application","hostname":"MacbookPro.local","pid":80422,"message":"Log message"}
 
 logger.info message: 'User logged in', user_id: 42
 # => {"timestamp":"2022-06-26T17:44:01.926+02:00","level":"INFO","logger":"Application","hostname":"MacbookPro.local","pid":80422,"message":"User logged in","user_id":42}
 
-logger.warn error
+logger.error error
 # Formatted for better readability (the original is a single line string):
 # => {
 #      "timestamp": "2022-06-26T17:46:42.418+02:00",
-#      "level": "WARN",
+#      "level": "ERROR",
 #      "logger": "Application",
 #      "hostname": "MacbookPro.local",
 #      "pid": 80422,
@@ -96,6 +132,22 @@ logger.warn error
 #        }
 #      }
 #    }
+
+# Any top-level field of the log message can be an Exception (so the error message can be customized):
+logger.warn message: 'An error occured', warning: error
+# => {
+#      "timestamp": "2022-06-26T17:46:42.418+02:00",
+#      "level": "WARN",
+#      "logger": "Application",
+#      "hostname": "MacbookPro.local",
+#      "pid": 80422,
+#      "message": "An error occured",
+#      "warning": {
+#        "class": "StandardError",
+#        "message": "original error message",
+#        "backtrace": [...]
+#      }
+#    }
 ```
 
 #### Adding context information to log messages
@@ -131,17 +183,20 @@ You can access these methods either in the global scope by calling them via `Log
 
 ### Rails logging
 
-Logcraft automatically configures Rails to provide you with structured logging capability via the `Rails.logger`. 
+Logcraft automatically configures Rails to provide you with structured logging capability via the `Rails.logger`.
 It also changes Rails's default logging configuration to be more concise and emit less "noise".
 
 In more detail:
+
 * The `Rails.logger` is set up to be a Logcraft logger with the name `Application`.
-* Rails's default logging of uncaught errors is modified and instead of spreading the error message across several lines,
-  Logcraft log every uncaught error in 1 line (per error), including the error's name and context (stack trace, etc.).
-* Most importantly, Rails's default request logging - which logs several lines per event during the processing of an action -
-  is replaced by Logcraft's own access log middleware. The end result is an access log that
-   * contains all relevant information (request ID, method, path, params, client IP, duration and response status code), and
-   * has 1 log line per request, logged at the end of the request.
+* Rails's default logging of uncaught errors is modified and instead of spreading the error message across several
+  lines, Logcraft log every uncaught error in 1 line (per error), including the error's name and context (stack trace,
+  etc.).
+* Most importantly, Rails's default request logging - which logs several lines per event during the processing of an
+  action - is replaced by Logcraft's own access log middleware. The end result is an access log that
+    * contains all relevant information (request ID, method, path, params, client IP, duration and
+      response status code), and
+    * has 1 log line per request, logged at the end of the request.
 
 Thanks to Mathias Meyer for writing [Lograge](https://github.com/roidrage/lograge), which inspired the solution.
 If Logcraft is not your cup of tea but you're looking for a way to tame Rails's logging then be sure to check out
@@ -168,7 +223,8 @@ Formatted for readability:
   "level": "INFO",
   "logger": "AccessLog",
   "hostname": "MacbookPro.local",
-  "pid": 80908, "request_id": "9a43631b-284c-4677-9d08-9c1cc5c7d3a7",
+  "pid": 80908, 
+  "request_id": "9a43631b-284c-4677-9d08-9c1cc5c7d3a7",
   "message": "GET /welcome?subsession_id=34ea8596f9764f475f81158667bc2654 - 200 (OK)",
   "remote_ip": "127.0.0.1",
   "method": "GET",
@@ -187,51 +243,85 @@ Formatted for readability:
 By default, Logcraft logs all request parameters as a hash (JSON object) under the `params` key. This is very convenient
 in a structured logging system and makes it easy to search for specific request parameter values e.g. in ElasticSearch
 (should you happen to store your logs there). Unfortunately, in some cases - such as when handling large forms - this
-can create quite a bit of noise and impact the searchability of your logs negatively or pose a security risk or data policy
-violation. You have the option to restrict the logging of certain parameters via configuration options (see the
+can create quite a bit of noise and impact the searchability of your logs negatively or pose a security risk or data
+policy violation. You have the option to restrict the logging of certain parameters via configuration options (see the
 Configuration section).
 
 #### The log level
 
 The logger's log level is determined as follows (in order of precedence):
+
 * the log level set in the application's configuration (for Rails applications),
-* the LOG_LEVEL environment variable, or
+* the `LOG_LEVEL` environment variable, or
 * `INFO` as the default log level if none of the above are set.
 
 The following log levels are available: `DEBUG`, `INFO`, `WARN`, `ERROR`, `FATAL`.
 
+#### JSON serialization
+
+Logcraft uses the [MultiJSON](https://github.com/intridea/multi_json) gem for serializing data to JSON, which in turn
+uses ActiveSupport's JSON encoder by default (unless you have some other JSON gem loaded in your project).
+However, ActiveSupport's JSON encoder has some quirks which you might not be aware of:
+
+```ruby
+ActiveSupport::JSON.encode test: 'foo > bar'
+#=> "{\"test\":\"foo \\u003e bar\"}"
+
+{test: 'foo > bar'}.to_json
+#=> "{\"test\":\"foo \\u003e bar\"}"
+```
+
+I highly recommend using the [Oj](https://github.com/ohler55/oj) gem which - if present - will be automatically
+picked up by Logcraft, as it is significantly faster and will serialize your messages as you would expect.
+
+In a nutshell:
+```ruby
+# With default ActiveSupport serialization
+Rails.logger.info 'foo > bar'
+#=> {...,"message":"foo \u003e bar"}
+
+# With Oj
+Rails.logger.info 'foo > bar'
+#=> {...,"message":"foo > bar"}
+```
+
 ## Configuration options
 
-### Rails
+### Rails configuration
 
 Logcraft provides the following configuration options for Rails:
 
-| Option                                          | Default value            | Description                                                                                                 |
-|-------------------------------------------------|--------------------------|-------------------------------------------------------------------------------------------------------------|
-| logcraft.initial_context                        | `{}`                     | A global log context that will be included in every log message. May include lambdas (see examples).        |
-| logcraft.layout_options                         | `{}`                     | Custom options for the log layout. Currently only the `level_formatter` option is supported (see examples). |
-| logcraft.access_log.logger_name                 | `'AccessLog'`            | The name of the logger emitting access log messages.                                                        |
-| logcraft.access_log.exclude_paths               | `[]`                     | A list of paths (array of strings or RegExps) not to include in the access log.                             |
-| logcraft.access_log.log_only_whitelisted_params | `false`                  | If `true`, the access log will only contain whitelisted parameters.                                         |
-| logcraft.access_log.whitelisted_params          | `[:controller, :action]` | The only parameters to be logged in the access log if whitelisting is enabled.                              |
+| Option                                                | Default value            | Description                                                                                                                                                          |
+|-------------------------------------------------------|--------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| logcraft.global_context                               | `{}`                     | A global log context that will be included in every log message. Must be either a Hash or a lambda/Proc returning a Hash.                                            |
+| logcraft.layout_options                               | `{}`                     | Custom options for the log layout. Currently only the `level_formatter` option is supported (see examples).                                                          |
+| logcraft.access_log.logger_name                       | `'AccessLog'`            | The name of the logger emitting access log messages.                                                                                                                 |
+| logcraft.access_log.exclude_paths                     | `[]`                     | A list of paths (array of strings or RegExps) not to include in the access log.                                                                                      |
+| logcraft.access_log.log_only_whitelisted_params       | `false`                  | If `true`, the access log will only contain whitelisted parameters.                                                                                                  |
+| logcraft.access_log.whitelisted_params                | `[:controller, :action]` | The only parameters to be logged in the access log if whitelisting is enabled.                                                                                       |
+| logcraft.unhandled_errors.log_level                   | `:fatal`                 | The log level with which to log unhandled errors. Rails logs these with FATAL, by default.                                                                           |
+| logcraft.unhandled_errors.log_errors_handled_by_rails | `true`                   | Whether or not to log unhandled errors which are actually handled by Rails (e.g. 404). For a detailed list, see `ActionDispatch::ExceptionWrapper.rescue_responses`. |
 
 Examples:
+
 ```ruby
 # Use these options in your Rails configuration files (e.g. application.rb)
 
 # Set up a global context you want to see in every log message
-config.logcraft.initial_context = {
-  environment: ENV['RAILS_ENV'],
-  timestamp_linux: -> { Time.current.to_i } # evaluated when emitting a log message
-}
+config.logcraft.global_context = -> do
+  {
+    environment: ENV['RAILS_ENV'],
+    timestamp_linux: Time.current.to_i # evaluated every time when emitting a log message
+  }
+end
 
 # Set up a custom log level formatter (e.g. Ougai-like numbers)
 config.logcraft.layout_options = {
-  level_formatter: ->(level_number) { (level_number + 2) * 10 } 
+  level_formatter: ->(level_number) { (level_number + 2) * 10 }
 }
 Rails.logger.error('Boom!')
 # => {...,"level":50,"message":"Boom!"}
-        
+
 # Exclude healthcheck and monitoring URLs from your access log:
 config.logcraft.exclude_paths = ['/healthcheck', %r(/monitoring/.*)]
 
@@ -239,35 +329,36 @@ config.logcraft.exclude_paths = ['/healthcheck', %r(/monitoring/.*)]
 config.logcraft.log_only_whitelisted_params = true
 ```
 
-### Non-Rails
+### Non-Rails configuration
 
-The `initial_context` and `layout_options` configuration options (see above) are available to non-Rails projects 
+The `global_context` and `layout_options` configuration options (see above) are available to non-Rails projects
 via Logcraft's initialization mechanism. You can also set the default log level this way.
 
 ```ruby
-Logcraft.initialize log_level: :info, initial_context: {}, layout_options: {}
+Logcraft.initialize log_level: :info, global_context: {}, layout_options: {}
 ```
 
 ## Integration with DataDog
 
-You can set up tracing with [DataDog](https://www.datadoghq.com/) by providing an initial context to be included in every log message:
+You can set up tracing with [DataDog](https://www.datadoghq.com/) by providing a global context to be included in
+every log message:
 
 ```ruby
-config.logcraft.initial_context = {
-  dd: -> do
-    return unless Datadog::Tracing.enabled?
+config.logcraft.global_context = -> do
+  return {} unless Datadog::Tracing.enabled?
 
-    correlation = Datadog::Tracing.correlation
-    {
+  correlation = Datadog::Tracing.correlation
+  {
+    dd: {
       trace_id: correlation.trace_id.to_s,
       span_id: correlation.span_id.to_s,
       env: correlation.env.to_s,
       service: correlation.service.to_s,
       version: correlation.version.to_s
-    }
-  end,
-  ddsource: ['ruby']
-}
+    },
+    ddsource: ['ruby']
+  }
+end
 ```
 
 ## RSpec support
@@ -280,12 +371,13 @@ require 'logcraft/rspec'
 ```
 
 What you get:
+
 * Helpers
-  * `log_output` provides access to the complete log output (array of strings) in your specs
-  * `log_output_is_expected` shorthand for writing expectations for the log output
+    * `log_output` provides access to the complete log output (array of strings) in your specs
+    * `log_output_is_expected` shorthand for writing expectations for the log output
 * Matchers
-  * `include_log_message` matcher for expecting a certain message in the log output
-  * `log` matcher for expecting an operation to log a certain message
+    * `include_log_message` matcher for expecting a certain message in the log output
+    * `log` matcher for expecting an operation to log a certain message
 
 ```ruby
 # Check that the log output contains a certain message
@@ -293,8 +385,13 @@ expect(log_output).to include_log_message message: 'Test message'
 log_output_is_expected.to include_log_message message: 'Test message'
 
 # Check that the message is not present in the logs before the operation but is present after it 
-expect { operation }.to log message: 'Test message', 
-                            user_id: 123456 
+expect { operation }.to log message: 'Test message',
+                            user_id: 123456
+
+# RSpec's matchers can be used inside the expectation
+expect { get '/' }.to log message: 'GET / - 200 (OK)',
+                          request_id: match(/[\w-]+/),
+                          duration: be_within(100).of(100)
 
 # Expect a certain log level
 log_output_is_expected.to include_log_message(message: 'Test message').at_level(:info)
@@ -303,22 +400,22 @@ expect { operation }.to log(message: 'Test message').at_level(:info)
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. 
+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 
+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 the created tag, 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/zormandi/logcraft. This project is intended 
-to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the 
+Bug reports and pull requests are welcome on GitHub at https://github.com/zormandi/logcraft. 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/zormandi/logcraft/blob/master/CODE_OF_CONDUCT.md).
 
 ## Disclaimer
 
-Logcraft is highly opinionated software and does in no way aim or claim to be useful for everyone. 
+Logcraft is highly opinionated software and does in no way aim or claim to be useful for everyone.
 Use at your own discretion.
 
 ## License
@@ -327,5 +424,5 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Logcraft project's codebases, issue trackers, chat rooms and mailing lists is expected 
+Everyone interacting in the Logcraft project's codebases, issue trackers, chat rooms and mailing lists is expected
 to follow the [code of conduct](https://github.com/zormandi/logcraft/blob/master/CODE_OF_CONDUCT.md).

data/gemfiles/rails_7.0.gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in logcraft.gemspec
+gemspec path: '..'
+
+group :test do
+  gem 'rails', '~> 7.0.0'
+  gem 'rspec-rails', '~> 4.0'
+  gem 'sqlite3', '~> 1.4'
+  gem 'net-smtp', require: false
+end

data/lib/logcraft/log_layout.rb

@@ -4,13 +4,13 @@ require 'time'
 
 module Logcraft
   class LogLayout < Logging::Layout
-    def initialize(context = {}, options = {})
-      @general_context = context
+    def initialize(global_context = {}, options = {})
+      @global_context = global_context
       @level_formatter = options.fetch :level_formatter, ->(level) { Logging::LNAMES[level] }
     end
 
     def format(event)
-      log_entry = background_of(event).merge evaluated_general_context,
+      log_entry = background_of(event).merge evaluated_global_context,
                                              dynamic_log_context,
                                              message_from(event.data)
       MultiJson.dump(log_entry) + "\n"
@@ -28,8 +28,12 @@ module Logcraft
       }
     end
 
-    def evaluated_general_context
-      @general_context.transform_values { |v| v.is_a?(Proc) ? v.call : v }
+    def evaluated_global_context
+      if @global_context.respond_to? :call
+        @global_context.call
+      else
+        @global_context
+      end
     end
 
     def dynamic_log_context
@@ -52,8 +56,7 @@ module Logcraft
     end
 
     def format_exception(exception)
-      error_hash = {'class' => exception.class.name,
-                    'message' => exception.message}
+      error_hash = {'class' => exception.class.name, 'message' => exception.message}
       error_hash['backtrace'] = exception.backtrace.first(20) if exception.backtrace
       error_hash['cause'] = format_cause(exception.cause) if exception.cause
       error_hash

data/lib/logcraft/rails/extensions.rb

@@ -1,12 +1,22 @@
+# frozen_string_literal: true
+
 module ActionDispatch
   class DebugExceptions
+
+    private
+
     def log_error_with_logcraft(request, wrapper)
       logger = logger(request)
       exception = wrapper.exception
-      logger.fatal exception
+      config = Rails.configuration.logcraft.unhandled_errors
+      logger.public_send config.log_level, exception if config.log_errors_handled_by_rails || !handled_by_rails?(exception)
     end
 
     alias_method :original_log_error, :log_error
     alias_method :log_error, :log_error_with_logcraft
+
+    def handled_by_rails?(exception)
+      ActionDispatch::ExceptionWrapper.rescue_responses.key? exception.class.name
+    end
   end
 end

data/lib/logcraft/rails/request_logger.rb

@@ -14,12 +14,9 @@ module Logcraft
         request = ActionDispatch::Request.new env
 
         instrumentation_start request
-
         status, headers, body = @app.call env
-        body = ::Rack::BodyProxy.new(body) do
-          instrumentation_finish request
-          log_request request, status, start_time
-        end
+        body = ::Rack::BodyProxy.new(body) { instrumentation_finish request }
+        log_request request, status, start_time
 
         [status, headers, body]
       rescue Exception => ex
@@ -50,17 +47,14 @@ module Logcraft
         return if path_ignored? request
 
         end_time = current_time_in_milliseconds
-        message = {
-          message: '%s %s - %i (%s)' % [request.method, request.filtered_path, status, Rack::Utils::HTTP_STATUS_CODES[status]],
-          remote_ip: request.remote_ip,
-          method: request.method,
-          path: request.filtered_path,
-          params: params_to_log(request),
-          response_status_code: status,
-          duration: end_time - start_time,
-          duration_sec: (end_time - start_time) / 1000.0
-        }
-        @logger.info message
+        @logger.info message: '%s %s - %i (%s)' % [request.method, request.filtered_path, status, Rack::Utils::HTTP_STATUS_CODES[status]],
+                     remote_ip: request.remote_ip,
+                     method: request.method,
+                     path: request.filtered_path,
+                     params: params_to_log(request),
+                     response_status_code: status,
+                     duration: end_time - start_time,
+                     duration_sec: (end_time - start_time) / 1000.0
       end
 
       def path_ignored?(request)

data/lib/logcraft/railtie.rb

@@ -5,7 +5,7 @@ require 'rails/railtie'
 module Logcraft
   class Railtie < ::Rails::Railtie
     config.logcraft = ActiveSupport::OrderedOptions.new
-    config.logcraft.initial_context = {}
+    config.logcraft.global_context = {}
     config.logcraft.layout_options = {}
 
     config.logcraft.access_log = ActiveSupport::OrderedOptions.new
@@ -14,9 +14,13 @@ module Logcraft
     config.logcraft.access_log.log_only_whitelisted_params = false
     config.logcraft.access_log.whitelisted_params = [:controller, :action]
 
+    config.logcraft.unhandled_errors = ActiveSupport::OrderedOptions.new
+    config.logcraft.unhandled_errors.log_level = :fatal
+    config.logcraft.unhandled_errors.log_errors_handled_by_rails = true
+
     initializer 'logcraft.initialize' do |app|
       Logcraft.initialize log_level: app.config.log_level,
-                          initial_context: app.config.logcraft.initial_context,
+                          global_context: app.config.logcraft.global_context,
                           layout_options: app.config.logcraft.layout_options
     end
 

data/lib/logcraft/rspec/matchers.rb

@@ -2,21 +2,30 @@
 
 require 'json'
 
-RSpec::Matchers.define :include_log_message do |expected|
+RSpec::Matchers.define :include_log_message do |expected_message|
   chain :at_level, :log_level
 
   match do |actual|
-    actual.any? { |log_line| includes? log_line, expected_messages_from(expected) }
+    actual.any? { |log_line| includes? log_line, expected_message }
   end
 
-  def includes?(log_line, messages)
-    return false unless includes_log_level? log_line
-    messages.all? { |message| log_line.include? message }
+  def includes?(log_line, expected)
+    actual = JSON.parse log_line, symbolize_names: true
+    expected = normalize_expectation expected
+    RSpec::Matchers::BuiltIn::Include.new(expected).matches? actual
   end
 
-  def includes_log_level?(log_line)
-    return true if log_level.nil?
-    log_line.include? log_level_string(log_level)
+  def normalize_expectation(expected)
+    result = case expected
+             when String
+               {message: expected}
+             when Hash
+               expected
+             else
+               raise ArgumentError, 'Log expectation must be either a String or a Hash'
+             end
+    result[:level] = log_level_string(log_level) unless log_level.nil?
+    result
   end
 
   def log_level_string(log_level)
@@ -24,19 +33,8 @@ RSpec::Matchers.define :include_log_message do |expected|
     log_level.to_s.upcase
   end
 
-  def expected_messages_from(object)
-    @expected_messages ||= case object
-                           when Hash
-                             object.map { |k, v| JSON.dump(k => v)[1...-1] }
-                           when String
-                             [object]
-                           else
-                             raise NotImplementedError, 'log expectation must be Hash or String'
-                           end
-  end
-
   failure_message do |actual|
-    error_message = "expected log output\n\t'#{actual.join('')}'\nto include log message\n\t'#{expected}'"
+    error_message = "expected log output\n\t'#{actual.join('')}'\nto include log message\n\t'#{expected_message}'"
     error_message += " at #{log_level} level" if log_level
     error_message
   end

data/lib/logcraft/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Logcraft
-  VERSION = "1.0.0.rc"
+  VERSION = "2.0.1"
 end

data/lib/logcraft.rb

@@ -12,8 +12,8 @@ module Logcraft
 
   extend LogContextHelper
 
-  def self.initialize(log_level: :info, initial_context: {}, layout_options: {})
-    Logging.logger.root.appenders = Logging.appenders.stdout layout: LogLayout.new(initial_context, layout_options)
+  def self.initialize(log_level: :info, global_context: {}, layout_options: {})
+    Logging.logger.root.appenders = Logging.appenders.stdout layout: LogLayout.new(global_context, layout_options)
     Logging.logger.root.level = log_level
   end
 

data/logcraft.gemspec

@@ -8,20 +8,20 @@ Gem::Specification.new do |spec|
   spec.authors = ["Zoltan Ormandi"]
   spec.email = ["zoltan.ormandi@gmail.com"]
 
-  spec.summary = "A zero-configuration logging solution for Ruby on Rails."
+  spec.summary = "A zero-configuration structured logging solution for pure Ruby or Ruby on Rails projects."
   spec.homepage = "https://github.com/zormandi/logcraft"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 2.6.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/zormandi/logcraft"
-  spec.metadata["changelog_uri"] = "https://github.com/zormandi/logcraft/blob/master/CHANGELOG.md"
+  spec.metadata["changelog_uri"] = "https://github.com/zormandi/logcraft/blob/main/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor|Rakefile)})
     end
   end
   spec.bindir = "exe"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: logcraft
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc
+  version: 2.0.1
 platform: ruby
 authors:
 - Zoltan Ormandi
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-26 00:00:00.000000000 Z
+date: 2022-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logging
@@ -80,7 +80,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: 
+description:
 email:
 - zoltan.ormandi@gmail.com
 executables: []
@@ -93,10 +93,10 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
 - gemfiles/rails_5.2.gemfile
 - gemfiles/rails_6.0.gemfile
 - gemfiles/rails_6.1.gemfile
+- gemfiles/rails_7.0.gemfile
 - lib/logcraft.rb
 - lib/logcraft/log_context_helper.rb
 - lib/logcraft/log_layout.rb
@@ -119,8 +119,8 @@ licenses:
 metadata:
   homepage_uri: https://github.com/zormandi/logcraft
   source_code_uri: https://github.com/zormandi/logcraft
-  changelog_uri: https://github.com/zormandi/logcraft/blob/master/CHANGELOG.md
-post_install_message: 
+  changelog_uri: https://github.com/zormandi/logcraft/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -131,12 +131,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
-summary: A zero-configuration logging solution for Ruby on Rails.
+summary: A zero-configuration structured logging solution for pure Ruby or Ruby on
+  Rails projects.
 test_files: []

data/Rakefile

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-def add_logcraft_options_to_application_configuration
-  project_root = File.dirname __FILE__
-  Dir.chdir(project_root + '/spec') do
-    app_config = File.readlines 'test-app/config/application.rb'
-    modified_config = app_config.each_with_object([]) do |line, config|
-      config << line
-      if line.include? 'config.load_defaults'
-        logcraft_config = File.readlines 'fixtures/test-app/config/logcraft_config.rb'
-        config.concat logcraft_config
-      end
-    end
-    File.write 'test-app/config/application.rb', modified_config.join
-  end
-end
-
-desc 'Generate sample Rails app for acceptance testing'
-task :generate_rails_app do
-  project_root = File.dirname __FILE__
-  Dir.chdir(project_root + '/spec') do
-    FileUtils.rm_rf 'test-app'
-    system 'rails new test-app --database=sqlite3 --skip-gemfile --skip-git --skip-keeps --skip-action-mailer'\
-           '--skip-action-mailbox --skip-action-text --skip-active-job --skip-active-storage --skip-puma --skip-action-cable'\
-           '--skip-sprockets --skip-spring --skip-listen --skip-javascript --skip-turbolinks --skip-jbuilder --skip-test'\
-           '--skip-system-test --skip-bootsnap --skip-bundle --skip-webpack-install'
-    FileUtils.cp_r 'fixtures/test-app/.', 'test-app', remove_destination: true
-    add_logcraft_options_to_application_configuration
-  end
-end
-
-namespace :spec do
-  desc 'Run RSpec unit tests'
-  RSpec::Core::RakeTask.new(:unit) do |t|
-    t.exclude_pattern = 'spec/integration/*_spec.rb'
-  end
-
-  desc 'Run RSpec integration tests'
-  RSpec::Core::RakeTask.new(:integration) do |t|
-    t.pattern = 'spec/integration/*_spec.rb'
-  end
-end
-
-desc 'Run all RSpec examples'
-RSpec::Core::RakeTask.new(:spec)
-
-task default: :spec