coach 0.5.2 → 1.0.0

data/lib/coach/middleware.rb

@@ -16,7 +16,7 @@ module Coach
 
     def self.provides(*new_provided)
       if new_provided.include?(:_metadata)
-        raise 'Cannot provide :_metadata, Coach uses this internally!'
+        raise "Cannot provide :_metadata, Coach uses this internally!"
       end
 
       provided.concat(new_provided)
@@ -73,10 +73,14 @@ module Coach
     # Use ActiveSupport to instrument the execution of the subsequent chain.
     def instrument
       proc do
-        ActiveSupport::Notifications.
-          publish('coach.middleware.start', middleware_event)
-        ActiveSupport::Notifications.
-          instrument('coach.middleware.finish', middleware_event) { call }
+        publish_start
+
+        if ActiveSupport::Notifications.notifier.listening?("coach.middleware.finish")
+          instrument_deprecated { call }
+        else
+          ActiveSupport::Notifications.
+            instrument("finish_middleware.coach", middleware_event) { call }
+        end
       end
     end
 
@@ -99,8 +103,31 @@ module Coach
     def middleware_event
       {
         middleware: self.class.name,
-        request: request
+        request: request,
       }
     end
+
+    def publish_start
+      if ActiveSupport::Notifications.notifier.listening?("coach.middleware.start")
+        ActiveSupport::Deprecation.warn("The 'coach.middleware.start' event has " \
+          "been renamed to 'start_middleware.coach' and the old name will be " \
+          "removed in a future version.")
+        ActiveSupport::Notifications.
+          publish("coach.middleware.start", middleware_event)
+      end
+      ActiveSupport::Notifications.
+        publish("start_middleware.coach", middleware_event)
+    end
+
+    def instrument_deprecated(&block)
+      ActiveSupport::Deprecation.warn("The 'coach.middleware.finish' event has " \
+        "been renamed to 'finish_middleware.coach' and the old name will be " \
+        "removed in a future version.")
+      ActiveSupport::Notifications.
+        instrument("coach.middleware.finish", middleware_event) do
+        ActiveSupport::Notifications.
+          instrument("finish_middleware.coach", middleware_event, &block)
+      end
+    end
   end
 end

data/lib/coach/middleware_item.rb

@@ -24,11 +24,13 @@ module Coach
     end
 
     # Assigns the parent for this middleware, allowing config inheritance
+    # rubocop:disable Naming/AccessorMethodName
     def set_parent(parent)
       @parent = parent
 
       self
     end
+    # rubocop:enable Naming/AccessorMethodName
 
     # Generates config by either cloning our given config (if it's a hash) else if a
     # lambda value, then will compute the config by calling the lambda with this

data/lib/coach/notifications.rb

@@ -1,5 +1,5 @@
-require_relative 'request_benchmark'
-require_relative 'request_serializer'
+require_relative "request_benchmark"
+require_relative "request_serializer"
 
 module Coach
   # By default, Coach will trigger ActiveSupport::Notifications at specific times in a
@@ -8,15 +8,15 @@ module Coach
   # Notifications is used to coordinate the listening and aggregation of these middleware
   # notifications, while RequestEvent processes the published data.
   #
-  # Once a request has completed, Notifications will emit a 'coach.request' with
+  # Once a request has completed, Notifications will emit a 'requst.coach' with
   # aggregated request data.
   class Notifications
-    # Begin processing/emitting 'coach.request's
+    # Begin processing/emitting 'request.coach's
     def self.subscribe!
       instance.subscribe!
     end
 
-    # Cease to emit 'coach.request's
+    # Cease to emit 'request.coach's
     def self.unsubscribe!
       instance.unsubscribe!
     end
@@ -28,15 +28,15 @@ module Coach
     def subscribe!
       return if active?
 
-      @subscriptions << subscribe('handler.start') do |_, event|
+      @subscriptions << subscribe("start_handler") do |_, event|
         @benchmarks[event[:request].uuid] = RequestBenchmark.new(event[:middleware])
       end
 
