blabbermouth 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a78223e98752990442658537e8adb72eb25c402a
-  data.tar.gz: c4075260334a80209ebaf6567547245afe32a0c7
+  metadata.gz: 010d190597b04b7a4ea7709fddd137c9d9975b81
+  data.tar.gz: 9263f8c9c390a5447092f5b4dba3735f1c2f77e1
 SHA512:
-  metadata.gz: a5f5d76743381b4a271030215d1c0cb0f5b748f001722addb4fbda92e6e21d3154ce136a677c80ceecb9a38f2465c099cc6c00dfc39761ab363023578f5afb15
-  data.tar.gz: 894723a59b490f1c86ebe83d21fddbb91c45c22d59e476418cf702413487cbfacffa5d565719f67515d286658bad0acac5175415eccc491e31c55338a51e6c79
+  metadata.gz: b08e982695a8e518ea8b7a3ed04d806743723ef9c815a944dbd968289114deddaa0a38143c882c1228caf93f882282d3f1bece563c39f1c7170a27a7c1ef38f8
+  data.tar.gz: b6573f304388f7660560abffa576febf14d6190b94119ee57063da6c27c5be4ae63c28aade92c96c08d7c64b84ad3920f82b0bea63c0f86aa9eadc6dcbf410ce

data/lib/blabbermouth.rb

@@ -3,7 +3,7 @@ require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/string'
 require 'blabbermouth/version'
 require 'blabbermouth/configuration'
-require 'blabbermouth/gawkers'
+require 'blabbermouth/bystanders'
 require 'blabbermouth/blabber'
 
 module Blabbermouth
@@ -14,12 +14,12 @@ module Blabbermouth
     @@configuration.configure &block
   end
 
-  def self.blabber(*gawkers)
-    Blabbermouth::Blabber.new *gawkers
+  def self.blabber(*bystanders)
+    Blabbermouth::Blabber.new *bystanders
   end
 
-  def self.new(*gawkers)
-    blabber *gawkers
+  def self.new(*bystanders)
+    blabber *bystanders
   end
 
   def self.error(key, e, *args)

data/lib/blabbermouth/blabber.rb

@@ -1,84 +1,84 @@
 module Blabbermouth
   class Blabber
-    attr_reader :gawkers, :options
+    attr_reader :bystanders, :options
 
     class << self
       def parse_args(*args)
         opts = args.extract_options!
-        args = Blabbermouth.configuration.gawkers if args.empty?
-        gawkers = args + [opts.slice!(:data)]
-        [gawkers, opts]
+        args = Blabbermouth.configuration.bystanders if args.empty?
+        bystanders = args + [opts.slice!(:data)]
+        [bystanders, opts]
       end
 
       def error(key, e, *args)
-        gawkers, opts = parse_args(*args)
-        new(*gawkers).error(key, e, opts)
+        bystanders, opts = parse_args(*args)
+        new(*bystanders).error(key, e, opts)
       end
 
       def info(key, msg=nil, *args)
-        gawkers, opts = parse_args(*args)
-        new(*gawkers).info(key, msg, opts)
+        bystanders, opts = parse_args(*args)
+        new(*bystanders).info(key, msg, opts)
       end
 
       def increment(key, by=1, *args)
-        gawkers, opts = parse_args(*args)
-        new(*gawkers).increment(key, by, opts)
+        bystanders, opts = parse_args(*args)
+        new(*bystanders).increment(key, by, opts)
       end
 
       def count(key, total, *args)
-        gawkers, opts = parse_args(*args)
-        new(*gawkers).count(key, total, opts)
+        bystanders, opts = parse_args(*args)
+        new(*bystanders).count(key, total, opts)
       end
 
       def time(key, duration=nil, *args, &block)
-        gawkers, opts = parse_args(*args)
-        new(*gawkers).time(key, duration, opts, &block)
+        bystanders, opts = parse_args(*args)
+        new(*bystanders).time(key, duration, opts, &block)
       end
     end
 
-    def add_gawker!(gawker)
-      @gawkers ||= []
-      unless gawker_exists?(gawker)
-        @gawkers << "Blabbermouth::Gawkers::#{gawker.to_s.camelize}".constantize.new
+    def add_bystander!(bystander)
+      @bystanders ||= []
+      unless bystander_exists?(bystander)
+        @bystanders << "Blabbermouth::Bystanders::#{bystander.to_s.camelize}".constantize.new
       end
