semantic_logger 2.10.0 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0114b0cd9c89056b16e797dad89c995cc0fb9485
-  data.tar.gz: f2df244261d122b2967e973380cf94770b24325e
+  metadata.gz: d8ef6f216370a6763f9cd28aa1c5a098c1cc584e
+  data.tar.gz: c02264af59deef219f5970e8ec51b4af852ed48e
 SHA512:
-  metadata.gz: 2eb3829a86b55f7b0014e72a0c624970f134ebc1e9c25ad7a89298078a4d71a993728ec0817f5205fa3afcd82d96186f5dc2e649cceab1e0502bdbfde3cd7845
-  data.tar.gz: 614edca05b62f3de8b48c301c2e059868e607ebea3e4eaa25aacb6fe86e7cde3e83f24fe86b7ca21ac007ff8a96dc217aaaf8c14062e0574003b98876fffcc1c
+  metadata.gz: e5bf5e189ddccbcf52c57be758a53d8224777ec4a35c2beea4502a3c271cb15e82078ca67ab1aec4da5f5d80a1cf01ef4e8ccea20d9623c442eba0bc272a39b0
+  data.tar.gz: 4299412a428431a41126a3e6ba47ea6a3c19867c2393162dd61e02d8c6cda8ca5b084405cb1203bb7fc25044d5a47b6cf9e790ddf34fdccbd7b538d57903c1d0

data/README.md

@@ -7,19 +7,21 @@ Next generation logging system for Ruby to support highly concurrent, high throu
 
 ## Documentation
 
