klogger-logger 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 721caa676f9ec6ff59d0faa7823f40b63c9ca1fbcde1ac017e19c0f809000574
+  data.tar.gz: '0686ea87fa8f6f86a79b599ed11009061608adcf2884069381fad7f4b6a69d4e'
+SHA512:
+  metadata.gz: 594e56869cb217f308d49e1d5ab5a6669b6c69cb617e64f853a357fd8a30b8d2fc88803157cf54bb7ee9e12641ab2264fab364d7e57f5814c712bbdeb8238805
+  data.tar.gz: 737f6c90d84067dbb1f6697f5f3c6466c83ebc5d1dd3054481b4397bf40737705b4a345d9901fb923768e28374615c0c428f113beb113d3d56785edcedd4de5c

data/lib/klogger/colors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Klogger
+  module Colors
+
+    COLORS = {
+      info: 75,
+      warn: 220,
+      debug: 252,
+      error: 203,
+      fatal: 203,
+      white: 255,
+      gray: 243
+    }.freeze
+
+    class << self
+
+      def colorize(text, color)
+        color = COLORS[color]
+        "\e[38;5;#{color}m#{text}\e[0m"
+      end
+
+    end
+
+  end
+end

data/lib/klogger/formatters/abstract.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Klogger
+  class Abstract
+
+    def initialize(highlight: false)
+      @highlight = highlight
+    end
+
+    def call(_severity, _time, _progname, _payload)
+      'no formatter'
+    end
+
+  end
+end

data/lib/klogger/formatters/go.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'klogger/formatters/abstract'
+require 'klogger/colors'
+
+module Klogger
+  module Formatters
+    class Go < Abstract
+
+      EXCLUDE_FROM_TAGS = [:time, :severity, :message].freeze
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def call(_severity, time, _progname, payload)
+        string = String.new
+        string << time.strftime('%Y-%m-%d %H:%M:%S %z')
+        string << ' '
+        string << colorize(payload[:severity].ljust(8, ' ').upcase, payload[:severity].to_sym)
+        if payload[:message]
+          string << colorize(payload[:message], :white)
+          string << ' '
+        end
+        payload.each do |key, value|
+          next if EXCLUDE_FROM_TAGS.include?(key)
+
+          string << colorize("#{key}=", :gray)
+          string << colorize(sanitize_value(value), :white)
+          string << ' '
+        end
+        string + "\n"
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def colorize(text, color)
+        return text unless @highlight
+
+        Colors.colorize(text, color)
+      end
+
+      def sanitize_value(value)
+        value.to_s.gsub("\n", '\\\\n')
+      end
+
+    end
+  end
+end

data/lib/klogger/formatters/json.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'klogger/formatters/abstract'
+require 'klogger/json_highlighter'
+
+module Klogger
+  module Formatters
+    class JSON < Abstract
+
+      def call(_severity, _time, _progname, payload)
+        json = payload.to_json
+        if @highlight
+          json.gsub!('","', '", "')
+          json.gsub!(/\A{/, '{ ')
+          json.gsub!(/\}\z/, ' }')
+          json = JSONHighlighter.highlight(json)
+        end
+        json + "\n"
+      end
+
+    end
+  end
+end

data/lib/klogger/formatters/simple.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'klogger/formatters/abstract'
+
+module Klogger
+  module Formatters
+    class Simple < Abstract
+
+      def call(_severity, _time, _progname, payload)
+        string = String.new
+        payload.each do |key, value|
+          string << ' ' if string.length.positive?
+          string << "#{colorize(key.to_s + ':', payload[:severity].to_sym)} #{sanitize_value(value)}"
+        end
+        string + "\n"
+      end
+
+      private
+
+      def colorize(text, color)
+        return text unless @highlight
+
+        Colors.colorize(text, color)
+      end
+
+      def sanitize_value(value)
+        value.to_s.gsub("\n", '\\\\n')
+      end
+
+    end
+  end
+end

data/lib/klogger/json_highlighter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'rouge'
+
+# This class is responsible for receiving log data and sending it to an underlying
+module Klogger
+  class JSONHighlighter
+
+    class Theme < Rouge::CSSTheme
+
+      style Text, fg: '#ffffff'
+      style Literal::String,
+            Literal::Number, fg: '#35AEFF'
+      style Punctuation, fg: '#888888'
+
+    end
+
+    class ErrorTheme < Theme
+
+      style Literal::String,
+            Literal::Number, fg: '#FF355D'
+
+    end
+
+    class WarnTheme < Theme
+
+      style Literal::String,
+            Literal::Number, fg: '#FFD700'
+
+    end
+
+    class DebugTheme < Theme
+
+      style Text, fg: '#999999'
+      style Literal::String,
+            Literal::Number, fg: '#cccccc'
+
+    end
+
+    LEXER = Rouge::Lexers::JSON.new
+    FORMATTER = Rouge::Formatters::Terminal256
+    FORMATTERS = {
+      info: FORMATTER.new(Theme.new),
+      debug: FORMATTER.new(DebugTheme.new),
+      warn: FORMATTER.new(WarnTheme.new),
+      error: FORMATTER.new(ErrorTheme.new),
+      fatal: FORMATTER.new(ErrorTheme.new)
+    }.freeze
+
+    class << self
+
+      def highlight(output)
+        severity = ::Regexp.last_match(1).to_sym if output.match(/"severity":"(\w+)"/)
+        formatter = FORMATTERS[severity] || FORMATTERS[:info]
+        formatter.format(LEXER.lex(output))
+      end
+
+    end
+
+  end
+end

