semantic_logger 4.18.0 → 5.1.0

data/lib/semantic_logger/base.rb

@@ -155,8 +155,6 @@ module SemanticLogger
           log.named_tags  = (thread[:semantic_logger_named_tags] || {}).clone
           thread.backtrace
         end
-      # TODO: Keep backtrace instead of transforming into a text message at this point
-      # Maybe log_backtrace: true
       if backtrace
         message += "\n"
         message << backtrace.join("\n")
@@ -198,7 +196,18 @@ module SemanticLogger
     #   to:
     #     `logger.tagged('first', 'more', 'other')`
     # - For better performance with clean tags, see `SemanticLogger.tagged`.
+    #
+    # Child logger:
+    # - When called *without* a block, returns a new logger instance that permanently
+    #   carries the supplied tags ("instance tags"). Those tags are added to every log
+    #   entry emitted by the returned logger, and _only_ that logger, even across threads.
+    #   Unlike the block form they are not pushed onto the thread, so other loggers are
+    #   unaffected. This is the recommended way to bind a logger to an object's identity:
+    #     logger = SemanticLogger['Cart'].tagged(cart_id: cart.id)
     def tagged(*tags)
+      # No block: build a child logger that carries these tags on every entry.
+      return tagged_child(tags) unless block_given?
+
       block = -> { yield(self) }
       # Allow named tags to be passed into the logger
       # Rails::Rack::Logger passes logs as an array with a single argument
@@ -226,6 +235,10 @@ module SemanticLogger
       SemanticLogger.named_tags
     end
 
+    # Tags permanently bound to this logger instance via `#tagged` (without a block).
+    # Empty for a regular (non-child) logger.
+    attr_reader :instance_tags, :instance_named_tags
+
     # Returns the list of tags pushed after flattening them out and removing blanks
     #
     # Note:
@@ -244,13 +257,13 @@ module SemanticLogger
     end
 
     # :nodoc:
-    def silence(new_level = :error, &block)
-      SemanticLogger.silence(new_level, &block)
+    def silence(new_level = :error, &)
+      SemanticLogger.silence(new_level, &)
     end
 
     # :nodoc:
-    def fast_tag(tag, &block)
-      SemanticLogger.fast_tag(tag, &block)
+    def fast_tag(tag, &)
+      SemanticLogger.fast_tag(tag, &)
     end
 
     # Write log data to underlying data storage
@@ -263,6 +276,11 @@ module SemanticLogger
       meets_log_level?(log) && !filtered?(log)
     end
 
+    protected
+
+    # Only assigned to when building a child logger via `#tagged` (see #tagged_child).
+    attr_writer :instance_tags, :instance_named_tags
+
     private
 
     # Initializer for Abstract Class SemanticLogger::Base
@@ -294,8 +312,13 @@ module SemanticLogger
         raise ":filter must be a Regexp, Proc, or implement :call"
       end
 
-      @filter = filter.is_a?(Regexp) ? filter.freeze : filter
-      @name   = klass.is_a?(String) ? klass : klass.name
+      @filter              = filter.is_a?(Regexp) ? filter.freeze : filter
+      @name                = klass.is_a?(String) ? klass : klass.name
+      # `[].freeze` / `{}.freeze` compile to `opt_ary_freeze` / `opt_hash_freeze`, which return
+      # a shared frozen singleton. Every logger points at the same two objects, so these default
+      # (empty) instance tags allocate no garbage. Child loggers replace them via #tagged_child.
+      @instance_tags       = [].freeze
+      @instance_named_tags = {}.freeze
       if level.nil?
         # Allow the global default level to determine this loggers log level
         @level_index = nil
@@ -324,13 +347,59 @@ module SemanticLogger
       (level_index <= (log.level_index || 0))
     end
 
