semantic_logger 4.1.1 → 4.2.0

data/test/metric/new_relic_test.rb

@@ -0,0 +1,36 @@
+# So that the NewRelic appender will load the mock
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require_relative '../test_helper'
+
+# Unit Test for SemanticLogger::Appender::NewRelic
+module Metric
+  class NewRelicTest < Minitest::Test
+    describe SemanticLogger::Appender::NewRelic do
+
+      before do
+        @appender = SemanticLogger::Metric::NewRelic.new
+        @message  = 'AppenderNewRelicTest log message'
+      end
+
+      it 'logs counter metric' do
+        name = amount = nil
+        NewRelic::Agent.stub(:increment_metric, -> name_, amount_ { name = name_, amount = amount_ }) do
+          @appender.info(message: @message, metric: 'User/authenticated')
+        end
+        assert_equal 'Custom/User/authenticated', name.first
+        assert_equal 1, amount
+      end
+
+      it 'logs duration metric' do
+        name = duration = nil
+        NewRelic::Agent.stub(:record_metric, -> name_, duration_ { name = name_, duration = duration_ }) do
+          @appender.measure_info(message: @message, metric: 'User/authenticate') do
+            sleep 0.001
+          end
+        end
+        assert_equal 'Custom/User/authenticate', name.first
+        assert duration
+      end
+    end
+  end
+end

data/test/metric/signalfx_test.rb

@@ -0,0 +1,78 @@
+require_relative '../test_helper'
+
+module Appender
+  class SignalfxTest < Minitest::Test
+    describe SemanticLogger::Metric::Signalfx do
+      before do
+        @metric     = '/user/login'
+        @log        = SemanticLogger::Log.new('User', :debug)
+        @log.metric = @metric
+      end
+
+      let :appender do
+        if ENV['SIGNALFX_TOKEN']
+          SemanticLogger::Metric::Signalfx.new(token: ENV['SIGNALFX_TOKEN'])
+        else
+          Net::HTTP.stub_any_instance(:start, true) do
+            @appender = SemanticLogger::Metric::Signalfx.new(token: 'TEST')
+          end
+        end
+      end
+
+      describe 'log message' do
+        let :response do
+          # Do not stub if the token is available in the environment
+          if ENV['SIGNALFX_TOKEN']
+            appender.log(@log)
+          else
+            response_mock = Struct.new(:code, :body)
+            request       = nil
+            appender.http.stub(:request, -> r { request = r; response_mock.new('200', 'ok') }) do
+              appender.log(@log)
+            end
+          end
+        end
+
+        it 'send counter metric when there is no duration' do
+          assert response
+        end
+
+        it 'send custom counter metric when there is no duration' do
+          @log.metric     = 'Filter/count'
+          @log.dimensions = {action: 'hit', user: 'jbloggs', state: 'FL'}
+          assert response
+        end
+
+        it 'send gauge metric when log includes duration' do
+          @log.duration = 1234
+          assert response
+        end
+
+        it 'whitelists dimensions' do
+          @log.named_tags               = {user_id: 47, application: 'sample', tracking_number: 7474, session_id: 'hsdhngsd'}
+          appender.formatter.dimensions = [:user_id, :application]
+          assert response
+        end
+      end
+
+      describe 'should_log?' do
+        it 'logs metric only metric' do
+          assert appender.should_log?(@log)
+        end
+
+        it 'not logs when no metric' do
+          @log.message = 'blah'
+          @log.metric = nil
+          refute appender.should_log?(@log)
+        end
+
+        it 'logs metric only metric with dimensions' do
+          @log.metric = 'Filter/count'
+          @log.dimensions = {action: 'hit', user: 'jbloggs', state: 'FL'}
+          assert appender.should_log?(@log)
+        end
+      end
+
+    end
+  end
+end

data/test/semantic_logger_test.rb

@@ -23,7 +23,7 @@ class SemanticLoggerTest < Minitest::Test
         @appender = SemanticLogger.add_appender(file_name: 'sample.log', formatter: :json)
         assert @appender.is_a?(SemanticLogger::Appender::File)
         assert SemanticLogger.appenders.include?(@appender)
-        assert @appender.formatter.is_a?(SemanticLogger::Formatters::Json)
+        assert @appender.formatter.is_a?(SemanticLogger::Formatters::Json), @appender.formatter.inspect
       end
 
       it 'adds stream appender' do
