Class: Kiev::Logger

Inherits:

Object

• Object
• Kiev::Logger

Extended by:

Forwardable

Defined in:

lib/kiev/logger.rb

Constant Summary

DEFAULT_LOG_NAME =

"log"

DEFAULT_MESSAGE =

"log"

LOG_ERROR =

"ERROR"

ERROR_STATUS =

500

FORMATTER =

proc do |severity, time, log_name, data|
  entry =
    {
      application: Config.instance.app,
      log_name: log_name || DEFAULT_LOG_NAME,
      level: severity,
      timestamp: time.utc,
      message: log_name || DEFAULT_MESSAGE,
      tracking_id: RequestStore.store[:tracking_id],
      request_id: RequestStore.store[:request_id],
      request_depth: RequestStore.store[:request_depth],
      tree_path: RequestStore.store[:tree_path]
    }

  # data required to restore source of log entry
  if RequestStore.store[:web]
    entry[:verb] = RequestStore.store[:request_verb]
    entry[:path] = RequestStore.store[:request_path]
  end
  if RequestStore.store[:background_job]
    entry[:job_name] = RequestStore.store[:job_name]
    entry[:jid] = RequestStore.store[:jid]
  end

  if !RequestStore.store[:subrequest_count] && %i(request_finished job_finished).include?(log_name)
    entry[:tree_leaf] = true
  end

  if RequestStore.store[:payload]
    if %i(request_finished job_finished).include?(log_name)
      entry.merge!(RequestStore.store[:payload])
    else
      Config.instance.persistent_log_fields.each do |field|
        entry[field] = RequestStore.store[:payload][field]
      end
    end
  end

  if data.is_a?(Hash)
    entry.merge!(data)
  elsif !data.nil?
    entry[:message] = data.to_s
    entry[:status] = ERROR_STATUS if data.to_s.downcase.include?(LOG_ERROR)
  end

  entry[:level] = LOG_ERROR if entry[:status].to_i.between?(400, 599)

  # Save some disk space
  entry.reject! { |_, value| value.nil? }

  JSON.logstash(entry)
end

DEVELOPMENT_FORMATTER =

proc do |severity, time, log_name, data|
  entry = []

  entry << time.iso8601
  entry << (log_name || severity).upcase

  if data.is_a?(String)
    entry << "#{data}\n"
  end

  if %i(request_finished job_finished).include?(log_name)
    verb = RequestStore.store[:request_verb]
    path = RequestStore.store[:request_path]
    entry << "#{verb} #{path}" if verb && path

    job_name = RequestStore.store[:job_name]
    jid = RequestStore.store[:jid]
    entry << "#{job_name} #{jid}" if job_name && jid

    status = data.is_a?(Hash) ? data.delete(:status) : nil
    entry << "- #{status}" if status
    duration = data.is_a?(Hash) ? data.delete(:request_duration) : nil
    entry << "(#{duration}ms)" if duration
    entry << "\n"

    meta = RequestStore.store.slice(:trakcing_id, :request_id, :request_depth)
                       .reverse_merge!(Hash(RequestStore.store[:payload]))

    meta.reject! { |_, value| value.nil? }

    entry << "  Meta: #{meta.inspect}\n"

    entry << "  Params: #{data[:params].inspect}\n" if data.is_a?(Hash) && data[:params]

    if data.is_a?(Hash) && data[:body]
      entry << "  Response: #{data[:body]}\n"
    end
  end

  entry.join(" ")
end

Instance Method Summary

• #initialize(log_path) ⇒ Logger constructor

  A new instance of Logger.

• #path=(log_path) ⇒ Object

Constructor Details

#initialize(log_path) ⇒ Logger

Returns a new instance of Logger.

# File 'lib/kiev/logger.rb', line 115

def initialize(log_path)
  @logger = ::Logger.new(log_path)
end

Instance Method Details

#path=(log_path) ⇒ Object

# File 'lib/kiev/logger.rb', line 119

def path=(log_path)
  previous_logger = @logger
  @logger = ::Logger.new(log_path)
  if previous_logger
    @logger.level = previous_logger.level
    @logger.formatter = previous_logger.formatter
  end
end