semantic_logger 3.0.1 → 3.1.0

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = '3.0.1'
+  VERSION = '3.1.0'
 end

data/test/appender/bugsnag_test.rb

@@ -9,9 +9,18 @@ module Appender
         @message  = 'AppenderBugsnagTest log message'
       end
 
-      (SemanticLogger::LEVELS - [:warn, :error]).each do |level|
+      SemanticLogger::LEVELS.each do |level|
         it "sends #{level} message" do
-          exception = hash = nil
+          bugsnag_level =
+            case level
+            when :warn
+              'warning'
+            when :fatal
+              'error'
+            else
+              level.to_s
+            end
+          exception     = hash = nil
           Bugsnag.stub(:notify, -> exc, h { exception = exc; hash = h }) do
             @appender.send(level, @message)
           end
@@ -21,7 +30,7 @@ module Appender
           else
             assert_equal 'RuntimeError', exception.class.to_s
             assert_equal @message, exception.message
-            assert_equal level.to_s, hash[:severity]
+            assert_equal bugsnag_level.to_s, hash[:severity]
           end
         end
 

data/test/appender/mongodb_test.rb

@@ -23,7 +23,7 @@ module Appender
       end
 
       describe 'format logs into documents' do
-        it 'handle nil name, message and hash' do
+        it 'handle no arguments' do
           @appender.debug
           document = @appender.collection.find_one
           assert_equal :debug, document['level']
@@ -36,15 +36,16 @@ module Appender
           assert_equal 'test_application', document['application']
         end
 
-        it "handle nil message and payload" do
+        it 'handle hash message' do
           @appender.debug(@hash)
 
           document = @appender.collection.find_one
           assert_equal :debug, document['level']
-          assert_equal @hash.inspect, document['message']
+          assert_equal nil, document['message']
           assert_equal 'thread', document['thread']
           assert document['time'].is_a?(Time)
-          assert_nil document['payload']
+          assert_equal 12345, document['tracking_number']
+          assert_equal 'HSSKLEU@JDK767', document['session_id']
           assert_equal $$, document['pid']
           assert_equal 'test', document['host']
           assert_equal 'test_application', document['application']
@@ -80,7 +81,7 @@ module Appender
         end
       end
 
-      describe "for each log level" do
+      describe 'for each log level' do
         # Ensure that any log level can be logged
         SemanticLogger::LEVELS.each do |level|
           it 'log #{level} information' do

data/test/appender/new_relic_test.rb

@@ -46,7 +46,7 @@ module Appender
         NewRelic::Agent.stub(:notice_error, -> exc, h { exception = exc; hash = h }) do
           @appender.tagged('test') do
             @appender.with_payload({key1: 1, key2: 'a'}) do
-              @appender.benchmark(:error, @message) do
+              @appender.measure(:error, @message) do
                 sleep 0.001
               end
             end

data/test/appender/splunk_http_test.rb

@@ -55,6 +55,7 @@ module Appender
           end
           body = decompress_data(request.body)
           message = JSON.parse(body)
+          assert message['event'], message.ai
           assert_equal @message, message['event']['message']
           assert_equal level.to_s, message['event']['level']
           refute message['event']['stack_trace']

data/test/concerns/compatibility_test.rb