-      @subscriptions << subscribe('middleware.finish') do |_name, start, finish, _, event|
+      @subscriptions << subscribe("finish_middleware") do |_name, start, finish, _, event|
         log_middleware_finish(event, start, finish)
       end
 
-      @subscriptions << subscribe('handler.finish') do |_name, start, finish, _, event|
+      @subscriptions << subscribe("finish_handler") do |_name, start, finish, _, event|
         log_handler_finish(event, start, finish)
       end
     end
@@ -63,7 +63,10 @@ module Coach
     end
 
     def subscribe(event, &block)
-      ActiveSupport::Notifications.subscribe("coach.#{event}", &block)
+      # New key formats don't include a period. If they do, they're the old deprecated
+      # format. No need to warn here since the warnings will show up from elsewhere.
+      key = event.include?(".") ? "coach.#{event}" : "#{event}.coach"
+      ActiveSupport::Notifications.subscribe(key, &block)
     end
 
     def log_middleware_finish(event, start, finish)
@@ -79,12 +82,17 @@ module Coach
     end
 
     # Receives a handler.finish event, with processed benchmark. Publishes to
-    # coach.request notification.
+    # request.coach notification.
     def broadcast(event, benchmark)
       serialized = RequestSerializer.new(event[:request]).serialize.
-                   merge(benchmark.stats).
-                   merge(event.slice(:response, :metadata))
-      ActiveSupport::Notifications.publish('coach.request', serialized)
+        merge(benchmark.stats).
+        merge(event.slice(:response, :metadata))
+      if ActiveSupport::Notifications.notifier.listening?("coach.request")
+        ActiveSupport::Deprecation.warn("The 'coach.request' event has been renamed " \
+          "to 'request.coach' and the old name will be removed in a future version.")
+        ActiveSupport::Notifications.publish("coach.request", serialized)
+      end
+      ActiveSupport::Notifications.publish("request.coach", serialized)
     end
   end
 end

data/lib/coach/request_benchmark.rb

@@ -1,6 +1,6 @@
 module Coach
   # This class is built to aggregate data during the course of the request. It relies on
-  # 'coach.middleware.start' and 'coach.middleware.end' events to register the
+  # 'start_middleware.coach' and 'finish_middleware.coach' events to register the
   # start/end of each middleware element, and thereby calculate running times for each.
   #
   # Coach::Notifications makes use of this class to produce benchmark data for
@@ -15,7 +15,7 @@ module Coach
       event = { name: name, start: start, finish: finish }
 
       duration_of_children = child_events_for(event).
-                             inject(0) { |total, e| total + e[:duration] }
+        inject(0) { |total, e| total + e[:duration] }
       event[:duration] = (finish - start) - duration_of_children
 
       @events.push(event)
@@ -34,7 +34,7 @@ module Coach
         duration: format_ms(@duration),
         chain: sorted_chain.map do |event|
           { name: event[:name], duration: format_ms(event[:duration]) }
-        end
+        end,
       }
     end
 

data/lib/coach/request_serializer.rb

@@ -8,7 +8,7 @@ module Coach
     # that will determine how to transform the original header value, otherwise a default
     # string is used.
     def self.sanitize_header(header, &rule)
-      header_rules[header] = rule || ->(value) { '[FILTERED]' }
+      header_rules[header] = rule || ->(_value) { "[FILTERED]" }
     end
 
     # Applies sanitizing rules. Expects `header` to be in 'http_header_name' form.
@@ -39,7 +39,7 @@ module Coach
 
         # Extra request info
         headers: filtered_headers,
-        session_id: @request.remote_ip
+        session_id: @request.remote_ip,
       }
     end
 
@@ -47,7 +47,7 @@ module Coach
 
     def request_path
       @request.fullpath
-    rescue
+    rescue StandardError
       "unknown"
     end
 

data/lib/coach/router.rb

