Module: Cogger

Extended by:

Registry

Defined in:

lib/cogger.rb,
lib/cogger/hub.rb,
lib/cogger/tag.rb,
lib/cogger/entry.rb,
lib/cogger/level.rb,
lib/cogger/program.rb,
lib/cogger/registry.rb,
lib/cogger/time/span.rb,
lib/cogger/time/unit.rb,
lib/cogger/time/clock.rb,
lib/cogger/time/range.rb,
lib/cogger/rack/logger.rb,
lib/cogger/configuration.rb,
lib/cogger/formatters/json.rb,
lib/cogger/formatters/color.rb,
lib/cogger/formatters/crash.rb,
lib/cogger/formatters/emoji.rb,
lib/cogger/formatters/simple.rb,
lib/cogger/formatters/kit/colorizer.rb,
lib/cogger/formatters/kit/sanitizer.rb,
lib/cogger/formatters/parsers/dynamic.rb,
lib/cogger/formatters/processors/color.rb,
lib/cogger/formatters/parsers/universal.rb,
lib/cogger/formatters/parsers/individual.rb

Overview

Provides a function for computing the default program name based on current file.

Defined Under Namespace

Modules: Formatters, Rack, Registry, Time Classes: Hub

Constant Summary

LEVELS =

%w[debug info warn error fatal unknown].freeze

Tag =

Models a tag which may consist of an array and/or hash.

Data.define :singles, :pairs do
  using Refinements::Hash

  def self.for(*bag)
    bag.each.with_object new do |item, tag|
      value = item.is_a?(Proc) ? item.call : item
      value.is_a?(Hash) ? tag.pairs.merge!(value) : tag.singles.append(value)
    end
  end

  def initialize singles: [], pairs: {}
    super
  end

  def empty? = singles.empty? && pairs.empty?

  def to_h = empty? ? Core::EMPTY_HASH : {tags: singles.to_a, **pairs}.tap(&:compress!)

  def to_s = empty? ? Core::EMPTY_STRING : "#{format_singles} #{format_pairs}".tap(&:strip!)

  private

  def format_singles
    singles.map { |value| "[#{value}]" }
           .join " "
  end

  def format_pairs
    pairs.map { |key, value| "[#{key}=#{value}]" }
         .join(" ")
  end
end

Entry =

Defines a log entry which can be formatted for output.

Data.define :id, :level, :at, :message, :tags, :payload do
  def self.for(message = nil, **payload)
    new id: payload.delete(:id) || Program.call,
        level: (payload.delete(:level) || "INFO").upcase,
        at: payload.delete(:at) || ::Time.now,
        message: (block_given? ? yield : message),
        tags: Array(payload.delete(:tags)),
        payload:
  end

  def self.for_crash message, error, id:
    new id:,
        level: "FATAL",
        message:,
        payload: {
          error_message: error.message,
          error_class: error.class,
          backtrace: error.backtrace
        }
  end

  def initialize id: Program.call,
                 level: "INFO",
                 at: ::Time.now,
                 message: nil,
                 tags: [],
                 payload: Core::EMPTY_HASH
    super
  end

  def attributes = {id:, level:, at:, message:, **payload}

  def tagged_attributes tagger: Tag
    computed_tags = tagger.for(*tags)

    return attributes if computed_tags.empty?

    {id:, level:, at:, message:, **computed_tags.to_h, **payload}
  end

  def tagged tagger: Tag
    attributes.tap do |pairs|
      computed_tags = tagger.for(*tags)
      pairs[:message] = "#{computed_tags} #{pairs[:message]}" unless computed_tags.empty?
    end
  end
end

Level =

lambda do |logger = Logger, environment: ENV, allowed: LEVELS|
  value = String environment.fetch("LOG_LEVEL", "INFO")

  return logger.const_get value.upcase if allowed.include? value.downcase

  fail ArgumentError, %(Invalid log level: #{value.inspect}. Use: #{allowed.to_usage "or"}.)
end

Program =

lambda do |name = $PROGRAM_NAME|
  Pathname(name).then { |path| path.basename(path.extname).to_s }
end

Configuration =

Defines the default configuration for all pipes.

Data.define(
  :id,
  :io,
  :level,
  :formatter,
  :tags,
  :mode,
  :age,
  :size,
  :suffix,
  :entry,
  :logger
) do
  def initialize id: Program.call,
                 io: $stdout,
                 level: Level.call,
                 formatter: Formatters::Emoji.new,
                 tags: Core::EMPTY_ARRAY,
                 mode: false,
                 age: 0,
                 size: 1_048_576,
                 suffix: "%Y-%m-%d",
                 entry: Entry,
                 logger: Logger
    super
  end

  def to_logger
    logger.new io,
               age,
               size,
               progname: id,
               level:,
               formatter:,
               binmode: mode,
               shift_period_suffix: suffix
  end

  def inspect
    "#<#{self.class} @id=#{id}, @io=#{io.class}, @level=#{level}, " \
    "@formatter=#{formatter.class}, @tags=#{tags.inspect}, " \
    "@mode=#{mode}, @age=#{age}, @size=#{size}, @suffix=#{suffix.inspect}, " \
    "@entry=#{entry}, @logger=#{logger}>"
  end
end

Class Method Summary

• .loader(registry = Zeitwerk::Registry) ⇒ Object
• .new ⇒ Object

Methods included from Registry

add_alias, add_emoji, add_filter, add_formatter, aliases, color, defaults, emojis, extended, filters, formatters, get_emoji, get_formatter

Class Method Details

.loader(registry = Zeitwerk::Registry) ⇒ Object

# File 'lib/cogger.rb', line 18

def self.loader registry = Zeitwerk::Registry
  @loader ||= registry.loaders.find { |loader| loader.tag == File.basename(__FILE__, ".rb") }
end

.new ⇒ Object

# File 'lib/cogger.rb', line 22

def self.new(...) = Hub.new(...)