paul_bunyan 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39c2d1964ce640e53681be266ec3fd065ec310d5
-  data.tar.gz: d3b1aad302c4b7ee5f2025f5e718595202985199
+  metadata.gz: 0b7d9fd1c7ac8e2b72e82b72171ea627c9597196
+  data.tar.gz: 270c98aa6aa254836aa244db96847b432204df92
 SHA512:
-  metadata.gz: 2e408a9c88d81bf995d0982114728b8d261ad4bad9b1ac0151ebfa80d3ccf90bf85f732f468a928480ee7930e11e3517825b15af06315b6237e44a3856a48aae
-  data.tar.gz: 1fe0abb219320d2fb0e05f0e04da4c1ac307e7e09ef9f3a5d7e72b1147acd889e21457cb05531e0664518a6f517a3f2b86c791e46b5616917258696f71504995
+  metadata.gz: 7cd3fb82d143d9b6fba0d2f4949ad5a15b52459a6b85fa2ff273a3d13f17754d3bf212a6c133a554a222691e2a6adc90a16a62dc5cfa325513a4e8099e869488
+  data.tar.gz: 19f8c7c07ac6027f48302882a814b7426dcd3dad228bf4be858075aeccb32d94db72feaddfcdb2cd3019991f775d8969447c1ceb57a6cb0f7485422577bae276

data/.dockerignore

@@ -1 +1,2 @@
 Gemfile.lock