+    # Build a new Log entry, layering this logger's instance tags on top of the
+    # current thread context.
+    def new_log(level, index = nil)
+      apply_instance_tags(Log.new(name, level, index))
+    end
+
+    # Merge this logger's instance tags into the supplied Log entry.
+    #
+    # Composition (mirrors the per-logger merge rule proposed in PR #301):
+    # - Positional: thread tags first, then this logger's instance tags appended.
+    # - Named: instance named tags merged on top of the thread named tags, so on a
+    #   key conflict the logger's own identity wins (it is the more specific value).
+    # Only this logger's entries are affected; the thread context is left untouched.
+    def apply_instance_tags(log)
+      unless @instance_tags.empty?
+        log.tags = log.tags.empty? ? @instance_tags.dup : log.tags + @instance_tags
+      end
+      unless @instance_named_tags.empty?
+        log.named_tags = log.named_tags.empty? ? @instance_named_tags.dup : log.named_tags.merge(@instance_named_tags)
+      end
+      log
+    end
+
+    # Returns a copy of this logger that permanently carries the supplied tags.
+    # Positional (string) and named (Hash) tags may be mixed; they are merged on
+    # top of any instance tags this logger already carries.
+    def tagged_child(tags)
+      positional = @instance_tags.dup
+      named      = @instance_named_tags.dup
+      tags.flatten.each do |tag|
+        case tag
+        when Hash
+          named = named.merge(tag)
+        when nil, ""
+          # Ignore blanks for Rails compatibility, matching the block form.
+        else
+          positional << tag.to_s
+        end
+      end
+
+      child                     = clone
+      child.instance_tags       = positional.freeze
+      child.instance_named_tags = named.freeze
+      child
+    end
+
     # Log message at the specified level
-    def log_internal(level, index, message = nil, payload = nil, exception = nil)
+    def log_internal(level, index, message = nil, payload = nil, exception = nil, &block)
       # Handle variable number of arguments by detecting exception object and payload hash.
       if exception.nil? && payload.nil? && message.respond_to?(:backtrace) && message.respond_to?(:message)
         exception = message
         message   = nil
-      elsif exception.nil? && payload && payload.respond_to?(:backtrace) && payload.respond_to?(:message)
+      elsif exception.nil? && payload.respond_to?(:backtrace) && payload.respond_to?(:message)
         exception = payload
         payload   = nil
       elsif payload && !payload.is_a?(Hash)
@@ -338,12 +407,12 @@ module SemanticLogger
         payload = nil
       end
 
-      log = Log.new(name, level, index)
+      log = new_log(level, index)
       should_log =
         if exception.nil? && payload.nil? && message.is_a?(Hash)
           # All arguments as a hash in the message.
           log.assign(**log.extract_arguments(message))
-        elsif exception.nil? && message && payload && payload.is_a?(Hash)
+        elsif exception.nil? && message && payload.is_a?(Hash)
           # Message supplied along with a hash with the remaining arguments.
           log.assign(**log.extract_arguments(payload, message))
         else
@@ -352,20 +421,28 @@ module SemanticLogger
         end
 
       # Add result of block to message or payload if not nil
-      if block_given?
-        result = yield(log)
-        case result
-        when String
-          log.message = log.message.nil? ? result : "#{log.message} -- #{result}"
-        when Hash
-          log.assign_hash(result)
-        end
-      end
+      apply_block_result(log, &block) if block
 
       # Log level may change during assign due to :on_exception_level
       self.log(log) if should_log && should_log?(log)
     end
 
+    # Merge the result of a logging block into the log entry.
+    #
+    # Zero-arity blocks (e.g. `logger.info { "msg" }` or a zero-arity lambda) are called without
+    # arguments. Lambdas enforce their arity, so yielding the log to a zero-arity lambda would
+    # raise ArgumentError. Blocks that accept an argument still receive the log so they can read
+    # or mutate it.
+    def apply_block_result(log, &block)
+      result = block.arity.zero? ? block.call : block.call(log)
+      case result
+      when String
+        log.message = log.message.nil? ? result : "#{log.message} -- #{result}"
+      when Hash
+        log.assign_hash(result)
+      end
+    end
+
     # Measure the supplied block and log the message
     def measure_internal(level, index, message, params)
       exception = nil
@@ -389,7 +466,7 @@ module SemanticLogger
         exception = e
       ensure
         # Must use ensure block otherwise a `return` in the yield above will skip the log entry
-        log = Log.new(name, level, index)
+        log = new_log(level, index)
         exception ||= params[:exception]
         message   = params[:message] if params[:message]
         duration  =
@@ -437,7 +514,7 @@ module SemanticLogger
       rescue Exception => e
         exception = e
       ensure
