bellman 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a729b18b61a082bb6b7c2614885528357e7f4f7c0b04c8059067b86d4ed18c8e
+  data.tar.gz: 4f6247d06e4a57523b0dfd7ecd33f6502bc82ada83e1e596961cdbbee9c04f88
+SHA512:
+  metadata.gz: 9e515a69379105d8399709472777ef11070c0514cf9f6e1c97a4557cfc2eec9786d3ac666f02a4fe9c8efff00f0bcb2d051de06b4623a923c7e59b9d50338b62
+  data.tar.gz: 0a2dd55ed8d89d9fc43da2db58844a71fa93e699f5536ffb6d36d8aec93ee54a7ceca4bc2e6f56d2446f78616f418af9b8585753cee47ac94fa0430911f0ff12

data/.rubocop.yml

@@ -0,0 +1,58 @@
+require:
+  - 'rubocop-performance'
+  - 'rubocop-rails'
+  - 'rubocop-minitest'
+  - 'rubocop-rake'
+
+AllCops:
+  NewCops: enable
+  # Don't run rubocop on these files/directories
+  Exclude:
+    - '**/templates/**/*'
+    - '**/vendor/**/*'
+    - 'lib/templates/**/*'
+    - 'db/**/*'
+    - 'config/**/*'
+    - 'vendor/**/*'
+    - 'bin/**/*'
+    - 'test/dummy/**/*'
+
+Layout/LineLength:
+  Max: 80
+  Exclude:
+    - 'bellman.gemspec'
+
+Metrics/AbcSize:
+  Max: 30
+  Exclude:
+    - 'test/**/*'
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'bellman.gemspec'
+    - 'test/**/*'
+
+Metrics/ClassLength:
+  Max: 150
+  Exclude:
+    - 'test/**/*'
+
+Metrics/MethodLength:
+  Max: 35
+  Exclude:
+    - 'test/**/*'
+
+Metrics/ModuleLength:
+  Max: 100
+
+Minitest/MultipleAssertions:
+  Max: 10
+
+Rails/RakeEnvironment:
+  Exclude:
+    - 'Rakefile'
+
+Rails/RefuteMethods:
+  Exclude:
+    - 'test/**/*'

data/.ruby-gemset

@@ -0,0 +1 @@
+bellman

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.2.2

data/Gemfile

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in bellman.gemspec
+gemspec
+
+gem 'bundler', '~> 2.3'
+gem 'bundler-audit', '>= 0'
+gem 'minitest', '~> 5.0'
+gem 'rake', '~> 13.0'
+gem 'rubocop', '~> 1.21'
+gem 'rubocop-minitest', '>= 0'
+gem 'rubocop-performance', '>= 0'
+gem 'rubocop-rails', '>= 0'
+gem 'rubocop-rake', '>= 0'
+gem 'ruby_audit', '>= 0'
+
+##
+## Rails App Gemfile contents
+##
+
+# Bundle edge Rails instead: gem "rails", github: "rails/rails", branch: "main"
+gem 'rails', '~> 7.1.0'
+
+# The original asset pipeline for Rails
+# [https://github.com/rails/sprockets-rails]
+gem 'sprockets-rails'
+
+# Use the Puma web server
+# [https://github.com/puma/puma]
+gem 'puma', '~> 6.0'
+
+# Build JSON APIs with ease
+# [https://github.com/rails/jbuilder]
+# gem 'jbuilder'
+
+# Use Kredis to get higher-level data types in Redis
+# [https://github.com/rails/kredis]
+# gem "kredis"
+
+# Use Active Model has_secure_password
+# [https://guides.rubyonrails.org/active_model_basics.html#securepassword]
+# gem "bcrypt", "~> 3.1.7"
+
+# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
+gem 'tzinfo-data', platforms: %i[mingw mswin x64_mingw jruby]
+
+# Reduces boot times through caching; required in config/boot.rb
+gem 'bootsnap', require: false
+
+# Use Sass to process CSS
+# gem "sassc-rails"
+
+group :development, :test do
+  # See https://guides.rubyonrails.org/debugging_rails_applications.html#debugging-with-the-debug-gem
+  gem 'debug', platforms: %i[mri mingw x64_mingw]
+end
+
+group :development do
+  # Use console on exceptions pages [https://github.com/rails/web-console]
+  # gem 'web-console'
+
+  # Add speed badges [https://github.com/MiniProfiler/rack-mini-profiler]
+  # gem "rack-mini-profiler"
+
+  # Speed up commands on slow machines / big apps
+  # [https://github.com/rails/spring]
+  # gem "spring"
+end
+
+group :test do
+  # Use system testing
+  # [https://guides.rubyonrails.org/testing.html#system-testing]
+  gem 'capybara'
+  gem 'selenium-webdriver'
+  gem 'webdrivers'
+end
+
+#
+# Gem that has been added to default Gemfile so that we can run the tests
+# for the handlers
+#
+
+# rubocop:disable Bundler/OrderedGems
+# Ruby Error and Performance Monitoring
+# https://github.com/getsentry/sentry-ruby
+# NOTE: sentry-rails need to be added after sentry-ruby kindly do not reorder
+gem 'sentry-ruby'
+gem 'sentry-rails'
+gem 'sentry-sidekiq'
+# rubocop:enable Bundler/OrderedGems
+
+# Sidekiq for background jobs
+# https://github.com/mperham/sidekiq
+gem 'sidekiq'