@@ -116,40 +116,25 @@ class SemanticLoggerTest < Minitest::Test
     end
 
     describe 'mock_logger' do
-      before do
-        # Use a mock logger that just keeps the last logged entry in an instance
-        # variable
-        SemanticLogger.default_level   = :trace
-        SemanticLogger.backtrace_level = nil
-        @mock_logger                   = MockLogger.new
-        @appender                      = SemanticLogger.add_appender(logger: @mock_logger)
-
-        # Use this test's class name as the application name in the log output
-        @logger                        = SemanticLogger['LoggerTest']
-        @hash                          = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
-        @hash_str                      = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
-        @thread_name                   = Thread.current.name
-      end
-
-      after do
-        SemanticLogger.remove_appender(@appender)
-      end
+      include InMemoryAppenderHelper
 
       describe '.tagged' do
         it 'add tags to log entries' do
           SemanticLogger.tagged('12345', 'DJHSFK') do
-            @logger.info('Hello world')
-            SemanticLogger.flush
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \[12345\] \[DJHSFK\] LoggerTest -- Hello world/, @mock_logger.message)
+            logger.info('Hello world')
+
+            assert log = log_message
+            assert_equal %w(12345 DJHSFK), log.tags
           end
         end
 
         it 'add embedded tags to log entries' do
           SemanticLogger.tagged('First Level', 'tags') do
             SemanticLogger.tagged('Second Level') do
-              @logger.info('Hello world')
-              SemanticLogger.flush
-              assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \[First Level\] \[tags\] \[Second Level\] LoggerTest -- Hello world/, @mock_logger.message)
+              logger.info('Hello world')
+
+              assert log = log_message
+              assert_equal ['First Level', 'tags', 'Second Level'], log.tags
             end
             assert_equal 2, SemanticLogger.tags.count, SemanticLogger.tags
             assert_equal 'First Level', SemanticLogger.tags.first
@@ -189,9 +174,10 @@ class SemanticLoggerTest < Minitest::Test
           SemanticLogger.named_tagged(level1: 1) do
             SemanticLogger.named_tagged(level2: 2, more: 'data') do
               SemanticLogger.named_tagged(level3: 3) do
-                @logger.info('Hello world')
-                SemanticLogger.flush
-                assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \{level1: 1, level2: 2, more: data, level3: 3\} LoggerTest -- Hello world/, @mock_logger.message)
+                logger.info('Hello world')
+
+                assert log = log_message
+                assert_equal({level1: 1, level2: 2, more: 'data', level3: 3}, log.named_tags)
               end
             end
           end
@@ -200,10 +186,11 @@ class SemanticLoggerTest < Minitest::Test
 
       describe '.fast_tag' do
         it 'add string tag to log entries' do
-          @logger.fast_tag('12345') do
-            @logger.info('Hello world')
-            SemanticLogger.flush
-            assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] \[12345\] LoggerTest -- Hello world/, @mock_logger.message)
+          logger.fast_tag('12345') do
+            logger.info('Hello world')
+
+            assert log = log_message
+            assert_equal %w(12345), log.tags
           end
         end
       end
@@ -215,28 +202,30 @@ class SemanticLoggerTest < Minitest::Test
 
         it 'not log at a level below the global default' do
           assert_equal :debug, SemanticLogger.default_level
-          assert_equal :debug, @logger.level
-          @logger.trace('hello world', @hash) { 'Calculations' }
-          SemanticLogger.flush
-          assert_nil @mock_logger.message
+          assert_equal :debug, logger.level
+          logger.trace('hello world')
+
+          refute log_message
         end
 
         it 'log at the instance level' do
           assert_equal :debug, SemanticLogger.default_level
-          @logger.level = :trace
-          assert_equal :trace, @logger.level
-          @logger.trace('hello world', @hash) { 'Calculations' }
-          SemanticLogger.flush
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:#{@thread_name}\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message)
+          logger.level = :trace
+          assert_equal :trace, logger.level
+          logger.trace('hello world')
+
+          assert log = log_message
+          assert_equal :trace, log.level
+          assert_equal 'hello world', log.message
         end
 
         it 'not log at a level below the instance level' do
           assert_equal :debug, SemanticLogger.default_level
