ougai 1.7.1-java

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'yard'
+require 'yard/rake/yardoc_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+FILES = ['lib/**/*.rb']
+OPTIONS = ['--debug', '--verbose']
+
+YARD::Rake::YardocTask.new do |t|
+  t.files   = FILES
+  t.options = []
+  t.options << OPTIONS if $trace
+end

data/lib/ougai.rb

@@ -0,0 +1,11 @@
+require 'logger'
+require 'ougai/version'
+require 'ougai/logging'
+require 'ougai/formatters/base'
+require 'ougai/formatters/for_json'
+require 'ougai/formatters/bunyan'
+require 'ougai/formatters/readable'
+require 'ougai/formatters/pino'
+require 'ougai/serializer'
+require 'ougai/child_logger'
+require 'ougai/logger'

data/lib/ougai/child_logger.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Ougai
+  # A logger created by the `child` method of parent logger
+  class ChildLogger
+    include Logging
+
+    # @private
+    def initialize(parent, fields)
+      @before_log = nil
+      @parent = parent
+      @with_fields = fields
+    end
+
+    def level
+      @parent.level
+    end
+
+    # Whether the current severity level allows for logging DEBUG.
+    # @return [Boolean] true if allows
+    def debug?
+      @parent.debug?
+    end
+
+    # Whether the current severity level allows for logging INFO.
+    # @return [Boolean] true if allows
+    def info?
+      @parent.info?
+    end
+
+    # Whether the current severity level allows for logging WARN.
+    # @return [Boolean] true if allows
+    def warn?
+      @parent.warn?
+    end
+
+    # Whether the current severity level allows for logging ERROR.
+    # @return [Boolean] true if allows
+    def error?
+      @parent.error?
+    end
+
+    # Whether the current severity level allows for logging FATAL.
+    # @return [Boolean] true if allows
+    def fatal?
+      @parent.fatal?
+    end
+
+    # @private
+    def chain(severity, args, fields, hooks)
+      hooks.push(@before_log) if @before_log
+      @parent.chain(severity, args, weak_merge!(fields, @with_fields), hooks)
+    end
+
+    protected
+
+    def append(severity, args)
+      hooks = @before_log ? [@before_log] : []
+      @parent.chain(severity, args, @with_fields.dup, hooks)
+    end
+  end
+end

data/lib/ougai/formatters/base.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'socket'
+
+module Ougai
+  module Formatters
+    # Base formatter
+    # Custom formatter must override `_call`.
+    # @attr [Fixnum] trace_indent Specify exception backtrace indent (by default this is 2).
+    # @attr [Fixnum] trace_max_lines Keep exception backtrace lines (by default this is 100).
+    # @attr [Boolean] serialize_backtrace Whether exception should converts String (by default this is on).
+    class Base < Logger::Formatter
+      attr_accessor :trace_indent, :trace_max_lines
+      attr_accessor :serialize_backtrace
+      attr_reader :app_name, :hostname
+
+      # Intialize a formatter
+      # @param [String] app_name application name
+      # @param [String] hostname hostname
+      # @param [Hash] opts the initial values of attributes
+      # @option opts [String] :trace_indent (2) the value of trace_indent attribute
+      # @option opts [String] :trace_max_lines (100) the value of trace_max_lines attribute
+      # @option opts [String] :serialize_backtrace (true) the value of serialize_backtrace attribute
+      def initialize(app_name = nil, hostname = nil, opts = {})
+        @app_name = app_name || File.basename($0, ".rb")
+        @hostname = hostname || Socket.gethostname.force_encoding('UTF-8')
+        @trace_indent = opts.fetch(:trace_indent, 2)
+        @trace_max_lines = opts.fetch(:trace_max_lines, 100)
+        @serialize_backtrace = opts.fetch(:serialize_backtrace, true)
+        self.datetime_format = nil
+      end
+
+      def call(severity, time, progname, data)
+        _call(severity, time, progname, data.is_a?(Hash) ? data : { msg: data.to_s })
+      end
+
+      def _call(severity, time, progname, data)
+        raise NotImplementedError, "_call must be implemented"
+      end
+
+      def datetime_format=(value)
+        @datetime_format = value || default_datetime_format
+      end
+
+      def serialize_exc(ex)
+        err = {
+          name: ex.class.name,
+          message: ex.to_s
+        }
+        if ex.backtrace
+          bt = ex.backtrace.slice(0, @trace_max_lines)
+          err[:stack] = @serialize_backtrace ? serialize_trace(bt) : bt
+        end
+        err
+      end
+
+      def serialize_trace(trace)
+        sp = "\n" + ' ' * @trace_indent
+        trace.join(sp)
+      end
+
+      private
+
+      def format_datetime(time)
+        time.strftime(@datetime_format)
+      end
+
+      def default_datetime_format
+        "%FT%T.%3N#{(Time.new.utc? ? 'Z' : '%:z')}"
+      end
+
+      def self.parse_new_params(args)
+        idx = args.index {|i| i.is_a?(Hash) }
+        return args if idx == 2
+        opts = args[idx]
+        app_name = opts.delete(:app_name)
+        hostname = opts.delete(:hostname)
+        app_name ||= args[0] if idx > 0
+        [app_name, hostname, opts]
+      end
+    end
+  end
+end