@@ -0,0 +1,106 @@
+require_relative '../test_helper'
+
+# Unit Test for SemanticLogger::Logger
+class CompatibilityTest < Minitest::Test
+  describe SemanticLogger::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[CompatibilityTest]
+      @thread_name                   = Thread.current.name
+    end
+
+    after do
+      SemanticLogger.remove_appender(@appender)
+    end
+
+    it '#add' do
+      @logger.add(Logger::INFO, 'hello world', 'progname') { 'Data' }
+      SemanticLogger.flush
+      assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] CompatibilityTest -- hello world -- Data -- \"progname\"/, @mock_logger.message
+    end
+
+    it '#log' do
+      @logger.log(Logger::FATAL, 'hello world', 'progname') { 'Data' }
+      SemanticLogger.flush
+      assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ F \[\d+:#{@thread_name}\] CompatibilityTest -- hello world -- Data -- \"progname\"/, @mock_logger.message
+    end
+
+    it '#unknown' do
+      @logger.unknown('hello world') { 'Data' }
+      SemanticLogger.flush
+      assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ E \[\d+:#{@thread_name}\] CompatibilityTest -- hello world -- Data/, @mock_logger.message
+    end
+
+    it '#unknown? as error?' do
+      SemanticLogger.default_level = :error
+      assert @logger.unknown?
+    end
+
+    it '#unknown? as error? when false' do
+      SemanticLogger.default_level = :fatal
+      refute @logger.unknown?
+    end
+
+    it '#<< as info' do
+      @logger << 'hello world'
+      SemanticLogger.flush
+      assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] CompatibilityTest -- hello world/, @mock_logger.message
+    end
+
+    it '#progname= as #name=' do
+      assert_equal 'CompatibilityTest', @logger.name
+      @logger.progname = 'NewTest'
+      assert_equal 'NewTest', @logger.name
+    end
+
+    it '#progname as #name' do
+      assert_equal 'CompatibilityTest', @logger.name
+      assert_equal 'CompatibilityTest', @logger.progname
+    end
+
+    it '#sev_threshold= as #level=' do
+      assert_equal :trace, @logger.level
+      @logger.sev_threshold = Logger::DEBUG
+      assert_equal :debug, @logger.level
+    end
+
+    it '#sev_threshold as #level' do
+      assert_equal :trace, @logger.level
+      assert_equal :trace, @logger.sev_threshold
+    end
+
+    it '#formatter NOOP' do
+      assert_equal nil, @logger.formatter
+      @logger.formatter = 'blah'
+      assert_equal 'blah', @logger.formatter
+    end
+
+    it '#datetime_format NOOP' do
+      assert_equal nil, @logger.datetime_format
+      @logger.datetime_format = 'blah'
+      assert_equal 'blah', @logger.datetime_format
+    end
+
+    it '#close NOOP' do
+      @logger.close
+      @logger.info('hello world') { 'Data' }
+      SemanticLogger.flush
+      assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] CompatibilityTest -- hello world -- Data/, @mock_logger.message
+    end
+
+    it '#reopen NOOP' do
+      @logger.reopen
+      @logger.info('hello world') { 'Data' }
+      SemanticLogger.flush
+      assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ I \[\d+:#{@thread_name}\] CompatibilityTest -- hello world -- Data/, @mock_logger.message
+    end
+
+  end
+end

data/test/debug_as_trace_logger_test.rb

@@ -11,7 +11,7 @@ class DebugAsTraceLoggerTest < Minitest::Test
           # variable
           SemanticLogger.default_level = :trace
           @mock_logger                 = MockLogger.new
-          appender                     = SemanticLogger.add_appender(@mock_logger)
+          appender                     = SemanticLogger.add_appender(logger: @mock_logger)
           appender.filter              = filter
 
           # Use this test's class name as the application name in the log output

data/test/loggable_test.rb

@@ -79,7 +79,7 @@ class AppenderFileTest < Minitest::Test
         @appender                    = SemanticLogger::Appender::File.new(@io)
         SemanticLogger.default_level = :trace
         @mock_logger                 = MockLogger.new
-        @appender                    = SemanticLogger.add_appender(@mock_logger)
+        @appender                    = SemanticLogger.add_appender(logger: @mock_logger)
         @hash                        = {session_id: 'HSSKLEU@JDK767', tracking_number: 12345}
         @hash_str                    = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
         @thread_name                 = Thread.current.name

data/test/logger_test.rb

@@ -3,6 +3,105 @@ require_relative 'test_helper'
 # Unit Test for SemanticLogger::Logger
 class LoggerTest < Minitest::Test
   describe SemanticLogger::Logger do
+    describe '.add_appender' do
+      after do
+        SemanticLogger.remove_appender(@appender) if @appender
+        File.delete('sample.log') if File.exists?('sample.log')
+      end
+
+      it 'adds file appender' do
+        @appender = SemanticLogger.add_appender(file_name: 'sample.log')
+        assert @appender.is_a?(SemanticLogger::Appender::File)
+        assert SemanticLogger.appenders.include?(@appender)
+        assert @appender.formatter.is_a?(SemanticLogger::Formatters::Default)
+      end
+
+      it 'adds file appender with json format' do
+        @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)
+      end
+
+      it 'adds stream appender' do
+        @appender = SemanticLogger.add_appender(io: STDOUT)
+        assert @appender.is_a?(SemanticLogger::Appender::File)
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'adds symbol appender' do
+        @appender = SemanticLogger.add_appender(appender: :http, url: 'http://localhost:8088/path')
+        assert @appender.is_a?(SemanticLogger::Appender::Http), @appender.ai
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'adds logger wrapper appender' do
+        @appender = SemanticLogger.add_appender(logger: ::Logger.new(STDOUT))
+        assert @appender.is_a?(SemanticLogger::Appender::Wrapper)
+        assert @appender.logger.is_a?(::Logger)
+        assert SemanticLogger.appenders.include?(@appender)
+        assert @appender.formatter.is_a?(SemanticLogger::Formatters::Default)
+      end
+
+      it 'adds logger wrapper appender with color formatter' do
+        @appender = SemanticLogger.add_appender(logger: ::Logger.new(STDOUT), formatter: :color)
+        assert @appender.is_a?(SemanticLogger::Appender::Wrapper)
+        assert @appender.logger.is_a?(::Logger)
+        assert SemanticLogger.appenders.include?(@appender)
+        assert @appender.formatter.is_a?(SemanticLogger::Formatters::Color)
+      end
+
+      it 'adds appender' do
+        @appender = SemanticLogger.add_appender(appender: SemanticLogger::Appender::Http.new(url: 'http://localhost:8088/path'))
+        assert @appender.is_a?(SemanticLogger::Appender::Http), @appender.ai
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'fails to add invalid logger appender' do
+        assert_raises do
+          SemanticLogger.add_appender(logger: 'blah')
+        end
+      end
+    end
+
+    describe '.add_appender DEPRECATED' do
+      after do
+        SemanticLogger.remove_appender(@appender) if @appender
+        File.delete('sample.log') if File.exists?('sample.log')
+      end
+
+      it 'adds file appender' do
+        @appender = SemanticLogger.add_appender('sample.log')
+        assert @appender.is_a?(SemanticLogger::Appender::File)
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'adds stream appender' do
+        @appender = SemanticLogger.add_appender(STDOUT)
+        assert @appender.is_a?(SemanticLogger::Appender::File)
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'adds appender' do
+        @appender = SemanticLogger.add_appender(SemanticLogger::Appender::Http.new(url: 'http://localhost:8088/path'))
+        assert @appender.is_a?(SemanticLogger::Appender::Http), @appender.ai
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'adds logger wrapper appender' do
+        @appender = SemanticLogger.add_appender(::Logger.new(STDOUT))
+        assert @appender.is_a?(SemanticLogger::Appender::Wrapper)
+        assert @appender.logger.is_a?(::Logger)
+        assert SemanticLogger.appenders.include?(@appender)
+      end
+
+      it 'fails to add invalid logger appender' do
+        assert_raises do
+          SemanticLogger.add_appender(logger: 'blah')
+        end
+      end
+    end
+
     # Test each filter
     [nil, /\ALogger/, Proc.new { |l| (/\AExclude/ =~ l.message).nil? }].each do |filter|
       describe "filter: #{filter.class.name}" do
