semantic_logger 4.1.1 → 4.2.0

data/lib/semantic_logger/utils.rb

@@ -0,0 +1,47 @@
+module SemanticLogger::Utils
+
+  def self.constantize_symbol(symbol, namespace = 'SemanticLogger::Appender')
+    klass = "#{namespace}::#{camelize(symbol.to_s)}"
+    begin
+      if RUBY_VERSION.to_i >= 2
+        Object.const_get(klass)
+      else
+        klass.split('::').inject(Object) { |o, name| o.const_get(name) }
+      end
+    rescue NameError
+      raise(ArgumentError, "Could not convert symbol: #{symbol.inspect} to a class in: #{namespace}. Looking for: #{klass}")
+    end
+  end
+
+  # Borrow from Rails, when not running Rails
+  def self.camelize(term)
+    string = term.to_s
+    string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
+    string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+    string.gsub!('/'.freeze, '::'.freeze)
+    string
+  end
+
+  # Returns the visibility for an instance method
+  def self.method_visibility(mod, method_name)
+    method_name = method_name.to_sym
+    if mod.instance_methods.include?(method_name)
+      :public
+    elsif mod.private_instance_methods.include?(method_name)
+      :private
+    elsif mod.protected_instance_methods.include?(method_name)
+      :protected
+    end
+  end
+
+  SELF_PATTERN = File.join('lib', 'semantic_logger')
+
+  # Extract the backtrace leaving out the last few Semantic Logger lines.
+  def self.cleanse_backtrace(stack = caller)
+    while (first = stack.first) && first.include?(SELF_PATTERN)
+      stack.shift
+    end
+    stack
+  end
+
+end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = '4.1.1'
+  VERSION = '4.2.0'
 end

data/test/appender/async_batch_test.rb

@@ -0,0 +1,61 @@
+require_relative '../test_helper'
+
+module Appender
+  class AsyncBatchTest < Minitest::Test
+    describe SemanticLogger::Appender::Async do
+      include InMemoryAppenderHelper
+
+      let :appender do
+        InMemoryBatchAppender.new
+      end
+
+      describe 'with default batch_size' do
+        let :appender_options do
+          {appender: appender, batch: true}
+        end
+
+        it 'uses the batch proxy' do
+          assert_instance_of SemanticLogger::Appender::AsyncBatch, added_appender
+        end
+
+        it 'logs messages after a flush' do
+          logger.info('hello world1')
+          refute appender.message
+
+          logger.info('hello world2')
+          refute appender.message
+
+          logger.info('hello world3')
+          refute appender.message
+
+          # Calls flush
+          assert logs = log_message
+          assert_equal 3, logs.size, logs
+          assert_equal 'hello world1', logs[0].message
+          assert_equal 'hello world2', logs[1].message
+          assert_equal 'hello world3', logs[2].message
+        end
+      end
+
+      # :batch_size, :batch_seconds
+      describe 'with batch_size 1' do
+        let :appender_options do
+          {appender: appender, batch: true, batch_size: 1}
+        end
+
+        it 'uses the batch proxy' do
+          assert_instance_of SemanticLogger::Appender::AsyncBatch, added_appender
+        end
+
+        it 'logs message immediately' do
+          logger.info('hello world')
+
+          assert logs = log_message
+          assert_equal 1, logs.size, logs
+          assert_equal 'hello world', logs.first.message
+        end
+      end
+
+    end
+  end
+end

data/test/appender/async_test.rb

@@ -0,0 +1,45 @@
+require_relative '../test_helper'
+
+module Appender
+  class AsyncTest < Minitest::Test
+    describe SemanticLogger::Appender::Async do
+      include InMemoryAppenderHelper
+
+      describe 'with capped queue' do
+        let :appender_options do
+          {appender: appender, async: true}
+        end
+
+        it 'uses the async proxy' do
+          assert_instance_of SemanticLogger::Appender::Async, added_appender
+        end
+
+        it 'logs message immediately' do
+          logger.info('hello world')
+
+          assert log = log_message
+          assert_equal 'hello world', log.message
+        end
+
+        it 'uses an capped queue' do
+          assert_instance_of SizedQueue, added_appender.queue
+        end
+      end
+
+      describe 'with uncapped queue' do
+        let :appender_options do
+          {appender: appender, async: true, max_queue_size: -1}
+        end
+
+        it 'uses the async proxy' do
+          assert_instance_of SemanticLogger::Appender::Async, added_appender
+        end
+
+        it 'uses an uncapped queue' do
+          assert_instance_of Queue, added_appender.queue
+        end
+      end
+
+    end
+  end
+end

data/test/appender/elasticsearch_http_test.rb