-For complete documentation see: http://reidmorrison.github.io/semantic_logger
+[Semantic Logger Guide](http://reidmorrison.github.io/semantic_logger)
+
+API Documentation: [![semantic_logger API Documentation](https://www.omniref.com/ruby/gems/semantic_logger.png)](https://www.omniref.com/ruby/gems/semantic_logger)
 
 ## Dependencies
 
 Semantic Logger supports the following Ruby platforms:
-- Ruby 1.9.3, 2.0, 2.1
+- Ruby 1.9.3, 2.x
 - JRuby 1.7
 
 The following gems are only required when their corresponding appenders are being used,
 and are therefore not automatically included by this gem:
 - MongoDB Appender: gem 'mongo' 1.9.2 or above
 - Syslog Appender: gem 'syslog_protocol' 0.9.2 or above
-- Syslog Appender to a remote syslogng server over TCP or UDP: gem 'resilient_socket' 0.5.0 or above
+- Syslog Appender to a remote syslogng server over TCP or UDP: gem 'net_tcp_client'
 - Splunk Appender: gem 'splunk-sdk-ruby'
 
 ## Install
@@ -58,7 +60,7 @@ This project uses [Semantic Versioning](http://semver.org/).
 
 ## License
 
-Copyright 2012, 2013, 2014 Reid Morrison
+Copyright 2012, 2013, 2014, 2015 Reid Morrison
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/lib/semantic_logger/appender/mongodb.rb

@@ -30,7 +30,7 @@ module SemanticLogger
     #    }
     #
     class MongoDB < SemanticLogger::Appender::Base
-      attr_reader :db, :collection_name
+      attr_reader :db, :collection_name, :collection
       attr_accessor :host_name, :write_concern, :application
 
       # Create a MongoDB Appender instance
@@ -52,7 +52,7 @@ module SemanticLogger
       # :write_concern [Integer]
       #   Write concern to use
       #   see: http://docs.mongodb.org/manual/reference/write-concern/
-      #   Default: 0
+      #   Default: 1
       #
       # :application [String]
       #   Name of the application to include in the document written to mongo
@@ -83,7 +83,7 @@ module SemanticLogger
         @db              = params[:db] || raise('Missing mandatory parameter :db')
         @collection_name = params[:collection_name] || 'semantic_logger'
         @host_name       = params[:host_name] || Socket.gethostname.split('.').first
-        @write_concern   = params[:write_concern] || 0
+        @write_concern   = params[:write_concern] || 1
         @application     = params[:application]
         filter           = params[:filter]
 
@@ -91,6 +91,8 @@ module SemanticLogger
         @collection_size = params[:collection_size] || 1024**3
         @collection_max  = params[:collection_max]
 
+        reopen
+
         # Create the collection and necessary indexes
         create_indexes
 
@@ -98,6 +100,12 @@ module SemanticLogger
         super(params[:level], filter, &block)
       end
 
+      # After forking an active process call #reopen to re-open
+      # open the handles to resources
+      def reopen
+        @collection = db[@collection_name]
+      end
+
       # Create the required capped collection
       # Features of capped collection:
       # * No indexes by default (not even on _id)
@@ -111,7 +119,7 @@ module SemanticLogger
         options = {:capped => true, :size => @collection_size}
         options[:max] = @collection_max if @collection_max
         db.create_collection(collection_name, options)
-        collection.ensure_index('tags')
+        db[@collection_name].ensure_index('tags')
       end
 
       # Purge all data from the capped collection by dropping the collection
@@ -123,11 +131,6 @@ module SemanticLogger
         create_indexes
       end
 
-      # Return the collection being used to write the log document to
-      def collection
-        @collection ||= db[collection_name]
-      end
-
       # Flush all pending logs to disk.
       #  Waits for all sent documents to be written to disk
       def flush
@@ -182,7 +185,7 @@ module SemanticLogger
         return false if (level_index > (log.level_index || 0)) || !include_message?(log)
 
         # Insert log entry into Mongo
-        collection.insert(formatter.call(log), :w=>@write_concern)
+        collection.insert(formatter.call(log), w: @write_concern)
         true
       end
 

data/lib/semantic_logger/appender/splunk.rb

@@ -1,8 +1,6 @@
 require 'splunk-sdk-ruby'
 
-
-# Recommended not to use the colorized formatter.
-
+# Note: Not recommended to use the colorized formatter.
 class SemanticLogger::Appender::Splunk < SemanticLogger::Appender::Base
   attr_reader :config, :index, :service, :service_index
 
@@ -12,17 +10,22 @@ class SemanticLogger::Appender::Splunk < SemanticLogger::Appender::Base
     # Parse input options for setting up splunk connection
     parse_options(options)
 
+    reopen
+
+    # Pass on the level and custom formatter if supplied
+    super(level, &block)
+  end
+
+  # After forking an active process call #reopen to re-open
+  # open the handles to resources
+  def reopen
     # Connect to splunk. Connect is a synonym for creating a Service by hand and calling login.
     @service = Splunk::connect(@config)
 
     # The index we are logging to
     @service_index = @service.indexes[@index]
-
-    # Pass on the level and custom formatter if supplied
-    super(level, &block)
   end
 
-
   # Log the message to Splunk
   def log(log)
     # Ensure minimum log level is met, and check filter
@@ -34,23 +37,23 @@ class SemanticLogger::Appender::Splunk < SemanticLogger::Appender::Base
 
   private
 
-    def parse_options(options)
-      @config = {
-       scheme:   options[:scheme] || :https,
-       host:     options[:host]   || 'localhost',
-       port:     options[:port]   || 8089,
-       username: options[:username],
-       password: options[:password]
-      }
-
-      @index = options[:index]
-
-      if @config[:username].nil?
-        raise ArgumentError, 'Must supply a username.'
-      elsif @config[:password].nil?
-        raise ArgumentError, 'Must supply a password.'
-      elsif @index.nil?
-        raise ArgumentError, 'Must supply an index.'
-      end
+  def parse_options(options)
+    @config = {
+      scheme:   options[:scheme] || :https,
+      host:     options[:host]   || 'localhost',
+      port:     options[:port]   || 8089,
+      username: options[:username],
+      password: options[:password]
+    }
+
+    @index = options[:index]
+
+    if @config[:username].nil?
+      raise ArgumentError, 'Must supply a username.'
+    elsif @config[:password].nil?
+      raise ArgumentError, 'Must supply a password.'
+    elsif @index.nil?
+      raise ArgumentError, 'Must supply an index.'
     end
+  end
 end

data/lib/semantic_logger/appender/syslog.rb

@@ -139,29 +139,28 @@ module SemanticLogger
       #   :tcp_client [Hash]
       #     Default: {}
       #     Only used with the TCP protocol.
-      #     Specify custom parameters to pass into ResilientSocket.TCPClient.new
-      #     For a list of options see the resilient_socket documentation:
-      #       https://github.com/reidmorrison/resilient_socket/blob/master/lib/resilient_socket/tcp_client.rb
+      #     Specify custom parameters to pass into Net::TCPClient.new
+      #     For a list of options see the net_tcp_client documentation:
+      #       https://www.omniref.com/ruby/gems/net_tcp_client/1.0.0/symbols/Net::TCPClient/initialize
       def initialize(params = {}, &block)
-        params     = params.dup
-        @ident     = params.delete(:ident) || 'ruby'
-        options    = params.delete(:options) || (::Syslog::LOG_PID | ::Syslog::LOG_CONS)
-        @facility  = params.delete(:facility) || ::Syslog::LOG_USER
-        filter     = params.delete(:filter)
-        level      = params.delete(:level)
-        level_map  = params.delete(:level_map)
-        @level_map = DEFAULT_LEVEL_MAP.dup
+        params              = params.dup
+        @ident              = params.delete(:ident) || 'ruby'
+        @options            = params.delete(:options) || (::Syslog::LOG_PID | ::Syslog::LOG_CONS)
+        @facility           = params.delete(:facility) || ::Syslog::LOG_USER
+        filter              = params.delete(:filter)
+        level               = params.delete(:level)
+        level_map           = params.delete(:level_map)
+        @level_map          = DEFAULT_LEVEL_MAP.dup
         @level_map.update(level_map) if level_map
-        @server    = params.delete(:server) || 'syslog://localhost'
-        uri        = URI(@server)
-        @host      = uri.host || 'localhost'
-        @protocol  = (uri.scheme || :syslog).to_sym
+        @server             = params.delete(:server) || 'syslog://localhost'
+        uri                 = URI(@server)
+        @host               = uri.host || 'localhost'
+        @protocol           = (uri.scheme || :syslog).to_sym
         raise "Unknown protocol #{@protocol}!" unless [:syslog, :tcp, :udp].include?(@protocol)
-        @host      = 'localhost' if @protocol == :syslog
-        @port      = URI(@server).port || 514
-
-        @local_hostname    = params.delete(:local_hostname) || Socket.gethostname || `hostname`.strip
-        tcp_client_options = params.delete(:tcp_client)
+        @host               = 'localhost' if @protocol == :syslog
+        @port               = URI(@server).port || 514
+        @local_hostname     = params.delete(:local_hostname) || Socket.gethostname || `hostname`.strip
+        @tcp_client_options = params.delete(:tcp_client)
 
         # Warn about any unknown configuration options.
         params.each_pair { |key,val| SemanticLogger::Logger.logger.warn "Ignoring unknown configuration option: #{key.inspect} => #{val.inspect}" }
@@ -173,30 +172,39 @@ module SemanticLogger
           rescue LoadError
             raise 'Missing gem: syslog_protocol. This gem is required when logging over TCP or UDP. To fix this error: gem install syslog_protocol'
           end
+
+          # The net_tcp_client gem is required when logging over TCP.
+          if protocol == :tcp
+            @tcp_client_options ||= {}
+            @tcp_client_options[:server] = "#{@host}:#{@port}"
+            begin
+              require 'net/tcp_client'
+            rescue LoadError
+              raise 'Missing gem: net_tcp_client. This gem is required when logging over TCP. To fix this error: gem install net_tcp_client'
+            end
+          end
         end
 
+        reopen
+
+        super(level, filter, &block)
+      end
+
+      # After forking an active process call #reopen to re-open
+      # open the handles to resources
+      def reopen
         case @protocol
         when :syslog
-          ::Syslog.open(@ident, options, @facility)
+          ::Syslog.open(@ident, @options, @facility)
         when :tcp
-          # The resilient_socket gem is required when logging over TCP.
-          begin
-            require 'resilient_socket'
-          rescue LoadError
-            raise 'Missing gem: resilient_socket. This gem is required when logging over TCP. To fix this error: gem install resilient_socket'
-          end
-          options = tcp_client_options || {}
-          options[:server] = "#{@host}:#{@port}"
-          @remote_syslog = ResilientSocket::TCPClient.new(options)
           # Use the local logger for @remote_syslog so errors with the remote logger can be recorded locally.
-          @remote_syslog.logger = SemanticLogger::Logger.logger
+          @tcp_client_options[:logger] = SemanticLogger::Logger.logger
+          @remote_syslog = Net::TCPClient.new(@tcp_client_options)
         when :udp
           @remote_syslog = UDPSocket.new
         else
-          raise "Unsupported protocol: #{protocol}"
+          raise "Unsupported protocol: #{@protocol}"
         end
-
-        super(level, filter, &block)
       end
 
       # Write the log using the specified protocol and host.
@@ -221,7 +229,7 @@ module SemanticLogger
 
       # Flush is called by the semantic_logger during shutdown.
       def flush
-        # TODO Add flush for :tcp.
+        @remote_syslog.flush if @remote_syslog && @remote_syslog.respond_to?(:flush)
       end
 
       # Custom log formatter for syslog
@@ -245,8 +253,8 @@ module SemanticLogger
         packet.hostname = @local_hostname
         packet.facility = @facility
         packet.severity =  @level_map[log.level]
-        packet.tag = @ident
-        packet.content = default_formatter.call(log)
+        packet.tag      = @ident
+        packet.content  = default_formatter.call(log)
         packet.to_s
       end
     end

data/lib/semantic_logger/base.rb

@@ -320,11 +320,12 @@ module SemanticLogger
       ensure
         end_time = Time.now
         # Extract options after block completes so that block can modify any of the options
-        log_exception = params[:log_exception] || :partial
-        min_duration  = params[:min_duration] || 0.0
-        payload       = params[:payload]
-        metric        = params[:metric]
-        duration      = if block_given?
+        log_exception      = params[:log_exception] || :partial
+        on_exception_level = params[:on_exception_level]
+        min_duration       = params[:min_duration] || 0.0
+        payload            = params[:payload]
+        metric             = params[:metric]
+        duration           = if block_given?
           1000.0 * (end_time - start)
         else
           params[:duration] || raise("Mandatory block missing when :duration option is not supplied")
@@ -335,14 +336,28 @@ module SemanticLogger
           payload = payload.nil? ? self.payload : self.payload.merge(payload)
         end
         if exception
+          logged_exception = exception
           case log_exception
           when :full
-            struct = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, exception, metric)
-            log(struct) if include_message?(struct)
+            # On exception change the log level
+            if on_exception_level
+              level = on_exception_level
+              index = SemanticLogger.level_to_index(level)
+            end
           when :partial
-            struct = Log.new(level, Thread.current.name, name, "#{message} -- Exception: #{exception.class}: #{exception.message}", payload, end_time, duration, tags, index, nil, metric)
-            log(struct) if include_message?(struct)
+            # On exception change the log level
+            if on_exception_level
+              level = on_exception_level
+              index = SemanticLogger.level_to_index(level)
+            end
+            message = "#{message} -- Exception: #{exception.class}: #{exception.message}"
+            logged_exception = nil
+          else
+            # Log the message with its duration but leave out the exception that was raised
+            logged_exception = nil
           end
+          struct = Log.new(level, Thread.current.name, name, message, payload, end_time, duration, tags, index, logged_exception, metric)
+          log(struct) if include_message?(struct)
           raise exception
         elsif duration >= min_duration
           # Only log if the block took longer than 'min_duration' to complete

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = "2.10.0"
+  VERSION = "2.11.0"
 end

data/test/appender_file_test.rb

@@ -1,16 +1,10 @@
-# Allow test to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'logger'
-require 'semantic_logger'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'test_helper'
 require 'stringio'
 
 # Unit Test for SemanticLogger::Appender::File
 #
-class AppenderFileTest < Test::Unit::TestCase
+class AppenderFileTest < Minitest::Test
   context SemanticLogger::Appender::File do
     setup do
       SemanticLogger.default_level = :trace

data/test/appender_mongodb_test.rb

@@ -1,26 +1,21 @@
-# Allow test to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'mongo'
-require 'semantic_logger'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'test_helper'
 
 # Unit Test for SemanticLogger::Appender::MongoDB
 #
-class AppenderMongoDBTest < Test::Unit::TestCase
+class AppenderMongoDBTest < Minitest::Test
   context SemanticLogger::Appender::MongoDB do
     setup do
       @db = Mongo::Connection.new['test']
       @appender = SemanticLogger::Appender::MongoDB.new(
-        :db               => @db,
-        :collection_size  => 10*1024**2, # 10MB
-        :host_name        => 'test',
-        :application      => 'test_application'
+        db:              @db,
+        collection_size: 10*1024**2, # 10MB
+        host_name:       'test',
+        application:     'test_application',
+        level:           :trace
       )
       @hash = { :tracking_number => 12345, :session_id => 'HSSKLEU@JDK767'}
-      @time = Time.now
+      Thread.current.name = 'thread'
     end
 
     teardown do
@@ -30,12 +25,12 @@ class AppenderMongoDBTest < Test::Unit::TestCase
     context "format logs into documents" do
 
       should "handle nil name, message and hash" do
-        @appender.log SemanticLogger::Base::Log.new(:debug)
+        @appender.debug
         document = @appender.collection.find_one
         assert_equal :debug, document['level']
         assert_equal nil, document['message']
-        assert_equal nil, document['thread_name']
-        assert_equal nil, document['time']
+        assert_equal 'thread', document['thread_name']
+        assert document['time'].is_a?(Time)
         assert_equal nil, document['payload']
         assert_equal $$, document['pid']
         assert_equal 'test', document['host_name']
@@ -43,34 +38,27 @@ class AppenderMongoDBTest < Test::Unit::TestCase
       end
 
       should "handle nil message and payload" do
-        log = SemanticLogger::Base::Log.new(:debug)
-        log.payload = @hash
-        @appender.log(log)
+        @appender.debug(@hash)
 
         document = @appender.collection.find_one
         assert_equal :debug, document['level']
-        assert_equal nil, document['message']
-        assert_equal nil, document['thread_name']
-        assert_equal nil, document['time']
-        assert_equal({ "tracking_number" => 12345, "session_id" => 'HSSKLEU@JDK767'}, document['payload'])
+        assert_equal @hash.inspect, document['message']
+        assert_equal 'thread', document['thread_name']
+        assert document['time'].is_a?(Time)
+        assert_nil document['payload']
         assert_equal $$, document['pid']
         assert_equal 'test', document['host_name']
         assert_equal 'test_application', document['application']
       end
 
       should "handle message and payload" do
-        log = SemanticLogger::Base::Log.new(:debug)
-        log.message = 'hello world'
-        log.payload = @hash
-        log.thread_name = 'thread'
-        log.time = @time
-        @appender.log(log)
+        @appender.debug('hello world', @hash)
 
         document = @appender.collection.find_one
         assert_equal :debug, document['level']
         assert_equal 'hello world', document['message']
         assert_equal 'thread', document['thread_name']
-        assert_equal @time.to_i, document['time'].to_i
+        assert document['time'].is_a?(Time)
         assert_equal({ "tracking_number" => 12345, "session_id" => 'HSSKLEU@JDK767'}, document['payload'])
         assert_equal $$, document['pid']
         assert_equal 'test', document['host_name']
@@ -79,16 +67,13 @@ class AppenderMongoDBTest < Test::Unit::TestCase
 
       should "handle message without payload" do
         log = SemanticLogger::Base::Log.new(:debug)
-        log.message = 'hello world'
-        log.thread_name = 'thread'
-        log.time = @time
-        @appender.log(log)
+        @appender.debug('hello world')
 
         document = @appender.collection.find_one
         assert_equal :debug, document['level']
         assert_equal 'hello world', document['message']
         assert_equal 'thread', document['thread_name']
-        assert_equal @time.to_i, document['time'].to_i
+        assert document['time'].is_a?(Time)
         assert_equal nil, document['payload']
         assert_equal $$, document['pid']
         assert_equal 'test', document['host_name']
@@ -100,12 +85,12 @@ class AppenderMongoDBTest < Test::Unit::TestCase
       # Ensure that any log level can be logged
       SemanticLogger::LEVELS.each do |level|
         should "log #{level} information" do
-          @appender.log SemanticLogger::Base::Log.new(level, 'thread', 'my_class', 'hello world -- Calculations', @hash, @time)
+          @appender.send(level, 'hello world -- Calculations', @hash)
           document = @appender.collection.find_one
           assert_equal level, document['level']
           assert_equal 'hello world -- Calculations', document['message']
           assert_equal 'thread', document['thread_name']
-          assert_equal @time.to_i, document['time'].to_i
+          assert document['time'].is_a?(Time)
           assert_equal({ "tracking_number" => 12345, "session_id" => 'HSSKLEU@JDK767'}, document['payload'])
           assert_equal $$, document['pid']
           assert_equal 'test', document['host_name']

data/test/appender_new_relic_test.rb

@@ -1,22 +1,13 @@
-# Allow test to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-# Load mocked newrelic_rpm from test directory
 $LOAD_PATH.unshift File.dirname(__FILE__)
-
-
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'mocha/setup'
-require 'semantic_logger'
+require 'test_helper'
 
 # Unit Test for SemanticLogger::Appender::NewRelic
 #
-class AppenderNewRelicTest < Test::Unit::TestCase
+class AppenderNewRelicTest < Minitest::Test
   context SemanticLogger::Appender::NewRelic do
 
     setup do
-      @appender = SemanticLogger::Appender::NewRelic.new
+      @appender = SemanticLogger::Appender::NewRelic.new(:error)
       @message  = 'AppenderNewRelicTest log message'
       @multi_line_message = <<-EOSTR
 
@@ -31,48 +22,60 @@ class AppenderNewRelicTest < Test::Unit::TestCase
 
     (SemanticLogger::LEVELS - [:error, :fatal]).each do |level|
       should "not send :#{level.to_s} notifications to New Relic" do
-        @appender.tagged('test') do
-          @appender.send(level, "AppenderNewRelicTest #{level.to_s} message")
+        message = hash = nil
+        NewRelic::Agent.stub(:notice_error, -> msg, h { message = msg; hash = h }) do
+          @appender.tagged('test') do
+            @appender.send(level, "AppenderNewRelicTest #{level.to_s} message")
+          end
         end
-        assert_nil ::NewRelic::Agent.message
-        assert_nil ::NewRelic::Agent.hash, ::NewRelic::Agent.hash
+        assert_nil message
+        assert_nil hash
       end
     end
 
     [:error, :fatal].each do |level|
       should "send :#{level.to_s} notifications to New Relic" do
-      @appender.tagged('test') do
-        @appender.send(level, @message)
-      end
-      assert_equal @message, ::NewRelic::Agent.message
-      assert_equal ['test'], ::NewRelic::Agent.hash[:custom_params][:tags], ::NewRelic::Agent.hash
-      assert_equal "SemanticLogger::Appender::NewRelic/#{@message}", ::NewRelic::Agent.hash[:metric]
-      assert_nil ::NewRelic::Agent.hash[:custom_params][:duration], ::NewRelic::Agent.hash
-      assert_not_nil ::NewRelic::Agent.hash[:custom_params][:thread_name], ::NewRelic::Agent.hash
+        message = hash = nil
+        NewRelic::Agent.stub(:notice_error, -> msg, h { message = msg; hash = h }) do
+          @appender.tagged('test') do
+            @appender.send(level, @message)
+          end
+        end
+        assert_equal @message, message
+        assert_equal ['test'], hash[:custom_params][:tags]
+        assert_equal "SemanticLogger::Appender::NewRelic/#{@message}", hash[:metric]
+        assert_nil hash[:custom_params][:duration]
+        assert hash[:custom_params][:thread_name], hash.inspect
       end
     end
 
     should 'send notification to New Relic with custom attributes' do
-      @appender.tagged('test') do
-        @appender.with_payload({:key1 => 1, :key2 => 'a'}) do
-          @appender.benchmark(:error, @message) do
-            sleep 0.001
+      message = hash = nil
+      NewRelic::Agent.stub(:notice_error, -> msg, h { message = msg; hash = h }) do
+        @appender.tagged('test') do
+          @appender.with_payload({:key1 => 1, :key2 => 'a'}) do
+            @appender.benchmark(:error, @message) do
+              sleep 0.001
+            end
           end
         end
       end
-      assert_equal @message, ::NewRelic::Agent.message
-      assert_equal ['test'], ::NewRelic::Agent.hash[:custom_params][:tags], ::NewRelic::Agent.hash
-      assert_equal "SemanticLogger::Appender::NewRelic/#{@message}", ::NewRelic::Agent.hash[:metric]
-      assert_equal({:key1 => 1, :key2 => 'a'}, ::NewRelic::Agent.hash[:custom_params][:payload], ::NewRelic::Agent.hash)
-      assert_not_nil ::NewRelic::Agent.hash[:custom_params][:duration], ::NewRelic::Agent.hash
-      assert_not_nil ::NewRelic::Agent.hash[:custom_params][:thread_name], ::NewRelic::Agent.hash
+      assert_equal @message, message
+      assert_equal ['test'], hash[:custom_params][:tags], hash
+      assert_equal "SemanticLogger::Appender::NewRelic/#{@message}", hash[:metric]
+      assert_equal({:key1 => 1, :key2 => 'a'}, hash[:custom_params][:payload], hash)
+      assert hash[:custom_params][:duration], hash
+      assert hash[:custom_params][:thread_name], hash
     end
 
     should 'use the first non-blank line for a multi-line message' do
-      @appender.tagged('test') do
-        @appender.error @multi_line_message
+      message = hash = nil
+      NewRelic::Agent.stub(:notice_error, -> msg, h { message = msg; hash = h }) do
+        @appender.tagged('test') do
+          @appender.error @multi_line_message
+        end
       end
-      assert_equal 'first non-blank line', ::NewRelic::Agent.message
+      assert_equal 'first non-blank line', message
     end
 
   end

data/test/appender_splunk_test.rb

@@ -1,16 +1,9 @@
-# Allow test to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-
-require 'rubygems'
-require 'test/unit'
-require 'mocha/setup'
-require 'shoulda'
-require 'logger'
-require 'semantic_logger'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'test_helper'
 
 # Unit Test for SemanticLogger::Appender::Splunk
 #
-class AppenderSplunkTest < Test::Unit::TestCase
+class AppenderSplunkTest < Minitest::Test
   context SemanticLogger::Appender::Splunk do
 
     context '#parse_options' do
@@ -41,14 +34,12 @@ class AppenderSplunkTest < Test::Unit::TestCase
       end
 
       context 'set default values' do
-        # Stub the splunk connect call, and index call.
-        setup do
-          Splunk.expects(:connect).returns(Splunk::Service.new({}))
-          Splunk::Service.any_instance.expects(:indexes).returns({})
-        end
-
         should 'have default values' do
-          appender = SemanticLogger::Appender::Splunk.new(username: 'username', password: 'password', index: 'index')
+          appender = Splunk.stub(:connect, Splunk::Service.new({})) do
+            Splunk::Service.stub_any_instance(:indexes, {}) do
+              SemanticLogger::Appender::Splunk.new(username: 'username', password: 'password', index: 'index')
+            end
+          end
           config   = appender.config
           # Default host
           assert_equal 'localhost', config[:host]

data/test/appender_syslog_test.rb

@@ -1,58 +1,61 @@
-# Allow test to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'mocha/setup'
-require 'semantic_logger'
-require 'socket'
-require 'resilient_socket'
-require 'syslog_protocol'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'test_helper'
+require 'net/tcp_client'
 
 # Unit Test for SemanticLogger::Appender::Syslog
 #
-class AppenderSyslogTest < Test::Unit::TestCase
+class AppenderSyslogTest < Minitest::Test
   context SemanticLogger::Appender::Syslog do
 
     should 'handle local syslog' do
-      ::Syslog.expects(:open).once
-      ::Syslog.expects(:log).once
-      syslog_appender = SemanticLogger::Appender::Syslog.new
-      syslog_appender.debug 'AppenderSyslogTest log message'
+      message = nil
+      Syslog.stub(:open, nil) do
+        Syslog.stub(:log, -> level, msg { message = msg }) do
+          syslog_appender = SemanticLogger::Appender::Syslog.new(level: :debug)
+          syslog_appender.debug 'AppenderSyslogTest log message'
+        end
+      end
+      assert_match /D (.*?) SemanticLogger::Appender::Syslog -- AppenderSyslogTest log message/, message
     end
 
     should 'handle remote syslog over TCP' do
-      ::ResilientSocket::TCPClient.any_instance.stubs('closed?').returns(false)
-      ::ResilientSocket::TCPClient.any_instance.stubs('connect')
-      ::ResilientSocket::TCPClient.any_instance.expects(:write).with{ |message| message =~ /<70>(.*?)SemanticLogger::Appender::Syslog -- AppenderSyslogTest log message\r\n/ }
-      syslog_appender = SemanticLogger::Appender::Syslog.new(:server => 'tcp://localhost:88888')
-      syslog_appender.debug 'AppenderSyslogTest log message'
+      message = nil
+      Net::TCPClient.stub_any_instance(:closed?, false) do
+        Net::TCPClient.stub_any_instance(:connect, nil) do
+          syslog_appender = SemanticLogger::Appender::Syslog.new(server: 'tcp://localhost:88888', level: :debug)
+          syslog_appender.remote_syslog.stub(:write, Proc.new { |data| message = data }) do
+            syslog_appender.debug 'AppenderSyslogTest log message'
+          end
+        end
+      end
+      assert_match /<70>(.*?)SemanticLogger::Appender::Syslog -- AppenderSyslogTest log message\r\n/, message
     end
 
     should 'handle remote syslog over UDP' do
-      ::UDPSocket.any_instance.expects(:send).with{ |*params| params[0] =~ /<70>(.*?)SemanticLogger::Appender::Syslog -- AppenderSyslogTest log message/ }
-      syslog_appender = SemanticLogger::Appender::Syslog.new(:server => 'udp://localhost:88888')
-      syslog_appender.debug 'AppenderSyslogTest log message'
+      message = nil
+      syslog_appender = SemanticLogger::Appender::Syslog.new(server: 'udp://localhost:88888', level: :debug)
+      UDPSocket.stub_any_instance(:send, -> msg, num, host, port { message = msg }) do
+        syslog_appender.debug 'AppenderSyslogTest log message'
+      end
+      assert_match /<70>(.*?)SemanticLogger::Appender::Syslog -- AppenderSyslogTest log message/, message
     end
 
     # Should be able to log each level.
     SemanticLogger::LEVELS.each do |level|
       should "log #{level} information" do
-        ::Syslog.expects(:open).once
-        ::Syslog.expects(:log).once
-        syslog_appender = SemanticLogger::Appender::Syslog.new
-        syslog_appender.send(level, 'AppenderSyslogTest #{level.to_s} message')
+        Syslog.stub(:open, nil) do
+          Syslog.stub(:log, nil) do
+            syslog_appender = SemanticLogger::Appender::Syslog.new
+            syslog_appender.send(level, 'AppenderSyslogTest #{level.to_s} message')
+          end
+        end
       end
     end
 
     should "allow logging with %" do
       message = "AppenderSyslogTest %test"
       syslog_appender = SemanticLogger::Appender::Syslog.new
-
-      assert_nothing_raised ArgumentError do
-        syslog_appender.debug(message)
-      end
+      syslog_appender.debug(message)
     end
 
   end

data/test/appender_wrapper_test.rb

@@ -1,17 +1,9 @@
-# Allow test to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 $LOAD_PATH.unshift File.dirname(__FILE__)
-
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'logger'
-require 'semantic_logger'
-require 'mock_logger'
+require 'test_helper'
 
 # Unit Test for SemanticLogger::Appender::Wrapper
 #
-class AppenderWrapperTest < Test::Unit::TestCase
+class AppenderWrapperTest < Minitest::Test
   context SemanticLogger::Appender::Wrapper do
     setup do
       @time = Time.new

data/test/loggable_test.rb

@@ -1,21 +1,14 @@
-# Allow test to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'logger'
-require 'semantic_logger'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'test_helper'
 require 'stringio'
 
 class TestAttribute
   include SemanticLogger::Loggable
 end
 
-
 # Unit Test for SemanticLogger::Appender::File
 #
-class AppenderFileTest < Test::Unit::TestCase
+class AppenderFileTest < Minitest::Test
   context SemanticLogger::Loggable do
     setup do
       @time = Time.new

data/test/logger_test.rb

@@ -1,14 +1,8 @@
-# Allow test to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'logger'
-require 'semantic_logger'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'test_helper'
 
 # Unit Test for SemanticLogger::Logger
-class LoggerTest < Test::Unit::TestCase
+class LoggerTest < Minitest::Test
   context SemanticLogger::Logger do
     # Test each filter
     [ nil, /\ALogger/, Proc.new{|l| (/\AExclude/ =~ l.message).nil? } ].each do |filter|
@@ -41,11 +35,13 @@ class LoggerTest < Test::Unit::TestCase
 
         # Ensure that any log level can be logged
         SemanticLogger::LEVELS.each do |level|
+          level_char = level.to_s.upcase[0]
+
           context level do
             should "log" do
               @logger.send(level, 'hello world', @hash) { "Calculations" }
               SemanticLogger.flush
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
+              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
             end
 
             should "exclude log messages using Proc filter" do
@@ -73,7 +69,7 @@ class LoggerTest < Test::Unit::TestCase
             @logger.tagged('12345', 'DJHSFK') do
               @logger.info('Hello world')
               SemanticLogger.flush
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \[12345\] \[DJHSFK\] LoggerTest -- Hello world/, @mock_logger.message
+              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:.+\] \[12345\] \[DJHSFK\] LoggerTest -- Hello world/, @mock_logger.message
             end
           end
 
@@ -82,7 +78,7 @@ class LoggerTest < Test::Unit::TestCase
               @logger.tagged('Second Level') do
                 @logger.info('Hello world')
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \[First Level\] \[tags\] \[Second Level\] LoggerTest -- Hello world/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:.+\] \[First Level\] \[tags\] \[Second Level\] LoggerTest -- Hello world/, @mock_logger.message
               end
               assert_equal 2, @logger.tags.count, @logger.tags
               assert_equal 'First Level', @logger.tags.first
@@ -97,7 +93,7 @@ class LoggerTest < Test::Unit::TestCase
               @logger.with_payload(:even => 2, :more => 'data') do
                 @logger.info('Hello world')
                 SemanticLogger.flush
-                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:.+\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
               end
             end
           end
@@ -119,18 +115,19 @@ class LoggerTest < Test::Unit::TestCase
           context "benchmark" do
             # Ensure that any log level can be benchmarked and logged
             SemanticLogger::LEVELS.each do |level|
+              level_char = level.to_s.upcase[0]
 
               context 'direct method' do
                 should "log #{level} info" do
                   assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world') { "result" } # Measure duration of the supplied block
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
                 end
 
                 should "log #{level} info with payload" do
-                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :payload => @hash) { "result" } # Measure duration of the supplied block
+                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', payload: @hash) { "result" } # Measure duration of the supplied block
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
                 end
 
                 should "not log #{level} info when block is faster than :min_duration" do
