berkeley_library-logging 0.2.0

data/rakelib/.rubocop.yml

@@ -0,0 +1,4 @@
+inherit_from: ../.rubocop.yml
+
+Metrics/BlockLength:
+  Enabled: false

data/rakelib/bundle.rake

@@ -0,0 +1,8 @@
+namespace :bundle do
+  desc 'Check bundled gems for vulnerabilities against the latest ruby-advisory-db'
+  task :audit do
+    require 'bundler/audit/cli'
+    Bundler::Audit::CLI.start ['update']
+    Bundler::Audit::CLI.start %w[check --ignore CVE-2015-9284]
+  end
+end

data/rakelib/coverage.rake

@@ -0,0 +1,36 @@
+require 'colorize'
+
+namespace :simplecov do
+  task :check_coverage do
+    ENV['COVERAGE'] ||= 'true'
+    Rake::Task['spec'].invoke
+  rescue SystemExit
+    puts 'Code coverage analysis aborted, probably due to a previous test failure'.colorize(:red)
+    raise
+  end
+
+  task :report do
+    require 'simplecov'
+    require 'simplecov-rcov'
+    require 'simplecov-console'
+
+    result_sets = Dir.glob('artifacts/simplecov/**/.resultset.json')
+    SimpleCov.collate(result_sets) do
+      minimum_coverage 100
+      coverage_dir 'artifacts'
+
+      if ENV['GENERATE_REPORTS']
+        formatters = [
+          SimpleCov::Formatter::Console,
+          SimpleCov::Formatter::RcovFormatter
+        ]
+        formatter SimpleCov::Formatter::MultiFormatter.new(formatters)
+      else
+        formatter SimpleCov::Formatter::Console
+      end
+    end
+  end
+end
+
+desc 'Run all specs in spec directory, with coverage'
+task coverage: %w[simplecov:check_coverage simplecov:report]

data/rakelib/gem.rake

@@ -0,0 +1,56 @@
+require 'rubygems/gem_runner'
+require 'berkeley_library/logging/module_info'
+
+module BerkeleyLibrary
+  module Logging
+    class << self
+      def project_root
+        @project_root ||= File.expand_path('..', __dir__)
+      end
+
+      def artifacts_dir
+        return project_root unless ENV['CI']
+
+        @artifacts_dir ||= File.join(project_root, 'artifacts')
+      end
+
+      def gemspec_file
+        @gemspec_file ||= begin
+          gemspec_files = Dir.glob(File.expand_path('*.gemspec', project_root))
+          raise ArgumentError, "Too many .gemspecs: #{gemspec_files.join(', ')}" if gemspec_files.size > 1
+          raise ArgumentError, 'No .gemspec file found' if gemspec_files.empty?
+
+          gemspec_files[0]
+        end
+      end
+
+      def gemspec_basename
+        File.basename(gemspec_file)
+      end
+
+      def output_file
+        @output_file ||= begin
+          gem_name = File.basename(gemspec_file, '.*')
+          version = BerkeleyLibrary::Logging::ModuleInfo::VERSION
+          basename = "#{gem_name}-#{version}.gem"
+          File.join(artifacts_dir, basename)
+        end
+      end
+
+      def output_file_relative
+        return File.basename(output_file) unless ENV['CI']
+
+        @output_file_relative ||= begin
+          artifacts_dir_relative = File.basename(artifacts_dir)
+          File.join(artifacts_dir_relative, File.basename(output_file))
+        end
+      end
+    end
+  end
+end
+
+desc "Build #{BerkeleyLibrary::Logging.gemspec_basename} as #{BerkeleyLibrary::Logging.output_file_relative}"
+task :gem do
+  args = ['build', BerkeleyLibrary::Logging.gemspec_file, "--output=#{BerkeleyLibrary::Logging.output_file}"]
+  Gem::GemRunner.new.run(args)
+end

data/rakelib/rubocop.rake

@@ -0,0 +1,14 @@
+require 'rubocop'
+require 'rubocop/rake_task'
+
+desc 'Run RuboCop'
+RuboCop::RakeTask.new(:rubocop) do |cop|
+  next unless ENV['GENERATE_REPORTS']
+
+  output = ENV['RUBOCOP_OUTPUT'] || 'artifacts/rubocop/index.html'
+  puts "Writing RuboCop inspection report to #{output}"
+
+  cop.verbose = false
+  cop.formatters = ['html']
+  cop.options = ['--out', output]
+end

data/rakelib/spec.rake

