semantic_logger 5.0.0 → 5.2.0

data/lib/semantic_logger/appender/file.rb

@@ -10,6 +10,15 @@ module SemanticLogger
                     :reopen_period, :reopen_count, :reopen_size, :permissions
       attr_reader :log_count, :log_size, :current_file_name, :reopen_at
 
+      # With permissions, the log file is opened without following a symbolic link, so that a link
+      # planted in the log directory can neither create nor open the file it points at, without
+      # blocking, so that a planted FIFO fails to open instead of waiting for a reader, and without
+      # becoming the controlling terminal.
+      SECURE_OPEN_FLAGS = ::File::NOFOLLOW | ::File::NONBLOCK | ::File::NOCTTY
+      # Seconds to wait before opening a refused log file again.
+      REFUSED_RETRY_INTERVAL = 5
+      private_constant :SECURE_OPEN_FLAGS, :REFUSED_RETRY_INTERVAL
+
       # Create an appender to log to a named file.
       #
       # Parameters
@@ -77,7 +86,12 @@ module SemanticLogger
       #     Octal file permissions to apply to the log file.
       #     Log files frequently contain sensitive information, so restrict access
       #     by supplying for example `0o640` (owner read/write, group read).
-      #     Applied both when the file is created and to an existing log file.
+      #     Applied both when the file is created and to an existing log file, which must be
+      #     a regular file owned by the process, with a single hard link, that the file_name
+      #     names directly rather than through a symbolic link. Nothing is written to any
+      #     other file, or when the file cannot be opened: the appender raises IOError when it
+      #     is created, and when the file is later reopened, it reports why and writes nothing
+      #     until the file is fixed, trying again every few seconds.
       #     Default: nil (use the process umask, the standard Ruby behavior)
       #
       #   :retry_count [Integer]
@@ -150,43 +164,37 @@ module SemanticLogger
         @reopen_at      = nil
 
         super(**args, &)
+
+        # Open the file at creation time so that misconfiguration (bad directory,
+        # insufficient permissions, ...) raises immediately in SemanticLogger.add_appender,
+        # instead of surfacing later on the appender thread via the internal logger. With
+        # permissions, a refused log file raises IOError (see #open_with_permissions).
+        raise(IOError, refusal_message, cause: @refusal_cause) unless reopen
       end
 
       # After forking an active process call #reopen to re-open
       # open the file handles etc to resources.
       def reopen
-        begin
-          @file&.close
-        rescue StandardError
-          nil
-        end
+        close_quietly(@file)
 
         self.current_file_name = apply_format_directives(file_name)
-        if ::File.directory?(file_name)
+        # With permissions, a directory is refused when it fails to open, like any other file.
+        if !permissions && ::File.directory?(current_file_name)
           raise(ArgumentError, "The supplied log file_name: #{current_file_name} is already a directory.")
         end
 
         self.log_count = 0
-        if append && reopen_size && ::File.exist?(current_file_name)
-          self.log_size = ::File.size(current_file_name)
-          self.log_size = 0 if log_size >= reopen_size
-        else
-          self.log_size = 0
-        end
+        # File.size? rather than File.size, since the file can be removed at any time.
+        size = ::File.size?(current_file_name) if append && reopen_size
+        self.log_size = size && size < reopen_size ? size : 0
 
         self.reopen_at = reopen_period ? next_reopen_period(reopen_period) : nil
 
         options = ::File::WRONLY | ::File::CREAT
         options |= ::File::APPEND if append
-        @file =
-          if permissions
-            ::File.open(current_file_name, options, permissions)
-          else
-            ::File.open(current_file_name, options)
-          end
-        # File.open only applies the permissions when creating the file, so also
-        # enforce them on an already existing log file.
-        @file.chmod(permissions) if permissions
+        @file = permissions ? open_with_permissions(options) : ::File.open(current_file_name, options)
+        return unless @file
+
         # Force all log entries to write immediately without buffering
         # Allows multiple processes to write to the same log file simultaneously
         @file.sync = true
@@ -198,18 +206,23 @@ module SemanticLogger
       # Since only one appender thread will be writing to the file at a time
       # it is not necessary to protect access to the file with a semaphore.
       def log(log)