-        log = Log.new(name, level, index)
+        log = new_log(level, index)
         # May return false due to elastic logging
         should_log = log.assign(
           message:            message,

data/lib/semantic_logger/concerns/compatibility.rb

@@ -37,11 +37,11 @@ module SemanticLogger
       end
 
       # :nodoc:
-      def add(severity, message = nil, progname = nil, &block)
+      def add(severity, message = nil, progname = nil, &)
         index = Levels.index(severity)
         if level_index <= index
           level = Levels.level(index)
-          log_internal(level, index, message, progname, &block)
+          log_internal(level, index, message, progname, &)
           true
         else
           false

data/lib/semantic_logger/core_ext/process.rb

@@ -0,0 +1,34 @@
+module SemanticLogger
+  module CoreExt
+    # Reopen all appenders in the child process after a fork.
+    #
+    # Prepended onto `Process.singleton_class` when Semantic Logger is loaded.
+    # Enabled by default; opt out with `SemanticLogger.reopen_on_fork = false`.
+    #
+    # `Process._fork` (Ruby 3.1+) is the single method that every fork path routes
+    # through (`Kernel#fork`, `Process.fork`, `IO.popen`, `Kernel#system`, and
+    # backticks), so overriding it covers them all with one hook.
+    #
+    # Note: both `_fork` and `daemon` must be overridden to reliably restart the
+    # appender thread, since `Process.daemon` does not route through `_fork`
+    # (https://bugs.ruby-lang.org/issues/18911). Do not collapse this down to only
+    # `_fork`.
+    module Process
+      # `_fork` runs in both the parent and the child. It returns 0 in the child
+      # and the child's pid in the parent, so only reopen in the child. Reopening
+      # in the parent would needlessly recreate its queue and worker thread,
+      # risking the loss of messages still on the queue.
+      def _fork
+        child_pid = super
+        SemanticLogger.reopen if child_pid.zero? && SemanticLogger.reopen_on_fork?
+        child_pid
+      end
+
+      # `Process.daemon` does not route through `_fork`, so reopen explicitly. Once
+      # it returns, the caller is running as the daemon (child) process.
+      def daemon(...)
+        super.tap { SemanticLogger.reopen if SemanticLogger.reopen_on_fork? }
+      end
+    end
+  end
+end

data/lib/semantic_logger/formatters/base.rb

@@ -2,7 +2,21 @@ require "time"
 module SemanticLogger
   module Formatters
     class Base
-      attr_accessor :log, :logger, :time_format, :log_host, :log_application, :log_environment, :precision
+      attr_accessor :log, :logger, :time_format, :log_host, :log_application, :log_environment, :precision,
+                    :escape_control_chars
+
+      # Printable escapes for the most common control characters. Any other
+      # control character is escaped to its hexadecimal `\xHH` form by
+      # #escape_control_characters.
+      CONTROL_CHAR_ESCAPES = {
+        "\n" => "\\n",
+        "\r" => "\\r",
+        "\t" => "\\t",
+        "\e" => "\\e"
+      }.freeze
+
+      # Matches C0 control characters (including newlines and the ANSI escape) and DEL.
+      CONTROL_CHARS = /[\x00-\x1f\x7f]/
 
       # Time precision varies by Ruby interpreter
       # JRuby 9.1.8.0 supports microseconds
@@ -34,16 +48,27 @@ module SemanticLogger
       #   precision: [Integer]
       #     How many fractional digits to log times with.
       #     Default: PRECISION (6, except on older JRuby, where 3)
+      #   escape_control_chars: [Boolean]
+      #     Replace control characters (newlines, the ANSI escape, etc.) in
+      #     untrusted log data (message, tags, named tags, and exception
+      #     message) with a printable escaped form, e.g. "\n".
+      #     This prevents log forging and terminal escape-sequence injection
+      #     when logging data that may contain attacker-controlled content.
+      #     Note: Has no effect on structured formatters such as :json, which
+      #     already escape control characters via JSON encoding.
+      #     Default: false (preserve newlines and ANSI colors in text output)
       def initialize(time_format: nil,
                      log_host: true,
                      log_application: true,
                      log_environment: true,
-                     precision: PRECISION)
-        @time_format     = time_format || self.class.build_time_format(precision)
-        @log_host        = log_host
-        @log_application = log_application
-        @log_environment = log_environment
-        @precision       = precision
+                     precision: PRECISION,
+                     escape_control_chars: false)
+        @time_format          = time_format || self.class.build_time_format(precision)
+        @log_host             = log_host
+        @log_application      = log_application
+        @log_environment      = log_environment
+        @precision            = precision
+        @escape_control_chars = escape_control_chars
       end
 
       # Return default time format string