@@ -0,0 +1,31 @@
+require 'rspec/core/rake_task'
+
+namespace :spec do
+  task :prepare do
+    if ENV['GENERATE_REPORTS']
+      ENV['CI_REPORTS'] = 'artifacts/rspec'
+
+      require 'ci/reporter/rake/rspec'
+      Rake::Task['ci:setup:rspec'].invoke
+    end
+  end
+
+  test_groups = %i[standalone rails].tap do |groups|
+    groups.each do |group|
+      desc "Run specs in spec/#{group} directory"
+      RSpec::Core::RakeTask.new(group) do |task|
+        task.rspec_opts = %w[--color --format documentation --order default]
+        task.pattern = "spec/#{group}/**/*_spec.rb"
+      end
+    end
+  end
+  multitask all: test_groups
+end
+
+desc 'Run all specs in spec directory'
+task spec: ['spec:prepare'] do
+  Rake::Task['spec:all'].invoke
+ensure
+  reports_dir = ENV['CI_REPORTS']
+  puts "JUnit-format XML test report written to #{reports_dir}" if reports_dir
+end

data/spec/.rubocop.yml

@@ -0,0 +1,27 @@
+inherit_from: ../.rubocop.yml
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+############################################################
+# Added in Rubocop 0.89
+
+# Sometimes we're testing the operator
+Lint/BinaryOperatorWithIdenticalOperands:
+  Enabled: false
+  

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

@@ -0,0 +1,101 @@
+require 'rails_helper'
+require 'rails'
+require 'lograge'
+require 'berkeley_library/logging'
+
+module BerkeleyLibrary
+  module Logging
+    describe Configurator do
+      describe :configure! do
+
+        attr_reader :config
+
+        before(:each) do
+          app = Class.new(Rails::Application).new
+          allow(Rails).to receive(:application).and_return(app)
+          @config = app.config
+
+          config.lograge = Lograge::OrderedOptions.new
+        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/rails/ucblit/logging/env_spec.rb

@@ -0,0 +1,25 @@
+require 'rails_helper'
+
+module BerkeleyLibrary
+  describe Logging do
+
+    attr_reader :orig_rails_env
+
+    before(:each) do
+      @orig_rails_env = Rails.env
+    end
+
+    after(:each) do
+      Rails.env = orig_rails_env
+    end
+
+    describe :env= do
+      it 'sets Rails.env' do
+        expect(defined?(Rails)).to be_truthy # just to be sure
+        Logging.env = 'elvis'
+        expect(Rails.env).to eq('elvis')
+        expect(Rails.env.elvis?).to eq(true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require 'rails_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/rails/ucblit/logging/loggers_spec.rb

@@ -0,0 +1,117 @@
+require 'rails_helper'
+require 'rails'
+
+module BerkeleyLibrary
+  module Logging
+    describe Loggers do
+      attr_reader :orig_rails_env
+
+      before(:each) do
+        @orig_rails_env = Rails.env
+      end
+
+      after(:each) do
+        Rails.env = orig_rails_env
+      end
+
+      describe :new_json_logger do
+        it 'supports tagged logging' do
+          out = StringIO.new
+          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
+      end
+
+      describe :default_logger do
+        before(:each) { @rails_logger = Rails.logger }
+        after(:each) { Rails.logger = @rails_logger }
+
+        it 'returns the Rails logger' do
+          expected_logger = double(::Logger)
+          Rails.logger = expected_logger
+
+          expect(Loggers.default_logger).to be(expected_logger)
+        end
+
+        it 'returns a readable $stdout logger if Rails logger is nil' do
+          Rails.logger = nil
+
+          actual_logger = Loggers.default_logger
+          expect(actual_logger).to be_a(Logger)
+          expect(actual_logger.formatter).to be_a(Ougai::Formatters::Readable)
+
+          logdev = actual_logger.instance_variable_get(:@logdev)
+          expect(logdev).to be_a(::Logger::LogDevice)
+          expect(logdev.dev).to be($stdout)
+        end
+
+        it "doesn't cache the default logger if the Rails logger is initialized later" do
+          Rails.logger = nil
+
+          initial_default_logger = Loggers.default_logger
+
+          expected_logger = double(::Logger)
+          Rails.logger = expected_logger
+
+          actual_logger = Loggers.default_logger
+          expect(actual_logger).not_to be(initial_default_logger)
+          expect(actual_logger).to be(expected_logger)
+        end
+
+      end
+
+      describe :new_default_logger do
+        attr_reader :config
+
+        before(:each) do
+          app = Class.new(Rails::Application).new
+          @config = app.config
+        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
+      end
+    end
+  end
+end