@@ -140,24 +137,32 @@ class LoggerTest < Test::Unit::TestCase
                 end
 
                 should "log #{level} info when block duration exceeds :min_duration" do
-                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 200, :payload => @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
+                  assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 200, payload: @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
                 end
 
                 should "log #{level} info with an exception" do
-                  assert_raise RuntimeError do
-                    @logger.send("benchmark_#{level}", 'hello world', :payload => @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
+                  assert_raises RuntimeError do
+                    @logger.send("benchmark_#{level}", 'hello world', payload: @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
+                  end
+                  SemanticLogger.flush
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+                end
+
+                should "change log #{level} info with an exception" do
+                  assert_raises RuntimeError do
+                    @logger.send("benchmark_#{level}", 'hello world', payload: @hash, on_exception_level: :fatal) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
                   end
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ F \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
                 end
 
                 should "log #{level} info with metric" do
                   metric_name = '/my/custom/metric'
                   assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :metric => metric_name) { "result" } # Measure duration of the supplied block
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
                   assert metric_name, $last_metric.metric
                 end
               end
@@ -166,13 +171,13 @@ class LoggerTest < Test::Unit::TestCase
                 should "log #{level} info" do
                   assert_equal "result", @logger.benchmark(level, 'hello world') { "result" } # Measure duration of the supplied block
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
                 end
 
                 should "log #{level} info with payload" do
-                  assert_equal "result", @logger.benchmark(level, 'hello world', :payload => @hash) { "result" } # Measure duration of the supplied block
+                  assert_equal "result", @logger.benchmark(level, 'hello world', payload: @hash) { "result" } # Measure duration of the supplied block
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
                 end
 
                 should "not log #{level} info when block is faster than :min_duration" do
@@ -182,24 +187,24 @@ class LoggerTest < Test::Unit::TestCase
                 end
 
                 should "log #{level} info when block duration exceeds :min_duration" do
-                  assert_equal "result", @logger.benchmark(level, 'hello world', :min_duration => 200, :payload => @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
+                  assert_equal "result", @logger.benchmark(level, 'hello world', :min_duration => 200, payload: @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
                 end
 
                 should "log #{level} info with an exception" do
-                  assert_raise RuntimeError do
-                    @logger.benchmark(level, 'hello world', :payload => @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
+                  assert_raises RuntimeError do
+                    @logger.benchmark(level, 'hello world', payload: @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
                   end
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
                 end
 
                 should "log #{level} info with metric" do
                   metric_name = '/my/custom/metric'
                   assert_equal "result", @logger.benchmark(level, 'hello world', :metric => metric_name) { "result" } # Measure duration of the supplied block
                   SemanticLogger.flush
-                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
+                  assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
                   assert metric_name, $last_metric.metric
                 end
               end
@@ -208,7 +213,7 @@ class LoggerTest < Test::Unit::TestCase
             should "log when the block performs a return" do
               assert_equal "Good", function_with_return(@logger)
               SemanticLogger.flush
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
             end
           end
         end
@@ -219,7 +224,7 @@ class LoggerTest < Test::Unit::TestCase
   # Make sure that benchmark still logs when a block uses return to return from
   # a function
   def function_with_return(logger)
-    logger.benchmark_info('hello world', :payload => @hash) do
+    logger.benchmark_info('hello world', payload: @hash) do
       return "Good"
     end
     "Bad"

data/test/newrelic_rpm.rb

@@ -2,20 +2,7 @@
 
 module NewRelic
   module Agent
-    @@message = nil
-    @@hash = nil
-
     def self.notice_error(message, hash)
-      @@message = message
-      @@hash = hash
-    end
-
-    def self.message
-      @@message
-    end
-
-    def self.hash
-      @@hash
     end
   end
 end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+#require 'rubygems'
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'minitest/stub_any_instance'
+require 'shoulda/context'
+require 'semantic_logger'
+require 'logger'
+require 'mock_logger'
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 2.10.0
+  version: 2.11.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-29 00:00:00.000000000 Z
+date: 2015-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sync_attr
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: thread_safe
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: '0.1'
 description: Next generation logging system for Ruby to support highly concurrent,
   high throughput, low latency systems
 email:
@@ -73,6 +73,7 @@ files:
 - test/logger_test.rb
 - test/mock_logger.rb
 - test/newrelic_rpm.rb
+- test/test_helper.rb
 homepage: https://github.com/reidmorrison/semantic_logger
 licenses:
 - Apache License V2.0
@@ -93,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Scalable, next generation logging for Ruby
@@ -108,3 +109,4 @@ test_files:
 - test/logger_test.rb
 - test/mock_logger.rb
 - test/newrelic_rpm.rb
+- test/test_helper.rb