@@ -68,6 +93,20 @@ module SemanticLogger
 
       private
 
+      # When `escape_control_chars` is enabled, return a copy of the supplied
+      # value with any control characters replaced by a printable escaped form
+      # so that untrusted log data cannot forge log entries or inject terminal
+      # escape sequences. Otherwise the value is returned unchanged.
+      #
+      # Note: This escapes (preserves) control characters, and is opt-in. It is
+      # distinct from Log#cleansed_message, which unconditionally *strips* ANSI
+      # colorization from the message for structured (JSON/Loki) output.
+      def escape_control_characters(value)
+        return value unless escape_control_chars && value
+
+        value.to_s.gsub(CONTROL_CHARS) { |char| CONTROL_CHAR_ESCAPES[char] || format("\\x%02x", char.ord) }
+      end
+
       # Return the Time as a formatted string
       def format_time(time)
         time = time.dup

data/lib/semantic_logger/formatters/color.rb

@@ -85,7 +85,10 @@ module SemanticLogger
       end
 
       def tags
-        "[#{color}#{log.tags.join("#{color_map.clear}] [#{color}")}#{color_map.clear}]" if log.tags && !log.tags.empty?
+        return if log.tags.nil? || log.tags.empty?
+
+        tags = log.tags.map { |tag| escape_control_characters(tag) }
+        "[#{color}#{tags.join("#{color_map.clear}] [#{color}")}#{color_map.clear}]"
       end
 
       # Named Tags
@@ -94,7 +97,9 @@ module SemanticLogger
         return if named_tags.nil? || named_tags.empty?
 
         list = []
-        named_tags.each_pair { |name, value| list << "#{color}#{name}: #{value}#{color_map.clear}" }
+        named_tags.each_pair do |name, value|
+          list << "#{color}#{escape_control_characters(name)}: #{escape_control_characters(value)}#{color_map.clear}"
+        end
         "{#{list.join(', ')}}"
       end
 
@@ -123,7 +128,8 @@ module SemanticLogger
       def exception
         return unless log.exception
 
-        "-- Exception: #{color}#{log.exception.class}: #{log.exception.message}#{color_map.clear}\n#{log.backtrace_to_s}"
+        "-- Exception: #{color}#{log.exception.class}: " \
+          "#{escape_control_characters(log.exception.message)}#{color_map.clear}\n#{log.backtrace_to_s}"
       end
 
       def call(log, logger)

data/lib/semantic_logger/formatters/default.rb

@@ -32,7 +32,9 @@ module SemanticLogger
 
       # Tags
       def tags
-        "[#{log.tags.join('] [')}]" if log.tags && !log.tags.empty?
+        return if log.tags.nil? || log.tags.empty?
+
+        "[#{log.tags.map { |tag| escape_control_characters(tag) }.join('] [')}]"
       end
 
       # Named Tags
@@ -41,7 +43,9 @@ module SemanticLogger
         return if named_tags.nil? || named_tags.empty?
 
         list = []
-        named_tags.each_pair { |name, value| list << "#{name}: #{value}" }
+        named_tags.each_pair do |name, value|
+          list << "#{escape_control_characters(name)}: #{escape_control_characters(value)}"
+        end
         "{#{list.join(', ')}}"
       end
 
@@ -57,7 +61,7 @@ module SemanticLogger
 
       # Log message
       def message
-        "-- #{log.message}" if log.message
+        "-- #{escape_control_characters(log.message)}" if log.message
       end
 
       # Payload
@@ -70,7 +74,10 @@ module SemanticLogger
 
       # Exception
       def exception
-        "-- Exception: #{log.exception.class}: #{log.exception.message}\n#{log.backtrace_to_s}" if log.exception
+        return unless log.exception
+
+        "-- Exception: #{log.exception.class}: #{escape_control_characters(log.exception.message)}\n" \
+          "#{log.backtrace_to_s}"
       end
 
       # Default text log format

data/lib/semantic_logger/formatters/ecs.rb

