class SemanticLogger::Subscriber

def application

Allow application name to be set globally or on a per subscriber basis. 
def application
  @application || SemanticLogger.application
end

def close

A subscriber should implement close if it can. 
def close
  # NOOP
end

def console_output?

Whether this appender is logging to stdout or stderror 
def console_output?
  false
end

def default_formatter

Returns [SemanticLogger::Formatters::Default] default formatter for this subscriber. 
def default_formatter
  SemanticLogger::Formatters::Default.new
end

def environment

Allow environment name to be set globally or on a per subscriber basis. 
def environment
  @environment || SemanticLogger.environment
end

def flush

A subscriber should implement flush if it can. 
def flush
  # NOOP
end

def formatter=(formatter)

Set the formatter from Symbol|Hash|Block 
def formatter=(formatter)
  @formatter =
    if formatter.nil?
      respond_to?(:call) ? self : default_formatter
    else
      Formatters.factory(formatter)
    end
end

def host

Allow host name to be set globally or on a per subscriber basis. 
def host
  @host || SemanticLogger.host
end

def initialize(level: nil, formatter: nil, filter: nil, application: nil, environment: nil, host: nil,

Default: false
Whether to log metric only entries with this subscriber.
metrics: [Boolean]

Default: SemanticLogger.host
Name of this host to appear in log messages.
host: [String]

Default: SemanticLogger.application
Name of this application to appear in log messages.
application: [String]

The Proc must return true or false.
Proc: Only include log messages where the supplied Proc returns true
regular expression. All other messages will be ignored.
RegExp: Only include log messages where the class name matches the supplied.
filter: [Regexp|Proc]

Default: Use the built-in formatter (See: #call)
the output from this subscriber
An instance of a class that implements #call, or a Proc to be used to format
formatter: [Object|Proc]

Override the log level for this subscriber.
level: [:trace | :debug | :info | :warn | :error | :fatal]
Parameters

Initializer for Abstract Class SemanticLogger::Subscriber 
def initialize(level: nil, formatter: nil, filter: nil, application: nil, environment: nil, host: nil,
               metrics: false, &block)
  self.formatter = block || formatter
  @application   = application
  @environment   = environment
  @host          = host
  @metrics       = metrics
  # Subscribers don't take a class name, so use this class name if a subscriber
  # is logged to directly.
  super(self.class, level, filter)
end

def level

Returns the current log level if set, otherwise it logs everything it receives. 
def level
  @level || :trace
end

def level_index

set for this instance.
Returns the lowest level index if the level has not been explicitly
Return the level index for fast comparisons. 
def level_index
  @level_index || 0
end

def log(log)

Method called to log an event 
def log(log)
  raise NotImplementedError
end

def logger

For example trace messages sent to services or errors when something fails.
Give each appender its own logger for logging. 
def logger
  @logger ||=
    begin
      logger      = SemanticLogger::Processor.logger.clone
      logger.name = self.class.name
      logger
    end
end

def metrics?

Whether to log metric only entries with this subscriber 
def metrics?
  @metrics
end

def should_log?(log)

Whether this log entry meets the criteria to be logged by this appender. 
def should_log?(log)
  super && (log.metric_only? ? metrics? : true)
end