-      @gawkers
+      @bystanders
     end
 
-    def add_gawker(gawker)
-      add_gawker! gawker
+    def add_bystander(bystander)
+      add_bystander! bystander
     rescue => e
       false
     end
 
-    def remove_gawker!(gawker)
-      return if @gawkers.nil?
-      @gawkers.slice!(gawker_index(gawker), 1)
+    def remove_bystander!(bystander)
+      return if @bystanders.nil?
+      @bystanders.slice!(bystander_index(bystander), 1)
     end
 
-    def remove_gawker(gawker)
-      remove_gawker! gawker
+    def remove_bystander(bystander)
+      remove_bystander! bystander
     rescue => e
       false
     end
 
     def error(key, e, *args)
       opts = args.extract_options!
-      gawkers.map { |gawker| gawker.error key, e, *args.concat([gawker_options(gawker, opts)]) }
+      bystanders.map { |bystander| bystander.error key, e, *args.concat([bystander_options(bystander, opts)]) }
     end
 
     def info(key, msg=nil, *args)
       opts = args.extract_options!
-      gawkers.map { |gawker| gawker.info key, msg, *args.concat([gawker_options(gawker, opts)]) }
+      bystanders.map { |bystander| bystander.info key, msg, *args.concat([bystander_options(bystander, opts)]) }
     end
 
     def increment(key, by=1, *args)
       opts = args.extract_options!
-      gawkers.map { |gawker| gawker.increment key, by, *args.concat([gawker_options(gawker, opts)]) }
+      bystanders.map { |bystander| bystander.increment key, by, *args.concat([bystander_options(bystander, opts)]) }
     end
 
     def count(key, total, *args)
       opts = args.extract_options!
-      gawkers.map { |gawker| gawker.count key, total, *args.concat([gawker_options(gawker, opts)]) }
+      bystanders.map { |bystander| bystander.count key, total, *args.concat([bystander_options(bystander, opts)]) }
     end
 
     def time(key, duration=nil, *args, &block)
@@ -91,38 +91,38 @@ module Blabbermouth
         duration = (::Time.now - start_time).to_f
       end
 
-      gawkers.map { |gawker| gawker.time key, duration, *args.concat([gawker_options(gawker, opts)]) }
+      bystanders.map { |bystander| bystander.time key, duration, *args.concat([bystander_options(bystander, opts)]) }
     end
 
     def method_missing(meth, *args, &block)
-      gawkers.map do |gawker|
-        next unless gawker.respond_to?(meth)
-        gawker.send(meth, *args, &block)
+      bystanders.map do |bystander|
+        next unless bystander.respond_to?(meth)
+        bystander.send(meth, *args, &block)
       end
     end
 
     def respond_to_missing?(meth, include_private=false)
-      gawkers.any? { |gawker| gawker.respond_to?(meth, include_private) }
+      bystanders.any? { |bystander| bystander.respond_to?(meth, include_private) }
     end
 
     protected
 
-    def initialize(*gawks)
-      @options = gawks.extract_options!
-      gawks.concat(options.keys).uniq
-      gawks.each { |gawker| add_gawker! gawker }
+    def initialize(*bystdrs)
+      @options = bystdrs.extract_options!
+      bystdrs.concat(options.keys).uniq
+      bystdrs.each { |bystander| add_bystander! bystander }
     end
 
-    def gawker_options(gawker, opts={})
-     (@options[gawker.class.name.demodulize.underscore.to_sym] || {}).merge(opts)
+    def bystander_options(bystander, opts={})
+     (@options[bystander.class.name.demodulize.underscore.to_sym] || {}).merge(opts)
     end
 
-    def gawker_index(gawker)
-      @gawkers.index { |gawk| gawk.class.name.demodulize.underscore == gawker.to_s }
+    def bystander_index(bystander)
+      @bystanders.index { |bystdr| bystdr.class.name.demodulize.underscore == bystander.to_s }
     end
 
-    def gawker_exists?(gawker)
-      !gawker_index(gawker).nil?
+    def bystander_exists?(bystander)
+      !bystander_index(bystander).nil?
     end
   end
 end