@@ -47,10 +47,10 @@ module Appender
             @appender.send(level, 'Reading File', exc)
           end
           hash = JSON.parse(request.body)
-          assert 'Reading File', hash['message']
+          assert_equal 'Reading File', hash['message'], hash
           assert exception = hash['exception']
-          assert 'NameError', exception['name']
-          assert 'undefined local variable or method', exception['message']
+          assert_equal 'NameError', exception['name']
+          assert_match 'undefined local variable or method', exception['message']
           assert_equal level.to_s, hash['level']
           assert exception['stack_trace'].first.include?(__FILE__), exception
         end

data/test/appender/elasticsearch_test.rb

@@ -4,79 +4,241 @@ require_relative '../test_helper'
 module Appender
   class ElasticsearchTest < Minitest::Test
     describe SemanticLogger::Appender::Elasticsearch do
-      before do
-        skip('Concurrent::TimerTask issue is preventing the process from stopping.') if defined? JRuby
-        Elasticsearch::Transport::Client.stub_any_instance(:bulk, true) do
-          @appender = SemanticLogger::Appender::Elasticsearch.new(
-            url:        'http://localhost:9200',
-            batch_size: 1 # immediate flush
-          )
-        end
-        @message = 'AppenderElasticsearchTest log message'
-      end
+      describe 'providing a url' do
+        let :appender do
+          if ENV['ELASTICSEARCH']
+            SemanticLogger::Appender::Elasticsearch.new(url: 'http://localhost:9200')
+          else
+            Elasticsearch::Transport::Client.stub_any_instance(:bulk, true) do
+              SemanticLogger::Appender::Elasticsearch.new(url: 'http://localhost:9200')
+            end
+          end
+        end
 
-      after do
-        @appender.close if @appender
-      end
+        let :log_message do
+          'AppenderElasticsearchTest log message'
+        end
 
-      it 'logs to daily indexes' do
-        index = nil
-        @appender.stub(:enqueue, ->(ind, json) { index = ind['index']['_index'] }) do
-          @appender.info @message
+        let :log do
+          log         = SemanticLogger::Log.new('User', :info)
+          log.message = log_message
+          log
         end
-        assert_equal "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}", index
-      end
 
-      SemanticLogger::LEVELS.each do |level|
-        it "send #{level}" do
+        let :exception do
+          exc = nil
+          begin
+            Uh oh
+          rescue Exception => e
+            exc = e
+          end
+          exc
+        end
+
+        after do
+          appender.close
+        end
+
+        describe 'synchronous' do
+          it 'logs to daily indexes' do
+            bulk_index = nil
+            appender.stub(:write_to_elasticsearch, ->(messages) { bulk_index = messages.first }) do
+              appender.info log_message
+            end
+            index = bulk_index['index']['_index']
+            assert_equal "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}", index
+          end
+
+          it 'logs message' do
+            request = stub_client { appender.log(log) }
+
+            assert hash = request[:body][1]
+            assert_equal log_message, hash[:message]
+          end
+
+          it 'logs level' do
+            request = stub_client { appender.log(log) }
+
+            assert hash = request[:body][1]
+            assert_equal :info, hash[:level]
+          end
+
+          it 'logs exception' do
+            log.exception = exception
+            request       = stub_client { appender.log(log) }
+
+            assert hash = request[:body][1]
+            assert exception = hash[:exception]
+            assert_equal 'NameError', exception[:name]
+            assert_match 'undefined local variable or method', exception[:message]
+            assert exception[:stack_trace].first.include?(__FILE__), exception
+          end
+
+          it 'logs payload' do
+            h           = {key1: 1, key2: 'a'}
+            log.payload = h
+            request     = stub_client { appender.log(log) }
+
+            assert hash = request[:body][1]
+            refute hash[:stack_trace]
+            assert_equal h, hash[:payload], hash
+          end
+        end
+
+        describe 'async batch' do
+          it 'logs message' do
+            request = stub_client { appender.batch([log]) }
+
+            assert hash = request[:body][1]
+            assert_equal log_message, hash[:message]
+            assert_equal :info, hash[:level]
+          end
+
+          let :logs do
+            Array.new(3) do |i|
+              l         = log.dup
+              l.message = "hello world#{i + 1}"
+              l
+            end
+          end
+
+          it 'logs multiple messages' do
+            request = stub_client { appender.batch(logs) }
+
+            assert body = request[:body]
+            assert_equal 4, body.size, body
+            index = body[0]['index']['_index']
+            assert_equal "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}", index
+
+            assert_equal 'hello world1', body[1][:message]
+            assert_equal 'hello world2', body[2][:message]
+            assert_equal 'hello world3', body[3][:message]
+          end
+        end
+
+        def stub_client(&block)
           request = nil