-        reopen if time_to_reopen?
+        # Read once, since #reopen can be called from another thread meanwhile.
+        file = time_to_reopen? ? reopen : @file
+        return refused unless file
 
-        count = 0
+        # Formatted once, outside the retry below: reopening the file cannot fix the content.
+        message = format_log(log) << "\n"
+        count   = 0
         begin
-          message = formatter.call(log, self) << "\n"
-          @file.write(message)
+          file.write(message)
           @log_count += 1
           @log_size  += message.size
         rescue StandardError => e
           if count < retry_count
             count += 1
-            reopen
+            file = reopen
+            return refused unless file
+
             retry
           end
           raise(e)
@@ -223,18 +236,118 @@ module SemanticLogger
         @file&.flush
       end
 
+      # See Subscriber#inspect.
+      def inspect_details
+        "file_name=#{file_name.inspect}"
+      end
+
       private
 
       attr_writer :log_count, :log_size, :current_file_name, :reopen_at
 
+      # Opens the log file and applies the permissions to it, when it is safe to do so (see
+      # #permissions_refusal). Returns the open file, or nil after closing it and recording why it is
+      # refused, so that nothing is written to it.
+      #
+      # Changing the permissions of a file that another name links to could loosen them on an
+      # unrelated file, such as a private key linked into a shared log directory. Writing log messages
+      # to a file that this process does not own, or that another name links to, would let whoever
+      # controls it read them, despite the permissions asked for. So with permissions, the appender
+      # fails closed: it raises when it is created (see #initialize), and when the file is later
+      # reopened, on a rotation, a fork, or a write retry, it stops writing and reports why (see
+      # #refused) until the file is fixed (see #refused_retry_due?).
+      def open_with_permissions(options)
+        file   = ::File.open(current_file_name, options | SECURE_OPEN_FLAGS, permissions)
+        reason = permissions_refusal(file)
+        if reason
+          close_quietly(file)
+          return refuse(reason)
+        end
+
+        file.chmod(permissions)
+        @refusal = @refusal_cause = @reported_refusal = nil
+        file
+      rescue SystemCallError => e
+        close_quietly(file)
+        refuse(open_refusal(e), e)
+      end
+
+      # Records why the log file is refused, and returns nil.
+      def refuse(reason, cause = nil)
+        @refusal          = reason
+        @refusal_cause    = cause
+        @refused_retry_at = monotonic_time + REFUSED_RETRY_INTERVAL
+        nil
+      end
+
+      # Reports why log messages are not being written to the log file, once for each file and
+      # reason, and returns false.
+      def refused
+        refusal = [current_file_name, @refusal]
+        unless @reported_refusal == refusal
+          @reported_refusal = refusal
+          logger.error(refusal_message)
+        end
+        false
+      end
+
+      def refusal_message
+        "Not writing to the log file #{current_file_name}: #{@refusal}"
+      end
+
+      # Returns why the log file could not be opened with permissions.
+      def open_refusal(error)
+        return "it is a symbolic link" if error.is_a?(Errno::ELOOP) && ::File.symlink?(current_file_name)
+
+        "it could not be opened (#{error.message})"
+      end
+
+      # Returns why the permissions must not be applied to the open log file, nor log messages
+      # written to it, or nil when they can.
+      #
+      # It must be a regular file owned by this process, with a single hard link, since a hard link
+      # planted in the log directory is otherwise indistinguishable from the file it links to. The
+      # path must also still name it, so that swapping the path after opening cannot redirect the
+      # log messages.
+      def permissions_refusal(file)
+        stat      = file.stat
+        path_stat = ::File.lstat(current_file_name)
+        return "it is not a regular file" unless stat.file?
+        return "it is not owned by this process" unless stat.uid == ::Process.euid
+        return "it has more than one hard link" unless stat.nlink == 1
+        return "it changed after it was opened" unless path_stat.dev == stat.dev && path_stat.ino == stat.ino
+
+        nil
+      rescue SystemCallError => e
+        "it could not be checked (#{e.message})"
+      end
+
+      def close_quietly(file)
+        file&.close
+      rescue StandardError
+        nil
+      end
+
+      def monotonic_time
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
+
       def time_to_reopen?
-        return true unless @file
+        return refused_retry_due? unless @file
 
         (reopen_count.positive? && (log_count >= reopen_count)) ||
           (reopen_size.positive? && (log_size >= reopen_size)) ||
           (reopen_at && (Time.now > reopen_at))
       end
 
