berkeley_library-logging 0.2.0

data/spec/rails/ucblit/logging/railtie_spec.rb

@@ -0,0 +1,46 @@
+require 'rails_helper'
+
+module BerkeleyLibrary
+  module Logging
+    describe Railtie do
+      attr_reader :app
+      attr_reader :config
+
+      before(:each) do
+        @app = Class.new(Rails::Application).new
+        allow(Rails).to receive(:application).and_return(app)
+        @config = app.config
+      end
+
+      describe 'initializer' do
+        attr_reader :logging_initializer
+        attr_reader :bootstrap_logger_initializer
+
+        before(:each) do
+          expected_file, _line = Module.const_source_location(BerkeleyLibrary::Logging::Railtie.name)
+          @logging_initializer = app.initializers.find do |init|
+            block = init.block
+            file, _line = block.source_location
+            file == expected_file
+          end
+          @bootstrap_logger_initializer = app.initializers.find { |init| init.name == :initialize_logger }
+        end
+
+        it 'is added to the Rails application' do
+          expect(logging_initializer).not_to be_nil
+        end
+
+        it 'runs before the bootstrap logger initializer' do
+          expect(logging_initializer.before).to eq(bootstrap_logger_initializer.name)
+        end
+
+        it 'sets the logger' do
+          logging_initializer.run(app)
+          bootstrap_logger_initializer.run(app)
+
+          expect(Rails.logger).to be_a(BerkeleyLibrary::Logging::Logger)
+        end
+      end
+    end
+  end
+end

data/spec/rails/ucblit/logging_spec.rb

