Add shortcut log methods to Rackstash::Logger

Using methods named after the severity, users can esily log messages
based on their intended severity. We do support the block syntax
throughout to conditionally log expensive messages only if the log level
is low enough:

    logger.debug { compute_details_for_log }

lib/rackstash/logger.rb

@@ -82,6 +82,114 @@ module Rackstash
       end
     end
 
+    # Log a `message` at the DEBUG log level.
+    #
+    # @param message (see #add)
+    # @yield (see #add)
+    # @return (see #add)
+    def debug(message = nil)
+      if block_given?
+        add(DEBUG, message) { yield }
+      else
+        add(DEBUG, message)
+      end
+    end
+
+    # @return [Boolean] `true` if messages on the DEBUG level will be logged
+    def debug?
+      @level <= DEBUG
+    end
+
+    # Log a `message` at the INFO log level.
+    #
+    # @param message (see #add)
+    # @yield (see #add)
+    # @return (see #add)
+    def info(message = nil)
+      if block_given?
+        add(INFO, message) { yield }
+      else
+        add(INFO, message)
+      end
+    end
+
+    # @return [Boolean] `true` if messages on the INFO level will be logged
+    def info?
+      @level <= INFO
+    end
+
+    # Log a `message` at the WARN log level.
+    #
+    # @param message (see #add)
+    # @yield (see #add)
+    # @return (see #add)
+    def warn(message = nil)
+      if block_given?
+        add(WARN, message) { yield }
+      else
+        add(WARN, message)
+      end
+    end
+
+    # @return [Boolean] `true` if messages on the WARN level will be logged
+    def warn?
+      @level <= WARN
+    end
+
+    # Log a `message` at the ERROR log level.
+    #
+    # @param message (see #add)
+    # @yield (see #add)
+    # @return (see #add)
+    def error(message = nil)
+      if block_given?
+        add(ERROR, message) { yield }
+      else
+        add(ERROR, message)
+      end
+    end
+
+    # @return [Boolean] `true` if messages on the ERROR level will be logged
+    def error?
+      @level <= ERROR
+    end
+
+    # Log a `message` at the FATAL log level.
+    #
+    # @param message (see #add)
+    # @yield (see #add)
+    # @return (see #add)
+    def fatal(message = nil)
+      if block_given?
+        add(FATAL, message) { yield }
+      else
+        add(FATAL, message)
+      end
+    end
+
+    # @return [Boolean] `true` if messages on the FATAL level will be logged
+    def fatal?
+      @level <= FATAL
+    end
+
+    # Log a `message` at the UNKNOWN log level.
+    #
+    # @param message (see #add)
+    # @yield (see #add)
+    # @return (see #add)
+    def unknown(message = nil)
+      if block_given?
+        add(UNKNOWN, message) { yield }
+      else
+        add(UNKNOWN, message)
+      end
+    end
+
+    # @return [Boolean] `true` if messages on the UNKNOWN level will be logged
+    def unknown?
+      @level <= UNKNOWN
+    end
+
     # Log a message if the given severity is high enough. This is the generic
     # logging method. Users will be more inclined to use {#debug}, {#info},
     # {#warn}, {#error}, or {#fatal}.

spec/rackstash/logger_spec.rb

@@ -37,7 +37,6 @@ describe Rackstash::Logger do
 
       logger.level = -25
       expect(logger.level).to eql -25
-
     end
 
     it 'can be set as a symbol' do
@@ -71,6 +70,20 @@ describe Rackstash::Logger do
       expect { logger.level = false }.to raise_error(ArgumentError)
       expect { logger.level = true }.to raise_error(ArgumentError)
     end
+
+    it 'can set all the levels' do
+      levels = %i[debug info warn error fatal unknown]
+
+      levels.each_with_index do |level, number|
+        logger.level = level
+        expect(logger.level).to eql number
+
+        # only severities larger then the selected one are logged
+        levels.each_with_index do |check_level, check_number|
+          expect(logger.public_send(:"#{check_level}?")).to eql number <= check_number
+        end
+      end
+    end
   end
 
   describe '#progname' do
@@ -215,5 +228,77 @@ describe Rackstash::Logger do
       logger.add(0, nil, 'prog') { nil }
       expect(messages.last).to include message: nil, severity: 0, progname: 'prog'
     end
+
+    it 'can use debug shortcut' do
+      expect(logger).to receive(:add).with(0, 'Debug').and_call_original
+      logger.debug('Debug')
+      expect(messages.last).to include message: 'Debug', severity: 0
+    end
+
+    it 'can use debug shortcut with a block' do
+      expect(logger).to receive(:add).with(0, nil).and_call_original
+      logger.debug { 'Debug' }
+      expect(messages.last).to include message: 'Debug', severity: 0
+    end
+
+    it 'can use info shortcut' do
+      expect(logger).to receive(:add).with(1, 'Info').and_call_original
+      logger.info('Info')
+      expect(messages.last).to include message: 'Info', severity: 1
+    end
+
+    it 'can use info shortcut with a block' do
+      expect(logger).to receive(:add).with(1, nil).and_call_original
+      logger.info { 'Info' }
+      expect(messages.last).to include message: 'Info', severity: 1
+    end
+
+    it 'can use warn shortcut' do
+      expect(logger).to receive(:add).with(2, 'Warn').and_call_original
+      logger.warn('Warn')
+      expect(messages.last).to include message: 'Warn', severity: 2
+    end
+
+    it 'can use warn shortcut with a block' do
+      expect(logger).to receive(:add).with(2, nil).and_call_original
+      logger.warn { 'Warn' }
+      expect(messages.last).to include message: 'Warn', severity: 2
+    end
+
+    it 'can use error shortcut' do
+      expect(logger).to receive(:add).with(3, 'Error').and_call_original
+      logger.error('Error')
+      expect(messages.last).to include message: 'Error', severity: 3
+    end
+
+    it 'can use error shortcut with a block' do
+      expect(logger).to receive(:add).with(3, nil).and_call_original
+      logger.error { 'Error' }
+      expect(messages.last).to include message: 'Error', severity: 3
+    end
+
+    it 'can use fatal shortcut' do
+      expect(logger).to receive(:add).with(4, 'Fatal').and_call_original
+      logger.fatal('Fatal')
+      expect(messages.last).to include message: 'Fatal', severity: 4
+    end
+
+    it 'can use fatal shortcut with a block' do
+      expect(logger).to receive(:add).with(4, nil).and_call_original
+      logger.fatal { 'Fatal' }
+      expect(messages.last).to include message: 'Fatal', severity: 4
+    end
+
+    it 'can use unknown shortcut' do
+      expect(logger).to receive(:add).with(5, 'Unknown').and_call_original
+      logger.unknown('Unknown')
+      expect(messages.last).to include message: 'Unknown', severity: 5
+    end
+
+    it 'can use unknown shortcut with a block' do
+      expect(logger).to receive(:add).with(5, nil).and_call_original
+      logger.unknown { 'Unknown' }
+      expect(messages.last).to include message: 'Unknown', severity: 5
+    end
   end
 end