data/lib/blabbermouth/bystanders.rb

@@ -0,0 +1,7 @@
+module Blabbermouth
+  module Bystanders
+  end
+end
+
+require 'blabbermouth/bystanders/base'
+require 'blabbermouth/bystanders/stdout'

data/lib/blabbermouth/{gawkers → bystanders}/base.rb

@@ -1,5 +1,5 @@
 module Blabbermouth
-  module Gawkers
+  module Bystanders
     class Base
       def error(key, e, *args)
         raise NotImplementedError, "#{self.class.name}##{__method__} has not been implemented"

data/lib/blabbermouth/bystanders/new_relic.rb

@@ -0,0 +1,35 @@
+module Blabbermouth
+  module Bystanders
+    class NewRelic < Base
+      def error(key, e, *args)
+        super
+      end
+
+      def info(key, msg=nil, *args)
+        super
+      end
+
+      def increment(key, by=1, *args)
+        super
+      end
+
+      def count(key, total, *args)
+        super
+      end
+
+      def time(key, duration=nil, *args)
+        super
+      end
+
+      protected
+
+      def new_relic?
+        defined?(::NewRelic)
+      end
+
+      def new_relic!
+        raise "You must require and configure the newrelic_rpm gem to use it as a bystander" unless new_relic?
+      end
+    end
+  end
+end

data/lib/blabbermouth/{gawkers → bystanders}/stdout.rb

@@ -1,5 +1,5 @@
 module Blabbermouth
-  module Gawkers
+  module Bystanders
     class Stdout < Base
       def error(key, e, *args)
         data, opts, args = parse_args(*args)

data/lib/blabbermouth/configuration.rb

@@ -1,7 +1,7 @@
 module Blabbermouth
   class Configuration
     DEFAULT_CONFIGURATION_OPTIONS = {
-      gawkers: [:stdout]
+      bystanders: [:stdout]
     }
 
     attr_reader *DEFAULT_CONFIGURATION_OPTIONS.keys

data/lib/blabbermouth/version.rb

@@ -1,3 +1,3 @@
 module Blabbermouth
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/spec/blabbermouth/blabber_spec.rb

@@ -1,124 +1,124 @@
 require 'spec_helper'
 
 RSpec.describe Blabbermouth::Blabber do
-  describe '#add_gawker!' do
-    context 'when the gawker does not exist' do
-      it 'adds a gawker to the list of gawkers' do
-        subject.add_gawker!(:rails)
-        expect(subject.gawkers.count).to eql(1)
-        expect(subject.gawkers.first).to be_an_instance_of(Blabbermouth::Gawkers::Rails)
+  describe '#add_bystander!' do
+    context 'when the bystander does not exist' do
+      it 'adds a bystander to the list of bystanders' do
+        subject.add_bystander!(:rails)
+        expect(subject.bystanders.count).to eql(1)
+        expect(subject.bystanders.first).to be_an_instance_of(Blabbermouth::Bystanders::Rails)
       end
     end
   end
 
-  describe '#remove_gawker!' do
-    context 'when the gawker exists' do
-      it 'removes a gawker from the list of gawkers' do
-        subject.add_gawker!(:rails)
-        expect(subject.gawkers.count).to eql(1)
-        subject.remove_gawker!(:rails)
-        expect(subject.gawkers.count).to eql(0)
+  describe '#remove_bystander!' do
+    context 'when the bystander exists' do
+      it 'removes a bystander from the list of bystanders' do
+        subject.add_bystander!(:rails)
+        expect(subject.bystanders.count).to eql(1)
+        subject.remove_bystander!(:rails)
+        expect(subject.bystanders.count).to eql(0)
       end
     end
   end
 
   describe '#error' do
-    it 'blabs to any added gawkers' do
-      subject.add_gawker!(:test)
-      subject.add_gawker!(:rails)
+    it 'blabs to any added bystanders' do
+      subject.add_bystander!(:test)
+      subject.add_bystander!(:rails)
       subject.error('key', StandardError.new)