-          @appender.client.stub(:bulk, -> r { request = r; {"status" => 201} }) do
-            @appender.send(level, @message)
+          appender.client.stub(:bulk, ->(r) { request = r; {'status' => 201} }, &block)
+          request
+        end
+      end
+
+      describe 'elasticsearch parameters' do
+        let :appender do
+          Elasticsearch::Transport::Client.stub_any_instance(:bulk, true) do
+            SemanticLogger::Appender::Elasticsearch.new(
+              hosts: [{host: 'localhost', port: 9200}]
+            )
           end
+        end
+
+        let :log_message do
+          'AppenderElasticsearchTest log message'
+        end
 
-          message = request[:body][1]
-          assert_equal @message, message[:message]
-          assert_equal level, message[:level]
+        let :log do
+          log         = SemanticLogger::Log.new('User', :info)
+          log.message = log_message
+          log
         end
 
-        it "sends #{level} exceptions" do
+        let :exception do
           exc = nil
           begin
             Uh oh
           rescue Exception => e
             exc = e
           end
-          request = nil
-          @appender.client.stub(:bulk, -> r { request = r; {"status" => 201} }) do
-            @appender.send(level, 'Reading File', exc)
+          exc
+        end
+
+        after do
+          appender.close
+        end
+
+        describe 'synchronous' do
+          it 'logs to daily indexes' do
+            bulk_index = nil
+            appender.stub(:write_to_elasticsearch, ->(messages) { bulk_index = messages.first }) do
+              appender.info log_message
+            end
+            index = bulk_index['index']['_index']
+            assert_equal "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}", index
+          end
+
+          it 'logs message' do
+            request = stub_client { appender.log(log) }
+
+            assert hash = request[:body][1]
+            assert_equal log_message, hash[:message]
           end
 
-          hash = request[:body][1]
+          it 'logs level' do
+            request = stub_client { appender.log(log) }
 
-          assert 'Reading File', hash[:message]
-          assert exception = hash[:exception]
-          assert 'NameError', exception[:name]
-          assert 'undefined local variable or method', exception[:message]
-          assert_equal level, hash[:level]
-          assert exception[:stack_trace].first.include?(__FILE__), exception
+            assert hash = request[:body][1]
+            assert_equal :info, hash[:level]
+          end
+
+          it 'logs exception' do
+            log.exception = exception
+            request       = stub_client { appender.log(log) }
+
+            assert hash = request[:body][1]
+            assert exception = hash[:exception]
+            assert_equal 'NameError', exception[:name]
+            assert_match 'undefined local variable or method', exception[:message]
+            assert exception[:stack_trace].first.include?(__FILE__), exception
+          end
+
+          it 'logs payload' do
+            h           = {key1: 1, key2: 'a'}
+            log.payload = h
+            request     = stub_client { appender.log(log) }
+
+            assert hash = request[:body][1]
+            refute hash[:stack_trace]
+            assert_equal h, hash[:payload], hash
+          end
         end
 
-        it "sends #{level} custom attributes" do
-          request = nil
-          @appender.client.stub(:bulk, -> r { request = r; {"status" => 201} }) do
-            @appender.send(level, @message, {key1: 1, key2: 'a'})
+        describe 'async batch' do
+          it 'logs message' do
+            request = stub_client { appender.batch([log]) }
+
+            assert hash = request[:body][1]
+            assert_equal log_message, hash[:message]
+            assert_equal :info, hash[:level]
           end
 
-          message = request[:body][1]
-          assert_equal @message, message[:message]
-          assert_equal level, message[:level]
-          refute message[:stack_trace]
-          assert payload = message[:payload], message
-          assert_equal 1, payload[:key1], message
-          assert_equal 'a', payload[:key2], message
+          let :logs do
+            Array.new(3) do |i|
+              l         = log.dup
+              l.message = "hello world#{i + 1}"
+              l
+            end
+          end
+
+          it 'logs multiple messages' do
+            request = stub_client { appender.batch(logs) }
+
+            assert body = request[:body]
+            assert_equal 4, body.size, body
+            index = body[0]['index']['_index']
+            assert_equal "semantic_logger-#{Time.now.strftime('%Y.%m.%d')}", index
+
+            assert_equal 'hello world1', body[1][:message]
+            assert_equal 'hello world2', body[2][:message]
+            assert_equal 'hello world3', body[3][:message]
+          end
         end
-      end
 
+        def stub_client(&block)
+          request = nil
+          appender.client.stub(:bulk, ->(r) { request = r; {'status' => 201} }, &block)
+          request
+        end
+      end
     end
   end
 end