cogger 0.5.1 → 0.7.0

data/lib/cogger/configuration.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Cogger
+  # Defines the default configuration for all pipes.
+  Configuration = Data.define(
+    :id,
+    :io,
+    :level,
+    :formatter,
+    :mode,
+    :age,
+    :size,
+    :suffix,
+    :logger
+  ) do
+    def initialize id: Program.call,
+                   io: $stdout,
+                   level: Logger.const_get(ENV.fetch("LOG_LEVEL", "INFO")),
+                   formatter: Formatters::Color.new,
+                   mode: false,
+                   age: 0,
+                   size: 1_048_576,
+                   suffix: "%Y-%m-%d",
+                   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}, " \
+      "@mode=#{mode}, @age=#{age}, @size=#{size}, @suffix=#{suffix.inspect}, " \
+      "@logger=#{logger}>"
+    end
+  end
+end

data/lib/cogger/formatters/color.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    # Formats by color.
+    class Color
+      TEMPLATE = "%<message:dynamic>s"
+
+      def initialize template = TEMPLATE, processor: Processors::Color.new
+        @template = template
+        @processor = processor
+      end
+
+      def call(*entry)
+        updated_template, attributes = processor.call(template, *entry)
+        "#{format(updated_template, **attributes)}\n"
+      end
+
+      private
+
+      attr_reader :template, :processor
+    end
+  end
+end