data/lib/klogger/logger.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'klogger/formatters/json'
+require 'klogger/formatters/simple'
+require 'klogger/formatters/go'
+
+module Klogger
+  class Logger < ::Logger
+
+    attr_reader :name
+    attr_reader :destinations
+    attr_reader :extra
+
+    LEVELS = [:debug, :info, :warn, :error, :fatal].freeze
+    FORMATTERS = {
+      json: Formatters::JSON,
+      simple: Formatters::Simple,
+      go: Formatters::Go
+    }.freeze
+
+    def initialize(name, destination: $stdout, formatter: :json, highlight: false, extra: {})
+      @name = name
+      @extra = extra
+      @destinations = []
+
+      super(destination)
+      self.formatter = FORMATTERS[formatter].new(highlight: highlight)
+    end
+
+    def exception(exception, message = nil, **additional)
+      error({ message: message,
+              exception: exception.class.name,
+              exception_message: exception.message,
+              backtrace: exception.backtrace[0, 4].join("\n") }.merge(additional))
+    end
+
+    LEVELS.each do |level|
+      define_method(level) do |message = nil, progname = nil, **additional, &block|
+        add(Logger.const_get(level.to_s.upcase), message, progname, **additional, &block)
+      end
+    end
+
+    def group(**additional)
+      groups << additional
+      yield
+    ensure
+      groups.pop
+    end
+
+    def silence!
+      @silence = true
+      yield if block_given?
+    ensure
+      unsilence! if block_given?
+    end
+
+    def unsilence!
+      @silence = false
+      yield if block_given?
+    ensure
+      silence! if block_given?
+    end
+
+    def silenced?
+      @silence == true
+    end
+
+    def add_destination(destination)
+      @destinations << destination
+    end
+
+    def remove_destination(destination)
+      @destinations.delete(destination)
+    end
+
+    private
+
+    def groups
+      @groups ||= []
+    end
+
+    def add(severity, message = nil, progname = nil, **extra, &block)
+      return if silenced?
+
+      severity ||= Logger::UNKNOWN
+      return if severity < level
+
+      payload = create_payload(severity, message, extra)
+
+      @destinations.each do |destination|
+        destination.call(self, payload.dup)
+      rescue StandardError => e
+        # If something goes wrong in here, we don't want to break the application
+        # so we will rescue that and we'll just use standard warn.
+        Kernel.warn "Error while sending payload to destination (#{e.class}): #{e.message}"
+      end
+
+      super(severity, payload, progname, &block)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def create_payload(severity, message, extra)
+      payload = { time: Time.now.to_s, severity: LEVELS[severity]&.to_s, logger: @name }
+      payload.merge!(@extra)
+
+      if message.is_a?(Hash)
+        payload.merge!(message)
+      elsif message
+        payload[:message] = message
+      end
+
+      payload.merge!(extra)
+      payload.delete(:message) if payload[:message].nil?
+      payload.compact!
+
+      groups.each { |group| payload.merge!(group) }
+      payload
+    end
+    # rubocop:enable Metrics/AbcSize
+
+  end
+end

data/lib/klogger/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Klogger
+
+  VERSION_FILE_ROOT = File.expand_path('../../VERSION', __dir__)
+  if File.file?(VERSION_FILE_ROOT)
+    VERSION = File.read(VERSION_FILE_ROOT).strip.sub(/\Av/, '')
+  else
+    VERSION = '0.0.0.dev'
+  end
+
+end

data/lib/klogger-logger.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'klogger'

data/lib/klogger.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'klogger/logger'
+
+module Klogger
+
+  def self.new(*args, **kwargs)
+    Logger.new(*args, **kwargs)
+  end
+
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: klogger-logger
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.30'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.30'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: A simple Ruby logger
+email:
+- adam@krystal.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/klogger-logger.rb
+- lib/klogger.rb
+- lib/klogger/colors.rb
+- lib/klogger/formatters/abstract.rb
+- lib/klogger/formatters/go.rb
+- lib/klogger/formatters/json.rb
+- lib/klogger/formatters/simple.rb
+- lib/klogger/json_highlighter.rb
+- lib/klogger/logger.rb
+- lib/klogger/version.rb
+homepage: https://github.com/krystal/klogger
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key: 
+specification_version: 4
+summary: A simple Ruby logger
+test_files: []