semantic_logger 4.2.2 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5e2a3fa7d0cba9f44c7a64abbc17d3fe77a10174
-  data.tar.gz: bca2b99107ef30043276c03b5ea09cacb4065129
+SHA256:
+  metadata.gz: 951b7e0fc762a3801a11ccf9d3ca9cc503742453f39490ddd41112895d677fe7
+  data.tar.gz: 25c47bbee6b929b1f23fcc56ee6f34164066af52fb130ff238877d833538cb62
 SHA512:
-  metadata.gz: 4c5afd6c5af4110f7f63adbdce4fbd419c9c33c88522d3c3a36acc3d2335dacc0d34f79bdd2775f0b0eadb9cf4d6284b0c0cbe514011bd323b346e54ca0ae525
-  data.tar.gz: e7f2cbf6618aed0c38b10312dee1008b5eb4cf98809525826a2460c3003bb82816e043bde83dd9c56ccf9475e018e352f4cecfa14cd8674c305c3af44999ec38
+  metadata.gz: 9553643ca1faf2f9d124cd05333f648f4770f1249a46ec92c21b2cb41856d9d0ee62d65cb59bf097548a10b22f91b6530fe48a2138ecdca5ee997e69fd4da3ca
+  data.tar.gz: 25e1949848b10937692ea12fbab2d83a090c36c09cc9a005cc64a4263b8838cba9d712e628bd4f311b58ac6b416963ae759609864935faaf0efdc73501cd397c

data/README.md

@@ -50,11 +50,7 @@ Checkout the sister project [Rocket Job](http://rocketjob.io): Ruby's missing ba
 Fully supports Semantic Logger when running jobs in the background. Complete support for job metrics
 sent via Semantic Logger to your favorite dashboards.
 
-## Supports
-
-Semantic Logger is tested and supported on the following Ruby platforms:
-- Ruby 2.1 and higher.
-- JRuby 9.1 and higher.
+## Optional Dependencies
 
 The following gems are only required when their corresponding appenders are being used,
 and are therefore not automatically included by this gem:

data/lib/semantic_logger/appender/async.rb

@@ -42,6 +42,7 @@ module SemanticLogger
         @appender           = appender
         @lag_check_interval = lag_check_interval
         @lag_threshold_s    = lag_threshold_s
+        @thread             = nil
 
         if max_queue_size == -1
           @queue  = Queue.new

data/lib/semantic_logger/appender/bugsnag.rb

@@ -29,13 +29,13 @@ module SemanticLogger
       #     regular expression. All other messages will be ignored.
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
-      def initialize(level: :error, formatter: nil, filter: nil, application: nil, host: nil, &block)
+      def initialize(level: :error, **args, &block)
         raise 'Bugsnag only supports :info, :warn, or :error log levels' unless %i[info warn error fatal].include?(level)
 
         # Replace the Bugsnag logger so that we can identify its log messages and not forward them to Bugsnag
         ::Bugsnag.configure { |config| config.logger = SemanticLogger[Bugsnag] }
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(level: level, **args, &block)
       end
 
       # Returns [Hash] of parameters to send to Bugsnag.

data/lib/semantic_logger/appender/elasticsearch.rb

@@ -126,6 +126,7 @@ module SemanticLogger
                      filter: nil,
                      application: nil,
                      host: nil,
+                     metrics: false,
                      **elasticsearch_args,
                      &block)
 
@@ -136,7 +137,7 @@ module SemanticLogger
         @elasticsearch_args[:url]    = url if url && !elasticsearch_args[:hosts]
         @elasticsearch_args[:logger] = logger
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(level: level, formatter: formatter, filter: filter, application: application, host: host, metrics: false, &block)
         reopen
       end
 

data/lib/semantic_logger/appender/file.rb

@@ -59,7 +59,7 @@ module SemanticLogger
       #
       #    logger =  SemanticLogger['test']
       #    logger.info 'Hello World'
