amqp_logging 0.4.0 → 0.5.0

data/Readme.rdoc

@@ -1,24 +1,19 @@
 =AMQPLogging
 
-
-A ruby logger class that logs to an {AMQP}[http://www.amqp.org/] exchange in addition to your default log device.
+A ruby logger class that logs to an {AMQP}[http://www.amqp.org/] exchange
 
 ==Basic Configuration
 By default the logs are routed to the host, exchange and key specified in DEFAULT_OPTIONS.
 You can change the configuration when creating the logger object by specifying an argument hash:
 
-	require 'amqp_logging'
-
-	logging_config = { :routing_key => "applogging",
-	                   :host => AppConfig.amqp_logging.host,
-	                   :exchange => AppConfig.amqp_logging.exchange }
+   require 'amqp_logging'
 
-	logger = AMQPLogging::Logger.new(config.log_path, logging_config)
-	config.logger = logger
-	
-With Rails 3 you will need to modify this a bit, as config.log_path no longer has the desired effect:
+   logging_config = { :routing_key => "applogging",
+                      :host => AppConfig.amqp_logging.host,
+                      :exchange => AppConfig.amqp_logging.exchange }
 
-	config.logger = AMQPLogging::Logger.new(config.paths.log.to_a.first, logging_config)
+   logger = AMQPLogging::Logger.new(logging_config)
+   config.logger = logger
 
 ==Routing Keys
 
@@ -27,18 +22,23 @@ receives the logline as the first argument and returns the routing key.
 
 Example:
 
-	# You can use a lambda or whatever responds to #call as the routing key generator
-	AMQPRoutingKeyGenerator = lambda do |logline|
-	  if logline =~ /(?:engine\[([^\]]*)\])\: (Completed in|Processing|Session ID)?/
-	    key = "logs.app.#{$1}"
-	    key << ".statistics" unless $2.nil?
-	  else
-	    key = "logs.app.system"
-	  end
-	  key
-	end
-
-	AMQPLogging::Logger.new($stdout, :routing_key => AMQPRoutingKeyGenerator)
+   # You can use a lambda or whatever responds to #call as the routing key generator
+   AMQPRoutingKeyGenerator = lambda do |logline|
+     if logline =~ /(?:engine\[([^\]]*)\])\: (Completed in|Processing|Session ID)?/
+       key = "logs.app.#{$1}"
+       key << ".statistics" unless $2.nil?
+     else
+       key = "logs.app.system"
+     end
+     key
+   end
+
+   AMQPLogging::Logger.new($stdout, :routing_key => AMQPRoutingKeyGenerator)
+
+==Fallback to disk
+
+The support for a fallback logdevice was removed with version 0.5.0. A multi logger thatallows
+you get the same behaviour will follow soonish.
 
 ==License
 

data/lib/amqp_logging.rb

@@ -1,99 +1,17 @@
 require 'bunny'
 
 begin
-  require 'active_support/time' # ActiveSupport 3.x
+  # ActiveSupport 3.x
+  require 'active_support/time'
+  require 'active_support/core_ext/hash/slice'
 rescue LoadError
   require 'active_support'      # ActiveSupport 2.x
 end
 
 module AMQPLogging