+      # A refused log file is opened again every few seconds, and at the next scheduled reopen,
+      # rather than for every message.
+      def refused_retry_due?
+        return true unless @refused_retry_at
+
+        monotonic_time >= @refused_retry_at || (reopen_at && Time.now > reopen_at)
+      end
+
       def apply_format_directives(file_name)
         return file_name unless file_name.include?("%")
 

data/lib/semantic_logger/appender/graylog.rb

@@ -100,7 +100,7 @@ module SemanticLogger
 
       # Re-open after process fork
       def reopen
-        uri       = URI.parse(@url)
+        uri       = Utils.parse_url(@url)
         @server   = uri.host
         @port     = uri.port
         @protocol = uri.scheme.to_sym
@@ -120,10 +120,10 @@ module SemanticLogger
       def call(log, logger)
         h = default_formatter.call(log, logger)
 
-        h[:short_message] = h.delete(:message)
-        if h[:short_message].nil?
-          h[:short_message] = log.exception.nil? ? "<no-exception-message>" : log.exception.message
-        end
+        # GELF rejects an empty short_message, such as a message of only ANSI escape codes.
+        h[:short_message] = h.delete(:message).to_s
+        h[:short_message] = log.exception.message.to_s.strip if h[:short_message].empty? && log.exception
+        h[:short_message] = "<no-exception-message>" if h[:short_message].empty?
         h[:level]        = logger.level_map[log.level]
         h[:level_str]    = log.level.to_s
         h[:duration_str] = h.delete(:duration)
@@ -131,11 +131,27 @@ module SemanticLogger
       end
 
       # Forward log messages
+      #
+      # GELF serializes the Hash with #to_json, which raises for Infinity, NaN, invalid UTF-8, or a
+      # structure nested too deeply, and writes a Struct through its #inspect, so such a Hash is
+      # handed over as a copy that JSON can represent (see Utils.json_ready).
       def log(log)
-        notifier.notify!(formatter.call(log, self))
+        notifier.notify!(format_log(log) { |hash| Utils.json_ready(hash) })
         true
       end
 
+      # GELF raises ArgumentError for a log message it cannot send, such as one too large to fit in
+      # the maximum number of chunks, which retrying cannot send either. Unavailable servers raise
+      # network errors instead.
+      def message_error?(exception)
+        exception.is_a?(ArgumentError) || super
+      end
+
+      # The url without any credentials. See Subscriber#inspect.
+      def inspect_details
+        "url=#{Utils.redacted_url(url).inspect}"
+      end
+
       private
 
       def default_formatter

data/lib/semantic_logger/appender/honeybadger.rb

@@ -43,7 +43,7 @@ module SemanticLogger
 
       # Send an error notification to honeybadger
       def log(log)
-        context = formatter.call(log, self)
+        context = format_log(log)
         if log.exception
           context.delete(:exception)
           ::Honeybadger.notify(log.exception, context)

data/lib/semantic_logger/appender/honeybadger_insights.rb

@@ -43,7 +43,7 @@ module SemanticLogger
 
       # Send log to honeybadger events API
       def log(log)
-        event = formatter.call(log, self).merge(event_type: "log")
+        event = format_log(log).merge(event_type: "log")
 
         ::Honeybadger.event(event)
 

data/lib/semantic_logger/appender/http.rb

@@ -31,7 +31,13 @@ module SemanticLogger
     class Http < SemanticLogger::Subscriber
       attr_accessor :username, :compress, :header,
                     :open_timeout, :read_timeout, :continue_timeout
-      attr_reader :http, :url, :server, :port, :path, :ssl_options, :proxy_url
+      attr_reader :http, :url, :server, :port, :path, :query, :ssl_options, :proxy_url
+
+      # Maximum number of bytes of an error response body to write to the internal logger.
+      MAX_LOGGED_RESPONSE_BODY = 512
+
+      # Describes a valid url in the error raised for an invalid one.
+      URL_FORMAT_HINT = "Should be similar to: 'http://hostname:port/path'".freeze
 
       # Create HTTP(S) log appender
       #