@@ -12,13 +111,13 @@ class LoggerTest < Minitest::Test
           SemanticLogger.default_level   = :trace
           SemanticLogger.backtrace_level = nil
           @mock_logger                   = MockLogger.new
-          @appender                      = SemanticLogger.add_appender(@mock_logger)
+          @appender                      = SemanticLogger.add_appender(logger: @mock_logger)
           @appender.filter               = filter
 
           # Add mock metric subscriber
           $last_metric                   = nil
-          SemanticLogger.on_metric do |log_struct|
-            $last_metric = log_struct.dup
+          SemanticLogger.on_metric do |log|
+            $last_metric = log.dup
           end
 
           # Use this test's class name as the application name in the log output
@@ -96,6 +195,66 @@ class LoggerTest < Minitest::Test
               assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- Hello world/, @mock_logger.message
             end
 
+            describe 'hash only argument' do
+              it 'logs message' do
+                @logger.send(level, message: 'Hello world')
+                SemanticLogger.flush
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- Hello world/, @mock_logger.message
+              end
+
+              it 'logs payload and message' do
+                @logger.send(level, message: 'Hello world', tracking_number: '123456', even: 2, more: 'data')
+                hash = {tracking_number: '123456', even: 2, more: 'data'}
+                SemanticLogger.flush
+                hash_str = hash.inspect.sub('{', '\{').sub('}', '\}')
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
+              end
+
+              it 'logs payload and message from block' do
+                @logger.send(level) { {message: 'Hello world', tracking_number: '123456', even: 2, more: 'data'} }
+                hash = {tracking_number: '123456', even: 2, more: 'data'}
+                SemanticLogger.flush
+                hash_str = hash.inspect.sub('{', '\{').sub('}', '\}')
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
+              end
+
+              it 'logs payload only' do
+                hash = {tracking_number: '123456', even: 2, more: 'data'}
+                @logger.send(level, hash)
+                SemanticLogger.flush
+                hash_str = hash.inspect.sub('{', '\{').sub('}', '\}')
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] LoggerTest -- #{hash_str}/, @mock_logger.message
+              end
+
+              it 'logs duration' do
+                @logger.send(level, duration: 123.45, message: 'Hello world', tracking_number: '123456', even: 2, more: 'data')
+                hash = {tracking_number: '123456', even: 2, more: 'data'}
+                SemanticLogger.flush
+                hash_str       = hash.inspect.sub('{', '\{').sub('}', '\}')
+                duration_match = defined?(JRuby) ? '\(123ms\)' : '\(123\.5ms\)'
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] #{duration_match} LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
+              end
+
+              it 'does not log when below min_duration' do
+                @logger.send(level, min_duration: 200, duration: 123.45, message: 'Hello world', tracking_number: '123456', even: 2, more: 'data')
+                hash = {tracking_number: '123456', even: 2, more: 'data'}
+                SemanticLogger.flush
+                assert_nil @mock_logger.message
+              end
+
+              it 'logs metric' do
+                metric_name = '/my/custom/metric'
+                @logger.send(level, metric: metric_name, duration: 123.45, message: 'Hello world', tracking_number: '123456', even: 2, more: 'data')
+                hash = {tracking_number: '123456', even: 2, more: 'data'}
+                SemanticLogger.flush
+                hash_str       = hash.inspect.sub('{', '\{').sub('}', '\}')
+                duration_match = defined?(JRuby) ? '\(123ms\)' : '\(123\.5ms\)'
+                assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] #{duration_match} LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
+                assert metric_name, $last_metric.metric
+              end
+
+            end
+
           end
         end
 