@@ -0,0 +1,151 @@
+require "json"
+module SemanticLogger
+  module Formatters
+    # Formatter conforming to the Elastic Common Schema (ECS).
+    #
+    # Emits log events using the nested field names defined by ECS so that they
+    # integrate cleanly with Filebeat and the Elastic stack (Elasticsearch,
+    # Kibana) without requiring an ingest pipeline to rename fields.
+    #
+    # Usage:
+    #   SemanticLogger.add_appender(io: $stdout, formatter: :ecs)
+    #
+    #   # Route the payload, metric, and other SemanticLogger-specific data into
+    #   # a custom top-level namespace (default "semantic_logger"):
+    #   SemanticLogger.add_appender(io: $stdout, formatter: {ecs: {namespace: "my_app"}})
+    #
+    #   # Or merge the payload directly into ECS `labels` instead of a namespace:
+    #   SemanticLogger.add_appender(io: $stdout, formatter: {ecs: {namespace: nil}})
+    #
+    # == Field mapping (SemanticLogger -> ECS 8.x)
+    #   time                  -> @timestamp        (ISO-8601)
+    #   level                 -> log.level
+    #   name                  -> log.logger
+    #   file_name / line      -> log.origin.file.name / log.origin.file.line
+    #   message               -> message
+    #   thread_name           -> process.thread.name
+    #   pid                   -> process.pid
+    #   host                  -> host.hostname
+    #   application           -> service.name
+    #   environment           -> service.environment
+    #   exception             -> error.type / error.message / error.stack_trace
+    #   duration              -> event.duration   (nanoseconds, as required by ECS)
+    #   tags                  -> tags             (ECS top-level array)
+    #   named_tags            -> labels.*         (scalar key/value pairs)
+    #   payload               -> <namespace>.*    (or labels.* when namespace is nil)
+    #   metric/metric_amount  -> <namespace>.metric / <namespace>.metric_amount
+    #
+    # == Reference
+    #   * https://www.elastic.co/docs/reference/ecs
+    #   * https://www.elastic.co/docs/reference/ecs/ecs-custom-fields-in-ecs
+    class Ecs < Raw
+      # ECS version this formatter targets.
+      ECS_VERSION = "8.11.0".freeze
+
+      # namespace: [String|Symbol|nil]
+      #   Top-level field set used to hold SemanticLogger-specific data that has
+      #   no native ECS home (payload, metric, metric_amount). A proper-noun
+      #   namespace is guaranteed never to collide with a current or future ECS
+      #   field. Set to nil to merge the payload into ECS `labels` instead.
+      #   Default: "semantic_logger"
+      attr_reader :namespace
+
+      def initialize(namespace: "semantic_logger", time_format: :iso_8601, time_key: :timestamp, **args)
+        @namespace = namespace&.to_sym
+
+        super(time_format: time_format, time_key: time_key, **args)
+      end
+
+      # Returns the log event as a single line of ECS-formatted JSON, so it can
+      # be written to stdout / a file and shipped by Filebeat or Elastic Agent.
+      def call(log, logger)
+        Utils.to_json(ecs_hash(super))
+      end
+
+      # Returns a batch of log events as a single JSON array.
+      def batch(logs, logger)
+        "[#{logs.map { |log| call(log, logger) }.join(',')}]"
+      end
+
+      private
+
+      # Remap the flat hash built by Raw#call into the nested ECS field layout.
+      def ecs_hash(hash)
+        result = base(hash)
+        result[:process] = process(hash)
+        result[:host]    = {hostname: hash[:host]} if hash[:host]
+        add_service(result, hash)
+        add_origin(result, hash)
+        add_event(result, hash)
+        result[:tags] = hash[:tags] if hash[:tags]
+        add_error(result, hash)
+        add_extras(result, hash)
+        result
+      end
+
+      def base(hash)
+        log = {level: hash[:level].to_s}
+        log[:logger] = hash[:name] if hash[:name]
+        {
+          "@timestamp": hash[:timestamp],
+          message:      hash[:message],
+          ecs:          {version: ECS_VERSION},
+          log:          log
+        }
+      end
+
+      def process(hash)
+        result = {pid: hash[:pid]}
+        result[:thread] = {name: hash[:thread].to_s} if hash[:thread]
+        result
+      end
+
+      def add_service(result, hash)
+        service = {}
+        service[:name]        = hash[:application] if hash[:application]
+        service[:environment] = hash[:environment] if hash[:environment]
+        result[:service] = service unless service.empty?
+      end
+
+      def add_origin(result, hash)
+        return unless hash[:file]
+
+        result[:log][:origin] = {file: {name: hash[:file], line: hash[:line]}.compact}
+      end
+
+      # ECS event.duration is measured in nanoseconds.
+      def add_event(result, hash)
+        return unless hash[:duration_ms]
+
+        result[:event] = {duration: (hash[:duration_ms] * 1_000_000).round}
+      end
+
+      def add_error(result, hash)
+        return unless hash[:exception]
+
+        result[:error] = {
+          type:        hash[:exception][:name],
+          message:     hash[:exception][:message],
+          stack_trace: Array(hash[:exception][:stack_trace]).join("\n")
+        }
+      end
+
+      # Place SemanticLogger-specific data (payload, metric) that has no native
+      # ECS home into the configured namespace, plus named_tags into labels.
+      def add_extras(result, hash)
+        labels = hash[:named_tags].is_a?(Hash) ? hash[:named_tags].dup : {}
+
+        extra = {}
+        extra[:payload]       = hash[:payload] if hash[:payload]
+        extra[:metric]        = hash[:metric] if hash[:metric]
+        extra[:metric_amount] = hash[:metric_amount] if hash[:metric_amount]
+
+        unless extra.empty?
+          namespace ? result[namespace] = extra : labels.merge!(extra)
+        end
+
+        result[:labels] = labels unless labels.empty?
+      end
+    end
+  end
+end

