semantic_logger 0.11.4 → 1.0.0

data/README.md

@@ -204,12 +204,12 @@ logger.info?
 The following logging methods are available
 
 ```ruby
-trace(message, payload=nil, &block)
-debug(message, payload=nil, &block)
-info(message, payload=nil, &block)
-warn(message, payload=nil, &block)
-error(message, payload=nil, &block)
-fatal(message, payload=nil, &block)
+trace(message, payload=nil, exception=nil, &block)
+debug(message, payload=nil, exception=nil, &block)
+info(message, payload=nil, exception=nil, &block)
+warn(message, payload=nil, exception=nil, &block)
+error(message, payload=nil, exception=nil, &block)
+fatal(message, payload=nil, exception=nil, &block)
 ```
 
 Parameters
@@ -217,6 +217,7 @@ Parameters
 - message: The text message to log.
   Mandatory only if no block is supplied
 - payload: Optional, either a Ruby Exception object or a Hash
+- exception: Optional, Ruby Exception object. Allows both an exception and a payload to be logged
 - block:   The optional block is executed only if the corresponding log level
   is active. Can be used to prevent unnecessary calculations of debug data in
   production.
@@ -311,7 +312,10 @@ Parameters
     Default: 0.0
 
   :payload
-    Optional, either a Ruby Exception object or a Hash
+    Optional, Hash payload
+
+  :exception
+    Optional, Ruby Exception object to log along with the duration of the supplied block
 ```
 
 #### Logging levels
@@ -578,21 +582,15 @@ Example: Replace the Rails log formatter, in the environment configuration file:
     config.after_initialize do
       # Since the Rails logger is already initialized, replace its default formatter
       config.semantic_logger.appenders.first.formatter = Proc.new do |log|
-          message = log.message.to_s
           tags = log.tags.collect { |tag| "[#{tag}]" }.join(" ") + " " if log.tags && (log.tags.size > 0)
 
-          if log.payload
-            if log.payload.is_a?(Exception)
-              exception = log.payload
-              message << " -- " << "#{exception.class}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}"
-            else
-              message << " -- " << log.payload.inspect
-            end
-          end
-
-          str = "#{log.time.strftime("%Y-%m-%d %H:%M:%S")}.#{"%06d" % log.time.usec} #{"%-05s" % log.level.to_s.upcase} [#{$$}:#{log.thread_name}] #{tags}#{log.name} -- #{message}"
-          str << " (#{'%.1f' % log.duration}ms)" if log.duration
-          str
+          message = log.message.to_s
+          message << " -- " << log.payload.inspect if log.payload
+          message << " -- " << "#{log.exception.class}: #{log.exception.message}\n#{(log.exception.backtrace || []).join("\n")}" if log.exception
+
+          duration_str = log.duration ? "(#{'%.1f' % log.duration}ms) " : ''
+
+          "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{log.level.to_s[0..0].upcase} [#{$$}:#{log.thread_name}] #{tags}#{duration_str}#{log.name} -- #{message}"
       end
     end
 ```
@@ -614,24 +612,18 @@ Example: Replace the MongoDB formatter, in the environment configuration file:
             :thread_name => log.thread_name,
             :name        => log.name,
             :level       => log.level,
+            :level_index => log.level_index,
           }
           document[:application] = 'MyApplication'
           document[:message]     = SemanticLogger::Appender::MongoDB.strip_colorizing(log.message) if log.message
           document[:duration]    = log.duration if log.duration
           document[:tags]        = log.tags if log.tags && (log.tags.size > 0)
-
-          if log.payload
-            if log.payload.is_a?(Exception)
-              exception = log.payload
-              document[:payload] = {
-                :exception => exception.class.name,
-                :message   => exception.message,
-                :backtrace => exception.backtrace
-              }
-            else
-              document[:payload] = log.payload
-            end
-          end
+          document[:payload]     = log.payload if log.payload
+          document[:exception]   = {
+            :name        => log.exception.class.name,
+            :message     => log.exception.message,
+            :stack_trace => log.exception.backtrace
+          } if log.exception
           document
       end
       config.semantic_logger.appenders << mongodb_appender

data/lib/semantic_logger/appender/base.rb

