logcraft 1.0.0.rc

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cebda0be923bafa1e3409178e92baa0c0161540b94655c1ccf0cc756ff7dbc2f
+  data.tar.gz: 35bcecda73c4bca768c4178fa5a0f1fe478d142b93f91f63ef8c8835dbc7d3f0
+SHA512:
+  metadata.gz: 4ee4ea6eafd4e3b4ca5ff71b542baf38a58685ae639e083ece215a7e3f27d8c4b4fd08569f07e62d96602a5f37d7495478be90b7844adfa28b8caf3c6df7c829
+  data.tar.gz: 16f1d50ab12098b2e2ab341b4ff659f0504ff8282e8b78fe8cfe8a1ab8d8413e6d413b1ac4912e9e3af76080d7cc7407174a1b9a713b1922785180b562911f6a

data/.rspec

@@ -0,0 +1,3 @@
+--format progress
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+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).
+
+## [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)

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders 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, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement via https://github.com/zormandi/logcraft. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Zoltan Ormandi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,331 @@
+# Logcraft
+
+[![Build Status](https://github.com/zormandi/logcraft/actions/workflows/main.yml/badge.svg)](https://github.com/zormandi/logcraft/actions/workflows/main.yml)
+
+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.
+
+## Installation
+
+### Rails
+
+Add this line to your application's Gemfile:
+```ruby
+gem 'logcraft'
+```
+
+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.
+
+### 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
+
+### Structured logging
+
+Any loggers created by your application (including the `Rails.logger`) will automatically be configured to write
+messages in JSON format to the standard output. These loggers can handle a variety of message types:
+
+* String
+* Hash
+* Exception
+* 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)
+* hostname
+* 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"}
+
+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
+# Formatted for better readability (the original is a single line string):
+# => {
+#      "timestamp": "2022-06-26T17:46:42.418+02:00",
+#      "level": "WARN",
+#      "logger": "Application",
+#      "hostname": "MacbookPro.local",
+#      "pid": 80422,
+#      "message": "wrapping error",
+#      "error": {
+#        "class": "StandardError",
+#        "message": "wrapping error",
+#        "backtrace": [...],
+#        "cause": {
+#          "class": "RuntimeError",
+#          "message": "original error",
+#          "backtrace": [...]
+#        }
+#      }
+#    }
+```
+
+#### Adding context information to log messages
+
+Logcraft provides two helper methods which can be used to add context information to log messages:
+
+* `within_log_context(context)`: Starts a new log context initialized with `context` and executes the provided block
+  within that context. Once execution is finished, the log context is cleaned up and the previous context (if any) is
+  reinstated. In practice, this means that every time we log something (within the block), the log message will include
+  the information that's in the current context. This can be useful for storing request-specific information
+  (request ID, user ID, ...) in the log context early on (for example in a middleware) and not have to worry about
+  including it every time we want to log a message.
+
+  Example:
+
+  ```ruby
+  within_log_context customer_id: 1234 do
+    logger.info 'test 1'
+  end
+  logger.info 'test 2'
+  
+  #=> {...,"level":"INFO","customer_id":1234,"message":"test 1"}
+  #=> {...,"level":"INFO","message":"test 2"}
+  ```
+
+* `add_to_log_context(context)`: Adds the provided `context` to the current log context but provides no mechanism for
+  removing it later. Only use this method if you are sure that you're working within a specific log context and that it
+  will be cleaned up later (e.g. by only using this method in a block passed to the previously explained
+  `within_log_context` method).
+
+You can access these methods either in the global scope by calling them via `Logcraft.within_log_context` and
+`Logcraft.add_to_log_context` or locally by including the `Logcraft::LogContextHelper` module into your class/module.
+
+### Rails logging
+
+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.
+
+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
+[Lograge](https://github.com/roidrage/lograge).
+
+```
+GET /welcome?subsession_id=34ea8596f9764f475f81158667bc2654
+
+With default Rails logging:
+
+Started GET "/welcome?subsession_id=34ea8596f9764f475f81158667bc2654" for 127.0.0.1 at 2022-06-26 18:07:08 +0200
+Processing by PagesController#welcome as HTML
+  Parameters: {"subsession_id"=>"34ea8596f9764f475f81158667bc2654"}
+  Rendering pages/welcome.html.haml within layouts/application
+  Rendered pages/welcome.html.haml within layouts/application (5.5ms)
+Completed 200 OK in 31ms (Views: 27.3ms | ActiveRecord: 0.0ms)
+
+With Logcraft:
+{"timestamp":"2022-06-26T18:07:08.103+02:00","level":"INFO","logger":"AccessLog","hostname":"MacbookPro.local","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","path":"/welcome?subsession_id=34ea8596f9764f475f81158667bc2654","params":{"subsession_id":"34ea8596f9764f475f81158667bc2654","controller":"pages","action":"welcome"},"response_status_code":200,"duration":13,"duration_sec":0.013}
+
+Formatted for readability:
+{
+  "timestamp": "2022-06-26T18:07:08.103+02:00",
+  "level": "INFO",
+  "logger": "AccessLog",
+  "hostname": "MacbookPro.local",
+  "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",
+  "path": "/welcome?subsession_id=34ea8596f9764f475f81158667bc2654",
+  "params": {
+    "subsession_id": "34ea8596f9764f475f81158667bc2654",
+    "controller": "pages",
+    "action": "welcome"
+  }, 
+  "response_status_code": 200, 
+  "duration": 13, 
+  "duration_sec": 0.013
+}
+```
+
+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
+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
+* `INFO` as the default log level if none of the above are set.
+
+The following log levels are available: `DEBUG`, `INFO`, `WARN`, `ERROR`, `FATAL`.
+
+## Configuration options
+
+### Rails
+
+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.                              |
+
+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
+}
+
+# Set up a custom log level formatter (e.g. Ougai-like numbers)
+config.logcraft.layout_options = {
+  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/.*)]
+
+# Make sure no sensitive data is logged by accident in the access log, so only log controller and action:
+config.logcraft.log_only_whitelisted_params = true
+```
+
+### Non-Rails
+
+The `initial_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: {}
+```
+
+## 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:
+
+```ruby
+config.logcraft.initial_context = {
+  dd: -> do
+    return unless Datadog::Tracing.enabled?
+
+    correlation = Datadog::Tracing.correlation
+    {
+      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']
+}
+```
+
+## RSpec support
+
+Logcraft comes with built-in support for testing your logging activity using [RSpec](https://rspec.info/).
+To enable spec support for Logcraft, put this line in your `spec_helper.rb` or `rails_helper.rb`:
+
+```ruby
+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
+* 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
+
+```ruby
+# Check that the log output contains a certain message
+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 a certain log level
+log_output_is_expected.to include_log_message(message: 'Test message').at_level(:info)
+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. 
+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 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 
+[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. 
+Use at your own discretion.
+
+## 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 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/Rakefile

@@ -0,0 +1,50 @@
+# 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

data/gemfiles/rails_5.2.gemfile

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

data/gemfiles/rails_6.0.gemfile

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

data/gemfiles/rails_6.1.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', '~> 6.1.0'
+  gem 'rspec-rails', '~> 4.0'
+  gem 'sqlite3', '~> 1.4'
+  gem 'net-smtp', require: false
+end

data/lib/logcraft/log_context_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Logcraft
+  module LogContextHelper
+    def within_log_context(context = {})
+      Logging.mdc.push context
+      yield
+    ensure
+      Logging.mdc.pop
+    end
+
+    def add_to_log_context(context)
+      Logging.mdc.update context
+    end
+  end
+end

data/lib/logcraft/log_layout.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Logcraft
+  class LogLayout < Logging::Layout
+    def initialize(context = {}, options = {})
+      @general_context = context
+      @level_formatter = options.fetch :level_formatter, ->(level) { Logging::LNAMES[level] }
+    end
+
+    def format(event)
+      log_entry = background_of(event).merge evaluated_general_context,
+                                             dynamic_log_context,
+                                             message_from(event.data)
+      MultiJson.dump(log_entry) + "\n"
+    end
+
+    private
+
+    def background_of(event)
+      {
+        'timestamp' => event.time.iso8601(3),
+        'level' => @level_formatter.call(event.level),
+        'logger' => event.logger,
+        'hostname' => Socket.gethostname,
+        'pid' => Process.pid
+      }
+    end
+
+    def evaluated_general_context
+      @general_context.transform_values { |v| v.is_a?(Proc) ? v.call : v }
+    end
+
+    def dynamic_log_context
+      Logging.mdc.context
+    end
+
+    def message_from(payload)
+      case payload
+      when Hash
+        format_hash payload
+      when Exception
+        {'message' => payload.message, 'error' => format_exception(payload)}
+      else
+        {'message' => payload}
+      end
+    end
+
+    def format_hash(hash)
+      hash.transform_values { |v| v.is_a?(Exception) ? format_exception(v) : v }
+    end
+
+    def format_exception(exception)
+      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
+    end
+
+    def format_cause(cause)
+      cause = cause.cause while cause.cause
+      format_exception cause
+    end
+  end
+end

data/lib/logcraft/rails/active_record/log_subscriber.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Logcraft
+  module Rails
+    module ActiveRecord
+      class LogSubscriber < ActiveSupport::LogSubscriber
+        def sql(event)
+          ::ActiveRecord::Base.logger.debug { log_message_from(event) }
+        end
+
+        private
+
+        def log_message_from(event)
+          basic_message_from(event).tap do |message|
+            params = params_from event
+            message[:params] = params if params.any?
+          end
+        end
+
+        def basic_message_from(event)
+          {
+            message: "SQL - #{event.payload[:name] || 'Query'} (#{event.duration.round(3)}ms)",
+            sql: event.payload[:sql],
+            duration: event.duration,
+            duration_sec: (event.duration / 1000.0).round(5)
+          }
+        end
+
+        def params_from(event)
+          return {} if event.payload.fetch(:binds, []).empty?
+
+          params = event.payload[:binds]
+          values = type_casted_values_from event
+          param_value_pairs = params.zip(values).map do |param, value|
+            [param.name, value_of(param, value)]
+          end
+
+          Hash[param_value_pairs]
+        rescue NoMethodError
+          params
+        end
+
+        def type_casted_values_from(event)
+          binds = event.payload[:type_casted_binds]
+          binds.respond_to?(:call) ? binds.call : binds
+        end
+
+        def value_of(param, value)
+          param.type.binary? ? '-binary data-' : value
+        end
+      end
+    end
+  end
+end

data/lib/logcraft/rails/active_record.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Logcraft
+  module Rails
+    module ActiveRecord
+      autoload :LogSubscriber, 'logcraft/rails/active_record/log_subscriber'
+    end
+  end
+end

data/lib/logcraft/rails/extensions.rb

@@ -0,0 +1,12 @@
+module ActionDispatch
+  class DebugExceptions
+    def log_error_with_logcraft(request, wrapper)
+      logger = logger(request)
+      exception = wrapper.exception
+      logger.fatal exception
+    end
+
+    alias_method :original_log_error, :log_error
+    alias_method :log_error, :log_error_with_logcraft
+  end
+end

data/lib/logcraft/rails/log_subscription_handler.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rails/version'
+
+module Logcraft
+  module Rails
+    class LogSubscriptionHandler
+      class << self
+        def detach(subscriber_class, namespace)
+          case ::Rails::VERSION::MAJOR
+          when 5
+            subscriber = ::ActiveSupport::LogSubscriber.log_subscribers.find { |subscriber| subscriber.is_a? subscriber_class }
+            return unless subscriber
+
+            subscriber.patterns.each do |pattern|
+              ::ActiveSupport::Notifications.notifier.listeners_for(pattern).each do |listener|
+                ::ActiveSupport::Notifications.unsubscribe listener if listener.instance_variable_get('@delegate').is_a? subscriber_class
+              end
+            end
+
+          else
+            subscriber_class.detach_from namespace
+          end
+        end
+
+        def attach(subscriber_class, namespace)
+          subscriber_class.attach_to namespace
+        end
+      end
+    end
+  end
+end

data/lib/logcraft/rails/request_id_logger.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Logcraft
+  module Rails
+    class RequestIdLogger
+      include LogContextHelper
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        within_log_context request_id: env['action_dispatch.request_id'] do
+          @app.call env
+        end
+      end
+    end
+  end
+end

data/lib/logcraft/rails/request_logger.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Logcraft
+  module Rails
+    class RequestLogger
+      def initialize(app, logger, config)
+        @app = app
+        @logger = logger
+        @config = config
+      end
+
+      def call(env)
+        start_time = current_time_in_milliseconds
+        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
+
+        [status, headers, body]
+      rescue Exception => ex
+        instrumentation_finish request
+        log_request request, status_for_error(ex), start_time
+        raise
+      ensure
+        ActiveSupport::LogSubscriber.flush_all!
+      end
+
+      private
+
+      def current_time_in_milliseconds
+        Process.clock_gettime Process::CLOCK_MONOTONIC, :millisecond
+      end
+
+      def instrumentation_start(request)
+        instrumenter = ActiveSupport::Notifications.instrumenter
+        instrumenter.start 'request.action_dispatch', request: request
+      end
+
+      def instrumentation_finish(request)
+        instrumenter = ActiveSupport::Notifications.instrumenter
+        instrumenter.finish 'request.action_dispatch', request: request
+      end
+
+      def log_request(request, status, start_time)
+        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
+      end
+
+      def path_ignored?(request)
+        @config.exclude_paths.any? do |pattern|
+          case pattern
+          when Regexp
+            pattern.match? request.path
+          else
+            pattern == request.path
+          end
+        end
+      end
+
+      def params_to_log(request)
+        if @config.log_only_whitelisted_params
+          request.filtered_parameters.slice *@config.whitelisted_params&.map(&:to_s)
+        else
+          request.filtered_parameters
+        end
+      end
+
+      def status_for_error(error)
+        ActionDispatch::ExceptionWrapper.status_code_for_exception error.class.name
+      end
+    end
+  end
+end

data/lib/logcraft/rails.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'action_controller'
+require 'action_controller/log_subscriber'
+
+module Logcraft
+  module Rails
+    autoload :ActiveRecord, 'logcraft/rails/active_record'
+    autoload :RequestIdLogger, 'logcraft/rails/request_id_logger'
+    autoload :RequestLogger, 'logcraft/rails/request_logger'
+    autoload :LogSubscriptionHandler, 'logcraft/rails/log_subscription_handler'
+  end
+end

data/lib/logcraft/railtie.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module Logcraft
+  class Railtie < ::Rails::Railtie
+    config.logcraft = ActiveSupport::OrderedOptions.new
+    config.logcraft.initial_context = {}
+    config.logcraft.layout_options = {}
+
+    config.logcraft.access_log = ActiveSupport::OrderedOptions.new
+    config.logcraft.access_log.logger_name = 'AccessLog'
+    config.logcraft.access_log.exclude_paths = []
+    config.logcraft.access_log.log_only_whitelisted_params = false
+    config.logcraft.access_log.whitelisted_params = [:controller, :action]
+
+    initializer 'logcraft.initialize' do |app|
+      Logcraft.initialize log_level: app.config.log_level,
+                          initial_context: app.config.logcraft.initial_context,
+                          layout_options: app.config.logcraft.layout_options
+    end
+
+    initializer 'logcraft.configure_rails' do |app|
+      require 'logcraft/rails/extensions'
+      app.config.middleware.insert_before ::Rails::Rack::Logger,
+                                          Logcraft::Rails::RequestLogger,
+                                          Logcraft.logger(config.logcraft.access_log.logger_name),
+                                          config.logcraft.access_log
+      app.config.middleware.delete ::Rails::Rack::Logger
+      app.config.middleware.insert_after ::ActionDispatch::RequestId, Logcraft::Rails::RequestIdLogger
+    end
+
+    config.after_initialize do
+      Logcraft::Rails::LogSubscriptionHandler.detach ::ActionController::LogSubscriber, :action_controller
+      require 'action_view/log_subscriber' unless defined? ::ActionView::LogSubscriber
+      Logcraft::Rails::LogSubscriptionHandler.detach ::ActionView::LogSubscriber, :action_view
+      if defined? ::ActiveRecord
+        Logcraft::Rails::LogSubscriptionHandler.detach ::ActiveRecord::LogSubscriber, :active_record
+        Logcraft::Rails::LogSubscriptionHandler.attach Logcraft::Rails::ActiveRecord::LogSubscriber, :active_record
+      end
+    end
+
+    config.before_configuration do |app|
+      app.config.logger = Logcraft.logger 'Application'
+      app.config.log_level = ENV['LOG_LEVEL'] || :info
+    end
+  end
+end

data/lib/logcraft/rspec/helpers.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ezlog
+  module RSpec
+    module Helpers
+      def log_output_is_expected
+        expect(log_output)
+      end
+
+      def log_output
+        @log_output.clone.readlines
+      end
+    end
+  end
+end

data/lib/logcraft/rspec/matchers.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'json'
+
+RSpec::Matchers.define :include_log_message do |expected|
+  chain :at_level, :log_level
+
+  match do |actual|
+    actual.any? { |log_line| includes? log_line, expected_messages_from(expected) }
+  end
+
+  def includes?(log_line, messages)
+    return false unless includes_log_level? log_line
+    messages.all? { |message| log_line.include? message }
+  end
+
+  def includes_log_level?(log_line)
+    return true if log_level.nil?
+    log_line.include? log_level_string(log_level)
+  end
+
+  def log_level_string(log_level)
+    return 'WARN' if log_level == :warning
+    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 += " at #{log_level} level" if log_level
+    error_message
+  end
+end
+
+RSpec::Matchers.define :log do
+  supports_block_expectations
+  chain :at_level, :log_level
+
+  failure_message do
+    error_message = "expected operation to log '#{expected}'"
+    error_message += " at #{log_level} level" if log_level
+    "#{error_message}\n\nactual log output:\n#{log_output.join('')}"
+  end
+
+  match do |operation|
+    raise 'log matcher only supports block expectations' unless operation.is_a? Proc
+    log_output_is_expected.not_to include_log_message(expected)
+    operation.call
+    log_output_is_expected.to include_log_message(expected).at_level(log_level)
+  end
+end

data/lib/logcraft/rspec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'logging'
+require 'rspec/logging_helper'
+require_relative 'rspec/helpers'
+require_relative 'rspec/matchers'
+require_relative 'log_layout'
+
+RSpec.configure do |config|
+  config.include Ezlog::RSpec::Helpers
+  config.before(:suite) do
+    Logging.appenders.string_io('__logcraft_stringio__', layout: Logging.logger.root.appenders.first&.layout || Logcraft::LogLayout.new)
+    config.capture_log_messages to: '__logcraft_stringio__'
+  end
+end

data/lib/logcraft/version.rb

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

data/lib/logcraft.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'logging'
+
+require 'logcraft/version'
+require 'logcraft/railtie' if defined? Rails
+
+module Logcraft
+  autoload :LogContextHelper, 'logcraft/log_context_helper'
+  autoload :LogLayout, 'logcraft/log_layout'
+  autoload :Rails, 'logcraft/rails'
+
+  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)
+    Logging.logger.root.level = log_level
+  end
+
+  def self.logger(name, level = nil)
+    Logging::Logger[name].tap { |logger| logger.level = level if level }
+  end
+end

data/logcraft.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/logcraft/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "logcraft"
+  spec.version = Logcraft::VERSION
+  spec.authors = ["Zoltan Ormandi"]
+  spec.email = ["zoltan.ormandi@gmail.com"]
+
+  spec.summary = "A zero-configuration logging solution for Ruby on Rails."
+  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"
+
+  # 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)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "logging", "~> 2.0"
+  spec.add_dependency "multi_json", "~> 1.14"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", ">= 12.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: logcraft
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc
+platform: ruby
+authors:
+- Zoltan Ormandi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- zoltan.ormandi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemfiles/rails_5.2.gemfile
+- gemfiles/rails_6.0.gemfile
+- gemfiles/rails_6.1.gemfile
+- lib/logcraft.rb
+- lib/logcraft/log_context_helper.rb
+- lib/logcraft/log_layout.rb
+- lib/logcraft/rails.rb
+- lib/logcraft/rails/active_record.rb
+- lib/logcraft/rails/active_record/log_subscriber.rb
+- lib/logcraft/rails/extensions.rb
+- lib/logcraft/rails/log_subscription_handler.rb
+- lib/logcraft/rails/request_id_logger.rb
+- lib/logcraft/rails/request_logger.rb
+- lib/logcraft/railtie.rb
+- lib/logcraft/rspec.rb
+- lib/logcraft/rspec/helpers.rb
+- lib/logcraft/rspec/matchers.rb
+- lib/logcraft/version.rb
+- logcraft.gemspec
+homepage: https://github.com/zormandi/logcraft
+licenses:
+- MIT
+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: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: A zero-configuration logging solution for Ruby on Rails.
+test_files: []