-
-  DEFAULT_OPTIONS = {
-    :shift_age    => 0,
-    :shift_size   => 1048576,
-    :host         => "localhost",
-    :exchange     => "logging_exchange",
-    :queue        => "logging_queue",
-    :routing_key  => "logs"
-  }
-
-  RETRY_AFTER = 10.seconds
-
-  class Logger < ::Logger
-    attr_accessor :extra_attributes
-    attr_accessor :errback
-
-    def initialize(logdev, *args)
-      options = args.first.is_a?(Hash) ? DEFAULT_OPTIONS.merge(args.first) : DEFAULT_OPTIONS
-      super(logdev, options[:shift_age], options[:shift_size])
-      @logdev = AMQPLogDevice.new(@logdev, options)
-      @logdev.logger = self
-    end
-  end
-
-  class AMQPLogDevice
-    attr_reader :exchange, :configuration
-    attr_accessor :logger
-
-    def initialize(dev, opts = {})
-      @configuration = opts
-      @fallback_logdev = dev
-    end
-
-    def write(msg)
-      begin
-        if !@paused || @paused <= RETRY_AFTER.ago
-          routing_key = configuration[:routing_key].respond_to?(:call) ? configuration[:routing_key].call(msg).to_s : configuration[:routing_key]
-          exchange.publish(msg, :key => routing_key)
-        end
-      rescue Exception => exception
-        reraise_expectation_errors!
-        pause_amqp_logging(exception)
-      ensure
-        @fallback_logdev.write(msg)
-      end
-    end
-
-    def close
-      @fallback_logdev.close
-    end
-
-    private
-      def pause_amqp_logging(exception)
-        @paused = Time.now
-        reset_amqp
-        logger.errback.call(exception) if logger.errback && logger.errback.respond_to?(:call)
-      end
-
-      def reset_amqp
-        begin
-          bunny.stop if bunny.connected?
-        rescue
-          # if bunny throws an exception here, its not usable anymore anyway
-        ensure
-          @exchange = @bunny = nil
-        end
-      end
-
-      def exchange
-        bunny.start unless bunny.connected?
-        @exchange ||= bunny.exchange(configuration[:exchange], :type => :topic)
-      end
-
-      def bunny
-        @bunny ||= Bunny.new(:host => configuration[:host])
-        @bunny
-      end
-
-      if defined?(Mocha)
-        def reraise_expectation_errors! #:nodoc:
-          raise if $!.is_a?(Mocha::ExpectationError)
-        end
-      else
-        def reraise_expectation_errors! #:nodoc:
-          # noop
-        end
-      end
-  end
+  autoload :MetricsAgent, 'amqp_logging/metrics_agent'
 end
 
+require 'logger'
+require 'amqp_logging/logger'
+require 'amqp_logging/log_device'

data/lib/amqp_logging/log_device.rb

@@ -0,0 +1,65 @@
+class AMQPLogging::LogDevice
+  RETRY_AFTER = 10.seconds
+
+  attr_reader   :exchange, :configuration
+  attr_accessor :logger
+
+  def initialize(opts = {})
+    @configuration = opts
+  end
+
+  def write(msg)
+    begin
+      if !@paused || @paused <= RETRY_AFTER.ago
+        routing_key = configuration[:routing_key].respond_to?(:call) ? configuration[:routing_key].call(msg).to_s : configuration[:routing_key]
+        exchange.publish(msg, :key => routing_key)
+      end
+    rescue Exception => exception
+      reraise_expectation_errors!
+      pause_amqp_logging(exception)
+    end
+  end
+
+  def close
+    reset_amqp # TODO: Test!
+  end
+
+  private
+    def pause_amqp_logging(exception)
+      @paused = Time.now
+      reset_amqp
+      logger.errback.call(exception) if logger.errback && logger.errback.respond_to?(:call)
+    end
+
+    def reset_amqp
+      begin
+        bunny.stop if bunny.connected?
+      rescue
+        # if bunny throws an exception here, its not usable anymore anyway
+      ensure
+        @exchange = @bunny = nil
+      end
+    end
+
+    def exchange
+      bunny.start unless bunny.connected?
+      @exchange ||= bunny.exchange(configuration[:exchange], :durable => configuration[:exchange_durable],
+                                                             :auto_delete => configuration[:exchange_auto_delete],
+                                                             :type => configuration[:exchange_type])
+    end
+
+    def bunny
+      @bunny ||= Bunny.new(configuration.slice(:host, :port, :user, :pass))
+      @bunny
+    end
+
+    if defined?(Mocha)
+      def reraise_expectation_errors! #:nodoc:
+        raise if $!.is_a?(Mocha::ExpectationError)
+      end
+    else
+      def reraise_expectation_errors! #:nodoc:
+        # noop
+      end
+    end
+end

data/lib/amqp_logging/logger.rb