@@ -17,17 +17,11 @@ module SemanticLogger
       #    2011-07-19 14:36:15.660 D [1149:ScriptThreadProcess] Rails -- Hello World
       def default_formatter
         Proc.new do |log|
-          message = log.message.to_s
           tags = log.tags.collect { |tag| "[#{tag}]" }.join(" ") + " " if log.tags && (log.tags.size > 0)
 
-          if log.payload
-            if log.payload.is_a?(Exception)
-              exception = log.payload
-              message << " -- " << "#{exception.class}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}"
-            else
-              message << " -- " << self.class.inspect_payload(log.payload)
-            end
-          end
+          message = log.message.to_s
+          message << " -- " << log.payload.inspect if log.payload
+          message << " -- " << "#{log.exception.class}: #{log.exception.message}\n#{(log.exception.backtrace || []).join("\n")}" if log.exception
 
           duration_str = log.duration ? "(#{'%.1f' % log.duration}ms) " : ''
 
@@ -67,17 +61,6 @@ module SemanticLogger
         end
       end
 
-      if RUBY_VERSION.to_f >= 1.9
-        # With Ruby 1.9 calling .to_s on a hash now returns { 'a' => 1 }
-        def self.inspect_payload(payload)
-          payload.to_s
-        end
-      else
-        def self.inspect_payload(payload)
-          payload.inspect
-        end
-      end
-
     end
   end
 end

data/lib/semantic_logger/appender/mongodb.rb

@@ -144,19 +144,12 @@ module SemanticLogger
           document[:message]     = self.class.strip_colorizing(log.message) if log.message
           document[:duration]    = log.duration if log.duration
           document[:tags]        = log.tags if log.tags && (log.tags.size > 0)
-
-          if log.payload
-            if log.payload.is_a?(Exception)
-              exception = log.payload
-              document[:exception] = {
-                :name        => exception.class.name,
-                :message     => exception.message,
-                :stack_trace => exception.backtrace
-              }
-            else
-              document[:payload] = log.payload
-            end
-          end
+          document[:payload]     = log.payload if log.payload
+          document[:exception]   = {
+            :name        => log.exception.class.name,
+            :message     => log.exception.message,
+            :stack_trace => log.exception.backtrace
+          } if log.exception
           document
         end
       end

data/lib/semantic_logger/base.rb

@@ -31,7 +31,23 @@ module SemanticLogger
     # Implement the log level query
     #   logger.debug?
     #
-    # Example:
+    # Parameters:
+    #   message
+    #     [String] text message to be logged
+    #     Should always be supplied unless the result of the supplied block returns
+    #     a string in which case it will become the logged message
+    #     Default: nil
+    #
+    #   payload
+    #     [Hash|Exception] Optional hash payload or an exception to be logged
+    #     Default: nil
+    #
+    #   exception
+    #     [Exception] Optional exception to be logged
+    #     Allows both an exception and a payload to be logged
+    #     Default: nil
+    #
+    # Examples:
     #    require 'semantic_logger'
     #
     #    # Enable trace level logging
@@ -54,20 +70,28 @@ module SemanticLogger
     #
     SemanticLogger::LEVELS.each_with_index do |level, index|
       class_eval <<-EOT, __FILE__, __LINE__
-        def #{level}(message = nil, payload = nil)
+        def #{level}(message=nil, payload=nil, exception=nil)
           if @level_index <= #{index}
+            if exception.nil? && payload && payload.is_a?(Exception)
+              exception = payload
+              payload = nil
+            end
+
             if block_given? && (result = yield)
               if result.is_a?(String)
-                message = message.nil? ? result : "\#{message} -- \#{result.to_s}"
+                message = message.nil? ? result : "\#{message} -- \#{result}"
+              elsif payload && payload.respond_to?(:merge)
+                payload.merge(result)
               else
-                payload = payload.nil? ? result : payload.merge(result)
+                payload = result
               end
             end
+
             # Add scoped payload
             if self.payload
               payload = payload.nil? ? self.payload : self.payload.merge(payload)
             end