data/lib/cogger/formatters/crash.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    # Formats fatal crashes.
+    class Crash
+      TEMPLATE = <<~CONTENT
+        <dynamic>[%<id>s] [%<severity>s] [%<at>s] Crash!
+          %<message>s
+          %<error_message>s (%<error_class>s)
+        %<backtrace>s</dynamic>
+      CONTENT
+
+      def initialize template = TEMPLATE, processor: Processors::Color.new
+        @template = template
+        @processor = processor
+      end
+
+      def call(*entry)
+        updated_template, attributes = processor.call(template, *entry)
+        attributes[:backtrace] = %(  #{attributes[:backtrace].join "\n  "})
+        "#{format(updated_template, **attributes)}\n"
+      end
+
+      private
+
+      attr_reader :template, :processor
+    end
+  end
+end

data/lib/cogger/formatters/json.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Cogger
+  module Formatters
+    # Formats as JSON output.
+    class JSON
+      TEMPLATE = "%<id>s %<severity>s %<at>s %<message>s"
+
+      def initialize template = TEMPLATE,
+                     parser: Parsers::Individual.new,
+                     sanitizer: Kit::Sanitizer.new
+        @template = template
+        @parser = parser
+        @sanitizer = sanitizer
+      end
+
+      def call(*entry)
+        positions = parser.call(template).last.keys
+        attributes = sanitizer.call(*entry)
+        "#{attributes.slice(*positions).merge!(attributes.except(*positions)).to_json}\n"
+      end
+
+      private
+
+      attr_reader :template, :parser, :sanitizer
+    end
+  end
+end

data/lib/cogger/formatters/kit/colorizer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Kit
+      # Transform color based on dynamic (severity) or standard color preference.
+      Colorizer = lambda do |value, attributes|
+        value == "dynamic" ? attributes[:severity].downcase : value
+      end
+    end
+  end
+end

data/lib/cogger/formatters/kit/sanitizer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Kit
+      # Transforms a positional log entry into a hash entry for template parsing and formatting.
+      class Sanitizer
+        def initialize filters: Cogger.filters
+          @filters = filters
+        end
+
+        # :reek:FeatureEnvy
+        def call(*entry)
+          severity, at, id, message = entry
+
+          attributes = if message.is_a? Hash
+                         {id:, severity:, at:, **message.except(:id, :severity, :at)}
+                       else
+                         {id:, severity:, at:, message:}
+                       end
+
+          filter attributes
+        end
+
+        private
+
+        attr_reader :filters
+
+        # :reek:FeatureEnvy
+        def filter attributes
+          filters.each { |key| attributes[key] = "[FILTERED]" if attributes.key? key }
+          attributes
+        end
+      end
+    end
+  end
+end

data/lib/cogger/formatters/parsers/dynamic.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Parsers
+      # Dynamically extracts the universal or individual template attributes for log entry parsing.
+      class Dynamic
+        # Order matters.
+        DELEGATES = [Universal.new, Individual.new].freeze
+
+        def initialize delegates: DELEGATES
+          @delegates = delegates
+        end
+
+        def call(template) = parse(template) || template
+
+        private
+
+        attr_reader :delegates
+
+        def parse template
+          delegates.find do |delegate|
+            result = delegate.call template
+            break result unless result == template
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cogger/formatters/parsers/individual.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Parsers
+      # Sanitizes and extracts individual directives from a template.
+      class Individual
+        # rubocop:todo Lint/MixedRegexpCaptureTypes
+        PATTERN = /
+                    %                                   # Strict reference syntax.
+                    (?<flag>[\s#+-0*])?                 # Optional flag.
+                    (?<width>\d+)?                      # Optional width.
+                    \.?                                 # Optional precision delimiter.
+                    (?<precision>\d+)?                  # Optional precision value.
+                    <                                   # Reference start.
+                    (                                   # Conditional start.
+                    (?<key>\w+)                         # Key.
+                    :                                   # Directive delimiter.
+                    (?<directive>\w+)                   # Value.
+                    |                                   # Conditional.
+                    (?<key>\w+)                         # Key.
+                    )                                   # Conditional end.
+                    >                                   # Reference end.
+                    (?<specifier>[ABEGXabcdefgiopsux])  # Specifier.
+                  /mx
+        # rubocop:enable Lint/MixedRegexpCaptureTypes
+
+        def initialize pattern: PATTERN
+          @pattern = pattern
+        end
+
+        def call template
+          return template unless template.match? pattern
+
+          attributes = {}
+          template = sanitize_and_extract template, attributes
+          [template, attributes]
+        end
+
+        private
+
+        attr_reader :pattern
+
+        # :reek:FeatureEnvy
+        # :reek:TooManyStatements
+        def sanitize_and_extract template, attributes
+          template.dup.gsub pattern do
+            captures = Regexp.last_match.named_captures
+            attributes[captures["key"].to_sym] = captures["directive"]
+
+            captures.reduce(+"%") do |body, (key, value)|
+              next body if key == "directive"
+
+              body.concat key == "key" ? "<#{value}>" : value.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cogger/formatters/parsers/universal.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    module Parsers
+      # Sanitizes and extracts the universal directive a template.
+      class Universal
+        # rubocop:todo Lint/MixedRegexpCaptureTypes
+        PATTERN = %r(
+                    (                  # Conditional start.
+                    \A                 # Search start.
+                    <                  # Tag start.
+                    (?<directive>\w+)  # Directive.
+                    >                  # Tag end.
+                    |                  # Conditional pipe.
+                    <                  # Tag start.
+                    /                  # Tag close.
+                    (?<directive>\w+)  # Directive.
+                    >                  # Tag end.
+                    \Z                 # Search end.
+                    )                  # Conditional end.
+                  )mx
+        # rubocop:enable Lint/MixedRegexpCaptureTypes
+
+        KEY = "directive"
+
+        def initialize pattern: PATTERN, key: KEY
+          @pattern = pattern
+          @key = key
+        end
+
+        def call template
+          return template unless template.match? pattern
+
+          [template.gsub(pattern, ""), template.match(pattern)[key]]
+        end
+
+        private
+
+        attr_reader :pattern, :key
+      end
+    end
+  end
+end

data/lib/cogger/formatters/processors/color.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "tone"
+
+module Cogger
+  module Formatters
+    module Processors
+      # Processes emojis and colors.
+      class Color
+        def initialize parser: Parsers::Dynamic.new,
+                       kit: {sanitizer: Kit::Sanitizer.new, colorizer: Kit::Colorizer},
+                       registry: Cogger
+          @parser = parser
+          @kit = kit
+          @registry = registry
+        end
+
+        def call(template, *entry)
+          attributes = sanitizer.call(*entry)
+
+          case parser.call template
+            in [String => body, String => style] then universal body, style, **attributes
+            in [String => body, Hash => styles] then individual body, attributes, styles
+            else [template, {}]
+          end
+        end
+
+        private
+
+        attr_reader :parser, :kit, :registry
+
+        def universal body, style, **attributes
+          [registry.color[body, colorizer.call(style, attributes)], attributes]
+        end
+
+        def individual body, attributes, styles
+          attributes = attributes.each.with_object({}) do |(key, value), collection|
+            collection[key] = registry.color[value, colorizer.call(styles[key], attributes)]
+          end
+
+          emojify attributes, styles
+          [body, attributes]
+        end
+
+        def emojify attributes, styles
+          style = styles[:emoji]
+
+          return unless style
+
+          attributes[:emoji] = registry.get_emoji colorizer.call(style, attributes)
+        end
+
+        def sanitizer = kit.fetch :sanitizer
+
+        def colorizer = kit.fetch :colorizer
+      end
+    end
+  end
+end

data/lib/cogger/formatters/simple.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Cogger
+  module Formatters
+    # Formats simple templates that require no additional processing.
+    class Simple
+      TEMPLATE = "%<message>s"
+
+      def initialize template = TEMPLATE, sanitizer: Kit::Sanitizer.new
+        @template = template
+        @sanitizer = sanitizer
+      end
+
+      def call(*entry) = "#{format template, sanitizer.call(*entry)}\n"
+
+      private
+
+      attr_reader :template, :sanitizer
+    end
+  end
+end

data/lib/cogger/hub.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Cogger
+  # Loads configuration and simultaneously sends messages to multiple streams.
+  class Hub
+    def initialize(registry: Cogger, model: Configuration.new, **attributes)
+      @registry = registry
+      @configuration = model.with(**transform(attributes))
+      @mutex = Mutex.new
+      @streams = [configuration.to_logger]
+    end
+
+    def add_stream **attributes
+      attributes[:id] = configuration.id
+      streams.append configuration.with(**transform(attributes)).to_logger
+      self
+    end
+
+    def debug(...) = log(__method__, ...)
+
+    def info(...) = log(__method__, ...)
+
+    def warn(...) = log(__method__, ...)
+
+    def error(...) = log(__method__, ...)
+
+    def fatal(...) = log(__method__, ...)
+
+    def unknown(...) = log(__method__, ...)
+
+    alias any unknown
+
+    def inspect
+      %(#<#{self.class} #{configuration.inspect.delete_prefix! "#<Cogger::Configuration "})
+    end
+
+    private
+
+    attr_reader :registry, :configuration, :mutex, :streams
+
+    # :reek:FeatureEnvy
+    # :reek:TooManyStatements
+    def transform attributes
+      value = attributes[:formatter]
+
+      return attributes unless value.is_a?(Symbol) || value.is_a?(String)
+
+      formatter, template = registry.get_formatter value
+      attributes[:formatter] = template ? formatter.new(template) : formatter.new
+      attributes
+    end
+
+    # :reek:TooManyStatements
+    def log(severity, message = nil, &)
+      mutex.synchronize { streams.each { |logger| logger.public_send(severity, message, &) } }
+      true
+    rescue StandardError => error
+      configuration.with(id: "Cogger", io: $stdout, formatter: Formatters::Crash.new)
+                   .to_logger
+                   .fatal message:,
+                          error_message: error.message,
+                          error_class: error.class,
+                          backtrace: error.backtrace
+      true
+    end
+  end
+end

data/lib/cogger/program.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+# Provides a function for computing the default program name based on current file.
+module Cogger
+  Program = lambda do |name = $PROGRAM_NAME|
+    Pathname(name).then { |path| path.basename(path.extname).to_s }
+  end
+end

data/lib/cogger/registry.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "tone"
+
+module Cogger
+  # Provides a global regsitry for global configuration.
+  module Registry
+    def self.extended target
+      target.add_alias(:debug, :white)
+            .add_alias(:info, :green)
+            .add_alias(:warn, :yellow)
+            .add_alias(:error, :red)
+            .add_alias(:fatal, *%i[bold white on_red])
+            .add_alias(:unknown, *%i[bold white])
+            .add_alias(:any, *%i[bold white])
+            .add_emoji(:debug, "🔎")
+            .add_emoji(:info, "🟢")
+            .add_emoji(:warn, "⚠️ ")
+            .add_emoji(:error, "🛑")
+            .add_emoji(:fatal, "🔥")
+            .add_filter(:_csrf)
+            .add_filter(:password)
+            .add_filter(:password_confirmation)
+            .add_formatter(:color, Cogger::Formatters::Color)
+            .add_formatter(
+              :detail,
+              Cogger::Formatters::Simple,
+              "[%<id>s] [%<severity>s] [%<at>s] %<message>s"
+            )
+            .add_formatter(
+              :emoji,
+              Cogger::Formatters::Color,
+              "%<emoji:dynamic>s %<message:dynamic>s"
+            )
+            .add_formatter(:json, Cogger::Formatters::JSON)
+            .add_formatter(:simple, Cogger::Formatters::Simple)
+            .add_formatter :rack,
+                           Cogger::Formatters::Simple,
+                           "[%<id>s] [%<severity>s] [%<at>s] %<verb>s %<status>s %<duration>s " \
+                           "%<ip>s %<path>s %<length>s %<params>s"
+    end
+
+    def add_alias(key, *styles)
+      color.add_alias(key, *styles)
+      self
+    end
+
+    def aliases = color.aliases
+
+    def add_emoji key, value
+      emojis[key.to_sym] = value
+      self
+    end
+
+    def get_emoji(key) = emojis[key.to_sym]
+
+    def emojis = @emojis ||= {}
+
+    def add_filter key
+      filters.add key.to_sym
+      self
+    end
+
+    def filters = @filters ||= Set.new
+
+    def add_formatter key, formatter, template = nil
+      formatters[key.to_sym] = [formatter, template]
+      self
+    end
+
+    def get_formatter(key) = formatters[key.to_sym]
+
+    def formatters = @formatters ||= {}
+
+    def color = @color ||= Tone.new
+
+    def defaults = {emojis: emojis.dup, formatters: formatters.dup}
+  end
+end

data/lib/cogger.rb

@@ -2,8 +2,19 @@
 
 require "zeitwerk"
 
-Zeitwerk::Loader.for_gem.setup
+Zeitwerk::Loader.for_gem.then do |loader|
+  loader.inflector.inflect "json" => "JSON"
+  loader.setup
+end
 
 # Main namespace.
 module Cogger
+  extend Registry
+
+  def self.init(...)
+    warn "#{self}##{__method__} is deprecated, use `.new` instead.", category: :deprecated
+    Client.new(...)
+  end
+
+  def self.new(...) = Hub.new(...)
 end