@@ -0,0 +1,23 @@
+class AMQPLogging::Logger < ::Logger
+  DEFAULT_OPTIONS = {
+    :shift_age    => 0,
+    :shift_size   => 1048576,
+    :host         => "localhost",
+    :exchange     => "logging_exchange",
+    :queue        => "logging_queue",
+    :routing_key  => "logs",
+    :exchange_durable     => true,
+    :exchange_auto_delete => false,
+    :exchange_type        => :topic,
+  }
+
+  attr_accessor :extra_attributes
+  attr_accessor :errback
+
+  def initialize(options=DEFAULT_OPTIONS)
+    options = DEFAULT_OPTIONS.merge(options)
+    super(nil)
+    @logdev = AMQPLogging::LogDevice.new(options)
+    @logdev.logger = self
+  end
+end

data/lib/amqp_logging/metrics_agent.rb

@@ -0,0 +1,91 @@
+require 'json'
+
+
+module AMQPLogging
+  class MetricsAgent
+    attr_reader :fields
+
+    def initialize
+      @default_fields = {
+        :host => Socket.gethostname.split('.').first,
+        :pid => Process.pid,
+        :loglines => {
+          :default => []
+        }
+      }
+      @logger_types = {}
+      reset_fields
+    end
+
+    def logger
+      @logger || (self.logger = ::Logger.new($stdout))
+    end
+
+    def logger=(logger)
+      @logger = logger
+      @logger.formatter = Proc.new {|_, _, msg, progname| msg || progname}
+      @logger
+    end
+
+    def flush
+      logger.info(@fields.to_json + "\n")
+      reset_fields
+    end
+
+    def [](fieldname)
+      @fields[fieldname]
+    end
+
+    def []=(fieldname, value)
+      @fields[fieldname] = value
+    end
+
+    def add_logline(severity, message, progname, logger)
+      t = Time.now
+      msg = (message || progname).strip
+      @fields[:loglines][@logger_types[logger]] << [severity, t.strftime("%Y-%d-%mT%H:%M:%S.#{t.usec}"), msg]
+    end
+
+    def wrap_logger(logger, type = :default)
+      agent = self
+      register_logger(logger, type)
+      logger.instance_eval do
+        @agent = agent
+        class << self
+          include MetricsAgentSupport
+        end
+      end
+      logger
+    end
+
+    private
+    def register_logger(logger, type)
+      @logger_types[logger] = type
+      @fields[:loglines][type] = []
+    end
+
+    def reset_fields
+      @fields = {
+      }.merge!(@default_fields)
+      @logger_types.values.each {|logtype| @fields[:loglines][logtype] = []}
+    end
+    
+    module MetricsAgentSupport
+      def self.included(base)
+        base.class_eval do
+          alias :add_without_proxy :add
+          alias :add :add_with_proxy
+        end
+      end
+
+      def agent
+        @agent
+      end
+
+      def add_with_proxy(severity, message = nil, progname = nil)
+        @agent.add_logline(severity, message, progname, self) unless severity < @level
+        add_without_proxy(severity, message, progname)
+      end
+    end
+  end
+end

data/lib/amqp_logging/metrics_agent/rails.rb

@@ -0,0 +1,16 @@
+require 'amqp_logging'
+require 'amqp_logging/metrics_agent/rails/after_dispatch_callback_handler'
+
+ActionController::Dispatcher.after_dispatch do |dispatcher|
+  AMQPLogging::Rails::AfterDispatchCallbackHandler.run(dispatcher)
+end
+
+class ActionController::Base
+  def log_processing_for_request_id_with_metrics_agent
+    logger.agent[:page] = "#{self.class.name}\##{action_name}"
+    t = Time.now
+    logger.agent[:started_at] = t.strftime("%Y-%d-%mT%H:%M:%S.#{t.usec}")
+    log_processing_for_request_id_without_metrics_agent
+  end
+  alias_method_chain :log_processing_for_request_id, :metrics_agent
+end

data/lib/amqp_logging/metrics_agent/rails/after_dispatch_callback_handler.rb

