Extract resolving of severity values to Rackstash.severity

lib/rackstash.rb

@@ -49,6 +49,8 @@ module Rackstash
   # its numeric value or its name in most variations (`Symbol`, `String`,
   # different cases).
   #
+  # If the given severity if unknown or out of range, we return `"ANY"`.
+  #
   # @param severity [Integer, #to_s] A numeric value of one of the {SEVERITIES}
   #   or a {SEVERITY_NAMES} key
   # @return [String] one of the {SEVERITY_LABELS}
@@ -62,6 +64,26 @@ module Rackstash
     end
   end
 
+  # Resolve a given severity to its numeric value. You can specify the severity
+  # either by its numeric value (generally one of the {SEVERITIES}), or its name
+  # in most variations (`Symbol`, `String`, different cases), i.e. one of the
+  # {SEVERITY_NAMES}.
+  #
+  # If an invalid severity name is given, we raise an `ArgumentError`. All
+  # Integer values are accepted without further checks.
+  #
+  # @param severity [Integer, #to_s] A numeric value of one of the {SEVERITIES}
+  #   or a {SEVERITY_NAMES} key)
+  # @raise [ArgumentError] if an invalid severity name is given.
+  # @return [Integer] the resolved severity
+  def self.severity(severity)
+    return severity if severity.is_a?(Integer)
+
+    SEVERITY_NAMES.fetch(severity.to_s.downcase) do
+      raise ArgumentError, "invalid log severity: #{severity.inspect}"
+    end
+  end
+
   PROGNAME = "rackstash/v#{Rackstash::VERSION}".freeze
 
   # A class for the {UNDEFINED} object. Generally, there will only be exactly

lib/rackstash/adapters/logger.rb

@@ -69,13 +69,7 @@ module Rackstash
       # @raise [ArgumentError] if no severity could be found for the given
       #   value.
       def severity=(severity)
-        if severity.is_a?(Integer)
-          @severity = severity
-        else
-          @severity = SEVERITY_NAMES.fetch(severity.to_s.downcase) do
-            raise ArgumentError, "invalid log severity: #{severity.inspect}"
-          end
-        end
+        @severity = Rackstash.severity(severity)
       end
 
       # Close the base logger (if supported). The exact behavior is dependent on

lib/rackstash/logger.rb

@@ -168,13 +168,7 @@ module Rackstash
     # @param severity [Integer, String, Symbol] one of the {SEVERITIES} or its
     #   name
     def level=(severity)
-      if severity.is_a?(Integer)
-        @level = severity
-      else
-        @level = SEVERITY_NAMES.fetch(severity.to_s.downcase) do
-          raise ArgumentError, "invalid log level: #{severity}"
-        end
-      end
+      @level = Rackstash.severity(severity)
     end
 
     # (see Sink#close)

spec/rackstash/adapters/logger_spec.rb

@@ -84,6 +84,19 @@ describe Rackstash::Adapters::Logger do
     end
   end
 
+  describe '#severity' do
+    it 'defaults to INFO' do
+      expect(adapter.severity).to eql 1
+    end
+
+    it 'resolves value with Rackstash.severity' do
+      adapter # initialize the logger
+      expect(Rackstash).to receive(:severity).with(:WaRn).and_call_original
+      adapter.severity = :WaRn
+      expect(adapter.severity).to eql 2
+    end
+  end
+
   describe '#reopen' do
     context 'with logger' do
       it 'closes the logger object' do

spec/rackstash/logger_spec.rb

@@ -160,47 +160,12 @@ describe Rackstash::Logger do
       expect(logger.level).to eql 0
     end
 
-    it 'can be set as an integer' do
-      logger.level = 3
+    it 'resolves value with Rackstash.severity' do
+      logger # initialize the logger
+
+      expect(Rackstash).to receive(:severity).with(:ErRor).and_call_original
+      logger.level = :ErRor
       expect(logger.level).to eql 3
-
-      logger.level = 42
-      expect(logger.level).to eql 42
-
-      logger.level = -25
-      expect(logger.level).to eql(-25)
-    end
-
-    it 'can be set as a symbol' do
-      %i[debug info warn error fatal unknown].each_with_index do |level, i|
-        logger.level = level
-        expect(logger.level).to eql i
-      end
-
-      %i[DeBuG InFo WaRn ErRoR FaTaL UnKnOwN].each_with_index do |level, i|
-        logger.level = level
-        expect(logger.level).to eql i
-      end
-    end
-
-    it 'can be set as a string' do
-      %w[debug info warn error fatal unknown].each_with_index do |level, i|
-        logger.level = level
-        expect(logger.level).to eql i
-      end
-
-      %w[DeBuG InFo WaRn ErRoR FaTaL UnKnOwN].each_with_index do |level, i|
-        logger.level = level
-        expect(logger.level).to eql i
-      end
-    end
-
-    it 'rejects invalid values' do
-      expect { logger.level = 'invalid' }.to raise_error(ArgumentError)
-      expect { logger.level = Object.new }.to raise_error(ArgumentError)
-      expect { logger.level = nil }.to raise_error(ArgumentError)
-      expect { logger.level = false }.to raise_error(ArgumentError)
-      expect { logger.level = true }.to raise_error(ArgumentError)
     end
 
     it 'can set all the levels' do

spec/rackstash_spec.rb

@@ -100,6 +100,42 @@ describe Rackstash do
     end
   end
 
+  describe '.severity' do
+    it 'can be set as an integer' do
+      expect(Rackstash.severity(3)).to eql 3
+      expect(Rackstash.severity(42)).to eql 42
+      expect(Rackstash.severity(-25)).to eql(-25)
+    end
+
+    it 'can be set as a symbol' do
+      %i[debug info warn error fatal unknown].each_with_index do |level, i|
+        expect(Rackstash.severity(level)).to eql i
+      end
+
+      %i[DeBuG InFo WaRn ErRoR FaTaL UnKnOwN].each_with_index do |level, i|
+        expect(Rackstash.severity(level)).to eql i
+      end
+    end
+
+    it 'can be set as a string' do
+      %w[debug info warn error fatal unknown].each_with_index do |level, i|
+        expect(Rackstash.severity(level)).to eql i
+      end
+
+      %w[DeBuG InFo WaRn ErRoR FaTaL UnKnOwN].each_with_index do |level, i|
+        expect(Rackstash.severity(level)).to eql i
+      end
+    end
+
+    it 'rejects invalid values' do
+      expect { Rackstash.severity('invalid') }.to raise_error(ArgumentError)
+      expect { Rackstash.severity(Object.new) }.to raise_error(ArgumentError)
+      expect { Rackstash.severity(nil) }.to raise_error(ArgumentError)
+      expect { Rackstash.severity(false) }.to raise_error(ArgumentError)
+      expect { Rackstash.severity(true) }.to raise_error(ArgumentError)
+    end
+  end
+
   describe '.error_flow' do
     it 'returns a default Flow' do
       expect(described_class.error_flow).to be_instance_of Rackstash::Flow