data/lib/ougai/formatters/bunyan.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ougai/formatters/base'
+
+module Ougai
+  module Formatters
+    # A JSON formatter compatible with node-bunyan
+    class Bunyan < Base
+      include ForJson
+
+      # Intialize a formatter
+      # @param [String] app_name application name (execution program name if nil)
+      # @param [String] hostname hostname (hostname if nil)
+      # @param [Hash] opts the initial values of attributes
+      # @option opts [String] :trace_indent (2) the value of trace_indent attribute
+      # @option opts [String] :trace_max_lines (100) the value of trace_max_lines attribute
+      # @option opts [String] :serialize_backtrace (true) the value of serialize_backtrace attribute
+      # @option opts [String] :jsonize (true) the value of jsonize attribute
+      # @option opts [String] :with_newline (true) the value of with_newline attribute
+      def initialize(app_name = nil, hostname = nil, opts = {})
+        aname, hname, opts = Base.parse_new_params([app_name, hostname, opts])
+        super(aname, hname, opts)
+        init_opts_for_json(opts)
+      end
+
+      def _call(severity, time, progname, data)
+        dump({
+          name: progname || @app_name,
+          hostname: @hostname,
+          pid: $$,
+          level: to_level(severity),
+          time: time,
+          v: 0
+        }.merge(data))
+      end
+
+      def convert_time(data)
+        data[:time] = format_datetime(data[:time])
+      end
+    end
+  end
+end

data/lib/ougai/formatters/for_json.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Ougai
+  # The features for JSON formatter
+  # @attr [Boolean] jsonize Whether log should converts JSON
+  # @attr [Boolean] with_newline Whether tailing NL should be appended
+  module Formatters::ForJson
+    attr_accessor :jsonize, :with_newline
+
+    protected
+
+    def init_opts_for_json(opts)
+      @jsonize = opts.fetch(:jsonize, true)
+      @with_newline = opts.fetch(:with_newline, true)
+      @serializer = Ougai::Serializer.for_json
+    end
+
+    def to_level(severity)
+      case severity
+      when 'TRACE'
+        10
+      when 'DEBUG'
+        20
+      when 'INFO'
+        30
+      when 'WARN'
+        40
+      when 'ERROR'
+        50
+      when 'FATAL'
+        60
+      else
+        70
+      end
+    end
+
+    # requires convert_time(data) method
+    def dump(data)
+      return data unless @jsonize
+      convert_time(data)
+      str = @serializer.serialize(data)
+      str << "\n" if @with_newline
+      str
+    end
+  end
+end