data/lib/semantic_logger/formatters/fluentd.rb

@@ -7,9 +7,9 @@ module SemanticLogger
     class Fluentd < Json
       attr_reader :need_process_info
 
-      def initialize(time_format: :rfc_3339, time_key: :time, need_process_info: false, **args)
+      def initialize(time_format: :rfc_3339, time_key: :time, need_process_info: false, log_host: false, **args)
         @need_process_info = need_process_info
-        super(time_format: time_format, time_key: time_key, **args)
+        super(time_format: time_format, time_key: time_key, log_host: log_host, **args)
       end
 
       def level
@@ -17,8 +17,19 @@ module SemanticLogger
         hash["severity_index"] = log.level_index
       end
 
-      def process_info
-        # Ignore fields: pid, thread, file and line by default
+      # Ignore process fields: pid, thread, file and line by default.
+      # These are rarely useful under Fluentd (e.g. containerized processes
+      # usually have pid 1), so they are only included when explicitly requested
+      # via `need_process_info: true`.
+      def pid
+        super if need_process_info
+      end
+
+      def thread_name
+        super if need_process_info
+      end
+
+      def file_name_and_line
         super if need_process_info
       end
     end

data/lib/semantic_logger/formatters/json.rb

@@ -9,7 +9,12 @@ module SemanticLogger
 
       # Returns log messages in JSON format
       def call(log, logger)
-        super.to_json
+        Utils.to_json(super)
+      end
+
+      # Returns a batch of log messages as a single JSON array.
+      def batch(logs, logger)
+        "[#{logs.map { |log| call(log, logger) }.join(',')}]"
       end
     end
   end

data/lib/semantic_logger/formatters/logfmt.rb

@@ -8,11 +8,13 @@ module SemanticLogger
     #   :timestamp, :level, :name, :message, :duration, :tags, :named_tags
     #
     # E.g.
-    #   timestamp="2020-07-20T08:32:05.375276Z" level=info name="DefaultTest" base="breakfast" spaces="second breakfast" double_quotes="\"elevensies\"" single_quotes="'lunch'" tag="success"
+    #   timestamp="2020-07-20T08:32:05.375276Z" level=info name="DefaultTest" base="breakfast"
+    #   spaces="second breakfast" double_quotes="\"elevensies\"" single_quotes="'lunch'" tag="success"
     #
     # All timestamps are ISO8601 formatteed
     # All user supplied values are escaped and surrounded by double quotes to avoid ambiguious message delimeters
-    # `tags` are treated as keys with boolean values. Tag names are not formatted or validated, ensure you use valid logfmt format for tag names.
+    # `tags` are treated as keys with boolean values. Tag names are not formatted or validated;
+    # ensure you use valid logfmt format for tag names.
     # `named_tags` are flattened are merged into the top level message field. Any conflicting fields are overridden.
     # `payload` values take precedence over `tags` and `named_tags`. Any conflicting fields are overridden.
     #
@@ -64,9 +66,9 @@ module SemanticLogger
         flattened = @parsed.map do |key, value|
           case value
           when Hash, Array
-            "#{key}=#{value.to_s.to_json}"
+            "#{key}=#{Utils.to_json(value.to_s)}"
           else
-            "#{key}=#{value.to_json}"
+            "#{key}=#{Utils.to_json(value)}"
           end
         end