@@ -0,0 +1,28 @@
+module AMQPLogging
+  module Rails
+    class AfterDispatchCallbackHandler
+      def self.run(dispatcher)
+        env = dispatcher.instance_variable_get(:@env)
+        response = env["action_controller.rescue.response"]
+        request = env["action_controller.rescue.request"]
+        request_headers  = request.headers.dup
+        request_headers.each do |k, v|
+          case v
+          when String, Fixnum, Numeric
+          else
+            request_headers[k] = "#<#{v.class.name}>"
+          end
+        end
+        agent = ActionController::Base.logger.agent
+        agent.fields.merge!({
+          :env => RAILS_ENV,
+          :response_code    => response.status,
+          :request_params   => request.request_parameters,
+          :request_headers  => request_headers,
+          :response_headers => response.headers
+        })
+        agent.flush
+      end
+    end
+  end
+end

data/test/{amqp_logger_test.rb → logger_test.rb}

@@ -6,34 +6,21 @@ class TheAMQPLoggerTest < Test::Unit::TestCase
     @io = StringIO.new
   end
 
-  test "should be instanciated like a normal logger" do
-    assert_nothing_raised { AMQPLogging::Logger.new(@io) }
-    assert_nothing_raised { AMQPLogging::Logger.new(@io, 2) }
-    assert_nothing_raised { AMQPLogging::Logger.new(@io, 2, 1048576) }
-  end
-
   test "should be instanciated with an amqp configuration hash" do
-    config = { :queue => "testqueue", :exchange => "testexchange", :host => "testhost", :shift_age => 4, :shift_size => 1338, :routing_key => "foobar" }
-    AMQPLogging::AMQPLogDevice.expects(:new).with(anything, config).returns(stub_everything)
-
-    logger = AMQPLogging::Logger.new(@io, config)
-  end
+    config = { :queue => "testqueue", :exchange => "testexchange", :host => "testhost", :shift_age => 4, :shift_size => 1338, :routing_key => "foobar", :exchange_durable => true, :exchange_auto_delete => false, :exchange_type => :topic }
+    AMQPLogging::LogDevice.expects(:new).with(config).returns(stub_everything)
 
-  test "should write to the default io" do
-    AMQPLogging::AMQPLogDevice.any_instance.stubs(:exchange).returns(stub_everything('test_exchange'))
-    logger = AMQPLogging::Logger.new(@io)
-    logger.debug "logging something"
-    assert_match "logging something", @io.string
+    logger = AMQPLogging::Logger.new(config)
   end
 
   test "should pause AMQP logging if exceptions during logging occure" do
     # in case you ask why not just using mocha expectations here: the rescue in the tested code also rescues the mocha exception
     # this fake exchange object increases a counter everytime publish is executed so we can check the number of executions
     class TestExchange; attr_reader :counter; def publish(*args); @counter ||= 0; @counter += 1; raise 'Foo'; end; end
-    logger = AMQPLogging::Logger.new(@io)
+    logger = AMQPLogging::Logger.new
     exchange = TestExchange.new
-    AMQPLogging::AMQPLogDevice.any_instance.stubs(:exchange).returns(exchange)
-    AMQPLogging::AMQPLogDevice.any_instance.stubs(:bunny).returns(stub_everything("bunny stub"))
+    AMQPLogging::LogDevice.any_instance.stubs(:exchange).returns(exchange)
+    AMQPLogging::LogDevice.any_instance.stubs(:bunny).returns(stub_everything("bunny stub"))
     2.times { logger.debug "This will raise" }
 
     assert_equal 1, exchange.counter
@@ -46,8 +33,8 @@ class TheAMQPLoggerTest < Test::Unit::TestCase
     errback = lambda {|exception| begin raise exception; rescue FooBarException; @called = true; end}
     raising_exchange = mock("mocked exchange")
     raising_exchange.expects(:publish).raises(FooBarException)
-    AMQPLogging::AMQPLogDevice.any_instance.stubs(:exchange).returns(raising_exchange)
-    logger = AMQPLogging::Logger.new(@io)
+    AMQPLogging::LogDevice.any_instance.stubs(:exchange).returns(raising_exchange)
+    logger = AMQPLogging::Logger.new
     logger.errback = errback
 
     assert_nothing_raised do