+spec/gemfiles/*.lock

data/.gitignore

@@ -23,3 +23,4 @@ spec/dummy/log/*.log
 spec/dummy/tmp/
 spec/dummy/.sass-cache
 spec/gemfiles/*.lock
+docker-compose.override.yml

data/.travis.yml

@@ -1,21 +1,17 @@
 language: ruby
-sudo: false
-cache: bundler
-bundler_args: --path ../../vendor/bundle
 rvm:
-  # - ruby-head
-  - 2.1
   - 2.2
-  - 2.3.0
+  - 2.3
+  - 2.4
 matrix:
   fast_finish: true
   # WWTD doesn't support allow_failures... yet
   # allow_failures:
   #   - rvm: ruby-head
 gemfile:
-  - spec/gemfiles/40.gemfile
-  - spec/gemfiles/41.gemfile
   - spec/gemfiles/42.gemfile
+  - spec/gemfiles/50.gemfile
+  - spec/gemfiles/51.gemfile
 script: bundle exec rspec
 notifications:
   email:

data/Dockerfile

@@ -1,16 +1,19 @@
 FROM instructure/rvm
 MAINTAINER Instructure
 
-COPY Gemfile* *.gemspec /usr/src/app/
+WORKDIR /usr/src/app
+RUN /bin/bash -l -c "rvm use --default 2.4"
+
+COPY paul_bunyan.gemspec Gemfile /usr/src/app/
 COPY lib/paul_bunyan/version.rb /usr/src/app/lib/paul_bunyan/
 
 USER root
 RUN chown -R docker:docker /usr/src/app
 USER docker
-RUN /bin/bash -l -c "cd /usr/src/app && bundle install"
+RUN /bin/bash -l -c "bundle install"
 
 COPY . /usr/src/app
 USER root
 RUN chown -R docker:docker /usr/src/app/*
 USER docker
-CMD /bin/bash -l -c "cd /usr/src/app && bundle exec wwtd --parallel"
+CMD /bin/bash -l -c "wwtd --parallel"

data/README.md

@@ -19,8 +19,8 @@ end
 
 Also included is a Railtie that overrides the default rails logger to always
 print to STDOUT as well as format the messages to JSON for machine readable
-goodness. This has been tested with Rails 4.2 but should compatible with
-Rails 3 or newer since that's when Railties were introduced.
+goodness. This has been tested with Rails 4.2 through 5.1, older versions of
+Rails may work but are not guaranteed to and will not receive support.
 
 ## Installation
 
@@ -53,3 +53,12 @@ logger.warn "blah"
 ### Rails projects:
 
 Nothing after it's added to your Gemfile, the Railtie takes care of the rest.
+
+### Adding metadata to JSON logs
+The default logger includes the ability to accept arbitrary metadata, the
+primary use case for this functionality is to add context to log lines generated
+in the course of processing a Rails request. There is an example for adding
+the request host to the metadata in the examples directory. There are a few
+keys that are used internally that will be overwritten when added to user
+supplied metadata, this list can be found in the `#call` method of
+`PaulBunyan::JSONFormatter`.

data/build.sh

@@ -2,5 +2,5 @@
 
 set -e
 
-docker-compose build --pull
+docker-compose build --pull test
 docker-compose run test

data/docker-compose.override.yml.example

@@ -0,0 +1,10 @@
+version: '2.0'
+services:
+  test:
+    build: .
+    volumes:
+      - "./:/usr/src/app"
+      - "gems:/home/docker/.rvm/gems/"
+
+volumes:
+  gems: {}

data/docker-compose.yml

@@ -1,4 +1,9 @@
-test:
-  build: .
-  volumes:
-    - "coverage:/app/coverage"
+version: '2.0'
+services:
+  test:
+    build: .
+    volumes:
+      - "coverage:/usr/src/app/coverage"
+
+volumes:
+  coverage: {}

data/examples/host_middleware.rb

@@ -0,0 +1,20 @@
+# An example Rack middleware to capture the host the request was made to
+require 'rack/request'
+
+class HostMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    if PaulBunyan.logger.respond_to?(:with_metadata)
+      req = Rack::Request.new(env)
+
+      PaulBunyan.logger.with_metadata(request_host: req.host) do
+        @app.call(env)
+      end
+    else
+      @app.call(env)
+    end
+  end
+end

data/lib/paul_bunyan.rb

@@ -1,8 +1,11 @@
 require 'logger'
 
+
 require_relative 'paul_bunyan/json_formatter'
 require_relative 'paul_bunyan/level'
 require_relative 'paul_bunyan/log_relayer'
+require_relative 'paul_bunyan/metadata_logging'
+require_relative 'paul_bunyan/tagged_logging'
 require_relative 'paul_bunyan/text_formatter'
 require_relative 'paul_bunyan/version'
 
@@ -23,7 +26,6 @@ module PaulBunyan
   class UnknownFormatterError < Error; end
   class UnknownLevelError < Error; end
 
-  # The ONE method we care about.
   def logger
     PaulBunyan.logger
   end
@@ -49,6 +51,8 @@ module PaulBunyan
     def create_logger(logdev, shift_age = 0, shift_size = 1048576, formatter_type: PaulBunyan.default_formatter_type)
       logger = Logger.new(logdev, shift_age, shift_size)
       logger.formatter = default_formatter(formatter_type) unless formatter_type.nil?
+      logger.extend(TaggedLogging) if logger.formatter.respond_to?(:tagged)
+      logger.extend(MetadataLogging) if logger.formatter.respond_to?(:with_metadata)
       add_logger(logger)
     end
 
@@ -59,7 +63,7 @@ module PaulBunyan
     end
 
     def remove_logger(logger)
-      @logger.remove_logger(logger)
+      @logger.remove_logger(logger) if @logger
     end
 
     private def default_formatter(formatter_type)

data/lib/paul_bunyan/json_formatter.rb

@@ -5,13 +5,17 @@ module PaulBunyan
   class JSONFormatter
     DATETIME_FORMAT = '%Y-%m-%dT%H:%M:%S.%3N'
 
+    def add_metadata(metadata)
+      current_metadata.merge!(metadata)
+    end
+
     def call(severity, time, progname, msg)
-      metadata = {
+      metadata = current_metadata.merge({
         "ts"       => time.utc.strftime(DATETIME_FORMAT),
         "unix_ts"  => time.to_f,
         "severity" => severity,
         "pid"      => $$,
-      }
+      })
       metadata['program'] = progname if progname
       metadata['tags'] = current_tags unless current_tags.empty?
 
@@ -20,13 +24,24 @@ module PaulBunyan
       JSON::generate(merge_metadata_and_message(metadata, message_data)) + "\n"
     end
 
+    def clear_metadata!
+      current_metadata.clear
+    end
+
     def clear_tags!
       current_tags.clear
     end
 
+    def current_metadata
+      metadata_thread_key = @metadata_thread_key ||=
+        "paul_bunyan_logging_metadata:#{self.object_id}"
+      Thread.current[metadata_thread_key] ||= {}
+    end
+
     def current_tags
-      thread_key = @thread_key ||= "logging_tagged_logging_tags:#{ Thread.current.object_id }"
-      Thread.current[thread_key] ||= []
+      tags_thread_key = @tags_thread_key ||=
+        "paul_bunyan_logging_tags:#{self.object_id}"
+      Thread.current[tags_thread_key] ||= []
     end
 
     def datetime_format=(value)
@@ -48,6 +63,10 @@ module PaulBunyan
       end
     end
 
+    def remove_metadata(metadata)
+      metadata.each { |k, _| current_metadata.delete(k) }
+    end
+
     def tagged(*tags)
       clean_tags = push_tags(tags)
       yield
@@ -55,6 +74,13 @@ module PaulBunyan
       pop_tags(clean_tags.size)
     end
 
+    def with_metadata(consumer_metadata)
+      add_metadata(consumer_metadata)
+      yield
+    ensure
+      remove_metadata(consumer_metadata)
+    end
+
     private
 
     # TODO: extract all of this formatting/merging out into another class if it grows

data/lib/paul_bunyan/log_relayer.rb

@@ -108,43 +108,66 @@ module PaulBunyan
       silencer.call
     end
 
-    module TaggedRelayer
-      def current_tags
-        tags = loggers.each_with_object(Set.new) do |logger, set|
-          set.merge(logger.current_tags) if logger.respond_to?(:current_tags)
-        end
-        tags.to_a
+    def current_tags
+      tags = loggers.each_with_object(Set.new) do |logger, set|
+        set.merge(logger.current_tags) if logger.respond_to?(:current_tags)
       end
+      tags.to_a
+    end
 
-      def push_tags(*tags)
-        tags.flatten.reject(&:blank?).tap do |new_tags|
-          loggers.each { |logger| logger.push_tags(*new_tags) if logger.respond_to?(:push_tags) }
-        end
+    def push_tags(*tags)
+      tags.flatten.reject(&:blank?).tap do |new_tags|
+        messaging_loggers(:push_tags, *new_tags)
       end
+    end
 
-      def pop_tags(size = 1)
-        loggers.each { |logger| logger.pop_tags(size) if logger.respond_to?(:pop_tags) }
-        nil
-      end
+    def pop_tags(size = 1)
+      messaging_loggers(:pop_tags, size)
+    end
 
-      def clear_tags!
-        loggers.each { |logger| logger.clear_tags! if logger.respond_to?(:clear_tags!) }
-        nil
-      end
+    def clear_tags!
+      messaging_loggers(:clear_tags!)
+    end
 
-      def flush
-        loggers.each { |logger| logger.flush if logger.respond_to?(:flush) }
-        nil
-      end
+    def flush
+      messaging_loggers(:flush)
+    end
+
+    def tagged(*tags)
+      new_tags = push_tags(*tags)
+      yield self
+    ensure
+      pop_tags(new_tags.size)
+    end
 
-      def tagged(*tags)
-        new_tags = push_tags(*tags)
-        yield self
-      ensure
-        pop_tags(new_tags.size)
+    def add_metadata(metadata)
+      messaging_loggers(:add_metadata, metadata)
+    end
+
+    def clear_metadata!
+      messaging_loggers(:clear_metadata!)
+    end
+
+    def current_metadata
+      loggers.inject({}) do |agg, logger|
+        if logger.respond_to?(:current_metadata)
+          agg.merge(logger.current_metadata)
+        else
+          agg
+        end
       end
     end
-    include TaggedRelayer
+
+    def remove_metadata(metadata)
+      messaging_loggers(:remove_metadata, metadata)
+    end
+
+    def with_metadata(metadata)
+      add_metadata(metadata)
+      yield
+    ensure
+      remove_metadata(metadata)
+    end
 
     private
 
@@ -157,5 +180,10 @@ module PaulBunyan
         result = block.call
       end
     end
+
+    def messaging_loggers(required_method, *args)
+      loggers.each { |l| l.public_send(required_method, *args) if l.respond_to?(required_method) }
+      nil
+    end
   end
 end

data/lib/paul_bunyan/metadata_logging.rb

@@ -0,0 +1,16 @@
+module PaulBunyan
+  module MetadataLogging
+    def clear_metadata!
+      formatter.clear_metadata!
+    end
+
+    def with_metadata(metadata)
+      formatter.with_metadata(metadata) { yield self }
+    end
+
+    def flush
+      clear_metadata!
+      super if defined?(super)
+    end
+  end
+end

data/lib/paul_bunyan/railtie.rb

@@ -31,6 +31,7 @@ module PaulBunyan
       new_logger.level = PaulBunyan::Level.coerce_level(ENV['LOG_LEVEL'] || ::Rails.application.config.log_level || 'INFO')
       new_logger.formatter = logging_config.formatter
       new_logger.extend(ActiveSupport::TaggedLogging) if logging_config.formatter.respond_to?(:tagged)
+      new_logger.extend(PaulBunyan::MetadataLogging) if logging_config.formatter.respond_to?(:with_metadata)
 
       if logging_config.handle_request_logging
         unsubscribe_default_log_subscribers

data/lib/paul_bunyan/railtie/log_subscriber.rb

@@ -71,15 +71,6 @@ module PaulBunyan
       end
     end
 
-    if Rails.version.start_with?('4.0')
-      attr_reader :patterns
-
-      def initialize
-        super
-        @patterns ||= []
-      end
-    end
-
     # Handle the start_processing event in the action_controller namespace
     #
     # We're only registering for this event so the default

data/lib/paul_bunyan/tagged_logging.rb

@@ -0,0 +1,24 @@
+module PaulBunyan
+  module TaggedLogging
+    def push_tags(*args)
+      formatter.push_tags(*args)
+    end
+
+    def pop_tags(count = 1)
+      formatter.pop_tags(count)
+    end
+
+    def clear_tags!
+      formatter.clear_tags!
+    end
+
+    def tagged(*tags)
+      formatter.tagged(*tags) { yield self }
+    end
+
+    def flush
+      clear_tags!
+      super if defined?(super)
+    end
+  end
+end

data/lib/paul_bunyan/version.rb

@@ -1,3 +1,3 @@
 module PaulBunyan
-  VERSION = '1.4.0'
+  VERSION = '1.5.0'
 end

data/paul_bunyan.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['duane@instructure.com', 'kromney@instructure.com', 'markse@instructure.com', 'tpickett@instructure.com']
   spec.summary       = 'Logging for all the things'
   spec.description   = "Extensions and enhancements to Ruby's built in Logger class. Extensions include: multiple output streams, JSON formatting for easy aggregation, and a Railtie to set some sane(ish) defaults for production Rails environments."
-  spec.homepage      = ''
+  spec.homepage      = 'https://github.com/instructure/paul_bunyan'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -24,11 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'wwtd'
-  spec.add_development_dependency 'rails'
+  spec.add_development_dependency 'rails', '>= 4.2'
   spec.add_development_dependency 'sqlite3'
   spec.add_development_dependency 'byebug'
-
-  if RUBY_VERSION < '2.2'
-    spec.add_development_dependency 'rack', '< 2.0'
-  end
 end

data/spec/dummy/config/application.rb

@@ -20,7 +20,7 @@ module Dummy
     # config.i18n.default_locale = :de
 
     # Do not swallow errors in after_commit/after_rollback callbacks.
-    if Rails.version > '4.2'
+    if Rails.version > '4.2' && Rails.version < '5.0'
       config.active_record.raise_in_transactional_callbacks = true
     end
   end

data/spec/dummy/config/environments/test.rb

@@ -13,8 +13,11 @@ Dummy::Application.configure do
   config.eager_load = false
 
   # Configure static file server for tests with Cache-Control for performance.
-  config.serve_static_files   = true
-  config.static_cache_control = 'public, max-age=3600'
+  if Rails.version <= '5.0'
+    config.serve_static_files   = true
+    config.static_cache_control = 'public, max-age=3600'
+  end
+
 
   # Show full error reports and disable caching.
   config.consider_all_requests_local       = true

data/spec/gemfiles/{40.gemfile → 50.gemfile}

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 
 gemspec path: '../../'
 
-gem 'rails', '~> 4.0.0'
+gem 'rails', '~> 5.0.0'

data/spec/gemfiles/{41.gemfile → 51.gemfile}

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 
 gemspec path: '../../'
 
-gem 'rails', '~> 4.1.0'
+gem 'rails', '~> 5.1.0'

data/spec/lib/paul_bunyan/json_formatter_spec.rb

@@ -56,6 +56,14 @@ module PaulBunyan
         end
       end
 
+      it 'must merge supplied metadata into the message' do
+        formatter.with_metadata(foo: 'bar') do
+          output = formatter.call('', time, '', 'This is my message, there are many like it.')
+          object = JSON.parse(output)
+          expect(object).to include 'foo' => 'bar'
+        end
+      end
+
       context 'when supplied a string as the message' do
         it 'must wrap the message in an object with a message key containing the key' do
           output = formatter.call('', time, '', 'This is my message, there are many like it.')

data/spec/lib/paul_bunyan/log_relayer_spec.rb

@@ -1,10 +1,6 @@
-require 'set'
 require 'spec_helper'
-require 'stringio'
 
 describe PaulBunyan::LogRelayer do
-  let(:device) { StringIO.new }
-
   let(:empty_relayer) { PaulBunyan::LogRelayer.new }
 
   let(:primary) { double('primary logger') }
@@ -34,10 +30,6 @@ describe PaulBunyan::LogRelayer do
     end
   end
 
-  describe '#loggers' do
-    # tested by specs for #primary_logger and #secondary_loggers
-  end
-
   describe '#primary_logger' do
     it 'matches the first value in #loggers' do
       expect(double_relayer.primary_logger).to eq(double_relayer.loggers.first)
@@ -66,7 +58,7 @@ describe PaulBunyan::LogRelayer do
   describe '#add_logger' do
     it 'adds loggers to the end of the #loggers array' do
       empty_relayer.add_logger(primary)
-      expect(empty_relayer.loggers.last).to be(primary)
+      expect(empty_relayer.loggers).to contain_exactly(primary)
     end
 
     it 'sets #primary_logger when the first logger is added' do
@@ -256,93 +248,160 @@ describe PaulBunyan::LogRelayer do
     end
   end
 
-  context 'tagging' do
-    describe '#current_tags' do
-      it 'aggregates the #current_tags of child loggers (skipping non-tagged loggers)' do
-        expect(primary).to receive(:current_tags).and_return(%w(a b))
-        expect(tertiary).to receive(:current_tags).and_return(%w(b c))
-        expect(Set.new(triple_relayer.current_tags)).to be_superset(Set.new(%w(a b c)))
+  context 'silence' do
+    describe '#silence' do
+      it 'calls silence on all loggers' do
+        expect(primary).to receive(:silence).with(Logger::WARN) { |&b| b.call }
+        expect(secondary).to receive(:silence).with(Logger::WARN) { |&b| b.call }
+        expect { |b| double_relayer.silence(Logger::WARN, &b) }.to yield_control
       end
-    end
 
-    describe '#push_tags' do
-      it 'delegates to all child loggers' do
-        expect(primary).to receive(:push_tags).with(*%w(a b c))
-        expect(tertiary).to receive(:push_tags).with(*%w(a b c))
-        triple_relayer.push_tags(*%w(a b c))
+      it 'skips loggers without a #silence method' do
+        allow(secondary).to receive(:respond_to?) { false }
+        expect(primary).to receive(:silence).with(Logger::WARN) { |&b| b.call }
+        expect { |b| double_relayer.silence(Logger::WARN, &b) }.to yield_control
       end
+    end
+  end
 
-      it 'flattens the tags list' do
-        expect(primary).to receive(:push_tags).with(*%w(a b c d))
-        single_relayer.push_tags(%w(a b), %w(c d))
-      end
+  describe '#current_tags' do
+    it 'aggregates the #current_tags of child loggers (skipping non-tagged loggers)' do
+      expect(primary).to receive(:current_tags).and_return(%w(a b))
+      expect(tertiary).to receive(:current_tags).and_return(%w(b c))
+      expect(Set.new(triple_relayer.current_tags)).to be_superset(Set.new(%w(a b c)))
+    end
+  end
 
-      it 'omits blank tags' do
-        expect(primary).to receive(:push_tags).with(*%w(a b c d))
-        single_relayer.push_tags(['a', 'b', '', nil, 'c', 'd'])
-      end
+  describe '#push_tags' do
+    it 'delegates to all child loggers' do
+      expect(primary).to receive(:push_tags).with(*%w(a b c))
+      expect(tertiary).to receive(:push_tags).with(*%w(a b c))
+      triple_relayer.push_tags(*%w(a b c))
+    end
 
-      it 'returns the flattened, non-blank list of tags' do
-        allow(primary).to receive(:push_tags)
-        expect(single_relayer.push_tags(%w(a b), nil, '', %w(c d))).to eq(%w(a b c d))
-      end
+    it 'flattens the tags list' do
+      expect(primary).to receive(:push_tags).with(*%w(a b c d))
+      single_relayer.push_tags(%w(a b), %w(c d))
     end
 
-    describe '#pop_tags' do
-      it 'delegates to all child loggers' do
-        expect(primary).to receive(:pop_tags).with(4)
-        expect(tertiary).to receive(:pop_tags).with(4)
-        triple_relayer.pop_tags(4)
+    it 'omits blank tags' do
+      expect(primary).to receive(:push_tags).with(*%w(a b c d))
+      single_relayer.push_tags(['a', 'b', '', nil, 'c', 'd'])
+    end
+
+    it 'returns the flattened, non-blank list of tags' do
+      allow(primary).to receive(:push_tags)
+      expect(single_relayer.push_tags(%w(a b), nil, '', %w(c d))).to eq(%w(a b c d))
+    end
+  end
+
+  describe '#pop_tags' do
+    it 'delegates to all child loggers' do
+      expect(primary).to receive(:pop_tags).with(4)
+      expect(tertiary).to receive(:pop_tags).with(4)
+      triple_relayer.pop_tags(4)
+    end
+  end
+
+  describe '#clear_tags!' do
+    it 'delegates to all child loggers' do
+      expect(primary).to receive(:clear_tags!)
+      expect(secondary).to receive(:clear_tags!)
+      triple_relayer.clear_tags!
+    end
+  end
+
+  describe '#flush' do
+    it 'delegates to all child loggers' do
+      expect(primary).to receive(:flush)
+      expect(secondary).to receive(:flush)
+      triple_relayer.flush
+    end
+  end
+
+  describe '#tagged' do
+    it 'calls #push_tags with the given tags' do
+      expect(single_relayer).to receive(:push_tags).with(*%w(a b c)).and_return(%w(a b c))
+      expect { |b| single_relayer.tagged(*%w(a b c), &b) }.to yield_control
+    end
+
+    it 'calls #pop_tags with the number of tags returned from #push_tags' do
+      expect(single_relayer).to receive(:push_tags).with('a', 'b', '', 'd').and_return(%w(a b c))
+      expect(single_relayer).to receive(:pop_tags).with(3)
+      single_relayer.tagged('a', 'b', '', 'd') {}
+    end
+
+    it 'calls #pop_tags when the block raises an exception' do
+      expect(single_relayer).to receive(:pop_tags)
+      expect { single_relayer.tagged('a') { fail StandardError, ':(' } }.to raise_error(StandardError)
+    end
+  end
+
+  context 'logging metadata' do
+    let(:my_metadata) { {foo: 'bar'} }
+
+    before do
+      allow(primary).to receive(:respond_to?).and_return(true)
+      allow(secondary).to receive(:respond_to?).and_return(false)
+      allow(tertiary).to receive(:respond_to?).and_return(true)
+    end
+
+    describe '#add_metadata' do
+      it 'delegates to all child loggers that support it' do
+        expect(primary).to receive(:add_metadata).with(my_metadata)
+        expect(secondary).to_not receive(:add_metadata)
+        double_relayer.add_metadata(my_metadata)
       end
     end
 
-    describe '#clear_tags!' do
+    describe '#clear_metadata!' do
       it 'delegates to all child loggers' do
-        expect(primary).to receive(:clear_tags!)
-        expect(secondary).to receive(:clear_tags!)
-        triple_relayer.clear_tags!
+        expect(primary).to receive(:clear_metadata!)
+        expect(secondary).to_not receive(:clear_metadata!)
+        double_relayer.clear_metadata!
       end
     end
 
-    describe '#flush' do
-      it 'delegates to all child loggers' do
-        expect(primary).to receive(:flush)
-        expect(secondary).to receive(:flush)
-        triple_relayer.flush
+    describe '#current_metadata' do
+      it 'aggregates the #current_metadata of child loggers (skipping non-metadata loggers)' do
+        expect(primary).to receive(:current_metadata).and_return(foo: 'bar')
+        expect(secondary).to_not receive(:current_metadata)
+        expect(tertiary).to receive(:current_metadata).and_return(baz: 'qux')
+
+        expect(triple_relayer.current_metadata).to eq(foo: 'bar', baz: 'qux')
       end
     end
 
-    describe '#tagged' do
-      it 'calls #push_tags with the given tags' do
-        expect(single_relayer).to receive(:push_tags).with(*%w(a b c)).and_return(%w(a b c))
-        expect { |b| single_relayer.tagged(*%w(a b c), &b) }.to yield_control
+    describe '#remove_metadata' do
+      it 'delegates to all child loggers' do
+        expect(primary).to receive(:remove_metadata).with(my_metadata)
+        expect(secondary).to_not receive(:remove_metadata)
+        double_relayer.remove_metadata(my_metadata)
       end
+    end
 
-      it 'calls #pop_tags with the number of tags returned from #push_tags' do
-        expect(single_relayer).to receive(:push_tags).with('a', 'b', '', 'd').and_return(%w(a b c))
-        expect(single_relayer).to receive(:pop_tags).with(3)
-        single_relayer.tagged('a', 'b', '', 'd') {}
+    describe '#with_metadata' do
+      before do
+        allow(single_relayer).to receive(:add_metadata).with(my_metadata)
+        allow(single_relayer).to receive(:remove_metadata).with(my_metadata)
       end
 
-      it 'calls #pop_tags when the block raises an exception' do
-        expect(single_relayer).to receive(:pop_tags)
-        expect { single_relayer.tagged('a') { fail StandardError, ':(' } }.to raise_error(StandardError)
+      it 'must call #add_metadata with the supplied hash' do
+        expect(single_relayer).to receive(:add_metadata).with(my_metadata)
+        expect { |b| single_relayer.with_metadata(my_metadata, &b) }.to yield_control
       end
-    end
-  end
 
-  context 'silence' do
-    describe '#silence' do
-      it 'calls silence on all loggers' do
-        expect(primary).to receive(:silence).with(Logger::WARN) { |&b| b.call }
-        expect(secondary).to receive(:silence).with(Logger::WARN) { |&b| b.call }
-        expect { |b| double_relayer.silence(Logger::WARN, &b) }.to yield_control
+      it 'must call #remove_metadata with the supplied hash' do
+        expect(single_relayer).to receive(:remove_metadata).with(my_metadata)
+        expect { |b| single_relayer.with_metadata(my_metadata, &b) }.to yield_control
       end
 
-      it 'skips loggers without a #silence method' do
-        allow(secondary).to receive(:respond_to?) { false }
-        expect(primary).to receive(:silence).with(Logger::WARN) { |&b| b.call }
-        expect { |b| double_relayer.silence(Logger::WARN, &b) }.to yield_control
+      it 'must call #remove_metadata when the block raises an exception' do
+        expect(single_relayer).to receive(:remove_metadata).with(my_metadata)
+        expect { single_relayer.with_metadata(my_metadata) do
+          fail StandardError, ':('
+        end
+        }.to raise_error(StandardError)
       end
     end
   end

data/spec/lib/paul_bunyan/metadata_logging_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe PaulBunyan::MetadataLogging do
+  subject { Object.new }
+  let(:formatter) { double('formatter') }
+
+  before do
+    subject.extend(PaulBunyan::MetadataLogging)
+    allow(subject).to receive(:formatter).and_return(formatter)
+  end
+
+  it 'must delegate clear_metadata! to the formatter' do
+    expect(formatter).to receive(:clear_metadata!)
+    subject.clear_metadata!
+  end
+
+  it 'must delegate with_metadata to the formatter' do
+    expect(formatter).to receive(:with_metadata).with(foo: 'bar').and_yield
+    subject.with_metadata(foo: 'bar') do |logger|
+      expect(subject).to eq logger
+    end
+  end
+
+  context '#flush' do
+    it 'clears metadata on the formatter' do
+      expect(formatter).to receive(:clear_metadata!)
+      subject.flush
+    end
+
+    it 'sends flush to a parent' do
+      klass = Class.new
+      klass.class_eval do
+        def flush
+          flush_behavior()
+        end
+      end
+
+      metadata_logger = klass.new
+      metadata_logger.extend(PaulBunyan::MetadataLogging)
+      allow(metadata_logger).to receive(:formatter).and_return(formatter)
+      allow(formatter).to receive(:clear_metadata!)
+
+      expect(metadata_logger).to receive(:flush_behavior)
+      metadata_logger.flush
+    end
+  end
+end

data/spec/lib/paul_bunyan/rails_ext/instrumentation_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe ActionController::Base do
   end
 
   before :each do
-    subject.request = ActionDispatch::TestRequest.new({
+    subject.request = build_request({
       'action_dispatch.request_id' => request_id,
       'REMOTE_ADDR' => '127.0.0.1',
     })
@@ -74,7 +74,7 @@ RSpec.describe ActionController::Base do
 
     context 'with sensitive info in the query params' do
       before do
-        subject.request = ActionDispatch::TestRequest.new({
+        subject.request = build_request({
           'action_dispatch.parameter_filter' => [:password, :baz],
           'PATH_INFO' => '/somewhere',
           'QUERY_STRING' => 'password=foo&bar=baz&baz=qux',
@@ -90,6 +90,11 @@ RSpec.describe ActionController::Base do
     end
   end
 
+  def build_request(attrs)
+    factory_method = (Rails.version >= '5.0' ? :create : :new)
+    ActionDispatch::TestRequest.send(factory_method, attrs)
+  end
+
   def calling_index(&block)
     with_subscription_to('process_action.action_controller', block) do
       subject.send(:process_action, :index)

data/spec/lib/paul_bunyan/railtie_spec.rb

@@ -4,10 +4,7 @@ module PaulBunyan
   RSpec.describe Railtie do
     describe 'initializer "initialize_logger.logging"' do
       it 'must extend the logger with ActiveSupport::TaggedLogging' do
-        # Since we're extending an instance of a class it's hard to actually
-        # check for the module in the ancestry chain. respond_to? should be a
-        # good enough proxy for it though.
-        expect(PaulBunyan.logger.primary_logger).to respond_to(:tagged)
+        expect(PaulBunyan.logger.primary_logger).to be_kind_of(ActiveSupport::TaggedLogging)
       end
     end
 

data/spec/lib/paul_bunyan/tagged_logging_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe PaulBunyan::TaggedLogging do
+  subject { Object.new }
+  let(:formatter) { double('formatter') }
+
+  before do
+    subject.extend(PaulBunyan::TaggedLogging)
+    allow(subject).to receive(:formatter).and_return(formatter)
+  end
+
+  it 'delegates #push_tags to #formatter' do
+    expect(formatter).to receive(:push_tags).with('a','b','c')
+    subject.push_tags('a', 'b', 'c')
+  end
+
+  it 'delegates #pop_tags to #formatter' do
+    expect(formatter).to receive(:pop_tags).with(3)
+    subject.pop_tags(3)
+  end
+
+  it 'delegates #clear_tags! to #formatter' do
+    expect(formatter).to receive(:clear_tags!)
+    subject.clear_tags!
+  end
+
+  it 'delegates #tagged to #formatter' do
+    expect(formatter).to receive(:tagged).with('a','b','c').and_yield
+    subject.tagged('a', 'b', 'c') do |logger|
+      expect(subject).to eq logger
+    end
+  end
+
+  context '#flush' do
+    it 'clears tags on the formatter' do
+      expect(formatter).to receive(:clear_tags!)
+      subject.flush
+    end
+
+    it 'sends flush to a parent' do
+      klass = Class.new
+      klass.class_eval do
+        def flush
+          flush_behavior()
+        end
+      end
+
+      tagged_logger = klass.new
+      tagged_logger.extend(PaulBunyan::TaggedLogging)
+      allow(tagged_logger).to receive(:formatter).and_return(formatter)
+      allow(formatter).to receive(:clear_tags!)
+
+      expect(tagged_logger).to receive(:flush_behavior)
+      tagged_logger.flush
+    end
+  end
+end

data/spec/lib/paul_bunyan_spec.rb

@@ -4,7 +4,7 @@ initial_default_formatter_type = PaulBunyan.default_formatter_type
 
 describe PaulBunyan do
   shared_examples 'respecting the ::default_formatter_type' do
-    let(:logger) { double('logger') }
+    let(:logger) { double('logger', formatter: nil) }
 
     before do
       allow(Logger).to receive(:new).and_return(logger)
@@ -69,7 +69,7 @@ describe PaulBunyan do
 
   describe '::create_logger' do
     let(:device) { double('device') }
-    let(:logger) { double('logger') }
+    let(:logger) { double('logger', formatter: nil) }
 
     before do
       allow(logger).to receive(:formatter=)
@@ -92,6 +92,32 @@ describe PaulBunyan do
       PaulBunyan.create_logger(device, formatter_type: :text)
     end
 
+    it 'creates a logger capable of tagging when using formatter that is capable of tagging' do
+      allow(logger).to receive(:formatter).and_return(double('formatter', tagged:nil))
+      allow(Logger).to receive(:new).and_return(logger)
+      PaulBunyan.create_logger(device)
+
+      expect(logger.formatter).to respond_to(:tagged)
+      expect(logger).to be_kind_of(PaulBunyan::TaggedLogging)
+    end
+
+    it 'must create a logger capable of handling metadata when using a formatter capable of handling metadata' do
+      allow(logger).to receive(:formatter).and_return(double('formatter', with_metadata:nil))
+      allow(Logger).to receive(:new).and_return(logger)
+      PaulBunyan.create_logger(device)
+
+      expect(logger.formatter).to respond_to(:with_metadata)
+      expect(logger).to be_kind_of(PaulBunyan::MetadataLogging)
+    end
+
+    it 'creates a regular logger when using formatter that is not capable of tagging' do
+      allow(Logger).to receive(:new).and_return(logger)
+      PaulBunyan.create_logger(device)
+
+      expect(logger.formatter).to_not respond_to(:tagged)
+      expect(logger).to_not be_kind_of(PaulBunyan::TaggedLogging)
+    end
+
     def default_formatter_type_call
       PaulBunyan.create_logger(device)
     end
@@ -129,6 +155,11 @@ describe PaulBunyan do
   end
 
   describe '::remove_logger' do
+    it 'must not blow up when the logger has not been set' do
+      PaulBunyan.instance_variable_set(:@logger, nil)
+      PaulBunyan.remove_logger('nxlogger')
+    end
+
     it 'removes the logger from the log relayer' do
       expect(PaulBunyan.logger).to receive(:remove_logger).with(PaulBunyan.logger.primary_logger)
       PaulBunyan.remove_logger(PaulBunyan.logger.primary_logger)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paul_bunyan
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Duane Johnson
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-28 00:00:00.000000000 Z
+date: 2017-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: request_store
@@ -89,14 +89,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.2'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -146,21 +146,24 @@ files:
 - Guardfile
 - LICENSE.txt
 - README.md
-- README.rdoc
 - Rakefile
 - bin/logging_demo
 - build.sh
+- docker-compose.override.yml.example
 - docker-compose.yml
+- examples/host_middleware.rb
 - lib/paul_bunyan.rb
 - lib/paul_bunyan/json_formatter.rb
 - lib/paul_bunyan/level.rb
 - lib/paul_bunyan/log_relayer.rb
+- lib/paul_bunyan/metadata_logging.rb
 - lib/paul_bunyan/rails_ext.rb
 - lib/paul_bunyan/rails_ext/active_support_logger.rb
 - lib/paul_bunyan/rails_ext/instrumentation.rb
 - lib/paul_bunyan/rails_ext/rack_logger.rb
 - lib/paul_bunyan/railtie.rb
 - lib/paul_bunyan/railtie/log_subscriber.rb
+- lib/paul_bunyan/tagged_logging.rb
 - lib/paul_bunyan/text_formatter.rb
 - lib/paul_bunyan/version.rb
 - lib/tasks/paul_bunyan_tasks.rake
@@ -206,19 +209,21 @@ files:
 - spec/dummy/public/422.html
 - spec/dummy/public/500.html
 - spec/dummy/public/favicon.ico
-- spec/gemfiles/40.gemfile
-- spec/gemfiles/41.gemfile
 - spec/gemfiles/42.gemfile
+- spec/gemfiles/50.gemfile
+- spec/gemfiles/51.gemfile
 - spec/lib/paul_bunyan/json_formatter_spec.rb
 - spec/lib/paul_bunyan/level_spec.rb
 - spec/lib/paul_bunyan/log_relayer_spec.rb
+- spec/lib/paul_bunyan/metadata_logging_spec.rb
 - spec/lib/paul_bunyan/rails_ext/instrumentation_spec.rb
 - spec/lib/paul_bunyan/railtie/log_subscriber_spec.rb
 - spec/lib/paul_bunyan/railtie_spec.rb
+- spec/lib/paul_bunyan/tagged_logging_spec.rb
 - spec/lib/paul_bunyan_spec.rb
 - spec/spec_helper.rb
 - spec/support/notification_helpers.rb
-homepage: ''
+homepage: https://github.com/instructure/paul_bunyan
 licenses:
 - MIT
 metadata: {}
@@ -238,7 +243,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Logging for all the things
@@ -284,15 +289,17 @@ test_files:
 - spec/dummy/public/422.html
 - spec/dummy/public/500.html
 - spec/dummy/public/favicon.ico
-- spec/gemfiles/40.gemfile
-- spec/gemfiles/41.gemfile
 - spec/gemfiles/42.gemfile
+- spec/gemfiles/50.gemfile
+- spec/gemfiles/51.gemfile
 - spec/lib/paul_bunyan/json_formatter_spec.rb
 - spec/lib/paul_bunyan/level_spec.rb
 - spec/lib/paul_bunyan/log_relayer_spec.rb
+- spec/lib/paul_bunyan/metadata_logging_spec.rb
 - spec/lib/paul_bunyan/rails_ext/instrumentation_spec.rb
 - spec/lib/paul_bunyan/railtie/log_subscriber_spec.rb
 - spec/lib/paul_bunyan/railtie_spec.rb
+- spec/lib/paul_bunyan/tagged_logging_spec.rb
 - spec/lib/paul_bunyan_spec.rb
 - spec/spec_helper.rb
 - spec/support/notification_helpers.rb

data/README.rdoc

@@ -1,3 +0,0 @@
-= PaulBunyan
-
-This project rocks and uses MIT-LICENSE.