@@ -42,6 +48,9 @@ module SemanticLogger
       #     To enable SSL include https in the URL.
       #       Example: https://example.com/some_path
       #       verify_mode will default: OpenSSL::SSL::VERIFY_PEER
+      #     A query string is kept and sent with every request that submits log data,
+      #     for the log servers that are configured through it.
+      #       Example: http://example.com/some_path?source=my_app
       #
       #   application: [String]
       #     Name of this application to appear in log messages.
@@ -136,11 +145,10 @@ module SemanticLogger
         }.merge(header)
         @header["Content-Encoding"] = "gzip" if @compress
 
-        uri     = URI.parse(@url)
+        uri     = parse_url(@url)
         @server = uri.host
-        unless @server
-          raise(ArgumentError, "Invalid format for :url: #{@url.inspect}. Should be similar to: 'http://hostname:port/path'")
-        end
+        # The url is left out of the message, since it can hold a user and password.
+        raise(ArgumentError, "Invalid format for :url, it has no host. #{URL_FORMAT_HINT}") unless @server
 
         @port     = uri.port
         @username = uri.user if !@username && uri.user
@@ -148,6 +156,11 @@ module SemanticLogger
         @path     = uri.path
         # Path cannot be empty
         @path     = "/" if @path == ""
+        # Query string of the url, applied to every request, see #uri_with_query.
+        # Kept separate from the path, because subclasses build their own request paths
+        # from it. For example Appender::ElasticsearchHttp appends the index name.
+        @query    = uri.query
+        @query    = nil if @query == ""
 
         if uri.scheme == "https"
           @ssl_options[:use_ssl] = true
@@ -157,7 +170,7 @@ module SemanticLogger
           @port ||= HTTP.http_default_port
         end
 
-        @proxy_uri = URI.parse(@proxy_url) if @proxy_url && @proxy_url != :ENV
+        @proxy_uri = Utils.parse_url(@proxy_url, option: ":proxy_url") if @proxy_url && @proxy_url != :ENV
 
         @http = nil
 
@@ -196,7 +209,7 @@ module SemanticLogger
 
       # Forward log messages to HTTP Server
       def log(log)
-        message = formatter.call(log, self)
+        message = format_log(log)
         logger.trace(message)
         post(message)
       end
@@ -204,7 +217,7 @@ module SemanticLogger
       # Forward a batch of log messages to the HTTP Server in a single request.
       # Only used when the appender is created with `batch: true`.
       def batch(logs)
-        message = formatter.batch(logs, self)
+        message = format_batch(logs)
         logger.trace(message)
         post(message)
       end
@@ -216,8 +229,30 @@ module SemanticLogger
         false
       end
 
+      # The whole batch is formatted into a single request before anything is sent.
+      def batch_all_or_nothing?
+        true
+      end
+
+      # Returns [String] the scheme, host, and any non-default port of the url. Safe to log.
+      # See Utils.redacted_url.
+      def redacted_url
+        @redacted_url ||= Utils.redacted_url(url)
+      end
+
+      # Only the redacted url, since the instance variables hold the password, the authorization
+      # headers, and any credential a subclass adds. See Subscriber#inspect.
+      def inspect_details
+        "url=#{redacted_url.inspect}"
+      end
+
       private
 
+      # Returns [URI] the parsed url, without the url in the error raised for an invalid one.
+      def parse_url(url)
+        Utils.parse_url(url, hint: URL_FORMAT_HINT)
+      end
+
       # Use JSON Formatter by default
       def default_formatter
         SemanticLogger::Formatters::Json.new
@@ -233,22 +268,43 @@ module SemanticLogger
 
       # HTTP Post
       def post(body, request_uri = path)
-        request = Net::HTTP::Post.new(request_uri, @header)
+        request = Net::HTTP::Post.new(uri_with_query(request_uri), @header)
         process_request(request, body)
       end
 
       # HTTP Put
       def put(body, request_uri = path)
-        request = Net::HTTP::Put.new(request_uri, @header)
+        request = Net::HTTP::Put.new(uri_with_query(request_uri), @header)
         process_request(request, body)
       end
 
       # HTTP Delete