-      expect(Blabbermouth::Gawkers::Test.logged?(:error, 'key', StandardError.new.message)).to be_true
-      expect(Rails.logger.errors).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :error, 'key', StandardError.new))
+      expect(Blabbermouth::Bystanders::Test.logged?(:error, 'key', StandardError.new.message)).to be_true
+      expect(Rails.logger.errors).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :error, 'key', StandardError.new))
     end
   end
 
   describe '#info' do
-    it 'blabs to any added gawkers' do
-      subject.add_gawker!(:test)
-      subject.add_gawker!(:rails)
+    it 'blabs to any added bystanders' do
+      subject.add_bystander!(:test)
+      subject.add_bystander!(:rails)
       subject.info('key', 'test')
-      expect(Blabbermouth::Gawkers::Test.logged?(:info, 'key', 'test')).to be_true
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :info, 'key', 'test'))
+      expect(Blabbermouth::Bystanders::Test.logged?(:info, 'key', 'test')).to be_true
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :info, 'key', 'test'))
     end
   end
 
   describe '#increment' do
-    it 'blabs to any added gawkers' do
-      subject.add_gawker!(:test)
-      subject.add_gawker!(:rails)
+    it 'blabs to any added bystanders' do
+      subject.add_bystander!(:test)
+      subject.add_bystander!(:rails)
       subject.increment('key', 1)
-      expect(Blabbermouth::Gawkers::Test.logged?(:increment, 'key', 1)).to be_true
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :increment, 'key', 1))
+      expect(Blabbermouth::Bystanders::Test.logged?(:increment, 'key', 1)).to be_true
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :increment, 'key', 1))
     end
   end
 
   describe '#count' do
-    it 'blabs to any added gawkers' do
-      subject.add_gawker!(:test)
-      subject.add_gawker!(:rails)
+    it 'blabs to any added bystanders' do
+      subject.add_bystander!(:test)
+      subject.add_bystander!(:rails)
       subject.count('key', 1)
-      expect(Blabbermouth::Gawkers::Test.logged?(:count, 'key', 1)).to be_true
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :count, 'key', 1))
+      expect(Blabbermouth::Bystanders::Test.logged?(:count, 'key', 1)).to be_true
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :count, 'key', 1))
     end
   end
 
   describe '#time' do
-    it 'blabs to any added gawkers' do
-      subject.add_gawker!(:test)
-      subject.add_gawker!(:rails)
+    it 'blabs to any added bystanders' do
+      subject.add_bystander!(:test)
+      subject.add_bystander!(:rails)
       subject.time('key', 1)
-      expect(Blabbermouth::Gawkers::Test.logged?(:time, 'key', 1)).to be_true
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :time, 'key', 1))
+      expect(Blabbermouth::Bystanders::Test.logged?(:time, 'key', 1)).to be_true
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :time, 'key', 1))
     end
   end
 
   describe '#method_missing' do
-    context 'when added gawkers respond to the requested method' do
-      it 'passes method calls through to added gawkers' do
-        subject.add_gawker!(:test)
+    context 'when added bystanders respond to the requested method' do
+      it 'passes method calls through to added bystanders' do
+        subject.add_bystander!(:test)
         subject.test('key', 'test')
-        expect(Blabbermouth::Gawkers::Test.logged?(:test, 'key', 'test')).to be_true
+        expect(Blabbermouth::Bystanders::Test.logged?(:test, 'key', 'test')).to be_true
       end
     end
   end
 
   describe '.error' do
-    it 'blabs to any provided gawkers' do
+    it 'blabs to any provided bystanders' do
       Blabbermouth::Blabber.error('key', StandardError.new, :test, :rails)
-      expect(Blabbermouth::Gawkers::Test.logged?(:error, 'key', StandardError.new.message)).to be_true
-      expect(Rails.logger.errors).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :error, 'key', StandardError.new))
+      expect(Blabbermouth::Bystanders::Test.logged?(:error, 'key', StandardError.new.message)).to be_true
+      expect(Rails.logger.errors).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :error, 'key', StandardError.new))
     end
   end
 
   describe '.info' do
-    it 'blabs to any provided gawkers' do
+    it 'blabs to any provided bystanders' do
       Blabbermouth::Blabber.info('key', 'test', :test, :rails)