@@ -5,10 +5,10 @@ module Coach
   class Router
     ACTION_TRAITS = {
       index:   { method: :get },
-      show:    { method: :get, url: ':id' },
+      show:    { method: :get, url: ":id" },
       create:  { method: :post },
-      update:  { method: :put, url: ':id' },
-      destroy: { method: :delete, url: ':id' }
+      update:  { method: :put, url: ":id" },
+      destroy: { method: :delete, url: ":id" },
     }.each_value(&:freeze).freeze
 
     def initialize(mapper)
@@ -45,9 +45,7 @@ module Coach
     # ...which will load the default route for `show` and `index`, while also configuring
     # a refund route.
     def action_traits(list_of_actions)
-      if list_of_actions.last.is_a?(Hash)
-        *list_of_actions, traits = list_of_actions
-      end
+      *list_of_actions, traits = list_of_actions if list_of_actions.last.is_a?(Hash)
 
       list_of_actions.reduce(traits || {}) do |memo, action|
         trait = ACTION_TRAITS.fetch(action) do
@@ -60,7 +58,7 @@ module Coach
 
     # Applies trait url to base, removing duplicate /'s
     def action_url(base, traits)
-      [base, traits[:url]].compact.join('/').gsub(%r{/+}, '/')
+      [base, traits[:url]].compact.join("/").gsub(%r{/+}, "/")
     end
 
     # Turns a snake_case string/symbol into a CamelCase

data/lib/coach/rspec.rb

@@ -1,8 +1,10 @@
-require 'rspec/expectations'
-require 'coach/middleware'
+require "rspec/expectations"
+require "coach/middleware"
 
 # Middleware stubbing ######################################
 
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/AbcSize
 def build_middleware(name)
   Class.new(Coach::Middleware) do
     # To access `name`, we need to use `define_method` instead of `def`
@@ -25,6 +27,8 @@ def build_middleware(name)
     end
   end
 end
+# rubocop:enable Metrics/AbcSize
+# rubocop:enable Metrics/MethodLength
 
 def null_middleware
   double(call: nil)
@@ -39,7 +43,7 @@ RSpec::Matchers.define :respond_with_status do |expected_status|
     @response[0] == expected_status
   end
 
-  failure_message do |actual|
+  failure_message do |_actual|
     "expected #{@middleware.class.name} to respond with #{expected_status} but got " \
     "#{@response[0]}"
   end
@@ -51,7 +55,7 @@ RSpec::Matchers.define :respond_with_body_that_matches do |body_regex|
     @response_body.match(body_regex)
   end
 
-  failure_message do |actual|
+  failure_message do |_actual|
     "expected that \"#{@response_body}\" would match #{body_regex}"
   end
 end
@@ -65,7 +69,7 @@ RSpec::Matchers.define :respond_with_envelope do |envelope, keys = []|
     expect(@envelope).to match(hash_including(*keys))
   end
 
-  failure_message do |actual|
+  failure_message do |_actual|
     "expected that \"#{@response}\" would have envelope \"#{envelope}\" that matches " \
     "hash_including(#{keys})"
   end
@@ -78,7 +82,7 @@ RSpec::Matchers.define :respond_with_header do |header, value_regex|
     @header_value.match(value_regex)
   end
 
-  failure_message do |actual|
+  failure_message do |_actual|
     "expected #{header} header in response to match #{value_regex} but found " \
     "\"#{@header_value}\""
   end

data/lib/coach/version.rb

@@ -1,3 +1,3 @@
 module Coach
-  VERSION = '0.5.2'.freeze
+  VERSION = "1.0.0".freeze
 end

data/spec/lib/coach/handler_spec.rb

@@ -5,27 +5,30 @@ require "coach/middleware"
 require "coach/errors"
 
 describe Coach::Handler do
+  subject(:handler) { described_class.new(terminal_middleware, handler: true) }
+
   let(:middleware_a) { build_middleware("A") }
   let(:middleware_b) { build_middleware("B") }
   let(:middleware_c) { build_middleware("C") }
   let(:middleware_d) { build_middleware("D") }
 
   let(:terminal_middleware) { build_middleware("Terminal") }
-  subject(:handler) { Coach::Handler.new(terminal_middleware, handler: true) }
 
   before { Coach::Notifications.unsubscribe! }
 
   describe "#call" do