@@ -160,39 +319,39 @@ class LoggerTest < Minitest::Test
           end
         end
 
-        describe 'benchmark' do
-          # Ensure that any log level can be benchmarked and logged
+        describe 'measure' do
+          # Ensure that any log level can be measured and logged
           SemanticLogger::LEVELS.each do |level|
             level_char = level.to_s.upcase[0]
 
             describe 'direct method' do
               it "log #{level} info" do
-                assert_equal 'result', @logger.send("benchmark_#{level}".to_sym, 'hello world') { 'result' } # Measure duration of the supplied block
+                assert_equal 'result', @logger.send("measure_#{level}".to_sym, 'hello world') { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
               end
 
               it "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("measure_#{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+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
               it "not log #{level} info when block is faster than :min_duration" do
-                assert_equal 'result', @logger.send("benchmark_#{level}".to_sym, 'hello world', min_duration: 500) { 'result' } # Measure duration of the supplied block
+                assert_equal 'result', @logger.send("measure_#{level}".to_sym, 'hello world', min_duration: 500) { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_nil @mock_logger.message
               end
 
               it "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("measure_#{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+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
               it "log #{level} info with an exception" do
                 assert_raises RuntimeError do
-                  @logger.send("benchmark_#{level}", 'hello world', payload: @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
+                  @logger.send("measure_#{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+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
@@ -200,7 +359,7 @@ class LoggerTest < Minitest::Test
 
               it "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
+                  @logger.send("measure_#{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+ F \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
@@ -208,7 +367,7 @@ class LoggerTest < Minitest::Test
 
               it "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
+                assert_equal 'result', @logger.send("measure_#{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+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
                 assert metric_name, $last_metric.metric
@@ -216,7 +375,7 @@ class LoggerTest < Minitest::Test
 
               it "log #{level} info with backtrace" do
                 SemanticLogger.stub(:backtrace_level_index, 0) do
-                  assert_equal 'result', @logger.send("benchmark_#{level}".to_sym, 'hello world') { 'result' }
+                  assert_equal 'result', @logger.send("measure_#{level}".to_sym, 'hello world') { 'result' }
                   SemanticLogger.flush
                   assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
                 end
@@ -225,32 +384,32 @@ class LoggerTest < Minitest::Test
 
             describe 'generic method' do
               it "log #{level} info" do
-                assert_equal 'result', @logger.benchmark(level, 'hello world') { 'result' } # Measure duration of the supplied block
+                assert_equal 'result', @logger.measure(level, 'hello world') { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
               end
 
               it "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.measure(level, 'hello world', payload: @hash) { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
               it "not log #{level} info when block is faster than :min_duration" do
-                assert_equal 'result', @logger.benchmark(level, 'hello world', min_duration: 500) { 'result' } # Measure duration of the supplied block
+                assert_equal 'result', @logger.measure(level, 'hello world', min_duration: 500) { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_nil @mock_logger.message
               end
 
               it "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.measure(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+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
               end
 
               it "log #{level} info with an exception" do
                 assert_raises RuntimeError do
-                  @logger.benchmark(level, 'hello world', payload: @hash) { raise RuntimeError.new('Test') } # Measure duration of the supplied block
+                  @logger.measure(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+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
@@ -258,7 +417,7 @@ class LoggerTest < Minitest::Test
 
               it "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
+                assert_equal 'result', @logger.measure(level, 'hello world', metric: metric_name) { 'result' } # Measure duration of the supplied block
                 SemanticLogger.flush
                 assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
                 assert metric_name, $last_metric.metric
@@ -266,7 +425,7 @@ class LoggerTest < Minitest::Test
 
               it "log #{level} info with backtrace" do
                 SemanticLogger.stub(:backtrace_level_index, 0) do
-                  assert_equal 'result', @logger.benchmark(level, 'hello world') { 'result' }
+                  assert_equal 'result', @logger.measure(level, 'hello world') { 'result' }
                   SemanticLogger.flush
                   assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ #{level_char} \[\d+:#{@thread_name}#{@file_name_reg_exp}\] \((\d+\.\d+)|(\d+)ms\) LoggerTest -- hello world/, @mock_logger.message
                 end
@@ -282,7 +441,7 @@ class LoggerTest < Minitest::Test
 
           it 'not log at a level below the silence level' do
             SemanticLogger.default_level = :info
-            @logger.benchmark_info('hello world', silence: :error) do
+            @logger.measure_info('hello world', silence: :error) do
               @logger.warn "don't log me"
             end
             SemanticLogger.flush
@@ -292,7 +451,7 @@ class LoggerTest < Minitest::Test
           it 'log at a silence level below the default level' do
             SemanticLogger.default_level = :info
             first_message                = nil
-            @logger.benchmark_info('hello world', silence: :trace) do
+            @logger.measure_info('hello world', silence: :trace) do
               @logger.debug('hello world', @hash) { 'Calculations' }
               SemanticLogger.flush
               first_message = @mock_logger.message
@@ -415,10 +574,10 @@ class LoggerTest < Minitest::Test
       end
     end
 
-    # Make sure that benchmark still logs when a block uses return to return from
+    # Make sure that measure 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.measure_info('hello world', payload: @hash) do
         return 'Good'
       end
       'Bad'