-          @logger.level = :warn
-          assert_equal :warn, @logger.level
-          @logger.debug('hello world', @hash) { 'Calculations' }
-          SemanticLogger.flush
-          assert_nil @mock_logger.message
+          logger.level = :warn
+          assert_equal :warn, logger.level
+          logger.debug('hello world')
+
+          refute log_message
         end
       end
 
@@ -247,35 +236,39 @@ class SemanticLoggerTest < Minitest::Test
 
         it 'not log at a level below the silence level' do
           assert_equal :info, SemanticLogger.default_level
-          assert_equal :info, @logger.level
-          @logger.silence do
-            @logger.warn('hello world', @hash) { 'Calculations' }
-            @logger.info('hello world', @hash) { 'Calculations' }
-            @logger.debug('hello world', @hash) { 'Calculations' }
-            @logger.trace('hello world', @hash) { 'Calculations' }
+          assert_equal :info, logger.level
+          logger.silence do
+            logger.warn('hello world')
+            logger.info('hello world')
+            logger.debug('hello world')
+            logger.trace('hello world')
           end
-          SemanticLogger.flush
-          assert_nil @mock_logger.message
+
+          refute log_message
         end
 
         it 'log at the instance level even with the silencer at a higher level' do
-          @logger.level = :trace
-          assert_equal :trace, @logger.level
-          @logger.silence do
-            @logger.trace('hello world', @hash) { 'Calculations' }
+          logger.level = :trace
+          assert_equal :trace, logger.level
+          logger.silence do
+            logger.trace('hello world')
           end
-          SemanticLogger.flush
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ T \[\d+:#{@thread_name}\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message)
+
+          assert log = log_message
+          assert_equal :trace, log.level
+          assert_equal 'hello world', log.message
         end
 
         it 'log at a silence level below the default level' do
           assert_equal :info, SemanticLogger.default_level
-          assert_equal :info, @logger.level
-          @logger.silence(:debug) do
-            @logger.debug('hello world', @hash) { 'Calculations' }
+          assert_equal :info, logger.level
+          logger.silence(:debug) do
+            logger.debug('hello world')
           end
-          SemanticLogger.flush
-          assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message)
+
+          assert log = log_message
+          assert_equal :debug, log.level
+          assert_equal 'hello world', log.message
         end
       end
 

data/test/test_helper.rb

@@ -8,8 +8,25 @@ require 'minitest/autorun'
 require 'minitest/reporters'
 require 'minitest/stub_any_instance'
 require 'semantic_logger'
-require 'logger'
-require_relative 'mock_logger'
+#require 'logger'
+require_relative 'in_memory_appender'
+require_relative 'in_memory_batch_appender'
+require_relative 'in_memory_metrics_appender'
+require_relative 'in_memory_appender_helper'
 require 'awesome_print'
 
 #Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+class Minitest::Test
+  # Use AwesomePrint to display diffs
+  define_method :mu_pp, &:awesome_inspect
+
+  # Use AwesomePrint to display messages
+  def message msg = nil, ending = nil, &default
+    proc {
+      msg = msg.call.chomp(".") if Proc === msg
+      custom_message = "#{msg.ai}.\n" unless msg.nil? or msg.to_s.empty?
+      "#{custom_message}#{default.call}#{ending || "."}"
+    }
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.1.1
+  version: 4.2.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-11 00:00:00.000000000 Z
+date: 2017-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -38,6 +38,8 @@ files:
 - lib/semantic_logger.rb
 - lib/semantic_logger/ansi_colors.rb
 - lib/semantic_logger/appender.rb
+- lib/semantic_logger/appender/async.rb
+- lib/semantic_logger/appender/async_batch.rb
 - lib/semantic_logger/appender/bugsnag.rb
 - lib/semantic_logger/appender/elasticsearch.rb
 - lib/semantic_logger/appender/elasticsearch_http.rb
@@ -59,24 +61,30 @@ files:
 - lib/semantic_logger/concerns/compatibility.rb
 - lib/semantic_logger/core_ext/thread.rb
 - lib/semantic_logger/debug_as_trace_logger.rb
+- lib/semantic_logger/formatters.rb
 - lib/semantic_logger/formatters/base.rb
 - lib/semantic_logger/formatters/color.rb
 - lib/semantic_logger/formatters/default.rb
 - lib/semantic_logger/formatters/json.rb