data/lib/ougai/formatters/pino.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'ougai/formatters/base'
+
+module Ougai
+  module Formatters
+    # A JSON formatter compatible with pino
+    class Pino < Base
+      include ForJson
+
+      # Intialize a formatter
+      # @param [String] app_name application name (execution program name if nil)
+      # @param [String] hostname hostname (hostname if nil)
+      # @param [Hash] opts the initial values of attributes
+      # @option opts [String] :trace_indent (4) the value of trace_indent attribute
+      # @option opts [String] :trace_max_lines (100) the value of trace_max_lines attribute
+      # @option opts [String] :serialize_backtrace (true) the value of serialize_backtrace attribute
+      # @option opts [String] :jsonize (true) the value of jsonize attribute
+      # @option opts [String] :with_newline (true) the value of with_newline attribute
+      def initialize(app_name = nil, hostname = nil, opts = {})
+        aname, hname, opts = Base.parse_new_params([app_name, hostname, opts])
+        super(aname, hname, opts)
+        init_opts_for_json(opts)
+        @trace_indent = opts.fetch(:trace_indent, 4)
+        @serialize_backtrace = true
+      end
+
+      def datetime_format=(val)
+        raise NotImplementedError, 'Not support datetime_format attribute' unless val.nil?
+      end
+
+      def _call(severity, time, progname, data)
+        flat_err(data)
+        dump({
+          name: progname || @app_name,
+          hostname: @hostname,
+          pid: $$,
+          level: to_level(severity),
+          time: time,
+          v: 1
+        }.merge(data))
+      end
+
+      def flat_err(data)
+        return unless data.key?(:err)
+        err = data.delete(:err)
+        msg = err[:message]
+        data[:type] ||= 'Error'
+        data[:msg] ||= msg
+        stack = "#{err[:name]}: #{msg}"
+        stack += "\n" + (" " * @trace_indent) + err[:stack] if err.key?(:stack)
+        data[:stack] ||= stack
+      end
+
+      def convert_time(data)
+        data[:time] = (data[:time].to_f * 1000).to_i
+      end
+    end
+  end
+end

data/lib/ougai/formatters/readable.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'ougai/formatters/base'
+
+module Ougai
+  module Formatters
+    # A human readble formatter with awesome_print
+    # @attr [Boolean] plain Whether log should be plain not colorized.
+    # @attr [Array<String, Symbol>] excluded_fields The fields excluded from all logs
+    class Readable < Base
+      attr_accessor :plain, :excluded_fields
+
+      # Intialize a formatter
+      # @param [String] app_name application name (execution program name if nil)
+      # @param [String] hostname hostname (hostname if nil)
+      # @param [Hash] opts the initial values of attributes
+      # @option opts [String] :trace_indent (4) the value of trace_indent attribute
+      # @option opts [String] :trace_max_lines (100) the value of trace_max_lines attribute
+      # @option opts [String] :plain (false) the value of plain attribute
+      # @option opts [String] :excluded_fields ([]) the value of excluded_fields attribute
+      def initialize(app_name = nil, hostname = nil, opts = {})
+        aname, hname, opts = Base.parse_new_params([app_name, hostname, opts])
+        super(aname, hname, opts)
+        @trace_indent = opts.fetch(:trace_indent, 4)
+        @plain = opts.fetch(:plain, false)
+        @excluded_fields = opts[:excluded_fields] || []
+        @serialize_backtrace = true
+        load_dependent
+      end
+
+      def _call(severity, time, progname, data)
+        msg = data.delete(:msg)
+        level = @plain ? severity : colored_level(severity)
+        dt = format_datetime(time)
+        err_str = create_err_str(data)
+
+        @excluded_fields.each { |f| data.delete(f) }
+        data_str = create_data_str(data)
+        format_log_parts(dt, level, msg, err_str, data_str)
+      end
+
+      def serialize_backtrace=(value)
+        raise NotImplementedError, 'Not support serialize_backtrace'
+      end
+
+      protected
+
+      def format_log_parts(datetime, level, msg, err, data)
+        strs = ["[#{datetime}] #{level}: #{msg}"]
+        strs.push(err) if err
+        strs.push(data) if data
+        strs.join("\n") + "\n"
+      end
+
+      def colored_level(severity)
+        case severity
+        when 'TRACE'
+          color = '0;34'
+        when 'DEBUG'
+          color = '0;37'
+        when 'INFO'
+          color = '0;36'
+        when 'WARN'
+          color = '0;33'
+        when 'ERROR'
+          color = '0;31'
+        when 'FATAL'
+          color = '0;35'
+        else
+          color = '0;32'
+        end
+        "\e[#{color}m#{severity}\e[0m"
+      end
+
+      def create_err_str(data)
+        return nil unless data.key?(:err)
+        err = data.delete(:err)
+        err_str = "  #{err[:name]} (#{err[:message]}):"
+        err_str += "\n" + (" " * @trace_indent) + err[:stack] if err.key?(:stack)
+        err_str
+      end
+
+      def create_data_str(data)
+        return nil if data.empty?
+        data.ai({ plain: @plain })
+      end
+
+      def load_dependent
+        require 'awesome_print'
+      rescue LoadError
+        puts 'You must install the awesome_print gem to use this output.'
+        raise
+      end
+    end
+  end
+end