+      #
+      # The query string of the configured url is _not_ applied here: it configures how
+      # the server ingests log data, and servers reject it on a maintenance request.
+      # Appender::ElasticsearchHttp#delete_all deletes an index, and Elasticsearch fails
+      # the request with a 400 when it carries unrecognized parameters.
       def delete(request_uri = path)
         request = Net::HTTP::Delete.new(request_uri, @header)
         process_request(request)
       end
 
+      # Applies the query string of the configured url, if any, to the uri of a request
+      # that submits log data.
+      #
+      # Kept out of `path` on purpose: subclasses build their own request paths from it
+      # (Appender::ElasticsearchHttp appends the index name and `_doc` to it), and the
+      # query has to stay at the end of the request uri regardless.
+      #
+      # @param request_uri [String] path of the request, `path` by default.
+      # @return [String]
+      def uri_with_query(request_uri)
+        return request_uri unless @query
+
+        separator = request_uri.include?("?") ? "&" : "?"
+        "#{request_uri}#{separator}#{@query}"
+      end
+
       # Process HTTP Request
       def process_request(request, body = nil)
         if body
@@ -260,7 +316,10 @@ module SemanticLogger
           true
         else
           # Failures are logged to the global semantic logger failsafe logger (Usually stderr or file)
-          logger.error("Bad HTTP response from: #{url} code: #{response.code}, #{response.body}")
+          logger.error(
+            "Bad HTTP response from: #{redacted_url} code: #{response.code}, " \
+            "#{response.body.to_s[0, MAX_LOGGED_RESPONSE_BODY].inspect}"
+          )
           false
         end
       rescue RuntimeError => e

data/lib/semantic_logger/appender/io.rb

@@ -50,7 +50,7 @@ module SemanticLogger
         # Since only one appender thread will be writing to the file at a time
         # it is not necessary to protect access to the file with a semaphore
         # Allow this logger to filter out log levels lower than it's own
-        @io.write(formatter.call(log, self) << "\n")
+        @io.write(format_log(log) << "\n")
         true
       end
 

data/lib/semantic_logger/appender/kafka.rb

@@ -23,6 +23,9 @@ require "date"
 module SemanticLogger
   module Appender
     class Kafka < SemanticLogger::Subscriber
+      SEED_BROKERS_HINT = "Each should be similar to: 'hostname:port' or 'kafka://hostname:port'".freeze
+      private_constant :SEED_BROKERS_HINT
+
       attr_accessor :seed_brokers, :client_id, :connect_timeout, :socket_timeout,
                     :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_key, :ssl_ca_certs_from_system,
                     :delivery_threshold, :delivery_interval, :required_acks,
@@ -149,17 +152,22 @@ module SemanticLogger
       end
 
       def reopen
-        @kafka = ::Kafka.new(
-          seed_brokers:             seed_brokers,
-          client_id:                client_id,
-          connect_timeout:          connect_timeout,
-          socket_timeout:           socket_timeout,
-          ssl_ca_cert:              ssl_ca_cert,
-          ssl_client_cert:          ssl_client_cert,
-          ssl_client_cert_key:      ssl_client_cert_key,
-          ssl_ca_certs_from_system: ssl_ca_certs_from_system,
-          logger:                   logger
-        )
+        # ruby-kafka puts the seed broker, which can hold credentials, in the error it raises for an
+        # invalid one: URI::InvalidURIError, or Kafka::Error for an unknown scheme.
+        errors = [URI::InvalidURIError, ::Kafka::Error]
+        @kafka = Utils.without_url_in_errors(option: ":seed_brokers", hint: SEED_BROKERS_HINT, errors: errors) do
+          ::Kafka.new(
+            seed_brokers:             seed_brokers,
+            client_id:                client_id,
+            connect_timeout:          connect_timeout,
+            socket_timeout:           socket_timeout,
+            ssl_ca_cert:              ssl_ca_cert,
+            ssl_client_cert:          ssl_client_cert,
+            ssl_client_cert_key:      ssl_client_cert_key,
+            ssl_ca_certs_from_system: ssl_ca_certs_from_system,
+            logger:                   logger
+          )
+        end
 
         @producer = @kafka.async_producer(
           delivery_threshold: delivery_threshold,
@@ -177,7 +185,7 @@ module SemanticLogger
 
       # Forward log messages to Kafka producer thread.
       def log(log)
-        json = formatter.call(log, self)
+        json = format_log(log)
         @producer.produce(json, topic: topic, partition: partition, partition_key: partition_key, key: key)
       end
 
@@ -195,6 +203,12 @@ module SemanticLogger
         )
       end
 