+- lib/semantic_logger/formatters/one_line.rb
 - lib/semantic_logger/formatters/raw.rb
+- lib/semantic_logger/formatters/signalfx.rb
 - lib/semantic_logger/formatters/syslog.rb
 - lib/semantic_logger/formatters/syslog_cee.rb
 - lib/semantic_logger/jruby/garbage_collection_logger.rb
 - lib/semantic_logger/log.rb
 - lib/semantic_logger/loggable.rb
 - lib/semantic_logger/logger.rb
-- lib/semantic_logger/metrics/new_relic.rb
-- lib/semantic_logger/metrics/statsd.rb
-- lib/semantic_logger/metrics/udp.rb
+- lib/semantic_logger/metric/new_relic.rb
+- lib/semantic_logger/metric/signalfx.rb
+- lib/semantic_logger/metric/statsd.rb
 - lib/semantic_logger/processor.rb
 - lib/semantic_logger/semantic_logger.rb
 - lib/semantic_logger/subscriber.rb
+- lib/semantic_logger/utils.rb
 - lib/semantic_logger/version.rb
+- test/appender/async_batch_test.rb
+- test/appender/async_test.rb
 - test/appender/bugsnag_test.rb
 - test/appender/elasticsearch_http_test.rb
 - test/appender/elasticsearch_test.rb
@@ -99,10 +107,18 @@ files:
 - test/debug_as_trace_logger_test.rb
 - test/formatters/color_test.rb
 - test/formatters/default_test.rb
+- test/formatters/one_line_test.rb
+- test/formatters/signalfx_test.rb
+- test/formatters_test.rb
+- test/in_memory_appender.rb
+- test/in_memory_appender_helper.rb
+- test/in_memory_batch_appender.rb
+- test/in_memory_metrics_appender.rb
 - test/loggable_test.rb
 - test/logger_test.rb
 - test/measure_test.rb
-- test/mock_logger.rb
+- test/metric/new_relic_test.rb
+- test/metric/signalfx_test.rb
 - test/semantic_logger_test.rb
 - test/test_helper.rb
 homepage: https://github.com/rocketjob/semantic_logger
@@ -130,6 +146,8 @@ signing_key:
 specification_version: 4
 summary: Scalable, next generation enterprise logging for Ruby
 test_files:
+- test/appender/async_batch_test.rb
+- test/appender/async_test.rb
 - test/appender/bugsnag_test.rb
 - test/appender/elasticsearch_http_test.rb
 - test/appender/elasticsearch_test.rb
@@ -152,9 +170,17 @@ test_files:
 - test/debug_as_trace_logger_test.rb
 - test/formatters/color_test.rb
 - test/formatters/default_test.rb
+- test/formatters/one_line_test.rb
+- test/formatters/signalfx_test.rb
+- test/formatters_test.rb
+- test/in_memory_appender.rb
+- test/in_memory_appender_helper.rb
+- test/in_memory_batch_appender.rb
+- test/in_memory_metrics_appender.rb
 - test/loggable_test.rb
 - test/logger_test.rb
 - test/measure_test.rb
-- test/mock_logger.rb
+- test/metric/new_relic_test.rb
+- test/metric/signalfx_test.rb
 - test/semantic_logger_test.rb
 - test/test_helper.rb

data/lib/semantic_logger/metrics/new_relic.rb

@@ -1,30 +0,0 @@
-module SemanticLogger
-  module Metrics
-    class NewRelic < Subscriber
-      attr_accessor :prefix
-
-      # Parameters:
-      #   :prefix [String]
-      #     Prefix to add to every metric before forwarding to NewRelic
-      #     Default: 'Custom'
-      def initialize(options = {})
-        options = options.dup
-        @prefix = options.delete(:prefix) || 'Custom'
-        raise(ArgumentError, "Unknown options: #{options.inspect}") if options.size > 0
-      end
-
-      def call(log)
-        metric = log.metric
-        # Add prefix for NewRelic
-        metric = "#{prefix}/#{metric}" unless metric.start_with?(prefix)
-
-        if duration = log.duration
-          # Convert duration to seconds
-          ::NewRelic::Agent.record_metric(metric, duration / 1000.0)
-        else
-          ::NewRelic::Agent.increment_metric(metric, log.metric_amount || 1)
-        end
-      end
-    end
-  end
-end