@@ -59,10 +46,10 @@ class TheAMQPLoggerTest < Test::Unit::TestCase
   test "should reset the bunny and exchange instance if a exception occures" do
     raising_exchange = mock("mocked exchange")
     raising_exchange.expects(:publish).raises("FFFFFFFFUUUUUUUUUU")
-    AMQPLogging::AMQPLogDevice.any_instance.stubs(:exchange).returns(raising_exchange)
-    logger = AMQPLogging::Logger.new(@io)
+    AMQPLogging::LogDevice.any_instance.stubs(:exchange).returns(raising_exchange)
+    logger = AMQPLogging::Logger.new
 
-    AMQPLogging::AMQPLogDevice.any_instance.expects(:reset_amqp)
+    AMQPLogging::LogDevice.any_instance.expects(:reset_amqp)
     logger.debug("This will raise and send a notification")
   end
 
@@ -73,9 +60,11 @@ class TheLogDeviceTest < Test::Unit::TestCase
     config = { :queue => "testqueue", :exchange => "testexchange", :host => "testhost", :shift_age => 4, :shift_size => 1338 }
     bunny_stub = stub_everything("bunny_stub")
     Bunny.expects(:new).with(:host => "testhost").returns(bunny_stub)
-    bunny_stub.expects(:exchange).with(config[:exchange], :type => :topic).returns(stub("exchange stub", :publish => true))
+    bunny_stub.expects(:exchange).with(config[:exchange], :durable     => true,
+                                                          :auto_delete => false,
+                                                          :type        => :topic).returns(stub("exchange stub", :publish => true))
 
-    logger = AMQPLogging::Logger.new(StringIO.new, config)
+    logger = AMQPLogging::Logger.new(config)
     logger.debug("foobar")
   end
 
@@ -83,16 +72,16 @@ class TheLogDeviceTest < Test::Unit::TestCase
     message = "some stuff to log"
     exchange = mock()
     exchange.expects(:publish).with(anything, :key => "a_routing_key")
-    AMQPLogging::AMQPLogDevice.any_instance.stubs(:exchange).returns(exchange)
-    AMQPLogging::Logger.new(StringIO.new, {:routing_key => "a_routing_key"}).debug(message)
+    AMQPLogging::LogDevice.any_instance.stubs(:exchange).returns(exchange)
+    AMQPLogging::Logger.new(:routing_key => "a_routing_key").debug(message)
   end
 
   test "should take a proc argument which gets the logline passed to generate the routing key" do
     key_generator = lambda {|msg| !!(msg =~ /a message/) }
     exchange = mock()
     exchange.expects(:publish).with(anything, :key => "true")
-    AMQPLogging::AMQPLogDevice.any_instance.stubs(:exchange).returns(exchange)
-    AMQPLogging::Logger.new(StringIO.new, {:routing_key => key_generator}).debug("a message")
+    AMQPLogging::LogDevice.any_instance.stubs(:exchange).returns(exchange)
+    AMQPLogging::Logger.new(:routing_key => key_generator).debug("a message")
   end
 end
 

