mlogger 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 97f10839f0123451cded5029fccd41450b3a6fcc
+  data.tar.gz: 1ca522b5e1fb344790afa3ea9fe83858051cc55e
+SHA512:
+  metadata.gz: 1486c2954255917e34255e716607f842f326db1d243b91526ba8326b2c3f6cfd6323eae53f865c749d57750e089cc25bd53849e94acb7bd375769992cdc22927
+  data.tar.gz: b4086c63b1f9d780e5e1b99f6ce2d81a56b2c4fcf7dd7a32c106ec6c6f847bbc1123eb5e531949bb1741e37b381bf1196ac946d95bde0848b65b5456eec09ddb

data/.gitignore

@@ -0,0 +1,6 @@
+.idea
+mlogger.iml
+pkg/
+/**/*.log
+/**/*.log.*
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://gems.ruby-china.org/"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in mlogger.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Hdzi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+# Simple logging utility with multiIO
+
+## CAUTION
+
+  mlogger is based on [logger](https://github.com/nahi/logger) that add some features.
+
+## Document
+  See RDoc in lib/mlogger.rb. To get RDoc in html format, exec 'rake doc'.
+
+## Author
+
+### Base [logger](https://github.com/nahi/logger)
+* NAKAMURA, Hiroshi a.k.a. NaHi
+* nahi@ruby-lang.org
+* Documentation: Gavin Sinclair
+
+### New Features
+* Hdzi
+* taojinhou@qq.com
+
+Legal notice
+  This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+  redistribute it and/or modify it under the same terms of Ruby's license;
+  either the dual license version in 2003, or any later version.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mlogger"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mlogger/version.rb

@@ -0,0 +1,3 @@
+class MLogger
+  VERSION = "1.0.2"
+end

data/lib/mlogger.rb

@@ -0,0 +1,650 @@
+# mlogger.rb - simple logging utility with multiIO
+# Copyright (C) 2000-2003, 2005, 2008, 2011  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+# Copyright (C) 2018 Hdzi <taojinhou@qq.com>
+#
+# Documentation:: NAKAMURA, Hiroshi and Gavin Sinclair
+# License::
+#   You can redistribute it and/or modify it under the same terms of Ruby's
+#   license; either the dual license version in 2003, or any later version.
+# Revision:: $Id$
+#
+# A simple system for logging messages.  See Logger for more documentation.
+
+
+require 'monitor'
+require 'mlogger/version'
+
+# == Description
+#
+# The Logger class provides a simple but sophisticated logging utility that
+# you can use to output messages.
+#
+# The messages have associated
+# levels, such as +INFO+ or +ERROR+ that indicate their importance.
+# You can then give the Logger a level, and only messages at that
+# level of higher will be printed.
+#
+# The levels are:
+#
+# +FATAL+:: an unhandleable error that results in a program crash
+# +ERROR+:: a handleable error condition
+# +WARN+::  a warning
+# +INFO+::  generic (useful) information about system operation
+# +DEBUG+:: low-level information for developers
+#
+# For instance, in a production system, you may have your Logger set to
+# +INFO+ or even +WARN+
+# When you are developing the system, however, you probably
+# want to know about the program's internal state, and would set the Logger to
+# +DEBUG+.
+#
+# *Note*: Logger does not escape or sanitize any messages passed to it.
+# Developers should be aware of when potentially malicious data (user-input)
+# is passed to Logger, and manually escape the untrusted data:
+#
+#   logger.info("User-input: #{input.dump}")
+#   logger.info("User-input: %p" % input)
+#
+# You can use #formatter= for escaping all data.
+#
+#   original_formatter = MLogger::Formatter.new
+#   logger.formatter = proc { |severity, datetime, progname, msg|
+#     original_formatter.call(severity, datetime, progname, msg.dump)
+#   }
+#   logger.info(input)
+#
+# === Example
+#
+# This creates a logger to the standard output stream, with a level of +WARN+
+#
+#   log = MLogger.new(STDOUT)
+#   log.level = MLogger::WARN
+#   # as run: log.level = :warn
+#
+#   log.debug("Created logger")
+#   log.info("Program started")
+#   log.warn("Nothing to do!")
+#
+#   begin
+#     File.each_line(path) do |line|
+#       unless line =~ /^(\w+) = (.*)$/
+#         log.error("Line in wrong format: #{line}")
+#       end
+#     end
+#   rescue => err
+#     log.fatal("Caught exception; exiting")
+#     log.fatal(err)
+#   end
+#
+# Because the Logger's level is set to +WARN+, only the warning, error, and
+# fatal messages are recorded.  The debug and info messages are silently
+# discarded.
+#
+# === Features
+#
+# There are several interesting features that Logger provides, like
+# auto-rolling of log files, setting the format of log messages, and
+# specifying a program name in conjunction with the message.  The next section
+# shows you how to achieve these things.
+#
+#
+# == HOWTOs
+#
+# === How to create a logger
+#
+# The options below give you various choices, in more or less increasing
+# complexity.
+#
+# 1. Create a logger which logs messages to STDERR/STDOUT.
+#
+#      logger = MLogger.new(STDERR)
+#      logger = MLogger.new(STDOUT)
+#
+# 2. Create a logger for the file which has the specified name.
+#
+#      logger = MLogger.new('logfile.log')
+#
+# 3. Create a logger for the specified file.
+#
+#      file = File.open('foo.log', File::WRONLY | File::APPEND)
+#      # To create new (and to remove old) logfile, add File::CREAT like;
+#      #   file = open('foo.log', File::WRONLY | File::APPEND | File::CREAT)
+#      logger = MLogger.new(file)
+#
+# 4. Create a logger which ages logfile once it reaches a certain size.  Leave
+#    10 "old log files" and each file is about 1,024,000 bytes.
+#
+#      logger = MLogger.new(['foo.log', {age: 10, size: 1024000}])
+#
+# 5. Create a logger which ages logfile daily/weekly/monthly.
+#
+#      logger = MLogger.new(['foo.log', {age: 'daily'}])
+#      logger = MLogger.new(['foo.log', {age: 'weekly'}])
+#      logger = MLogger.new(['foo.log', {age: 'monthly'}])
+#
+# 6. Create a logger with multiIO
+#
+#      logger = MLogger.new STDOUT, STDERR
+#      logger = MLogger.new ['foo.log', {age: 'daily'}], ['foo2.log', {age: 'weekly'}]
+#      logger = MLogger.new STDOUT, 'foo.log'
+#      logger = MLogger.new STDOUT, ['foo.log', {age: 'daily'}]
+#
+# 7. Create a logger with different log levels with different IO.
+#
+#     logger = MLogger.new STDOUT # default io
+#     logger.change_level_logdev MLogger::WARN, STDERR
+#     logger.change_level_logdev [:warn, :error], STDERR
+#
+# === How to log a message
+#
+# Notice the different methods (+fatal+, +error+, +info+) being used to log
+# messages of various levels?  Other methods in this family are +warn+ and
+# +debug+.  +add+ is used below to log a message of an arbitrary (perhaps
+# dynamic) level.
+#
+# 1. Message in block.
+#
+#      logger.fatal { "Argument 'foo' not given." }
+#
+# 2. Message as a string.
+#
+#      logger.error "Argument #{ @foo } mismatch."
+#
+# 3. With progname.
+#
+#      logger.info('initialize') { "Initializing..." }
+#
+#
+# The block form allows you to create potentially complex log messages,
+# but to delay their evaluation until and unless the message is
+# logged.  For example, if we have the following:
+#
+#     logger.debug { "This is a " + potentially + " expensive operation" }
+#
+# If the logger's level is +INFO+ or higher, no debug messages will be logged,
+# and the entire block will not even be evaluated.  Compare to this:
+#
+#     logger.debug("This is a " + potentially + " expensive operation")
+#
+# Here, the string concatenation is done every time, even if the log
+# level is not set to show the debug message.
+#
+# === How to close a logger
+#
+#      logger.close
+#
+# === Setting severity threshold
+#
+# 1. Original interface.
+#
+#      logger.sev_threshold = MLogger::WARN
+#
+# 2. Log4r (somewhat) compatible interface.
+#
+#      logger.level = MLogger::INFO
+#
+#      DEBUG < INFO < WARN < ERROR < FATAL
+#
+#
+# == Format
+#
+# Log messages are rendered in the output stream in a certain format by
+# default.  The default format and a sample are shown below:
+#
+# Log format:
+#   SeverityID, [Date Time mSec #pid] SeverityLabel -- ProgName: message
+#
+# Log sample:
+#   I, [Wed Mar 03 02:34:24 JST 1999 895701 #19074]  INFO -- Main: info.
+#
+# You may change the date and time format via #datetime_format=
+#
+#   logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+#         # e.g. "2004-01-03 00:54:26"
+#
+# Or, you may change the overall format with #formatter= method.
+#
+#   logger.formatter = proc do |severity, datetime, progname, msg|
+#     "#{datetime}: #{msg}\n"
+#   end
+#   # e.g. "Thu Sep 22 08:51:08 GMT+9:00 2005: hello world"
+#
+class MLogger
+  ProgName = "#{File.basename(__FILE__)}/#{VERSION}" # :nodoc:
+
+  class Error < RuntimeError # :nodoc:
+  end
+  # not used after 1.2.7. just for compat.
+  class ShiftingError < Error # :nodoc:
+  end
+
+  # When you set +$LOGGER_LEVEL+ before require mlogger, you can define yourself log level
+  # like default value [:DEBUG, :INFO, :WARN, :ERROR, :FATAL]
+  # DEBUG < INFO < WARN < ERROR < FATAL
+  LOGGER_LEVEL = $LOGGER_LEVEL || [:DEBUG, :INFO, :WARN, :ERROR, :FATAL]
+
+  LOGGER_LEVEL.each.with_index do |level, index| # :nodoc:
+    level_upcase, level_downcase = level.upcase, level.downcase
+
+    const_set level_upcase, index
+
+    define_method "#{level_downcase}" do |progname = nil, &block|
+      add(index, nil, progname, &block)
+    end
+
+    define_method "#{level_downcase}?" do
+      @level <= index
+    end
+  end
+
+  # Logging severity threshold (e.g. <tt>Logger::INFO</tt>).
+  attr_reader :level
+
+  def level= level # :nodoc:
+    @level = trans_level(level)
+  end
+
+  # program name to include in log messages.
+  attr_accessor :progname
+
+  # Set date-time format.
+  #
+  # +datetime_format+:: A string suitable for passing to +strftime+.
+  def datetime_format=(datetime_format)
+    @default_formatter.datetime_format = datetime_format
+  end
+
+  # Returns the date format being used.  See #datetime_format=
+  def datetime_format
+    @default_formatter.datetime_format
+  end
+
+  # Logging formatter, as a +Proc+ that will take four arguments and
+  # return the formatted message. The arguments are:
+  #
+  # +severity+:: The Severity of the log message
+  # +time+:: A Time instance representing when the message was logged
+  # +progname+:: The #progname configured, or passed to the logger method
+  # +msg+:: The _Object_ the user passed to the log message; not necessarily a String.
+  #
+  # The block should return an Object that can be written to the logging device via +write+.  The
+  # default formatter is used when no formatter is set.
+  attr_accessor :formatter
+
+  alias sev_threshold level
+  alias sev_threshold= level=
+
+  #
+  # === Synopsis
+  #
+  #   MLogger.new(+logdev+)
+  #   MLogger.new([name, {age: 7, size: 1048576}])
+  #   MLogger.new([name, {age: 'weekly'}])
+  #   MLogger.new([+logdev+, {age: +shift_age+, size: +shift_size+}])
+  #
+  # === Args
+  #
+  # Every Arg is a logdev information:
+  #
+  # +logdev+::
+  #   The log device.
+  #   Array This is a filename (String) or IO object (typically
+  #   +STDOUT+, +STDERR+, or an open file).
+  # +shift_age+::
+  #   Number of old log files to keep, *or* frequency of rotation (+daily+,
+  #   +weekly+ or +monthly+).
+  # +shift_size+::
+  #   Maximum logfile size (only applies when +shift_age+ is a number).
+  # === Description
+  #
+  # Create an instance.
+  #
+  def initialize(*logdev)
+    @progname = nil
+    @level = 0
+    @default_formatter = Formatter.new
+    @formatter = nil
+    logdev << STDOUT if logdev.empty?
+    @logdev = LogDeveices.new(*logdev)
+    @level_logdev = {}
+  end
+
+  #
+  # === Synopsis
+  #
+  #   Logger#change_level_logdev(levels, *logdev)
+  # 
+  # == Use
+  # 
+  #   logger.change_level_logdev :warn, STDERR
+  #   logger.change_level_logdev [:warn, :error], STDERR
+  #   logger.change_level_logdev MLogger::WARN..MLogger::FATAL, STDERR
+  #
+  # === Args
+  #
+  # +levels+::
+  #   Severity.  Constants are defined in Logger namespace: +DEBUG+, +INFO+,
+  #   +WARN+, +ERROR+, +FATAL+. Also can use a Severity Array.
+  # +logdev+::
+  #   The log device.  This is a filename (String) or IO object (typically
+  #   +STDOUT+, +STDERR+, or an open file).
+  # +shift_age+::
+  #   Number of old log files to keep, *or* frequency of rotation (+daily+,
+  #   +weekly+ or +monthly+).
+  # +shift_size+::
+  #   Maximum logfile size (only applies when +shift_age+ is a number).
+  #
+  # === Description
+  #
+  # Change LEVEL LogDev
+  #
+  def change_level_logdev(levels, *logdev)
+    levels = [levels] unless levels.is_a? Enumerable
+    log_deveices = LogDeveices.new(*logdev)
+    levels.each do |level|
+      level = trans_level level
+      @level_logdev[level] = log_deveices
+    end
+  end
+
+  #
+  # Dump given message to the log device without any formatting.  If no log
+  # device exists, return +nil+.
+  #
+  def <<(msg)
+    unless @logdev.nil?
+      @logdev.write(msg)
+    end
+  end
+
+  #
+  # Close the logging device.
+  #
+  def close
+    @logdev.close if @logdev
+    @level_logdev.values.each {|logdev| logdev.close if logdev}
+  end
+
+  private
+  
+  def trans_level(level)
+    (level.is_a? String or level.is_a? Symbol) ?
+        MLogger.const_get(level.upcase) : level
+  end
+
+  def format_severity(severity)
+    LOGGER_LEVEL[severity] || 'ANY'
+  end
+
+  def format_message(severity, datetime, progname, msg)
+    (@formatter || @default_formatter).call(severity, datetime, progname, msg)
+  end
+
+  #
+  # === Synopsis
+  #
+  #   MLogger#add(severity, message = nil, progname = nil) { ... }
+  #
+  # === Args
+  #
+  # +severity+::
+  #   Severity.  Constants are defined in Logger namespace: +DEBUG+, +INFO+,
+  #   +WARN+, +ERROR+, +FATAL+.
+  # +message+::
+  #   The log message.  A String or Exception.
+  # +progname+::
+  #   Program name string.  Can be omitted.  Treated as a message if no
+  #   +message+ and +block+ are given.
+  # +block+::
+  #   Can be omitted.  Called to get a message string if +message+ is nil.
+  #
+  # === Return
+  #
+  # +true+ if successful, +false+ otherwise.
+  #
+  # When the given severity is not high enough (for this particular logger), log
+  # no message, and return +true+.
+  #
+  # === Description
+  #
+  # Log a message if the given severity is high enough.  This is the generic
+  # logging method.  Users will be more inclined to use #debug, #info, #warn,
+  # #error, and #fatal.
+  #
+  # <b>Message format</b>: +message+ can be any object, but it has to be
+  # converted to a String in order to log it.  Generally, +inspect+ is used
+  # if the given object is not a String.
+  # A special case is an +Exception+ object, which will be printed in detail,
+  # including message, class, and backtrace.  See #msg2str for the
+  # implementation if required.
+  #
+  # === Bugs
+  #
+  # * Logfile is not locked.
+  # * Append open does not need to lock file.
+  # * If the OS which supports multi I/O, records possibly be mixed.
+  #
+  def add(severity, message = nil, progname = nil, &block)
+    if @logdev.nil? or severity < @level
+      return true
+    end
+    progname ||= @progname
+    if message.nil?
+      if block_given?
+        message = yield
+      else
+        message = progname
+        progname = @progname
+      end
+    end
+    (@level_logdev[severity] || @logdev).write(
+        format_message(format_severity(severity), Time.now, progname, message))
+    true
+  end
+
+  alias log add
+
+
+  # Default formatter for log messages
+  class Formatter
+    Format = "%s PID:%d %5s %s: %s\n"
+
+    attr_accessor :datetime_format
+
+    def initialize
+      @datetime_format = nil
+    end
+
+    def call(severity, time, progname, msg)
+      Format % [format_datetime(time), $$, severity, progname,
+                msg2str(msg)]
+    end
+
+    private
+
+    def format_datetime(time)
+      if @datetime_format.nil?
+        time.strftime("%Y-%m-%d %H:%M:%S.") << "%06d " % time.usec
+      else
+        time.strftime(@datetime_format)
+      end
+    end
+
+    def msg2str(msg)
+      case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{ msg.message } (#{ msg.class })\n" <<
+              (msg.backtrace || []).join("\n")
+        else
+          msg.inspect
+      end
+    end
+  end
+
+  class LogDeveices
+    attr_reader :devs
+
+    def initialize *logs
+      @devs = logs.map do |log|
+        # *STDOUT/*STDERR raise "IOError: not opened for reading"
+        LogDevice.new *(log.is_a?(Array) ? log : [log])
+      end
+    end
+
+    def write message
+      @devs.each {|dev| dev.write message}
+    end
+
+    def close
+      @devs.each {|dev| dev.close}
+    end
+
+    # Device used for logging messages.
+    class LogDevice
+      attr_reader :dev
+      attr_reader :filename
+
+      class LogDeviceMutex
+        include MonitorMixin
+      end
+
+      def initialize(log = nil, opt = {})
+        @dev = @filename = @shift_age = @shift_size = nil
+        @mutex = LogDeviceMutex.new
+        if log.respond_to?(:write) and log.respond_to?(:close)
+          @dev = log
+        else
+          @dev = open_logfile(log)
+          @dev.sync = true
+          @filename = log
+          @shift_age = opt[:age] || 7
+          @shift_size = opt[:size] || 1048576
+        end
+      end
+
+      def write(message)
+        begin
+          @mutex.synchronize do
+            if @shift_age and @dev.respond_to?(:stat)
+              begin
+                check_shift_log
+              rescue
+                warn("log shifting failed. #{$!}")
+              end
+            end
+            begin
+              @dev.write(message)
+            rescue
+              warn("log writing failed. #{$!}")
+            end
+          end
+        rescue Exception => ignored
+          warn("log writing failed. #{ignored}")
+        end
+      end
+
+      def close
+        return if @dev == STDOUT || @dev == STDERR
+
+        begin
+          @mutex.synchronize do
+            @dev.close rescue nil
+          end
+        rescue Exception
+          @dev.close rescue nil
+        end
+      end
+
+      private
+
+      def open_logfile(filename)
+        if (FileTest.exist?(filename))
+          open(filename, (File::WRONLY | File::APPEND))
+        else
+          create_logfile(filename)
+        end
+      end
+
+      def create_logfile(filename)
+        logdev = open(filename, (File::WRONLY | File::APPEND | File::CREAT))
+        logdev.sync = true
+        add_log_header(logdev)
+        logdev
+      end
+
+      def add_log_header(file)
+        file.write(
+            "# Logfile created on %s by %s\n" % [Time.now.to_s, MLogger::ProgName]
+        )
+      end
+
+      SiD = 24 * 60 * 60
+
+      def check_shift_log
+        if @shift_age.is_a?(Integer)
+          # Note: always returns false if '0'.
+          if @filename && (@shift_age > 0) && (@dev.stat.size > @shift_size)
+            shift_log_age
+          end
+        else
+          now = Time.now
+          period_end = previous_period_end(now)
+          if @dev.stat.mtime <= period_end
+            shift_log_period(period_end)
+          end
+        end
+      end
+
+      def shift_log_age
+        (@shift_age - 3).downto(0) do |i|
+          if FileTest.exist?("#{@filename}.#{i}")
+            File.rename("#{@filename}.#{i}", "#{@filename}.#{i + 1}")
+          end
+        end
+        @dev.close rescue nil
+        File.rename("#{@filename}", "#{@filename}.0")
+        @dev = create_logfile(@filename)
+        return true
+      end
+
+      def shift_log_period(period_end)
+        postfix = period_end.strftime("%Y%m%d") # YYYYMMDD
+        age_file = "#{@filename}.#{postfix}"
+        if FileTest.exist?(age_file)
+          # try to avoid filename crash caused by Timestamp change.
+          idx = 0
+          # .99 can be overridden; avoid too much file search with 'loop do'
+          while idx < 100
+            idx += 1
+            age_file = "#{@filename}.#{postfix}.#{idx}"
+            break unless FileTest.exist?(age_file)
+          end
+        end
+        @dev.close rescue nil
+        File.rename("#{@filename}", age_file)
+        @dev = create_logfile(@filename)
+        return true
+      end
+
+      def previous_period_end(now)
+        case @shift_age
+          when /^daily$/
+            eod(now - 1 * SiD)
+          when /^weekly$/
+            eod(now - ((now.wday + 1) * SiD))
+          when /^monthly$/
+            eod(now - now.mday * SiD)
+          else
+            now
+        end
+      end
+
+      def eod(t)
+        Time.mktime(t.year, t.month, t.mday, 23, 59, 59)
+      end
+    end
+  end
+end
+

data/mlogger.gemspec

@@ -0,0 +1,35 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "mlogger/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mlogger"
+  spec.version       = MLogger::VERSION
+  spec.authors       = ["NAKAMURA", "Hiroshi","Hdzi"]
+  spec.email         = ["taojinhou@qq.com"]
+
+  spec.summary       = %q{simple logging utility with multiIO}
+  spec.description   = %q{simple logging utility with multiIO}
+  spec.homepage      = "http://github.com/Hdzi/mlogger"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: mlogger
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- NAKAMURA
+- Hiroshi
+- Hdzi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: simple logging utility with multiIO
+email:
+- taojinhou@qq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/mlogger.rb
+- lib/mlogger/version.rb
+- mlogger.gemspec
+homepage: http://github.com/Hdzi/mlogger
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: simple logging utility with multiIO
+test_files: []