-    let(:a_spy) { spy('middleware a') }
-    let(:b_spy) { spy('middleware b') }
+    let(:a_double) { double }
+    let(:b_double) { double }
 
-    before { terminal_middleware.uses(middleware_a, callback: a_spy) }
-    before { terminal_middleware.uses(middleware_b, callback: b_spy) }
+    before do
+      terminal_middleware.uses(middleware_a, callback: a_double)
+      terminal_middleware.uses(middleware_b, callback: b_double)
+    end
 
     it "invokes all middleware in the chain" do
+      expect(a_double).to receive(:call)
+      expect(b_double).to receive(:call)
       result = handler.call({})
-      expect(a_spy).to have_received(:call)
-      expect(b_spy).to have_received(:call)
       expect(result).to eq(%w[A{} B{} Terminal{:handler=>true}])
     end
   end
@@ -45,9 +48,11 @@ describe Coach::Handler do
     end
 
     context "given a route that includes nested middleware" do
-      before { middleware_b.uses(middleware_c) }
-      before { middleware_a.uses(middleware_b) }
-      before { terminal_middleware.uses(middleware_a) }
+      before do
+        middleware_b.uses(middleware_c)
+        middleware_a.uses(middleware_b)
+        terminal_middleware.uses(middleware_a)
+      end
 
       it "assembles a sequence including all middleware" do
         expect(sequence).to match_array([middleware_c, middleware_b,
@@ -56,10 +61,12 @@ describe Coach::Handler do
     end
 
     context "when a middleware has been included more than once" do
-      before { middleware_a.uses(middleware_c) }
-      before { middleware_b.uses(middleware_c) }
-      before { terminal_middleware.uses(middleware_a) }
-      before { terminal_middleware.uses(middleware_b) }
+      before do
+        middleware_a.uses(middleware_c)
+        middleware_b.uses(middleware_c)
+        terminal_middleware.uses(middleware_a)
+        terminal_middleware.uses(middleware_b)
+      end
 
       it "only appears once" do
         expect(sequence).to match_array([middleware_c, middleware_a,
@@ -79,8 +86,10 @@ describe Coach::Handler do
   end
 
   describe "#build_request_chain" do
-    before { terminal_middleware.uses(middleware_a) }
-    before { terminal_middleware.uses(middleware_b, b: true) }
+    before do
+      terminal_middleware.uses(middleware_a)
+      terminal_middleware.uses(middleware_b, b: true)
+    end
 
     let(:root_item) { Coach::MiddlewareItem.new(terminal_middleware) }
     let(:sequence) { handler.build_sequence(root_item, {}) }
@@ -98,8 +107,10 @@ describe Coach::Handler do
     end
 
     context "with inheriting config" do
-      before { middleware_b.uses(middleware_c, ->(config) { config.slice(:b) }) }
-      before { middleware_b.uses(middleware_d) }
+      before do
+        middleware_b.uses(middleware_c, ->(config) { config.slice(:b) })
+        middleware_b.uses(middleware_d)
+      end
 
       it "calls lambda with parent middlewares config" do
         expect(handler.build_request_chain(sequence, {}).call).
@@ -111,19 +122,20 @@ describe Coach::Handler do
   describe "#call" do
     before { terminal_middleware.uses(middleware_a) }
 
-    describe 'notifications' do
-      before { Coach::Notifications.subscribe! }
-
-      # Prevent RequestSerializer from erroring due to insufficient request mock
+    describe "notifications" do
       before do
+        Coach::Notifications.subscribe!
+
+        # Prevent RequestSerializer from erroring due to insufficient request mock
         allow(Coach::RequestSerializer).
           to receive(:new).
-          and_return(double(serialize: {}))
+          and_return(instance_double("Coach::RequestSerializer", serialize: {}))
       end
 
       subject(:coach_events) do
         events = []
-        subscription = ActiveSupport::Notifications.subscribe(/coach/) do |name, *args|
+        subscription = ActiveSupport::Notifications.
+          subscribe(/\.coach$/) do |name, *_args|
           events << name
         end
 
@@ -132,19 +144,17 @@ describe Coach::Handler do
         events
       end
 
-      it { is_expected.to include('coach.handler.start') }
-      it { is_expected.to include('coach.middleware.start') }
-      it { is_expected.to include('coach.request') }
-      it { is_expected.to include('coach.middleware.finish') }
-      it { is_expected.to include('coach.handler.finish') }
+      it { is_expected.to include("start_handler.coach") }
+      it { is_expected.to include("start_middleware.coach") }
+      it { is_expected.to include("request.coach") }
+      it { is_expected.to include("finish_middleware.coach") }
+      it { is_expected.to include("finish_handler.coach") }
 
       context "when an exception is raised in the chain" do
-        let(:explosive_action) { -> { raise "AH" } }
-        before { terminal_middleware.uses(middleware_a, callback: explosive_action) }
-
         subject(:coach_events) do
           events = []
-          subscription = ActiveSupport::Notifications.subscribe(/coach/) do |name, *args|
+          subscription = ActiveSupport::Notifications.
+            subscribe(/\.coach$/) do |name, *args|
             events << [name, args.last]
           end
 
@@ -157,22 +167,92 @@ describe Coach::Handler do
           events
         end
 
-        it "should capture the error event with the metadata " do
+        let(:explosive_action) { -> { raise "AH" } }
+
+        before { terminal_middleware.uses(middleware_a, callback: explosive_action) }
+
+        it "captures the error event with the metadata" do
           is_expected.
-            to include(['coach.handler.finish', hash_including(
+            to include(["finish_handler.coach", hash_including(
               response: { status: 500 },
-              metadata: { A: true }
+              metadata: { A: true },
             )])
         end
 
-        it "should bubble the error to the next handler" do
+        it "bubbles the error to the next handler" do
           expect { handler.call({}) }.to raise_error(StandardError, "AH")
         end
       end
+
+      context "deprecations" do
+        subject(:coach_events) do
+          events = []
+          subscription = ActiveSupport::Notifications.
+            subscribe(/^coach\./) do |name, *_args|
+            events << name
+          end
+
+          handler.call({})
+          ActiveSupport::Notifications.unsubscribe(subscription)
+          events
+        end
+
+        let!(:deprecations_silenced) do
+          ActiveSupport::Deprecation.silenced
+        end
+
+        before do
+          ActiveSupport::Deprecation.silenced = true
+        end
+
+        after do
+          ActiveSupport::Deprecation.silenced = deprecations_silenced
+        end
+
+        it { is_expected.to include("coach.handler.start") }
+        it { is_expected.to include("coach.middleware.start") }
+        it { is_expected.to include("coach.request") }
+        it { is_expected.to include("coach.middleware.finish") }
+        it { is_expected.to include("coach.handler.finish") }
+
+        context "when an exception is raised in the chain" do
+          subject(:coach_events) do
+            events = []
+            subscription = ActiveSupport::Notifications.
+              subscribe(/^coach\./) do |name, *args|
+              events << [name, args.last]
+            end
+
+            begin
+              handler.call({})
+            rescue
+              :continue_anyway
+            end
+            ActiveSupport::Notifications.unsubscribe(subscription)
+            events
+          end
+
+          let(:explosive_action) { -> { raise "AH" } }
+
+          before { terminal_middleware.uses(middleware_a, callback: explosive_action) }
+
+          it "captures the error event with the metadata" do
+            is_expected.
+              to include(["coach.handler.finish", hash_including(
+                response: { status: 500 },
+                metadata: { A: true },
+              )])
+          end
+
+          it "bubbles the error to the next handler" do
+            expect { handler.call({}) }.to raise_error(StandardError, "AH")
+          end
+        end
+      end
     end
   end
 
   describe "#inspect" do
-    its(:inspect) { is_expected.to eql('#<Coach::Handler[Terminal]>') }
+    its(:inspect) { is_expected.to eql("#<Coach::Handler[Terminal]>") }
   end
 end