data/test/metrics_agent_test.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+
+module AMQPLogging
+  class MetricsAgentTest < Test::Unit::TestCase
+    def setup
+      @agent = MetricsAgent.new
+      @out = StringIO.new
+      @agent.logger = ::Logger.new(@out)
+    end
+
+    test "should record the process id" do
+      assert_equal Process.pid, @agent[:pid]
+    end
+
+    test "should record the hostname" do
+      assert_equal Socket.gethostname.split('.').first, @agent[:host]
+    end
+
+    test "should have convenience methods for accessing the fields" do
+      @agent[:foo] = :bar
+      assert_equal :bar, @agent[:foo]
+      assert_equal @agent[:foo], @agent[:foo]
+    end
+
+    test "should send the collected data as json when flushed" do
+      @agent.flush
+      json = JSON.parse(@out.string)
+      assert_equal Process.pid, json["pid"]
+    end
+
+    test "should reset the collected data when flushed" do
+      @agent[:foo] = :bar
+      @agent.flush
+      assert_equal nil, @agent[:foo]
+    end
+  end
+
+  class LoggingProxyTest < Test::Unit::TestCase
+    def setup
+      @agent = MetricsAgent.new
+      @agent.logger = ::Logger.new('/dev/null')
+      @logger = ::Logger.new('/dev/null')
+      @proxy = @agent.wrap_logger(@logger)
+    end
+
+    test "should return a logger proxy that quaks like a regular logger" do
+      @logger.expects(:debug)
+      @proxy.debug "foobar"
+    end
+
+    test "should register every logline on the agent" do
+      @agent.expects(:add_logline).with(0, nil, "foobar", @logger)
+      @proxy.debug("foobar")
+    end
+
+    test "should take the loglevel of the logger into account" do
+      @logger.level = ::Logger::INFO
+      no_lines_before_logging = @agent[:loglines][:default].size
+      @logger.debug "something"
+      assert_equal no_lines_before_logging, @agent[:loglines][:default].size
+    end
+
+    test "should store the loglines" do
+      assert_equal 0, @agent[:loglines][:default].size
+      @proxy.debug("foobar")
+      assert_equal 1, @agent[:loglines][:default].size
+    end
+
+    test "should store each logline with severity, a timestamp and the message" do
+      some_logline = "asdf0asdf"
+      @proxy.debug "foo"
+      @proxy.warn  "bar"
+      @proxy.info  some_logline
+      severity, timestamp, message = @agent[:loglines][:default][2]
+      assert_equal Logger::INFO, severity
+      assert_nothing_raised { Time.parse(timestamp) }
+      assert_equal some_logline, message
+    end
+
+    test "should allow to register multiple loggers with different types" do
+      other_logger = ::Logger.new('/dev/null')
+      @agent.wrap_logger(other_logger, :sql)
+      other_logger.info("some fancy stuff here")
+      assert_equal 1, @agent[:loglines][:sql].size
+    end
+
+    test "should reset the collected loglines when flushed" do
+      @proxy.debug "foo"
+      @agent.flush
+      assert_equal [], @agent[:loglines][:default]
+    end
+
+    test "should keep loglines fields for the registered loggers after flushing" do
+      other_logger = ::Logger.new('/dev/null')
+      @agent.wrap_logger(other_logger, :sql)
+      other_logger.info "foo"
+      @agent.flush
+
+      assert_equal [], @agent[:loglines][:sql]
+    end
+
+    test "should remove leading and trailing newlines from the stored loglines" do
+      @proxy.debug "\n\nfoo\n\n"
+      assert_equal "foo", @agent[:loglines][:default][-1][2]
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,3 +1,4 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
 require 'rubygems'
 require 'test/unit'
 require 'mocha'
@@ -13,3 +14,5 @@ end
 class Test::Unit::TestCase
   extend ActiveSupport::Testing::Declarative
 end
+
+require 'amqp_logging'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: amqp_logging
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: false
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Pascal Friederich
@@ -51,9 +51,25 @@ dependencies:
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: mocha
+  name: json
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 4
+        - 0
+        version: 1.4.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -63,7 +79,21 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id003
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: redgreen
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
 description: 
 email: 
 - pascal.friederich@xing.com
@@ -74,9 +104,15 @@ extensions: []
 extra_rdoc_files: 
 - Readme.rdoc
 files: 
+- lib/amqp_logging/log_device.rb
+- lib/amqp_logging/logger.rb
+- lib/amqp_logging/metrics_agent/rails/after_dispatch_callback_handler.rb
+- lib/amqp_logging/metrics_agent/rails.rb
+- lib/amqp_logging/metrics_agent.rb
 - lib/amqp_logging.rb
 - Readme.rdoc
-- test/amqp_logger_test.rb
+- test/logger_test.rb
+- test/metrics_agent_test.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/paukul/amqp_logging
@@ -115,5 +151,6 @@ signing_key:
 specification_version: 3
 summary: A ruby logger class that logs to an AMQP exchange in addition to your default log device.
 test_files: 
-- test/amqp_logger_test.rb
+- test/logger_test.rb
+- test/metrics_agent_test.rb
 - test/test_helper.rb