-      expect(Blabbermouth::Gawkers::Test.logged?(:info, 'key', 'test')).to be_true
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :info, 'key', 'test'))
+      expect(Blabbermouth::Bystanders::Test.logged?(:info, 'key', 'test')).to be_true
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :info, 'key', 'test'))
     end
   end
 
   describe '.increment' do
-    it 'blabs to any provided gawkers' do
+    it 'blabs to any provided bystanders' do
       Blabbermouth::Blabber.increment('key', 1, :test, :rails)
-      expect(Blabbermouth::Gawkers::Test.logged?(:increment, 'key', 1)).to be_true
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :increment, 'key', 1))
+      expect(Blabbermouth::Bystanders::Test.logged?(:increment, 'key', 1)).to be_true
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :increment, 'key', 1))
     end
   end
 
   describe '.count' do
-    it 'blabs to any provided gawkers' do
+    it 'blabs to any provided bystanders' do
       Blabbermouth::Blabber.count('key', 1, :test, :rails)
-      expect(Blabbermouth::Gawkers::Test.logged?(:count, 'key', 1)).to be_true
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :count, 'key', 1))
+      expect(Blabbermouth::Bystanders::Test.logged?(:count, 'key', 1)).to be_true
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :count, 'key', 1))
     end
   end
 
   describe '.time' do
-    it 'blabs to any provided gawkers' do
+    it 'blabs to any provided bystanders' do
       Blabbermouth::Blabber.time('key', 1, :test, :rails)
-      expect(Blabbermouth::Gawkers::Test.logged?(:time, 'key', 1)).to be_true
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :time, 'key', 1))
+      expect(Blabbermouth::Bystanders::Test.logged?(:time, 'key', 1)).to be_true
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :time, 'key', 1))
     end
   end
 end

data/spec/blabbermouth/{gawkers → bystanders}/base_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe Blabbermouth::Gawkers::Base do
+RSpec.describe Blabbermouth::Bystanders::Base do
   describe '#error' do
     it 'raises NotImplementedError' do
       expect { subject.error('key', StandardError.new) }.to raise_exception(NotImplementedError)

data/spec/blabbermouth/bystanders/new_relic_spec.rb

@@ -0,0 +1,5 @@
+require 'blabbermouth-new_relic'
+require 'spec_helper'
+
+RSpec.describe Blabbermouth::Bystanders::NewRelic do
+end

data/spec/blabbermouth/{gawkers → bystanders}/stdout_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-RSpec.describe Blabbermouth::Gawkers::Stdout do
+RSpec.describe Blabbermouth::Bystanders::Stdout do
   describe '#error' do
     it 'outputs to STDOUT' do
       expect(capture_stdout { subject.error('key', StandardError.new) }).to eql(subject.send(:log_message, :error, 'key', StandardError.new))

data/spec/blabbermouth_spec.rb

@@ -2,47 +2,47 @@ require 'spec_helper'
 
 RSpec.describe Blabbermouth do
   describe '#error' do
-    it 'blabs to any provided gawkers' do
+    it 'blabs to any provided bystanders' do
       subject.error('key', StandardError.new, :rollbar, :rails)
       error = ::Rollbar.errors.last
       expect(error[0]).to be_an_instance_of(Blabbermouth::Error)
-      expect(Rails.logger.errors).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :error, 'key', StandardError.new))
+      expect(Rails.logger.errors).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :error, 'key', StandardError.new))
     end
   end
 
   describe '#info' do
-    it 'blabs to any provided gawkers' do
+    it 'blabs to any provided bystanders' do
       subject.info('key', 'test', :rollbar, :rails)
       info = ::Rollbar.infos.last
       expect(info[0]).to be_an_instance_of(Blabbermouth::Info)
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :info, 'key', 'test'))
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :info, 'key', 'test'))
     end
   end
 
   describe '#increment' do
-    it 'blabs to any provided gawkers' do
+    it 'blabs to any provided bystanders' do
       subject.increment('key', 1, :rollbar, :rails)
       info = ::Rollbar.infos.last
       expect(info[0]).to be_an_instance_of(Blabbermouth::Increment)
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :increment, 'key', 1))
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :increment, 'key', 1))
     end
   end
 
   describe '#count' do