data/Gemfile.lock

@@ -0,0 +1,314 @@
+PATH
+  remote: .
+  specs:
+    bellman (0.1.0)
+      activerecord (> 4.2.0)
+      activesupport (> 4.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (7.1.2)
+      actionpack (= 7.1.2)
+      activesupport (= 7.1.2)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+      zeitwerk (~> 2.6)
+    actionmailbox (7.1.2)
+      actionpack (= 7.1.2)
+      activejob (= 7.1.2)
+      activerecord (= 7.1.2)
+      activestorage (= 7.1.2)
+      activesupport (= 7.1.2)
+      mail (>= 2.7.1)
+      net-imap
+      net-pop
+      net-smtp
+    actionmailer (7.1.2)
+      actionpack (= 7.1.2)
+      actionview (= 7.1.2)
+      activejob (= 7.1.2)
+      activesupport (= 7.1.2)
+      mail (~> 2.5, >= 2.5.4)
+      net-imap
+      net-pop
+      net-smtp
+      rails-dom-testing (~> 2.2)
+    actionpack (7.1.2)
+      actionview (= 7.1.2)
+      activesupport (= 7.1.2)
+      nokogiri (>= 1.8.5)
+      racc
+      rack (>= 2.2.4)
+      rack-session (>= 1.0.1)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    actiontext (7.1.2)
+      actionpack (= 7.1.2)
+      activerecord (= 7.1.2)
+      activestorage (= 7.1.2)
+      activesupport (= 7.1.2)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.1.2)
+      activesupport (= 7.1.2)
+      builder (~> 3.1)
+      erubi (~> 1.11)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    activejob (7.1.2)
+      activesupport (= 7.1.2)
+      globalid (>= 0.3.6)
+    activemodel (7.1.2)
+      activesupport (= 7.1.2)
+    activerecord (7.1.2)
+      activemodel (= 7.1.2)
+      activesupport (= 7.1.2)
+      timeout (>= 0.4.0)
+    activestorage (7.1.2)
+      actionpack (= 7.1.2)
+      activejob (= 7.1.2)
+      activerecord (= 7.1.2)
+      activesupport (= 7.1.2)
+      marcel (~> 1.0)
+    activesupport (7.1.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      mutex_m
+      tzinfo (~> 2.0)
+    addressable (2.8.5)
+      public_suffix (>= 2.0.2, < 6.0)
+    ast (2.4.2)
+    base64 (0.2.0)
+    bigdecimal (3.1.4)
+    bootsnap (1.17.0)
+      msgpack (~> 1.2)
+    builder (3.2.4)
+    bundler-audit (0.9.1)
+      bundler (>= 1.2.0, < 3)
+      thor (~> 1.0)
+    capybara (3.39.2)
+      addressable
+      matrix
+      mini_mime (>= 0.1.3)
+      nokogiri (~> 1.8)
+      rack (>= 1.6.0)
+      rack-test (>= 0.6.3)
+      regexp_parser (>= 1.5, < 3.0)
+      xpath (~> 3.2)
+    concurrent-ruby (1.2.2)
+    connection_pool (2.4.1)
+    crass (1.0.6)
+    date (3.3.4)
+    debug (1.8.0)
+      irb (>= 1.5.0)
+      reline (>= 0.3.1)
+    drb (2.2.0)
+      ruby2_keywords
+    erubi (1.12.0)
+    globalid (1.2.1)
+      activesupport (>= 6.1)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    io-console (0.6.0)
+    irb (1.9.1)
+      rdoc
+      reline (>= 0.3.8)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    loofah (2.22.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    mail (2.8.1)
+      mini_mime (>= 0.1.1)
+      net-imap
+      net-pop
+      net-smtp
+    marcel (1.0.2)
+    matrix (0.4.2)
+    mini_mime (1.1.5)
+    minitest (5.20.0)
+    msgpack (1.7.2)
+    mutex_m (0.2.0)
+    net-imap (0.4.7)
+      date
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.2.2)
+      timeout
+    net-smtp (0.4.0)
+      net-protocol
+    nio4r (2.6.1)
+    nokogiri (1.15.5-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.15.5-x86_64-linux)
+      racc (~> 1.4)
+    parallel (1.23.0)
+    parser (3.2.2.4)
+      ast (~> 2.4.1)
+      racc
+    psych (5.1.1.1)
+      stringio
+    public_suffix (5.0.4)
+    puma (6.4.0)
+      nio4r (~> 2.0)
+    racc (1.7.3)
+    rack (3.0.8)
+    rack-session (2.0.0)
+      rack (>= 3.0.0)
+    rack-test (2.1.0)
+      rack (>= 1.3)
+    rackup (2.1.0)
+      rack (>= 3)
+      webrick (~> 1.8)
+    rails (7.1.2)
+      actioncable (= 7.1.2)
+      actionmailbox (= 7.1.2)
+      actionmailer (= 7.1.2)
+      actionpack (= 7.1.2)
+      actiontext (= 7.1.2)
+      actionview (= 7.1.2)
+      activejob (= 7.1.2)
+      activemodel (= 7.1.2)
+      activerecord (= 7.1.2)
+      activestorage (= 7.1.2)
+      activesupport (= 7.1.2)
+      bundler (>= 1.15.0)
+      railties (= 7.1.2)
+    rails-dom-testing (2.2.0)
+      activesupport (>= 5.0.0)
+      minitest
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.6.0)
+      loofah (~> 2.21)
+      nokogiri (~> 1.14)
+    railties (7.1.2)
+      actionpack (= 7.1.2)
+      activesupport (= 7.1.2)
+      irb
+      rackup (>= 1.0.0)
+      rake (>= 12.2)
+      thor (~> 1.0, >= 1.2.2)
+      zeitwerk (~> 2.6)
+    rainbow (3.1.1)
+    rake (13.1.0)
+    rdoc (6.6.0)
+      psych (>= 4.0.0)
+    redis-client (0.18.0)
+      connection_pool
+    regexp_parser (2.8.2)
+    reline (0.4.1)
+      io-console (~> 0.5)
+    rexml (3.2.6)
+    rubocop (1.57.2)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.4)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.30.0)
+      parser (>= 3.2.1.0)
+    rubocop-minitest (0.33.0)
+      rubocop (>= 1.39, < 2.0)
+    rubocop-performance (1.19.1)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    rubocop-rails (2.22.2)
+      activesupport (>= 4.2.0)
+      rack (>= 1.1)
+      rubocop (>= 1.33.0, < 2.0)
+      rubocop-ast (>= 1.30.0, < 2.0)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    ruby-progressbar (1.13.0)
+    ruby2_keywords (0.0.5)
+    ruby_audit (2.2.0)
+      bundler-audit (~> 0.9.0)
+    rubyzip (2.3.2)
+    selenium-webdriver (4.10.0)
+      rexml (~> 3.2, >= 3.2.5)
+      rubyzip (>= 1.2.2, < 3.0)
+      websocket (~> 1.0)
+    sentry-rails (5.14.0)
+      railties (>= 5.0)
+      sentry-ruby (~> 5.14.0)
+    sentry-ruby (5.14.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+    sentry-sidekiq (5.14.0)
+      sentry-ruby (~> 5.14.0)
+      sidekiq (>= 3.0)
+    sidekiq (7.2.0)
+      concurrent-ruby (< 2)
+      connection_pool (>= 2.3.0)
+      rack (>= 2.2.4)
+      redis-client (>= 0.14.0)
+    sprockets (4.2.1)
+      concurrent-ruby (~> 1.0)
+      rack (>= 2.2.4, < 4)
+    sprockets-rails (3.4.2)
+      actionpack (>= 5.2)
+      activesupport (>= 5.2)
+      sprockets (>= 3.0.0)
+    stringio (3.1.0)
+    thor (1.3.0)
+    timeout (0.4.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.5.0)
+    webdrivers (5.3.1)
+      nokogiri (~> 1.6)
+      rubyzip (>= 1.3.0)
+      selenium-webdriver (~> 4.0, < 4.11)
+    webrick (1.8.1)
+    websocket (1.2.10)
+    websocket-driver (0.7.6)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    xpath (3.2.0)
+      nokogiri (~> 1.8)
+    zeitwerk (2.6.12)
+
+PLATFORMS
+  x86_64-darwin-22
+  x86_64-linux
+
+DEPENDENCIES
+  bellman!
+  bootsnap
+  bundler (~> 2.3)
+  bundler-audit
+  capybara
+  debug
+  minitest (~> 5.0)
+  puma (~> 6.0)
+  rails (~> 7.1.0)
+  rake (~> 13.0)
+  rubocop (~> 1.21)
+  rubocop-minitest
+  rubocop-performance
+  rubocop-rails
+  rubocop-rake
+  ruby_audit
+  selenium-webdriver
+  sentry-rails
+  sentry-ruby
+  sentry-sidekiq
+  sidekiq
+  sprockets-rails
+  tzinfo-data
+  webdrivers
+
+BUNDLED WITH
+   2.4.10

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 TODO: Write your name
+
+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,154 @@
+# Bellman
+
+[![CircleCI](https://dl.circleci.com/status-badge/img/gh/prschmid/bellman/tree/main.svg?style=shield)](https://dl.circleci.com/status-badge/redirect/gh/prschmid/bellman/tree/main)
+[![Gem Version](https://badge.fury.io/rb/bellman.svg)](https://badge.fury.io/rb/bellman)
+
+A simple and unified way to send log messages to the right place.
+
+Why is this gem called Bellman? For historical details on a [bellman/town crier](https://en.wikipedia.org/wiki/Town_crier).
+
+## Installation
+
+Install the gem and add it to the application's Gemfile by executing:
+
+    $ bundle add bellman
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install bellman
+
+## Usage
+
+Simply replace any call to a logger with
+
+```ruby
+# Use the default severity
+Bellman.handle('Log this error message')
+
+# Set the severity
+Bellman.handle('Log this info message', severity: info)
+```
+
+And then based on your configuration this message will be sent to the right place. By default the severity level for a message is set to `:error`, but that can easily be configured or overridden on a case by case basis.
+
+### Including Data
+
+In many cases you will want to add some extra data to your log messages. The log messages are formatted in such a way that it should be easy to pull the extra information out with regular expressions, etc. 
+
+You can add arbitrary data to the log message as follows:
+
+```ruby
+Bellman.handle(
+    'Something you should know about',
+    severity: :info,
+    data: {
+        favorite_food: 'Ice Cream'
+    }
+)
+```
+
+This will result in a message that looks like
+
+```sh
+INFO | Something you should know about | DATA[{"favorite_food":"Ice Cream"}]
+```
+
+If there is a case where you want to add some objects to this log message, you can do this by passing them in.
+
+```ruby
+project = Project.last
+task = project.tasks.last
+
+Bellman.handle(
+    'Something you should know about',
+    severity: :info,
+    objecst: [project, task]
+)
+```
+
+Assuming you are using UUIDs, this will result in a message that will look something like
+
+```sh
+INFO | Something you should know about | OBJECTS["Project|6a491e9d-ceb7-41fd-97ef-6cd8a6460242", "Task|ab30e8c7-eabf-4c95-ba97-a523bf017093"]
+```
+
+## Configuration
+
+The aim of `bellman` is to take the guesswork out of where to send the logs and have it be configured in a uniform way for an entire application. 
+
+For example, here is a common configuration for when an application uses the Rails logger to send all logs to a centralized logging store (e.g. Papertrail, Sumo Logic, etc.) and then sends only the "high severity" ones to Sentry.io.
+
+```ruby
+Bellman.configure do |config|
+  config.default_severity = :error
+  config.handlers = [
+      {
+        id: :log,
+        class: Bellman::Handlers::RailsLogger,
+        severities: %i[debug info warn error fatal]
+      },
+      {
+        id: :sentry,
+        class: Bellman::Handlers::Sentry,
+        severities: %i[error fatal]
+      }
+    ]
+end
+```
+
+If for some reason you want to pass parameters to a handler while it is being initialized (e.g. if you make your own custom handler) you can do this by passing in `params` as follows:
+
+```ruby
+Bellman.configure do |config|
+  config.default_severity = :error
+  config.handlers = [
+      {
+        id: :custom_handler,
+        class: Acme::Handlers::CustomHandler,
+        params: {
+            some_option: 'foo',
+            other_option: 'bar'
+        },
+        severities: %i[debug info warn error fatal]
+      }
+    ]
+end
+```
+
+## Handlers
+
+### Predefined Handlers
+
+Built-in are 2 pre-defined handlers for handling log message
+
+* `Bellman::Handlers::RailsLogger`: Send the log message to the Rails logger
+* `Bellman::Handlers::Sentry`: Send the log message to Sentry.io
+
+## Custom Handlers
+
+Need a specific handler that's not built in? One can easily create a new log handler by simply inheriting from `Bellman::BaseHandler` and implementing the one method
+
+```ruby
+def handle(
+    error, severity: nil, trace_id: nil, objects: nil, data: nil,
+    include_backtrace: false
+)
+    raise 'Not implemented'
+end
+```
+
+Once that is created, go ahead and add it to the configuration (see above).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/prschmid/bellman.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.verbose = false
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.libs << 'test/dummy'
+
+  # We will include all of the files in test but are going to explicitly
+  # exclude all tests in rails. This is because we copy those files
+  # to the dummy Rails app so that we can test the Rails specific handlers
+  # in the context of a Rails app. See the `generate_dummy_rails_app` for
+  # more details
+  t.test_files = \
+    FileList['test/**/*_test.rb'].exclude('test/rails/**/*_test.rb')
+end
+
+desc 'generate a dummy Rails app inside the test directory for testing purposes'
+task :generate_dummy_rails_app do
+  if File.exist?('test/dummy/config/environment.rb')
+    FileUtils.rm_r Dir.glob('test/dummy/')
+  end
+
+  #
+  # Create a dummy rails app
+  #
+  system(
+    'rails new test/dummy --skip-active-record ' \
+    '--skip-active-storage --skip-action-cable --skip-webpack-install ' \
+    '--skip-git --skip-sprockets --skip-javascript --skip-turbolinks'
+  )
+
+  # For now we don't need any DB specific things in our tests. However, if
+  # we ever do, we can update how we generate the rails app and then setup
+  # the DB appropriately using something like the following.
+  # system('rails new test/dummy --database=sqlite3')
+  # system('touch test/dummy/db/schema.rb')
+  # FileUtils.cp 'test/fixtures/database.yml', 'test/dummy/config/'
+
+  #
+  # Install/Setup the dependencies
+  #
+
+  system('cp -f test/rails/Gemfile test/dummy/.')
+  system(
+    'cp test/rails/config/initializers/*.rb test/dummy/config/initializers/.'
+  )
+
+  #
+  # Setup the tests by deleting the existing Rails app tests and then copying
+  # our test over to the dummy app
+  #
+
+  FileUtils.rm_r Dir.glob('test/dummy/test/*')
+  system('cp -r test/rails/test/lib test/dummy/test/.')
+end
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task default: %i[generate_dummy_rails_app test rubocop]

data/bellman.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bellman/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'bellman'
+  spec.version = Bellman::VERSION
+  spec.authors       = ['Patrick R. Schmid']
+  spec.email         = ['prschmid@gmail.com']
+
+  spec.summary       = 'Unified way to take all of the log messages and direct them to the right place.'
+  spec.description   = 'Unified way to take all of the log messages and direct them to the right place.'
+  spec.homepage      = 'https://github.com/prschmid/bellman'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the
+  # 'allowed_push_host' to allow pushing to a single host or delete this
+  # section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/prschmid/bellman'
+    spec.metadata['changelog_uri'] = 'https://github.com/prschmid/bellman'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+          'public gem pushes.'
+  end
+
+  # 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.required_ruby_version = '>= 3.2'
+
+  spec.add_runtime_dependency('activerecord', '> 4.2.0')
+  spec.add_runtime_dependency('activesupport', '> 4.2.0')
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/lib/bellman/bellman.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Bellman
+#
+# Unified way to take all of the log messages and direct them to the right
+# place.
+#
+# By default all messages will be logged using the Rails standard logger and
+# any message with severity of :error or :fatal will also be sent to
+# Sentry.
+#
+#
+# For historical details on a bellman/town crier see:
+#   https://en.wikipedia.org/wiki/Town_crier
+module Bellman
+  include ActiveSupport::Configurable
+
+  def self.configure
+    # Set the defaults
+    config.severities = %i[debug info warn error fatal].freeze
+    config.default_severity = :error
+    config.handlers = [
+      {
+        id: :log,
+        class: Bellman::Handlers::RailsLogger,
+        severities: %i[debug info warn error fatal]
+      },
+      {
+        id: :sentry,
+        class: Bellman::Handlers::Sentry,
+        severities: %i[error fatal]
+      }
+    ]
+
+    super
+
+    # Create an instance of the handler that can be used
+    @handler = Handlers::Handler.new
+  end
+
+  def self.handler
+    @handler
+  end
+
+  def self.error_handler(id:)
+    @handler.handlers.find { |hndlr| hndlr[:id] == id.to_sym }
+  end
+
+  # rubocop:disable Metrics/ParameterLists
+  def self.handle(
+    error, severity: nil, trace_id: nil, objects: nil, data: nil,
+    include_backtrace: false, handlers: nil
+  )
+    @handler.handle(
+      error, severity:, trace_id:, objects:, data:, include_backtrace:,
+             handlers:
+    )
+  end
+  # rubocop:enable Metrics/ParameterLists
+end

data/lib/bellman/handlers/base_handler.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Bellman
+  module Handlers
+    # Base class for all error handlers
+    class BaseHandler
+      # rubocop:disable Lint/UnusedMethodArgument
+      # rubocop:disable Metrics/ParameterLists
+      def handle(
+        _error, severity: nil, trace_id: nil, objects: nil, data: nil,
+        include_backtrace: false
+      )
+        raise 'Not implemented'
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+      # rubocop:enable Metrics/ParameterLists
+    end
+  end
+end

data/lib/bellman/handlers/handler.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Bellman
+  module Handlers
+    # Main interface for interacting with all of the registerd handlers
+    class Handler
+      attr_reader :handlers
+
+      def initialize(handlers: nil)
+        handlers ||= Bellman.config.handlers
+        @handlers = process_handlers_config(handlers)
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def handle(error, severity: :error, trace_id: nil, objects: nil,
+                 data: nil, include_backtrace: false, handlers: nil)
+        unless Bellman.config.severities.include?(severity)
+          severity = Bellman.config.default_severity
+        end
+
+        handlers = if handlers.present?
+                     process_handlers_config(handlers)
+                   else
+                     @handlers
+                   end
+
+        handled = false
+        handlers.each do |handler|
+          next unless handler[:severities].include?(severity)
+
+          raise "No handler specificed in #{handler}" unless handler[:handler]
+
+          handler[:handler].handle(
+            error, severity:, trace_id:, objects:, data:, include_backtrace:
+          )
+
+          handled = true
+        end
+
+        handled
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      private
+
+      def process_handlers_config(configs)
+        configs.map { |config| process_handler_config(config) }
+      end
+
+      def process_handler_config(config)
+        config = to_handler_config(config) unless config.is_a?(Hash)
+
+        initalize_from_config_hash(config)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/PerceivedComplexity
+      def initalize_from_config_hash(config)
+        if config[:handler]
+          config[:class] = config[:handler].class
+        elsif config[:class]
+          if config[:class].is_a?(String)
+            config[:class] = config[:class].safe_constantize
+          end
+          config[:handler] = if config[:params].blank?
+                               config[:class].new
+                             else
+                               config[:class].new(**config[:params])
+                             end
+        elsif config[:id]
+          config = Bellman.error_handler(config[:id])
+          config[:handler] = if config[:params].blank?
+                               config[:class].new
+                             else
+                               config[:class].new(**config[:params])
+                             end
+        else
+          raise "Bellman: Could not initialize handler from config: #{config}"
+        end
+        config
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def to_handler_config(config)
+        retval = { severities: Bellman.config.severities }
+
+        case config
+        when Symbol
+          handler = Bellman.error_handler(id: config)
+          return handler if handler
+        when String
+          # If the string matches the ID of a handler defined in the Bellman
+          # default config, return that.
+          handler = Bellman.error_handler(id: config.to_sym)
+          return handler if handler
+
+          # rubocop:disable Lint/SuppressedException
+          begin
+            retval[:class] = config.safe_constantize
+          rescue StandardError
+          end
+          # rubocop:enable Lint/SuppressedException
+        when Class
+          retval[:class] = config
+        when BaseHandler
+          retval[:class] = config.class
+        else
+          raise 'Bellman: Unsupported handler. Handlers ' \
+                'must be an array of strings, classes, ' \
+                'or instances of Bellman::BaseHandler: ' \
+                "#{config}"
+        end
+
+        retval
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+    end
+  end
+end

data/lib/bellman/handlers/rails_logger.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Bellman
+  module Handlers
+    # Handle Rails logging
+    class RailsLogger < BaseHandler
+      def initialize(logger: nil)
+        super()
+        @logger = logger
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+      def handle(
+        error, severity: nil, trace_id: nil, objects: nil, data: nil,
+        include_backtrace: false
+      )
+        logger.send(
+          severity,
+          build_message(
+            error, severity:, trace_id:, objects:, data:, include_backtrace:
+          )
+        )
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def logger
+        @logger || Rails.logger
+      end
+
+      private
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Metrics/PerceivedComplexity
+      def build_message(
+        error, severity: nil, trace_id: nil, data: nil, objects: nil,
+        include_backtrace: false
+      )
+        str = severity_to_s(severity)
+        str = "#{str} | TRACE_ID[#{trace_id}]" if trace_id
+
+        unless error.nil?
+          str = if error.respond_to?(:message)
+                  "#{str} | #{error.message}"
+                else
+                  "#{str} | #{error}"
+                end
+        end
+        str = "#{str} | #{objects_to_s(objects)}" if objects
+        str = "#{str} | DATA[#{data.to_json}]" if data
+        if !error.nil? && include_backtrace && error.respond_to?(:backtrace)
+          str = "#{str} | #{error.backtrace}"
+        end
+        str
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/ParameterLists
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def severity_to_s(severity)
+        Bellman.config.default_severity.to_s.upcase.to_s unless severity
+
+        severity.to_s.upcase.to_s
+      end
+
+      def objects_to_s(objects)
+        "OBJECTS#{objects.map do |object|
+                    "#{object.class.name}|#{object.id}"
+                  end}"
+      end
+    end
+  end
+end

data/lib/bellman/handlers/sentry.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Bellman
+  module Handlers
+    # Handle Sentry logging
+    class Sentry < BaseHandler
+      OBJECT_KEYS = [:profile_id, 'profile_id'].freeze
+
+      def initialize(sentry: nil)
+        super()
+        @sentry = sentry
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/ParameterLists
+      # rubocop:disable Metrics/PerceivedComplexity
+      def handle(
+        error, severity: nil, trace_id: nil, objects: nil, data: nil, **
+      )
+        sentry.with_scope do |scope|
+          scope.set_level(severity)
+          set_sentry_context(scope, objects) if objects.present?
+
+          if trace_id
+            data ||= {}
+            data[:trace_id] = trace_id
+          end
+
+          set_sentry_user_and_tags(scope, data) if data.present?
+
+          error = '[EMPTY MESSAGE]' if error.nil?
+          if error.respond_to?(:message) && error.respond_to?(:backtrace)
+            sentry.capture_exception(error)
+          else
+            sentry.capture_message(error.to_s)
+          end
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/ParameterLists
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def sentry
+        @sentry || ::Sentry
+      end
+
+      private
+
+      def set_sentry_context(scope, objects)
+        scope.set_context(
+          objects: objects.map { |object| "#{object.class.name}|#{object.id}" }
+        )
+      end
+
+      def set_sentry_user_and_tags(scope, data)
+        data = data.with_indifferent_access
+        scope.set_user(id: data[:profile_id]) if data[:profile_id]
+        data.each do |key, val|
+          next if OBJECT_KEYS.include? key
+
+          scope.send(:set_tags, **{ key => val })
+        end
+      end
+    end
+  end
+end

data/lib/bellman/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Bellman
+  VERSION = '0.1.0'
+end

data/lib/bellman.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bellman/version'
+
+directories = [
+  File.join(File.dirname(__FILE__), 'bellman'),
+  File.join(File.dirname(__FILE__), 'bellman', 'handlers')
+]
+
+directories.each do |directory|
+  Dir[File.join(directory, '*.rb')].each do |file|
+    require file
+  end
+end
+
+ActiveRecord::Base.instance_eval { include Bellman }
+if defined?(Rails) && Rails.version.to_i < 4
+  raise 'This version of bellman requires Rails 4 or higher'
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: bellman
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Patrick R. Schmid
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+description: Unified way to take all of the log messages and direct them to the right
+  place.
+email:
+- prschmid@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bellman.gemspec
+- lib/bellman.rb
+- lib/bellman/bellman.rb
+- lib/bellman/handlers/base_handler.rb
+- lib/bellman/handlers/handler.rb
+- lib/bellman/handlers/rails_logger.rb
+- lib/bellman/handlers/sentry.rb
+- lib/bellman/version.rb
+homepage: https://github.com/prschmid/bellman
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/prschmid/bellman
+  source_code_uri: https://github.com/prschmid/bellman
+  changelog_uri: https://github.com/prschmid/bellman
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Unified way to take all of the log messages and direct them to the right
+  place.
+test_files: []