@@ -0,0 +1,132 @@
+require 'rails_helper'
+
+module BerkeleyLibrary
+  describe Logging do
+
+    def logger_defined?
+      Logging.instance_variable_defined?(:@logger)
+    end
+
+    def reset_logger!
+      Logging.instance_variable_set(:@logger, @logging_logger_orig)
+    end
+
+    def undefine_logger!
+      Logging.send(:remove_instance_variable, :@logger) if logger_defined?
+    end
+
+    def new_mock_logger
+      mock_logger_class = Class.new do
+        def respond_to?(*args)
+          %i[debug info warn error].include?(args[0].to_sym) || super
+        end
+      end
+
+      mock_logger_class.new
+    end
+
+    before(:each) do
+      @rails_logger_orig = Rails.logger
+      Rails.logger = new_mock_logger
+
+      if (@logger_was_defined = logger_defined?)
+        @logging_logger_orig = Logging.instance_variable_get(:@logger)
+        undefine_logger!
+      end
+    end
+
+    after(:each) do
+      @logger_was_defined ? reset_logger! : undefine_logger!
+      Rails.logger = @rails_logger_orig
+    end
+
+    describe 'class methods' do
+      describe :logger do
+        it 'returns the default logger' do
+          logger = Logging::Loggers.default_logger
+          expect(Logging.logger).to be(logger)
+        end
+
+        it 'returns a set logger' do
+          logger = new_mock_logger
+          Logging.logger = logger
+          expect(Logging.logger).to be(logger)
+        end
+
+      end
+
+      describe :logger= do
+        it 'rejects a non-logger' do
+          original_logger = Logging.logger
+          expect { Logging.logger = Object.new }.to raise_error(ArgumentError)
+          expect(Logging.logger).to be(original_logger)
+        end
+
+        it 'can be reset to default with nil' do
+          default_logger = Logging::Loggers.default_logger
+          Logging.logger = new_mock_logger
+          Logging.logger = nil
+          expect(Logging.logger).to be(default_logger)
+        end
+      end
+    end
+
+    describe 'included' do
+      attr_reader :logificator
+
+      before(:each) do
+        @logificator = Object.new
+        @logificator.singleton_class.include(Logging)
+      end
+
+      describe :logger do
+        it 'returns the default logger' do
+          logger = Logging::Loggers.default_logger
+          expect(logificator.logger).to be(logger)
+        end
+
+        it 'returns a set logger' do
+          logger = new_mock_logger
+          logificator.logger = logger
+          expect(logificator.logger).to be(logger)
+        end
+
+        it 'returns a logger set via the class method' do
+          logger = new_mock_logger
+          Logging.logger = logger
+          expect(logificator.logger).to be(logger)
+        end
+      end
+
+      describe :logger= do
+        it 'sets the shared logger via the class method' do
+          logger = new_mock_logger
+          logificator.logger = logger
+          expect(Logging.logger).to be(logger)
+        end
+
+        it 'sets a shared logger accessible via another including class' do
+          logger = new_mock_logger
+          Object.new.tap do |logificator2|
+            logificator2.singleton_class.send(:include, Logging)
+            logificator2.logger = logger
+          end
+          expect(logificator.logger).to be(logger)
+        end
+
+        it 'rejects a non-logger' do
+          original_logger = logificator.logger
+          expect { logificator.logger = Object.new }.to raise_error(ArgumentError)
+          expect(logificator.logger).to be(original_logger)
+        end
+
+        it 'can be reset to default with nil' do
+          default_logger = Logging::Loggers.default_logger
+          logificator.logger = new_mock_logger
+          logificator.logger = nil
+          expect(logificator.logger).to be(default_logger)
+        end
+      end
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,15 @@
+# ------------------------------------------------------------
+# RSpec
+
+require 'spec_helper'
+
+# ------------------------------------------------------------
+# Rails
+
+require 'rails'
+Rails.env = 'test'
+
+# ------------------------------------------------------------
+# Code under test
+
+require 'berkeley_library/logging'

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+# ------------------------------------------------------------
+# SimpleCov
+
+if ENV['COVERAGE']
+  require 'simplecov'
+
+  spec_root = File.realpath(__dir__)
+  spec_group_re = %r{(?<=^#{spec_root}/)[^/]+(?=/)}
+
+  RSpec.configure do |config|
+    config.before(:each) do |example|
+      abs_path = File.realpath(example.metadata[:absolute_file_path])
+      match_data = spec_group_re.match(abs_path)
+      raise ArgumentError, "Unable to determine group for example at #{abs_path}" unless match_data
+
+      spec_group = match_data[0]
+      SimpleCov.command_name(spec_group)
+      SimpleCov.coverage_dir("artifacts/simplecov/#{spec_group}")
+    end
+  end
+end
+
+# ------------------------------------------------------------
+# RSpec
+
+RSpec.configure do |config|
+  config.color = true
+  config.tty = true
+  config.formatter = :documentation
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end

data/spec/standalone/ucblit/logging/configurator_spec.rb

@@ -0,0 +1,103 @@
+require 'standalone_helper'
+require 'ostruct'
+require 'lograge'
+
+module BerkeleyLibrary
+  module Logging
+    describe Configurator do
+      describe :configure! do
+        attr_reader :config
+
+        before(:each) do
+          @stdout_orig = $stdout
+          $stdout = StringIO.new
+
+          @config = OpenStruct.new
+          config.lograge = Lograge::OrderedOptions.new
+        end
+
+        after(:each) do
+          $stdout = @stdout_orig
+        end
+
+        it 'sets the logger' do
+          Configurator.configure(config)
+          expect(config.logger).to be_a(Logging::Logger)
+        end
+
+        describe :configure_lograge! do
+          it 'enables Lograge' do
+            Configurator.configure(config)
+            lograge = config.lograge
+            expect(lograge.enabled).to eq(true)
+          end
+
+          it 'extracts request info from log events' do
+            Configurator.configure(config)
+            lograge = config.lograge
+
+            request_headers = {
+              'HTTP_REFERER' => 'value from HTTP_REFERER',
+              'action_dispatch.request_id' => 'value from action_dispatch.request_id',
+              'action_dispatch.remote_ip' => 'value from action_dispatch.remote_ip',
+              'REMOTE_ADDR' => 'value from REMOTE_ADDR',
+              'HTTP_X_FORWARDED_FOR' => 'value from HTTP_X_FORWARDED_FOR',
+              'HTTP_FORWARDED' => 'value from HTTP_FORWARDED'
+            }
+
+            expected_header_map = {
+              referer: 'HTTP_REFERER',
+              request_id: 'action_dispatch.request_id',
+              remote_ip: 'action_dispatch.remote_ip',
+              remote_addr: 'REMOTE_ADDR',
+              x_forwarded_for: 'HTTP_X_FORWARDED_FOR',
+              forwarded: 'HTTP_FORWARDED'
+            }
+
+            event = instance_double(ActiveSupport::Notifications::Event)
+            allow(event).to receive(:payload).and_return({ headers: request_headers })
+
+            custom_options = lograge.custom_options
+            data = custom_options.call(event)
+            expect(data).to be_a(Hash)
+            expect(data[:time]).to be_a(Time) # TODO: check for accuracy
+            expected_header_map.each { |xh, rh| expect(data[xh]).to eq(request_headers[rh]) }
+          end
+
+          it 'formats Lograge data as a hash' do
+            Configurator.configure(config)
+            lograge = config.lograge
+
+            formatter = lograge.formatter
+            expect(formatter.call(nil)).to eq({ msg: 'Request', request: {} })
+            expect(formatter.call('elvis')).to eq({ msg: 'Request', request: { msg: 'elvis' } })
+            some_hash = { foo: 'bar' }
+            expect(formatter.call(some_hash)).to eq({ msg: 'Request', request: some_hash })
+          end
+        end
+
+        describe 'Webpacker' do
+          it 'works if Webpacker is not present' do
+            expect(Object.const_defined?(:Webpacker)).to eq(false) # just to be sure
+            expect { Configurator.configure(config) }.not_to raise_error
+          end
+
+          it 'sets the Webpacker logger if Webpacker is present' do
+            module ::Webpacker
+              module Instance
+                class << self
+                  attr_accessor :logger
+                end
+              end
+            end
+
+            Configurator.configure(config)
+            expect(Webpacker::Instance.logger).to eq(config.logger)
+          ensure
+            Object.send(:remove_const, :Webpacker) if defined?(Webpacker)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/standalone/ucblit/logging/formatters_spec.rb

@@ -0,0 +1,44 @@
+require 'standalone_helper'
+require 'json'
+require 'berkeley_library/logging'
+
+module BerkeleyLibrary
+  module Logging
+    describe Formatters do
+      describe :new_json_formatter do
+        it 'supports tagged logging' do
+          out = StringIO.new
+          logger = Logger.new(out)
+          logger.formatter = Formatters.new_json_formatter
+
+          logger = ActiveSupport::TaggedLogging.new(logger)
+
+          expected_tag = 'hello'
+          expected_msg = 'this is a test'
+
+          logger.tagged(expected_tag) { logger.info(expected_msg) }
+
+          logged_json = JSON.parse(out.string)
+          expect(logged_json['msg']).to eq(expected_msg)
+          expect(logged_json['tags']).to eq([expected_tag])
+        end
+      end
+
+      describe :ensure_hash do
+        it 'returns an empty hash for nil' do
+          expect(Formatters.ensure_hash(nil)).to eq({})
+        end
+
+        it 'returns the original hash for a hash' do
+          original_hash = { a: 1, b: 2 }
+          expect(Formatters.ensure_hash(original_hash)).to equal(original_hash)
+        end
+
+        it 'wraps anything else in a hash' do
+          message = 'this is a message'
+          expect(Formatters.ensure_hash(message)).to eq({ msg: message })
+        end
+      end
+    end
+  end
+end

data/spec/standalone/ucblit/logging/loggers_spec.rb

@@ -0,0 +1,278 @@
+require 'standalone_helper'
+require 'json'
+
+module BerkeleyLibrary
+  module Logging
+    describe Loggers do
+      attr_reader :out
+
+      # rubocop:disable Lint/ConstantDefinitionInBlock
+      before(:each) do
+        @out = StringIO.new
+        class ::TestError < StandardError; end
+      end
+      # rubocop:enable Lint/ConstantDefinitionInBlock
+
+      after(:each) do
+        Object.send(:remove_const, :TestError)
+      end
+
+      describe :new_json_logger do
+        it 'supports tagged logging' do
+          logger = Loggers.new_json_logger(out)
+          logger = ActiveSupport::TaggedLogging.new(logger)
+
+          expected_tag = 'hello'
+          expected_msg = 'this is a test'
+
+          logger.tagged(expected_tag) { logger.info(expected_msg) }
+
+          logged_json = JSON.parse(out.string)
+          expect(logged_json['msg']).to eq(expected_msg)
+          expect(logged_json['tags']).to eq([expected_tag])
+        end
+
+        it 'logs an error as a hash' do
+          msg = 'Help I am trapped in a unit test'
+
+          begin
+            raise TestError, msg
+          rescue TestError => e
+            ex = e
+            Loggers.new_json_logger(out).error(e)
+          end
+
+          logged_json = JSON.parse(out.string)
+          expect(logged_json['msg']).to eq(msg)
+          err_json = logged_json['err']
+          expect(err_json).to be_a(Hash)
+          expect(err_json['name']).to eq(TestError.name)
+          expect(err_json['message']).to eq(msg)
+
+          err_stack = err_json['stack']
+          backtrace = ex.backtrace
+          expect(backtrace).not_to be_nil # just to be sure
+          backtrace.each do |line|
+            expect(err_stack).to include(line)
+          end
+        end
+      end
+
+      describe :default_logger do
+        it 'returns a readable $stdout logger' do
+          logger = Loggers.default_logger
+          expect(logger).to be_a(Logger)
+          expect(logger.formatter).to be_a(Ougai::Formatters::Readable)
+
+          logdev = logger.instance_variable_get(:@logdev)
+          expect(logdev).to be_a(::Logger::LogDevice)
+          expect(logdev.dev).to eq($stdout)
+        end
+
+        describe 'errors' do
+          it 'logs an error alone with cause and backtrace' do
+            msg = 'Help I am trapped in a unit test'
+
+            begin
+              raise TestError, msg
+            rescue TestError => e
+              ex = e
+              Loggers.new_readable_logger(out).error(e)
+            end
+
+            logged_txt = out.string
+            expect(logged_txt).to include(msg)
+            expect(logged_txt).to include(TestError.name)
+            backtrace = ex.backtrace
+            expect(backtrace).not_to be_nil # just to be sure
+            backtrace.each do |line|
+              expect(logged_txt).to include(line)
+            end
+          end
+
+        end
+
+        describe 'messages with text and data' do
+          it 'logs an arbitrary hash in a reasonable way' do
+            out = StringIO.new
+            msg_txt = 'message text'
+            msg_h = {
+              foo: 'Foo',
+              bar: 'Bar',
+              baz: 'Baz'
+            }
+            Loggers.new_readable_logger(out).info(msg_txt, msg_h)
+
+            logged_txt = out.string
+            expect(logged_txt).to include(msg_txt)
+            msg_h.each do |k, v|
+              expect(logged_txt).to include(k.inspect)
+              expect(logged_txt).to include(v.inspect)
+            end
+          end
+
+          it 'logs something with #to_hash as a hash' do
+            out = StringIO.new
+            msg_txt = 'message text'
+            msg_h = {
+              foo: 'Foo',
+              bar: 'Bar',
+              baz: 'Baz'
+            }
+            msg_obj = Object.new
+            msg_obj.singleton_class.define_method(:to_hash) { msg_h }
+
+            Loggers.new_readable_logger(out).info(msg_txt, msg_obj)
+
+            logged_txt = out.string
+            expect(logged_txt).to include(msg_txt)
+            msg_h.each do |k, v|
+              expect(logged_txt).to include(k.inspect)
+              expect(logged_txt).to include(v.inspect)
+            end
+          end
+
+          it 'logs an error with cause and backtrace' do
+            msg_txt = 'message text'
+            ex_msg = 'Help I am trapped in a unit test'
+
+            begin
+              raise TestError, ex_msg
+            rescue TestError => e
+              ex = e
+              Loggers.new_readable_logger(out).error(msg_txt, e)
+            end
+
+            logged_txt = out.string
+            expect(logged_txt).to include(msg_txt)
+            expect(logged_txt).to include(ex_msg)
+            expect(logged_txt).to include(TestError.name)
+            backtrace = ex.backtrace
+            expect(backtrace).not_to be_nil # just to be sure
+            backtrace.each do |line|
+              expect(logged_txt).to include(line)
+            end
+          end
+
+        end
+
+        describe 'messages with data and no text' do
+          it 'logs an arbitrary hash in a reasonable way' do
+            out = StringIO.new
+            msg_h = {
+              foo: 'Foo',
+              bar: 'Bar',
+              baz: 'Baz'
+            }
+            Loggers.new_readable_logger(out).info(msg_h)
+            logged_txt = out.string
+            msg_h.each do |k, v|
+              expect(logged_txt).to include(k.inspect)
+              expect(logged_txt).to include(v.inspect)
+            end
+          end
+
+          it 'logs something with #to_hash as a hash' do
+            out = StringIO.new
+            msg_h = {
+              foo: 'Foo',
+              bar: 'Bar',
+              baz: 'Baz'
+            }
+            msg_obj = Object.new
+            msg_obj.singleton_class.define_method(:to_hash) { msg_h }
+
+            Loggers.new_readable_logger(out).info(msg_obj)
+
+            logged_txt = out.string
+            msg_h.each do |k, v|
+              expect(logged_txt).to include(k.inspect)
+              expect(logged_txt).to include(v.inspect)
+            end
+          end
+
+          it 'logs an error with cause and backtrace' do
+            ex_msg = 'Help I am trapped in a unit test'
+
+            begin
+              raise TestError, ex_msg
+            rescue TestError => e
+              ex = e
+              Loggers.new_readable_logger(out).error(e)
+            end
+
+            logged_txt = out.string
+            expect(logged_txt).to include(ex_msg)
+            expect(logged_txt).to include(TestError.name)
+            backtrace = ex.backtrace
+            expect(backtrace).not_to be_nil # just to be sure
+            backtrace.each do |line|
+              expect(logged_txt).to include(line)
+            end
+          end
+
+        end
+
+      end
+
+      describe :new_default_logger do
+        attr_reader :config
+
+        before(:each) do
+          @config = OpenStruct.new
+        end
+
+        after(:each) do
+          BerkeleyLibrary::Logging.instance_variable_set(:@env, nil)
+        end
+
+        it 'returns a readable $stdout logger if given no config' do
+          logger = Loggers.new_default_logger
+          expect(logger).not_to be_nil
+          expect(logger).to be_a(Logger)
+          expect(logger.formatter).to be_a(Ougai::Formatters::Readable)
+        end
+
+        it 'returns a file logger in test' do
+          BerkeleyLibrary::Logging.env = 'test'
+          logger = Loggers.new_default_logger(config)
+          expect(logger).not_to be_nil
+          logdev = logger.instance_variable_get(:@logdev)
+          expect(logdev.filename).to end_with('log/test.log')
+        end
+
+        it 'returns a stdout logger in production' do
+          BerkeleyLibrary::Logging.env = 'production'
+          stdout_orig = $stdout
+          stdout_tmp = StringIO.new
+          begin
+            $stdout = stdout_tmp
+            logger = Loggers.new_default_logger(config)
+          ensure
+            $stdout = stdout_orig
+          end
+          expect(logger).not_to be_nil
+          logdev = logger.instance_variable_get(:@logdev)
+          expect(logdev.filename).to be_nil
+          expect(logdev.dev).to eq(stdout_tmp)
+        end
+
+        it 'returns a stdout logger in development' do
+          BerkeleyLibrary::Logging.env = 'development'
+          logger = Loggers.new_default_logger(config)
+          expect(logger).not_to be_nil
+          logdev = logger.instance_variable_get(:@logdev)
+          expect(logdev.filename).to be_nil
+          expect(logdev.dev).to eq($stdout)
+
+          # TODO: come up with a succinct way to test broadcast to file
+        end
+
+        it 'fails on an unsupported environment' do
+          BerkeleyLibrary::Logging.env = 'some-unsupported-environment'
+          expect { Loggers.new_default_logger(config) }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end