-            log Log.new(:#{level}, self.class.thread_name, name, message, payload, Time.now, nil, tags, #{index})
+            log Log.new(:#{level}, self.class.thread_name, name, message, payload, Time.now, nil, tags, #{index}, exception)
             true
           else
             false
@@ -80,13 +104,17 @@ module SemanticLogger
 
         def benchmark_#{level}(message, params = nil)
           raise "Mandatory block missing" unless block_given?
-          log_exception = params.nil? ? :full : params[:log_exception]
-          min_duration  = params.nil? ? 0.0   : (params[:min_duration] || 0.0)
-          payload       = params.nil? ? nil   : params[:payload]
           if @level_index <= #{index}
-            start = Time.now
+            log_exception = params.nil? ? :partial : (params[:log_exception] || :partial)
+            min_duration  = params.nil? ? 0.0      : (params[:min_duration] || 0.0)
+            payload       = params.nil? ? nil      : params[:payload]
+            exception     = params[:exception]
+            start         = Time.now
             begin
-              result = yield
+              yield
+            rescue Exception => exc
+              exception = exc
+            ensure
               end_time = Time.now
               duration = 1000.0 * (end_time - start)
 
@@ -96,16 +124,18 @@ module SemanticLogger
                 if self.payload
                   payload = payload.nil? ? self.payload : self.payload.merge(payload)
                 end
-                log Log.new(:#{level}, self.class.thread_name, name, message, payload, end_time, duration, tags, #{index})
-              end
-              result
-            rescue Exception => exc
-              if log_exception == :full
-                log Log.new(:#{level}, self.class.thread_name, name, message, exc, Time.now, 1000.0 * (Time.now - start), tags, #{index})
-              elsif log_exception == :partial
-                log Log.new(:#{level}, self.class.thread_name, name, "\#{message} -- \#{exception.class}: \#{exception.message}", payload, end_time, 1000.0 * (end_time - start), tags, #{index})
+                if exception
+                  case log_exception
+                  when :full
+                    log Log.new(:#{level}, self.class.thread_name, name, message, payload, end_time, duration, tags, #{index}, exception)
+                  when :partial
+                    log Log.new(:#{level}, self.class.thread_name, name, "\#{message} -- Exception: \#{exception.class}: \#{exception.message}", payload, end_time, duration, tags, #{index}, nil)
+                  end
+                  raise exception
+                else
+                 log Log.new(:#{level}, self.class.thread_name, name, message, payload, end_time, duration, tags, #{index}, nil)
+                end
               end
-              raise exc
             end
           else
             yield
@@ -234,7 +264,7 @@ module SemanticLogger
     #
     # level_index
     #   Internal index of the log level
-    Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index)
+    Log = Struct.new(:level, :thread_name, :name, :message, :payload, :time, :duration, :tags, :level_index, :exception)
 
     # For JRuby include the Thread name rather than its id
     if defined? Java

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger #:nodoc
-  VERSION = "0.11.4"
+  VERSION = "1.0.0"
 end

data/test/appender_file_test.rb

@@ -36,6 +36,11 @@ class AppenderFileTest < Test::Unit::TestCase
         @appender.debug 'hello world', @hash
         assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str}\n/, @io.string
       end
+
+      should "handle message, payload, and exception" do
+        @appender.debug 'hello world', @hash, StandardError.new("StandardError")
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- hello world -- #{@hash_str} -- StandardError: StandardError\n\n/, @io.string
+      end
     end
 
     context "for each log level" do
@@ -51,21 +56,15 @@ class AppenderFileTest < Test::Unit::TestCase
     context "custom formatter" do
       setup do
         @appender = SemanticLogger::Appender::File.new(@io) do |log|
-          message = log.message.to_s
           tags = log.tags.collect { |tag| "[#{tag}]" }.join(" ") + " " if log.tags && (log.tags.size > 0)
 
-          if log.payload
-            if log.payload.is_a?(Exception)
-              exception = log.payload
-              message << " -- " << "#{exception.class}: #{exception.message}\n#{(exception.backtrace || []).join("\n")}"
-            else
-              message << " -- " << log.payload.inspect
-            end
-          end
+          message = log.message.to_s
+          message << " -- " << log.payload.inspect if log.payload
+          message << " -- " << "#{log.exception.class}: #{log.exception.message}\n#{(log.exception.backtrace || []).join("\n")}" if log.exception
+
+          duration_str = log.duration ? " (#{'%.1f' % log.duration}ms)" : ''
 
-          str = "#{log.time.strftime("%Y-%m-%d %H:%M:%S")}.#{"%03d" % (log.time.usec/1000)} #{log.level.to_s.upcase} [#{$$}:#{log.thread_name}] #{tags}#{log.name} -- #{message}"
-          str << " (#{'%.1f' % log.duration}ms)" if log.duration
-          str
+          "#{SemanticLogger::Appender::Base.formatted_time(log.time)} #{log.level.to_s.upcase} [#{$$}:#{log.thread_name}] #{tags}#{log.name} -- #{message}#{duration_str}"
         end
       end
 

data/test/logger_test.rb

@@ -10,104 +10,130 @@ require 'semantic_logger'
 # Unit Test for SemanticLogger::Logger
 class LoggerTest < Test::Unit::TestCase
   context SemanticLogger::Logger do
+    setup do
+      # Use a mock logger that just keeps the last logged entry in an instance
+      # variable
+      @mock_logger = MockLogger.new
+      @appender = SemanticLogger::Appender::Wrapper.new(@mock_logger)
+      SemanticLogger::Logger.appenders << @appender
+
+      # Use this test's class name as the application name in the log output
+      @logger            = SemanticLogger::Logger.new(self.class, :trace)
+      @hash              = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
+      @hash_str          = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
+    end
 
-    context "log to Ruby and Rails logger" do
-      setup do
-        # Use a mock logger that just keeps the last logged entry in an instance variable
-        @mock_logger = MockLogger.new
-        @appender = SemanticLogger::Appender::Wrapper.new(@mock_logger)
-        SemanticLogger::Logger.appenders << @appender
-
-        # Use this test's class name as the application name in the log output
-        @logger = SemanticLogger::Logger.new('LoggerTest', :trace)
-
-        @hash = { :session_id => 'HSSKLEU@JDK767', :tracking_number => 12345 }
-        @hash_str = @hash.inspect.sub("{", "\\{").sub("}", "\\}")
-      end
+    teardown do
+      SemanticLogger::Logger.appenders.delete(@appender)
+    end
 
-      teardown do
-        SemanticLogger::Logger.appenders.delete(@appender)
+    # Ensure that any log level can be logged
+    SemanticLogger::LEVELS.each do |level|
+      should "log #{level} info" do
+        @logger.send(level, 'hello world', @hash) { "Calculations" }
+        SemanticLogger::Logger.flush
+        assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
       end
+    end
 
-      # Ensure that any log level can be logged
-      SemanticLogger::LEVELS.each do |level|
-        should "log #{level} info" do
-          @logger.send(level, 'hello world', @hash) { "Calculations" }
+    context "with_tags logging" do
+      should "add tags to log entries" do
+        @logger.with_tags('12345', 'DJHSFK') do
+          @logger.info('Hello world')
           SemanticLogger::Logger.flush
-          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- hello world -- Calculations -- #{@hash_str}/, @mock_logger.message
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \[12345\] \[DJHSFK\] LoggerTest -- Hello world/, @mock_logger.message
         end
       end
 
-      context "with_tags logging" do
-        should "add tags to log entries" do
-          @logger.with_tags('12345', 'DJHSFK') do
+      should "add embedded tags to log entries" do
+        @logger.with_tags('First Level', 'tags') do
+          @logger.with_tags('Second Level') do
             @logger.info('Hello world')
             SemanticLogger::Logger.flush
-            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \[12345\] \[DJHSFK\] LoggerTest -- Hello world/, @mock_logger.message
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \[First Level\] \[tags\] \[Second Level\] LoggerTest -- Hello world/, @mock_logger.message
           end
         end
+      end
 
-        should "add embedded tags to log entries" do
-          @logger.with_tags('First Level', 'tags') do
-            @logger.with_tags('Second Level') do
-              @logger.info('Hello world')
-              SemanticLogger::Logger.flush
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \[First Level\] \[tags\] \[Second Level\] LoggerTest -- Hello world/, @mock_logger.message
-            end
+      should "add payload to log entries" do
+        hash = {:tracking_number=>"123456", :even=>2, :more=>"data"}
+        hash_str = hash.inspect.sub("{", "\\{").sub("}", "\\}")
+        @logger.with_payload(:tracking_number => '123456') do
+          @logger.with_payload(:even => 2, :more => 'data') do
+            @logger.info('Hello world')
+            SemanticLogger::Logger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
           end
         end
+      end
 
-        should "add payload to log entries" do
-          hash = {:tracking_number=>"123456", :even=>2, :more=>"data"}
-          hash_str = hash.inspect.sub("{", "\\{").sub("}", "\\}")
-          @logger.with_payload(:tracking_number => '123456') do
-            @logger.with_payload(:even => 2, :more => 'data') do
-              @logger.info('Hello world')
-              SemanticLogger::Logger.flush
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] LoggerTest -- Hello world -- #{hash_str}/, @mock_logger.message
+      context "Ruby Logger" do
+        # Ensure that any log level can be logged
+        Logger::Severity.constants.each do |level|
+          should "log Ruby logger #{level} info" do
+            @logger.level = Logger::Severity.const_get(level)
+            if level.to_s == 'UNKNOWN'
+              assert_equal Logger::Severity.const_get('ERROR')+1, @logger.send(:level_index)
+            else
+              assert_equal Logger::Severity.const_get(level)+1, @logger.send(:level_index)
             end
           end
         end
+      end
 
-        context "Ruby Logger" do
-          # Ensure that any log level can be logged
-          Logger::Severity.constants.each do |level|
-            should "log Ruby logger #{level} info" do
-              @logger.level = Logger::Severity.const_get(level)
-              if level.to_s == 'UNKNOWN'
-                assert_equal Logger::Severity.const_get('ERROR')+1, @logger.send(:level_index)
-              else
-                assert_equal Logger::Severity.const_get(level)+1, @logger.send(:level_index)
-              end
-            end
+      context "benchmark" do
+        # Ensure that any log level can be benchmarked and logged
+        SemanticLogger::LEVELS.each do |level|
+          should "log #{level} info" do
+            assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world') { "result" } # Measure duration of the supplied block
+            SemanticLogger::Logger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
           end
-        end
 
-        context "benchmark" do
-          # Ensure that any log level can be benchmarked and logged
-          SemanticLogger::LEVELS.each do |level|
-            should "log #{level} info" do
-              assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world') { "result" }
-              SemanticLogger::Logger.flush
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world/, @mock_logger.message
-            end
+          should "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
+            SemanticLogger::Logger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+          end
 
-            should "log #{level} info with payload" do
-              assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :payload => @hash) { "result" }
-              SemanticLogger::Logger.flush
-              assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
-            end
+          should "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 => 0.5) { "result" } # Measure duration of the supplied block
+            SemanticLogger::Logger.flush
+            assert_nil @mock_logger.message
+          end
+
+          should "log #{level} info when block duration exceeds :min_duration" do
+            assert_equal "result", @logger.send("benchmark_#{level}".to_sym, 'hello world', :min_duration => 0.2, :payload => @hash) { sleep 0.5; "result" } # Measure duration of the supplied block
+            SemanticLogger::Logger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+          end
 
-            should "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 => 0.5) { "result" }
-              SemanticLogger::Logger.flush
-              assert_nil @mock_logger.message
+          should "log #{level} info with an exception" do
+            assert_raise RuntimeError do
+              @logger.send("benchmark_#{level}", 'hello world', :payload => @hash) { raise RuntimeError.new("Test") } # Measure duration of the supplied block
             end
+            SemanticLogger::Logger.flush
+            assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- Exception: RuntimeError: Test -- #{@hash_str}/, @mock_logger.message
           end
         end
 
+        should "log when the block performs a return" do
+          assert_equal "Good", function_with_return(@logger)
+          SemanticLogger::Logger.flush
+          assert_match /\d+-\d+-\d+ \d+:\d+:\d+.\d+ \w \[\d+:.+\] \(\d+\.\dms\) LoggerTest -- hello world -- #{@hash_str}/, @mock_logger.message
+        end
       end
+
     end
+  end
 
+  # Make sure that benchmark 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
+      return "Good"
+    end
+    "Bad"
   end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 0.11.4
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-02 00:00:00.000000000 Z
+date: 2012-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sync_attr
@@ -108,7 +108,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3605629782528849560
+      hash: -2573404344883398043
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: