module Logged

# File lib/logged.rb, line 146
def components
  config.keys - CONFIG_KEYS
end

# File lib/logged.rb, line 138
def custom_data(conf, event, data)
  return data unless conf.enabled
  return data unless conf.custom_data.respond_to?(:call)

  conf.custom_data.call(event, data)
end

# File lib/logged.rb, line 42
def default_formatter
  config.formatter || (@default_formatter ||= Logged::Formatter::KeyValue.new)
end

# File lib/logged.rb, line 37
def default_level
  config.level || :info
end

# File lib/logged.rb, line 108
def enable_component(component)
  loggers = loggers_for(component)

  return unless loggers.any?

  loggers.each do |logger, options|
    level = options[:level] || config[component].level || default_level

    logger.level = level_to_const(level) if logger.respond_to?(:'level=')
  end

  # only attach subscribers with loggers
  @subscribers[component].each do |subscriber|
    subscriber.attach_to(component)
  end
end

# File lib/logged.rb, line 126
def ignore?(conf, event)
  return false unless event
  return false unless conf.enabled

  return true if !event.is_a?(String) && conf.ignore.is_a?(Array) && conf.ignore.include?(event.name)

  return conf.custom_ignore.call(event) if conf.custom_ignore.respond_to?(:call)

  false
end

# File lib/logged.rb, line 92
def load_logger(name, conf)
  return [nil, nil] unless conf.enabled

  options = conf.dup
  options[:name] = name

  logger = options.delete(:logger)

  logger = Rails.logger if logger == :rails

  return [nil, nil] unless logger

  [logger, options]
end

# File lib/logged.rb, line 47
def logger_by_component(component)
  return nil unless config.enabled

  key = "component_#{component}"

  return @component_loggers[key] if @component_loggers.key?(key)

  loggers = loggers_for(component)

  if loggers.blank?
    @component_loggers[key] = nil

    return nil
  end

  formatter = config[component].formatter || default_formatter

  @component_loggers[key] = Logger.new(loggers, component, formatter)
end

# File lib/logged.rb, line 69
def loggers_for(component)
  loggers_from_config(config)
    .merge(loggers_from_config(config[component]))
end

# File lib/logged.rb, line 75
def loggers_from_config(conf)
  loggers = {}

  return loggers unless conf.enabled

  conf.loggers.each do |name, c|
    logger, options = load_logger(name, c)

    next unless logger && options

    loggers[logger] = options
  end

  loggers
end

# File lib/logged.rb, line 151
def request_env
  Thread.current[:logged_request_env]
end

# File lib/logged.rb, line 27
def setup(app)
  self.app    = app
  self.config = app.config.logged

  app.config.middleware.insert_after ::Rails::Rack::Logger, Logged::Rack::Logger

  setup_components
end

# File lib/logged.rb, line 167
def init
  @subscribers       ||= Hash.new { |hash, key| hash[key] = [] }
  @component_loggers   = {}

  require_rails_subscribers
end

# File lib/logged.rb, line 157
def setup_components
  components.each do |component|
    remove_rails_subscriber(component) if config[component].disable_rails_logging

    next unless config[component].enabled

    enable_component(component)
  end
end