data/lib/ougai/logger.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Ougai
+  # Main Logger
+  # @attr [String] default_message Use this if log message is not specified (by default this is 'No message').
+  # @attr [String] exc_key The field name of Exception (by default this is :err).
+  # @attr [Hash] with_fields The fields appending to all logs.
+  # @attr [Proc] before_log Hook before logging.
+  class Logger < ::Logger
+    include Logging
+
+    attr_accessor :default_message, :exc_key
+
+    def initialize(*args)
+      super(*args)
+      @before_log = nil
+      @default_message = 'No message'
+      @exc_key = :err
+      @with_fields = {}
+      @formatter = create_formatter
+    end
+
+    # Broadcasts the same logs to the another logger
+    # @param logger [Logger] The logger receiving broadcast logs.
+    def self.broadcast(logger)
+      Module.new do |mdl|
+        Logger::Severity.constants.each do |severity|
+          method_name = severity.downcase.to_sym
+
+          mdl.send(:define_method, method_name) do |*args|
+            logger.send(method_name, *args)
+            super(*args)
+          end
+        end
+
+        define_method(:level=) do |level|
+          logger.level = level
+          super(level)
+        end
+
+        define_method(:close) do
+          logger.close
+          super()
+        end
+      end
+    end
+
+    def level=(severity)
+      if severity.is_a?(Integer)
+        @level = severity
+        return
+      end
+
+      if severity.to_s.downcase == 'trace'
+        @level = TRACE
+        return
+      end
+
+      super
+    end
+
+    # @private
+    def chain(severity, args, fields, hooks)
+      hooks.push(@before_log) if @before_log
+      write(severity, args, weak_merge!(fields, @with_fields), hooks)
+    end
+
+    protected
+
+    # @private
+    def append(severity, args)
+      hooks = @before_log ? [@before_log] : []
+      write(severity, args, @with_fields, hooks)
+    end
+
+    def create_formatter
+      Formatters::Bunyan.new
+    end
+
+    private
+
+    def format_severity(severity)
+      to_label(severity)
+    end
+
+    def write(severity, args, fields, hooks)
+      data = weak_merge!(to_item(args), fields)
+      hooks.each do |hook|
+        return false if hook.call(data) == false
+      end
+      add(severity, data)
+    end
+
+    def to_item(args)
+      msg, ex, data = args
+
+      if msg.nil?
+        { msg: @default_message }
+      elsif ex.nil?
+        create_item_with_1arg(msg)
+      elsif data.nil?
+        create_item_with_2args(msg, ex)
+      else
+        create_item_with_3args(msg, ex, data)
+      end
+    end
+
+    def create_item_with_1arg(arg)
+      item = {}
+      if arg.is_a?(Exception)
+        item[:msg] = arg.to_s
+        set_exc(item, arg)
+      elsif arg.is_a?(String)
+        item[:msg] = arg
+      else
+        item.merge!(as_hash(arg))
+        item[:msg] ||= @default_message
+      end
+      item
+    end
+
+    def create_item_with_2args(arg1, arg2)
+      item = {}
+      if arg2.is_a?(Exception) # msg, ex
+        item[:msg] = arg1.to_s
+        set_exc(item, arg2)
+      elsif arg1.is_a?(Exception) # ex, data
+        set_exc(item, arg1)
+        item.merge!(as_hash(arg2))
+        item[:msg] ||= arg1.to_s
+      else # msg, data
+        item[:msg] = arg1.to_s
+        item.merge!(as_hash(arg2))
+      end
+      item
+    end
+
+    def create_item_with_3args(msg, ex, data)
+      {}.tap do |item|
+        set_exc(item, ex) if ex.is_a?(Exception)
+        item.merge!(as_hash(data))
+        item[:msg] = msg.to_s
+      end
+    end
+
+    def set_exc(item, exc)
+      item[@exc_key] = @formatter.serialize_exc(exc)
+    end
+
+    def as_hash(data)
+      if data.is_a?(Hash) || data.respond_to?(:to_hash)
+        data
+      else
+        { data: data }
+      end
+    end
+  end
+end