-    it 'blabs to any provided gawkers' do
+    it 'blabs to any provided bystanders' do
       subject.count('key', 1, :rollbar, :rails)
       info = ::Rollbar.infos.last
       expect(info[0]).to be_an_instance_of(Blabbermouth::Count)
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :count, 'key', 1))
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :count, 'key', 1))
     end
   end
 
   describe '#time' do
-    it 'blabs to any provided gawkers' do
+    it 'blabs to any provided bystanders' do
       subject.time('key', 1, :rollbar, :rails)
       info = ::Rollbar.infos.last
       expect(info[0]).to be_an_instance_of(Blabbermouth::Time)
-      expect(Rails.logger.infos).to include(Blabbermouth::Gawkers::Rails.new.send(:log_message, :time, 'key', 1))
+      expect(Rails.logger.infos).to include(Blabbermouth::Bystanders::Rails.new.send(:log_message, :time, 'key', 1))
     end
   end
 end

data/spec/spec_helper.rb

@@ -4,7 +4,7 @@ require 'rspec'
 Dir[File.join(File.dirname(__FILE__), '..', "spec/support/**/*.rb")].each { |f| require f }
 
 Blabbermouth.configure do |config|
-  config.gawkers = []
+  config.bystanders = []
 end
 
 RSpec.configure do |config|

data/spec/support/{gawker.rb → bystander.rb}

@@ -1,5 +1,5 @@
 module Blabbermouth
-  module Gawkers
+  module Bystanders
     class Test < Base
       EVENTS = []
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blabbermouth
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Mark Rebec
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-05 00:00:00.000000000 Z
+date: 2015-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -53,8 +53,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Flexible instrumentation/reporting library for pushing info, errors,
-  counts, timing, etc. to various datastores like Librato, Rollbar, Rails logs or
-  custom ActiveRecord models
+  counts, timing, etc. to listening bystanders like Librato, Rollbar, New Relic, Rails
+  logs or any custom reporting class.
 email:
 - mark@markrebec.com
 executables: []
@@ -63,19 +63,21 @@ extra_rdoc_files: []
 files:
 - lib/blabbermouth.rb
 - lib/blabbermouth/blabber.rb
+- lib/blabbermouth/bystanders.rb
+- lib/blabbermouth/bystanders/base.rb
+- lib/blabbermouth/bystanders/new_relic.rb
+- lib/blabbermouth/bystanders/stdout.rb
 - lib/blabbermouth/configuration.rb
 - lib/blabbermouth/exceptions.rb
-- lib/blabbermouth/gawkers.rb
-- lib/blabbermouth/gawkers/base.rb
-- lib/blabbermouth/gawkers/stdout.rb
 - lib/blabbermouth/version.rb
 - spec/blabbermouth/blabber_spec.rb
-- spec/blabbermouth/gawkers/base_spec.rb
-- spec/blabbermouth/gawkers/stdout_spec.rb
+- spec/blabbermouth/bystanders/base_spec.rb
+- spec/blabbermouth/bystanders/new_relic_spec.rb
+- spec/blabbermouth/bystanders/stdout_spec.rb
 - spec/blabbermouth_spec.rb
 - spec/spec_helper.rb
+- spec/support/bystander.rb
 - spec/support/capture_stdout.rb
-- spec/support/gawker.rb
 homepage: http://github.com/markrebec/blabbermouth
 licenses: []
 metadata: {}
@@ -98,12 +100,13 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Blabs your business to various datastores
+summary: Blabs your business to listening bystanders
 test_files:
 - spec/blabbermouth_spec.rb
 - spec/spec_helper.rb
 - spec/support/capture_stdout.rb
-- spec/support/gawker.rb
+- spec/support/bystander.rb
 - spec/blabbermouth/blabber_spec.rb
-- spec/blabbermouth/gawkers/base_spec.rb
-- spec/blabbermouth/gawkers/stdout_spec.rb
+- spec/blabbermouth/bystanders/base_spec.rb
+- spec/blabbermouth/bystanders/new_relic_spec.rb
+- spec/blabbermouth/bystanders/stdout_spec.rb

data/lib/blabbermouth/gawkers.rb

@@ -1,7 +0,0 @@
-module Blabbermouth
-  module Gawkers
-  end
-end
-
-require 'blabbermouth/gawkers/base'
-require 'blabbermouth/gawkers/stdout'