-      def initialize(io: nil, file_name: nil, level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+      def initialize(io: nil, file_name: nil, **args, &block)
         if io
           @log = io
         else
@@ -68,7 +68,7 @@ module SemanticLogger
           reopen
         end
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(**args, &block)
       end
 
       # After forking an active process call #reopen to re-open

data/lib/semantic_logger/appender/graylog.rb

@@ -82,15 +82,19 @@ module SemanticLogger
       #   application: [String]
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
-      def initialize(url: 'udp://localhost:12201', max_size: 'WAN', gelf_options: {}, level_map: LevelMap.new,
-                     level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+      def initialize(url: 'udp://localhost:12201',
+                     max_size: 'WAN',
+                     gelf_options: {},
+                     level_map: LevelMap.new,
+                     **args,
+                     &block)
 
         @url          = url
         @max_size     = max_size
         @gelf_options = gelf_options
         @level_map    = level_map.is_a?(LevelMap) ? level_map : LevelMap.new(level_map)
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(**args, &block)
         reopen
       end
 

data/lib/semantic_logger/appender/honeybadger.rb

@@ -37,8 +37,8 @@ module SemanticLogger
       #   application: [String]
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
-      def initialize(level: :error, formatter: nil, filter: nil, application: nil, host: nil, &block)
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+      def initialize(level: :error, **args, &block)
+        super(level: level, **args, &block)
       end
 
       # Send an error notification to honeybadger

data/lib/semantic_logger/appender/http.rb

@@ -88,11 +88,7 @@ module SemanticLogger
                      open_timeout: 2.0,
                      read_timeout: 1.0,
                      continue_timeout: 1.0,
-                     level: nil,
-                     formatter: nil,
-                     filter: nil,
-                     application: nil,
-                     host: nil,
+                     **args,
                      &block)
 
         @url              = url
@@ -133,7 +129,7 @@ module SemanticLogger
         end
         @http = nil
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(**args, &block)
         reopen
       end
 

data/lib/semantic_logger/appender/kafka.rb

@@ -111,11 +111,15 @@ module SemanticLogger
       #   application: [String]
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
+      #
+      #   metrics: [Boolean]
+      #     Send metrics only events to kafka.
+      #     Default: true
       def initialize(seed_brokers:, client_id: 'semantic-logger', connect_timeout: nil, socket_timeout: nil,
                      ssl_ca_cert: nil, ssl_client_cert: nil, ssl_client_cert_key: nil,
                      topic: 'log_messages', partition: nil, partition_key: nil, key: nil,
                      delivery_threshold: 100, delivery_interval: 10,
-                     level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+                     metrics: true, **args, &block)
 
         @seed_brokers        = seed_brokers
         @client_id           = client_id
@@ -131,7 +135,7 @@ module SemanticLogger
         @delivery_threshold  = delivery_threshold
         @delivery_interval   = delivery_interval
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(metrics: metrics, **args, &block)
         reopen
       end
 

data/lib/semantic_logger/appender/mongodb.rb

@@ -103,8 +103,13 @@ module SemanticLogger
       #   application: [String]
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
-      def initialize(uri:, collection_name: 'semantic_logger', write_concern: 0, collection_size: 1024 ** 3, collection_max: nil,
-                     level: nil, formatter: nil, filter: nil, host: nil, application: nil, &block)
+      def initialize(uri:,
+                     collection_name: 'semantic_logger',
+                     write_concern: 0,
+                     collection_size: 1024 ** 3,
+                     collection_max: nil,
+                     **args,
+                     &block)
 
         @client          = Mongo::Client.new(uri, logger: logger)
         @collection_name = collection_name
@@ -120,7 +125,7 @@ module SemanticLogger
         # Create the collection and necessary indexes
         create_indexes
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(**args, &block)
       end
 
       # After forking an active process call #reopen to re-open

data/lib/semantic_logger/appender/new_relic.rb

@@ -31,14 +31,8 @@ module SemanticLogger
       #     regular expression. All other messages will be ignored.
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
-      def initialize(level: :error,
-                     formatter: nil,
-                     filter: nil,
-                     application: nil,
-                     host: nil,
-                     &block)
-
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+      def initialize(level: :error, **args, &block)
+        super(level: level, **args, &block)
       end
 
       # Returns [Hash] of parameters to send to New Relic.

data/lib/semantic_logger/appender/sentry.rb

@@ -37,10 +37,10 @@ module SemanticLogger
       #   application: [String]
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
-      def initialize(level: :error, formatter: nil, filter: nil, application: nil, host: nil, &block)
+      def initialize(level: :error, **args, &block)
         # Replace the Sentry Raven logger so that we can identify its log messages and not forward them to Sentry
         Raven.configure { |config| config.logger = SemanticLogger[Raven] }
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(level: level, **args, &block)
       end
 
       # Send an error notification to sentry
@@ -49,12 +49,14 @@ module SemanticLogger
         return false if log.name == 'Raven'
 
         context = formatter.call(log, self)
-        attrs   = {
+        user = context.delete(:user)
+        tags = context.delete(:tags)
+        attrs = {
           level: context.delete(:level),
-          user:  context.delete(:user),
-          tags:  context.delete(:tags),
           extra: context
         }
+        attrs[:user] = user if user
+        attrs[:tags] = tags if tags
         if log.exception
           context.delete(:exception)
           Raven.capture_exception(log.exception, attrs)

data/lib/semantic_logger/appender/splunk.rb

@@ -88,12 +88,11 @@ module SemanticLogger
       #     regular expression. All other messages will be ignored.
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
-      def initialize(index: 'main', source_type: nil,
-                     level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+      def initialize(index: 'main', source_type: nil, **args, &block)
         @index       = index
         @source_type = source_type
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(**args, &block)
         reopen
       end
 

data/lib/semantic_logger/appender/splunk_http.rb

@@ -68,15 +68,17 @@ module SemanticLogger
       #     regular expression. All other messages will be ignored.
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
-      def initialize(token: nil, source_type: nil, index: nil,
-                     url:, compress: true, ssl: {}, open_timeout: 2.0, read_timeout: 1.0, continue_timeout: 1.0,
-                     level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+      def initialize(token: nil,
+                     source_type: nil,
+                     index: nil,
+                     compress: true,
+                     **args,
+                     &block)
 
         @source_type = source_type
         @index       = index
 
-        super(url:   url, compress: compress, ssl: ssl, read_timeout: read_timeout, open_timeout: open_timeout, continue_timeout: continue_timeout,
-              level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(compress: compress, **args, &block)
 
         # Put splunk auth token in the header of every HTTP post.
         @header['Authorization'] = "Splunk #{token}"

data/lib/semantic_logger/appender/syslog.rb

@@ -120,9 +120,12 @@ module SemanticLogger
       #     # Change the warn level to LOG_NOTICE level instead of a the default of LOG_WARNING.
       #     SemanticLogger.add_appender(appender: :syslog, level_map: {warn: ::Syslog::LOG_NOTICE})
       def initialize(url: 'syslog://localhost',
-                     facility: ::Syslog::LOG_USER, level_map: SemanticLogger::Formatters::Syslog::LevelMap.new, options: ::Syslog::LOG_PID| ::Syslog::LOG_CONS,
+                     facility: ::Syslog::LOG_USER,
+                     level_map: SemanticLogger::Formatters::Syslog::LevelMap.new,
+                     options: ::Syslog::LOG_PID | ::Syslog::LOG_CONS,
                      tcp_client: {},
-                     level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+                     **args,
+                     &block)
 
         @options            = options
         @facility           = facility
@@ -155,7 +158,7 @@ module SemanticLogger
           end
         end
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(**args, &block)
         reopen
       end
 
@@ -164,7 +167,8 @@ module SemanticLogger
       def reopen
         case @protocol
         when :syslog
-          ::Syslog.open(application, options, facility)
+          method = ::Syslog.opened? ? :reopen : :open
+          ::Syslog.send(method, application, options, facility)
         when :tcp
           # Use the local logger for @remote_syslog so errors with the remote logger can be recorded locally.
           @tcp_client_options[:logger] = logger

data/lib/semantic_logger/appender/tcp.rb

@@ -182,7 +182,7 @@ module SemanticLogger
       #     connect_retry_count:    5
       #   )
       def initialize(separator: "\n",
-                     level: nil, formatter: nil, filter: nil, application: nil, host: nil,
+                     level: nil, formatter: nil, filter: nil, application: nil, host: nil, metrics: false,
                      **tcp_client_args, &block)
         @separator       = separator
         @tcp_client_args = tcp_client_args

data/lib/semantic_logger/appender/udp.rb

@@ -48,6 +48,10 @@ module SemanticLogger
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
       #
+      #   metrics: [Boolean]
+      #     Send metrics only events over udp.
+      #     Default: true
+      #
       # Limitations:
       # * UDP packet size is limited by the connected network and any routers etc
       #   that the message has to traverse. See https://en.wikipedia.org/wiki/Maximum_transmission_unit
@@ -57,11 +61,11 @@ module SemanticLogger
       #     appender: :udp,
       #     server:   'server:3300'
       #   )
-      def initialize(server:, udp_flags: 0, level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+      def initialize(server:, udp_flags: 0, metrics: true, **args, &block)
         @server    = server
         @udp_flags = udp_flags
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(metrics: metrics, **args, &block)
         reopen
       end
 

data/lib/semantic_logger/appender/wrapper.rb

@@ -39,7 +39,7 @@ module SemanticLogger
       #    logger.info('Hello World', some: :payload)
       #
       # Install the `rails_semantic_logger` gem to replace the Rails logger with Semantic Logger.
-      def initialize(logger:, level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+      def initialize(logger:, **args, &block)
         @logger = logger
 
         # Check if the custom appender responds to all the log levels. For example Ruby ::Logger
@@ -48,7 +48,7 @@ module SemanticLogger
           raise(ArgumentError, "Supplied logger does not implement:#{does_not_implement}. It must implement all of #{LEVELS[1..-1].inspect}")
         end
 
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(**args, &block)
       end
 
       # Pass log calls to the underlying Rails, log4j or Ruby logger

data/lib/semantic_logger/base.rb

@@ -136,7 +136,7 @@ module SemanticLogger
 
       backtrace =
         if thread == Thread.current
-          Log.cleanse_backtrace
+          Utils.extract_backtrace
         else
           log.thread_name = thread.name
           log.tags        = (thread[:semantic_logger_tags] || []).clone

data/lib/semantic_logger/log.rb

@@ -109,9 +109,9 @@ module SemanticLogger
       end
 
       if backtrace
-        self.backtrace = Utils.cleanse_backtrace(backtrace)
+        self.backtrace = Utils.extract_backtrace(backtrace)
       elsif level_index >= SemanticLogger.backtrace_level_index
-        self.backtrace = Utils.cleanse_backtrace
+        self.backtrace = Utils.extract_backtrace
       end
 
       if metric
@@ -149,7 +149,7 @@ module SemanticLogger
         if result.is_a?(String)
           message = message.nil? ? result : "#{message} -- #{result}"
           assign(message: message, payload: payload, exception: exception)
-        elsif message.nil? && result.is_a?(Hash) && [:message, :payload, :exception].any? { |k| result.key? k }
+        elsif message.nil? && result.is_a?(Hash) && %i[message payload exception].any? { |k| result.key? k }
           assign(result)
         elsif payload&.respond_to?(:merge)
           assign(message: message, payload: payload.merge(result), exception: exception)
@@ -295,9 +295,9 @@ module SemanticLogger
       (self.context ||= {})[key] = value
     end
 
-    # A metric only event has a metric but no message, exception, or payload.
+    # A metric only event has a metric but no message or exception.
     def metric_only?
-      metric && message.nil? && exception.nil? && payload.nil?
+      metric && message.nil? && exception.nil?
     end
   end
 end

data/lib/semantic_logger/metric/new_relic.rb

@@ -37,16 +37,9 @@ module SemanticLogger
       #     regular expression. All other messages will be ignored.
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
-      def initialize(prefix: 'Custom',
-                     level: nil,
-                     formatter: nil,
-                     filter: nil,
-                     application: nil,
-                     host: nil,
-                     &block)
-
+      def initialize(prefix: 'Custom', **args, &block)
         @prefix = prefix
-        super(level: level, formatter: formatter, filter: filter, application: application, host: host, &block)
+        super(**args, &block)
       end
 
       # Returns metric name to use.

data/lib/semantic_logger/metric/signalfx.rb

@@ -76,28 +76,13 @@ module SemanticLogger
       def initialize(token:,
                      dimensions: nil,
                      url: 'https://ingest.signalfx.com',
-                     open_timeout: 2.0,
-                     read_timeout: 1.0,
-                     continue_timeout: 1.0,
-                     filter: nil,
-                     application: nil,
-                     host: nil,
                      formatter: nil,
+                     **args,
                      &block)
 
         formatter ||= SemanticLogger::Formatters::Signalfx.new(token: token, dimensions: dimensions)
 
-        super(
-          url:              url,
-          read_timeout:     read_timeout,
-          open_timeout:     open_timeout,
-          continue_timeout: continue_timeout,
-          filter:           filter,
-          application:      application,
-          host:             host,
-          formatter:        formatter,
-          &block
-        )
+        super(url: url, formatter: formatter, **args, &block)
 
         @header['X-SF-TOKEN'] = token
         @full_url             = "#{url}/#{END_POINT}"

data/lib/semantic_logger/subscriber.rb

@@ -5,7 +5,7 @@ module SemanticLogger
   class Subscriber < SemanticLogger::Base
     # Every appender has its own formatter
     attr_reader :formatter
-    attr_writer :application, :host, :logger
+    attr_writer :application, :host, :logger, :metrics
 
     # Returns the current log level if set, otherwise it logs everything it receives.
     def level
@@ -59,7 +59,7 @@ module SemanticLogger
 
     # Whether this log entry meets the criteria to be logged by this appender.
     def should_log?(log)
-      super(log) && !log.metric_only?
+      super(log) && (log.metric_only? ? metrics? : true)
     end
 
     private
@@ -88,10 +88,15 @@ module SemanticLogger
     #   host: [String]
     #     Name of this host to appear in log messages.
     #     Default: SemanticLogger.host
-    def initialize(level: nil, formatter: nil, filter: nil, application: nil, host: nil, &block)
+    #
+    #   metrics: [Boolean]
+    #     Whether to log metric only entries with this subscriber.
+    #     Default: false
+    def initialize(level: nil, formatter: nil, filter: nil, application: nil, host: nil, metrics: false, &block)
       self.formatter = block || formatter
       @application   = application
       @host          = host
+      @metrics       = metrics
 
       # Subscribers don't take a class name, so use this class name if a subscriber
       # is logged to directly.
@@ -104,5 +109,10 @@ module SemanticLogger
     def level_index
       @level_index || 0
     end
+
+    # Whether to log metric only entries with this subscriber
+    def metrics?
+      @metrics
+    end
   end
 end

data/lib/semantic_logger/utils.rb

@@ -1,4 +1,6 @@
 module SemanticLogger
+  # Internal-use only utility functions for Semantic Logger.
+  # Not intended for public use.
   module Utils
     def self.constantize_symbol(symbol, namespace = 'SemanticLogger::Appender')
       klass = "#{namespace}::#{camelize(symbol.to_s)}"
@@ -37,11 +39,26 @@ module SemanticLogger
     SELF_PATTERN = File.join('lib', 'semantic_logger')
 
     # Extract the backtrace leaving out the last few Semantic Logger lines.
-    def self.cleanse_backtrace(stack = caller)
+    def self.extract_backtrace(stack = caller)
       while (first = stack.first) && first.include?(SELF_PATTERN)
         stack.shift
       end
       stack
     end
+
+    # Strips off all gems and built-in ruby code paths from the top of the stack until application code is found.
+    def self.strip_backtrace(stack = caller)
+      while (first = stack.first) && system_path?(first)
+        stack.shift
+      end
+      stack
+    end
+
+    GEM_ROOT = File.expand_path('../../..', __dir__) + '/'
+
+    def self.system_path?(path)
+      path.start_with?(GEM_ROOT) ||
+        path.start_with?(RbConfig::CONFIG['rubylibdir'])
+    end
   end
 end

data/lib/semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module SemanticLogger
-  VERSION = '4.2.2'.freeze
+  VERSION = '4.3.0'.freeze
 end

data/test/appender/bugsnag_test.rb

@@ -66,6 +66,15 @@ module Appender
             assert_equal @message, hash[:message], hash
           end
         end
+
+        it 'does not send metric only notifications' do
+          exception = hash = nil
+          Bugsnag.stub(:notify, ->(exc, h) { exception = exc; hash = h }) do
+            @appender.debug metric: 'my/custom/metric', payload: {hello: :world}
+          end
+          assert_nil exception
+          assert_nil hash
+        end
       end
     end
   end

data/test/appender/file_test.rb

@@ -64,6 +64,16 @@ module Appender
           @appender.debug exc
           assert_match(/\d+-\d+-\d+ \d+:\d+:\d+.\d+ D \[\d+:#{@thread_name}\] SemanticLogger::Appender::File -- Exception: StandardError: StandardError\n\n/, @io.string)
         end
+
+        it 'ignores metric only messages' do
+          @appender.debug metric: 'my/custom/metric'
+          assert_equal '', @io.string
+        end
+
+        it 'ignores metric only messages with payload' do
+          @appender.debug metric: 'my/custom/metric', payload: {hello: :world}
+          assert_equal '', @io.string
+        end
       end
 
       describe 'for each log level' do

data/test/appender/new_relic_test.rb

@@ -66,6 +66,15 @@ module Appender
         assert payload = params[:payload], params
         assert_equal 4, payload[:key3], payload
       end
+
+      it 'does not send metric only notifications' do
+        exception = hash = nil
+        NewRelic::Agent.stub(:notice_error, ->(exc, h) { exception = exc; hash = h }) do
+          @appender.debug metric: 'my/custom/metric', payload: {hello: :world}
+        end
+        assert_nil exception
+        assert_nil hash
+      end
     end
   end
 end

data/test/logger_test.rb

@@ -89,10 +89,10 @@ class LoggerTest < Minitest::Test
           end
 
           it 'logs payload from block' do
-            logger.send(level) { { 'test_key1' => 'hello world', 'test_key2' => payload} }
+            logger.send(level) { {'test_key1' => 'hello world', 'test_key2' => payload} }
 
             assert log = log_message
-            assert_equal log.payload, { 'test_key1' => 'hello world', 'test_key2' => payload }
+            assert_equal log.payload, 'test_key1' => 'hello world', 'test_key2' => payload
           end
 
           it 'logs payload only' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.2.2
+  version: 4.3.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-11 00:00:00.000000000 Z
+date: 2018-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -140,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Feature rich logging framework, and replacement for existing Ruby & Rails