+      # Only the topic: the seed brokers can hold credentials, and the options hold the TLS private
+      # key and SASL passwords. See Subscriber#inspect.
+      def inspect_details
+        "topic=#{@topic.inspect}"
+      end
+
       private
 
       attr_reader :producer

data/lib/semantic_logger/appender/loki.rb

@@ -33,6 +33,8 @@ module SemanticLogger
       #   url: [String]
       #     Define the loki instance URL.
       #     Example: https://logs-prod-999.grafana.net
+      #     A query string is kept and sent with every request.
+      #     Example: https://logs-prod-999.grafana.net?orgid=my_org
       #     Default: nil
       def initialize(url: nil,
                      formatter: SemanticLogger::Formatters::Loki.new,
@@ -40,18 +42,26 @@ module SemanticLogger
                      path: INGESTION_PATH,
                      **args,
                      &)
-        super(url: "#{url}/#{path}", formatter: formatter, header: header, **args, &)
+        super(url: self.class.ingestion_url(url, path), formatter: formatter, header: header, **args, &)
+      end
+
+      # Appends the ingestion path to the supplied url, keeping any query string at the
+      # end of the url where Appender::Http can parse it out.
+      def self.ingestion_url(url, path)
+        uri      = Utils.parse_url(url.to_s)
+        uri.path = "#{uri.path.chomp('/')}/#{path.delete_prefix('/')}"
+        uri.to_s
       end
 
       def log(log)
-        message = formatter.call(log, self)
+        message = format_log(log)
         logger.trace(message)
         post(message)
       end
 
       # Logs in batches
       def batch(logs)
-        message = formatter.batch(logs, self)
+        message = format_batch(logs)
         logger.trace(message)
         post(message)
       end

data/lib/semantic_logger/appender/mongodb.rb

@@ -164,10 +164,29 @@ module SemanticLogger
       # Log the message to MongoDB
       def log(log)
         # Insert log entry into Mongo
-        collection.insert_one(formatter.call(log, self))
+        collection.insert_one(format_log(log))
         true
       end
 
+      # Errors raised for a document that cannot be stored, which retrying cannot insert either.
+      # BSON raises BSON::Error, ArgumentError (a key with a NUL byte), or RangeError (an Integer too
+      # large for 64 bits) while the document is serialized, before anything is sent, and the driver
+      # raises Mongo::Error::MaxBSONSize for a document larger than the server accepts.
+      DOCUMENT_ERRORS = [BSON::Error, ArgumentError, RangeError, Mongo::Error::MaxBSONSize].freeze
+
+      # Except BSON::Error::BSONDecodeError, which comes from reading the server's reply rather than
+      # from the document, so it is retried like any other error from the server.
+      def message_error?(exception)
+        return false if exception.is_a?(BSON::Error::BSONDecodeError)
+
+        super || DOCUMENT_ERRORS.any? { |error| exception.is_a?(error) }
+      end
+
+      # Only the collection name: the uri can hold a user and password. See Subscriber#inspect.
+      def inspect_details
+        "collection=#{@collection_name.inspect}"
+      end
+
       private
 
       def default_formatter

data/lib/semantic_logger/appender/new_relic.rb

@@ -33,6 +33,12 @@ module SemanticLogger
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
       def initialize(level: :error, **args, &block)
+        Kernel.warn(
+          "SemanticLogger::Appender::NewRelic (appender: :new_relic) is deprecated and will be removed in v6. " \
+          "It reports errors via newrelic_rpm and is superseded by the log-forwarding appender " \
+          "appender: :new_relic_logs.",
+          category: :deprecated
+        )
         super
       end
 
@@ -58,7 +64,7 @@ module SemanticLogger
         # For more documentation on the NewRelic::Agent.notice_error method see:
         # http://rubydoc.info/github/newrelic/rpm/NewRelic/Agent#notice_error-instance_method
         # and https://docs.newrelic.com/docs/ruby/ruby-agent-api
-        ::NewRelic::Agent.notice_error(exception, formatter.call(log, self))
+        ::NewRelic::Agent.notice_error(exception, format_log(log))
         true
       end
     end