evt-log 0.4.3.5 → 0.5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4d99beb6d8242a242241e7c63c03b850063a7875
-  data.tar.gz: 010ddc003c80db1c15fafc633ceeaea6fb7285fd
+SHA256:
+  metadata.gz: aea91ca5533a3ac1adeaeb1fb8a896058ce379c54878b630fd635a17e2757705
+  data.tar.gz: 4866f0db99d5035dff9f305efb61c1a50760f998ea351ad460158aca6abdbbef
 SHA512:
-  metadata.gz: ba9376740c4883063b75bb9875852508d87828e459bf29a9f6a6159afdabe38a13458625fd3dba114c01d25481c27bc657c8aea44a33fe3b37e569f549128281
-  data.tar.gz: b2428268c903ae03fe259fc36e5f677b9ef1802a7e85f46d6b15012b240100870ba0437dc71459bbad0120abe97f87b8879aa7d84ce8f3f6afd7f7225b98b56e
+  metadata.gz: ebf2765c97c9831c79137a03aa8c9567ac9dec3720c3ccb831f78c4dce98f8262c6443815b28ac57d47c7d45008e4de8f339c198b3c1484f12127c2b1a8fbd5a
+  data.tar.gz: 96110e9ff8e5f4153c254a3d2510ed65a2e8b1d08411dd033fa6724aaccb9f6703c93dc353c8a4f9e3e1815485c35fcb38b73eeca8b5acdc771ce039aecb2bcb

data/lib/log/controls/log.rb

@@ -1,65 +1,67 @@
-module Log::Controls
-  module Log
-    def self.example
-      example = ::Log::Substitute::Log.new(::Log::Substitute.subject)
-
-      sink = ::Log.register_telemetry_sink(example)
-      example.telemetry_sink = sink
+class Log
+  module Controls
+    module Log
+      def self.example
+        example = ::Log::Substitute::Log.new(::Log::Substitute.subject)
 
-      example
-    end
+        sink = ::Log.register_telemetry_sink(example)
+        example.telemetry_sink = sink
 
-    module Levels
-      def self.example
-        logger = Log.example
-        logger.add_level(higher)
-        logger.add_level(middle)
-        logger.add_level(lower)
-        logger
+        example
       end
 
-      def self.higher
-        :higher
-      end
+      module Levels
+        def self.example
+          logger = Log.example
+          logger.add_level(higher)
+          logger.add_level(middle)
+          logger.add_level(lower)
+          logger
+        end
 
-      def self.middle
-        :middle
-      end
+        def self.higher
+          :higher
+        end
 
-      def self.lower
-        :lower
-      end
-    end
+        def self.middle
+          :middle
+        end
 
-    module Operational
-      def self.example
-        ::Log.build(subject)
+        def self.lower
+          :lower
+        end
       end
 
-      def self.subject
-        'some subject'
+      module Operational
+        def self.example
+          ::Log.build(subject)
+        end
+
+        def self.subject
+          'some subject'
+        end
       end
-    end
 
-    module Specialized
-      def self.example
-        example = Example.build('Specialized Logger')
+      module Specialized
+        def self.example
+          example = Example.build('Specialized Logger')
 
-        sink = ::Log.register_telemetry_sink(example)
-        example.telemetry_sink = sink
+          sink = ::Log.register_telemetry_sink(example)
+          example.telemetry_sink = sink
 
-        example.device = ::Log::Substitute::Log::NullDevice
+          example.device = ::Log::Substitute::Log::NullDevice
 
-        example.tags = :some_additional_tag
+          example.tags = :some_additional_tag
 
-        example
-      end
+          example
+        end
 
-      class Example < ::Log
-        attr_accessor :telemetry_sink
+        class Example < ::Log
+          attr_accessor :telemetry_sink
 
-        def tag!(tags)
-          tags << :some_additional_tag
+          def tag!(tags)
+            tags << :some_additional_tag
+          end
         end
       end
     end

data/lib/log/controls/subject.rb

@@ -1,26 +1,28 @@
-module Log::Controls
-  module Subject
-    def self.example
-      Example.new
-    end
+class Log
+  module Controls
+    module Subject
+      def self.example
+        Example.new
+      end
 
-    def self.new
-      example
-    end
+      def self.new
+        example
+      end
 
-    module Operational
-      def self.example
-        Subject::Example.build
+      module Operational
+        def self.example
+          Subject::Example.build
+        end
       end
-    end
 
-    class Example
-      dependency :logger, ::Log
+      class Example
+        dependency :logger, ::Log
 
-      def self.build
-        instance = new
-        ::Log.configure(instance)
-        instance
+        def self.build
+          instance = new
+          ::Log.configure(instance)
+          instance
+        end
       end
     end
   end

data/lib/log/controls/time.rb

@@ -1,3 +1,5 @@
-module Log::Controls
-  Time = Clock::Controls::Time
+class Log
+  module Controls
+    Time = Clock::Controls::Time
+  end
 end

data/lib/log/defaults.rb

@@ -1,67 +1,69 @@
-module Log::Defaults
-  def self.level
-    env_level = ENV['LOG_LEVEL']
-    return env_level.to_sym if !env_level.nil?
+class Log
+  module Defaults
+    def self.level
+      env_level = ENV['LOG_LEVEL']
+      return env_level.to_sym if !env_level.nil?
 
-    :info
-  end
+      :info
+    end
 
-  def self.tags
-    env_tags = ENV['LOG_TAGS']
+    def self.tags
+      env_tags = ENV['LOG_TAGS']
 
-    return [] if env_tags.nil?
+      return [] if env_tags.nil?
 
-    tags = env_tags.split(',')
+      tags = env_tags.split(',')
 
-    tags.map { |tag| tag.to_sym }
-  end
+      tags.map { |tag| tag.to_sym }
+    end
 
-  def self.device
-    env_device = ENV['CONSOLE_DEVICE']
+    def self.device
+      env_device = ENV['CONSOLE_DEVICE']
 
-    device = nil
+      device = nil
 
-    if !env_device.nil?
-      if !['stderr', 'stdout'].include?(env_device)
-        raise "The CONSOLE_DEVICE should be either 'stderr' (default) or 'stdout'"
+      if !env_device.nil?
+        if !['stderr', 'stdout'].include?(env_device)
+          raise "The CONSOLE_DEVICE should be either 'stderr' (default) or 'stdout'"
+        else
+          device = (env_device == 'stderr' ? STDERR : STDOUT)
+        end
       else
-        device = (env_device == 'stderr' ? STDERR : STDOUT)
+        device = STDERR
       end
-    else
-      device = STDERR
+
+      device
     end
 
-    device
-  end
+    def self.formatters
+      env_formatters = ENV['LOG_FORMATTERS']
 
-  def self.formatters
-    env_formatters = ENV['LOG_FORMATTERS']
+      if env_formatters.nil?
+        env_formatters = :on
+      end
 
-    if env_formatters.nil?
-      env_formatters = :on
+      env_formatters.to_sym
     end
 
-    env_formatters.to_sym
-  end
-
-  def self.levels
-    [
-      :fatal,
-      :error,
-      :warn,
-      :info,
-      :debug,
-      :trace
-    ]
-  end
+    def self.levels
+      [
+        :fatal,
+        :error,
+        :warn,
+        :info,
+        :debug,
+        :trace
+      ]
+    end
 
-  def self.level_formatters
-    {
-      error: proc { |message| TerminalColors::Apply.(message, bg: :red, bold: true) },
-      fatal: proc { |message| TerminalColors::Apply.(message, fg: :red, bg: :black) },
-      warn: proc { |message| TerminalColors::Apply.(message, fg: :yellow, bg: :black) },
-      debug: proc { |message| TerminalColors::Apply.(message, fg: :green) },
-      trace: proc { |message| TerminalColors::Apply.(message, fg: :cyan) }
-    }
+    def self.level_formatters
+      {
+        error: proc { |message, device| Format::Color.message(message, device, bg: :red, bold: true) },
+        fatal: proc { |message, device| Format::Color.message(message, device, fg: :red, bg: :black) },
+        warn: proc { |message, device| Format::Color.message(message, device, fg: :yellow, bg: :black) },
+        debug: proc { |message, device| Format::Color.message(message, device, fg: :green) },
+        trace: proc { |message, device| Format::Color.message(message, device, fg: :cyan) }
+      }
+    end
   end
 end

data/lib/log/filter.rb

@@ -1,58 +1,60 @@
-module Log::Filter
-  def write_level?(message_level)
-    if message_level.nil? && !logger_level?
-      return true
+class Log
+  module Filter
+    def write_level?(message_level)
+      if message_level.nil? && !logger_level?
+        return true
+      end
+
+      if message_level.nil? || !logger_level?
+        return false
+      end
+
+      precedent?(message_level)
     end
 
-    if message_level.nil? || !logger_level?
-      return false
+    def precedent?(message_level)
+      ordinal(message_level) <= logger_ordinal
     end
 
-    precedent?(message_level)
-  end
+    def write_tag?(message_tags)
+      message_tags ||= []
 
-  def precedent?(message_level)
-    ordinal(message_level) <= logger_ordinal
-  end
+      if message_tags.empty? && !logger_tags?
+        return true
+      end
 
-  def write_tag?(message_tags)
-    message_tags ||= []
+      if log_all_tags?
+        return true
+      end
 
-    if message_tags.empty? && !logger_tags?
-      return true
-    end
+      if message_tags.empty? && log_untagged?
+        return true
+      end
 
-    if log_all_tags?
-      return true
-    end
+      if !message_tags.empty? && logger_tags?
+        if logger_tags_intersect?(message_tags)
+          return true
+        end
+      end
 
-    if message_tags.empty? && log_untagged?
-      return true
+      false
     end
 
-    if !message_tags.empty? && logger_tags?
-      if logger_tags_intersect?(message_tags)
-        return true
-      end
+    def log_all_tags?
+      logger_tag?(:_all)
     end
 
-    false
-  end
-
-  def log_all_tags?
-    logger_tag?(:_all)
-  end
+    def log_untagged?
+      logger_tag?(:_untagged)
+    end
 
-  def log_untagged?
-    logger_tag?(:_untagged)
-  end
+    def tags_intersect?(message_tags)
+      if !(message_tags & logger_excluded_tags).empty?
+        return false
+      end
 
-  def tags_intersect?(message_tags)
-    if !(message_tags & logger_excluded_tags).empty?
-      return false
+      !(logger_included_tags & message_tags).empty?
     end
-
-    !(logger_included_tags & message_tags).empty?
+    alias :logger_tags_intersect? :tags_intersect?
   end
-  alias :logger_tags_intersect? :tags_intersect?
 end

data/lib/log/format.rb

@@ -1,29 +1,31 @@
-module Log::Format
-  def self.line(message, time, subject, level, &message_formatter)
-    "#{header(time, subject, level)} #{message(message, &message_formatter)}"
-  end
+class Log
+  module Format
+    def self.line(message, time, subject, level, device, &message_formatter)
+      "#{header(time, subject, level, device)} #{message(message, device, &message_formatter)}"
+    end
 
-  def self.message(message, &message_formatter)
-    return message unless block_given?
-    if Log::Defaults.formatters == :on
-      return message_formatter.(message)
-    else
-      return message
+    def self.message(message, device, &message_formatter)
+      return message unless block_given?
+      if Log::Defaults.formatters == :on
+        return message_formatter.(message, device)
+      else
+        return message
+      end
     end
-  end
 
-  def self.header(time, subject, level)
-    header = "[#{time}] #{subject}"
-    unless level.nil?
-      header << " #{level.to_s.upcase}"
+    def self.header(time, subject, level, device)
+      header = "[#{time}] #{subject}"
+      unless level.nil?
+        header << " #{level.to_s.upcase}"
+      end
+      header << ':'
+      Color.header(header, device)
     end
-    header << ':'
-    Color.header(header)
-  end
 
-  module Defaults
-    def self.message_formatter
-      proc {|message| message }
+    module Defaults
+      def self.message_formatter
+        proc {|message| message }
+      end
     end
   end
 end

data/lib/log/format/color.rb

@@ -1,5 +1,19 @@
-module Log::Format::Color
-  def self.header(text)
-    TerminalColors::Apply.(text, fg: :white)
+class Log
+  module Format
+    module Color
+      def self.color?(device)
+        device.tty?
+      end
+
+      def self.header(text, device)
+        return text unless color?(device)
+        TerminalColors::Apply.(text, fg: :white)
+      end
+
+      def self.message(text, device, **options)
+        return text unless color?(device)
+        TerminalColors::Apply.(text, options)
+      end
+    end
   end
 end

data/lib/log/level.rb

@@ -1,116 +1,118 @@
-module Log::Level
-  LevelInfo = Struct.new(:name, :ordinal, :message_formatter)
+class Log
+  module Level
+    LevelInfo = Struct.new(:name, :ordinal, :message_formatter)
 
-  def level
-    @level
-  end
-  alias :logger_level :level
-
-  def level=(level)
-    if [:_min, :_max].include?(level)
-      if level == :_min
-        level = min_level
-      else
-        level = max_level
-      end
+    def level
+      @level
     end
+    alias :logger_level :level
+
+    def level=(level)
+      if [:_min, :_max].include?(level)
+        if level == :_min
+          level = min_level
+        else
+          level = max_level
+        end
+      end
 
-    assure_level(level)
-    @level = level
-  end
-  alias :logger_level= :level=
-
-  def level?(level=nil)
-    if level.nil?
-      !logger_level.nil?
-    else
-      levels.has_key?(level)
+      assure_level(level)
+      @level = level
     end
-  end
-  alias :logger_level? :level?
+    alias :logger_level= :level=
 
-  def add_level(level, &message_formatter)
-    return nil if logger_level?(level)
+    def level?(level=nil)
+      if level.nil?
+        !logger_level.nil?
+      else
+        levels.has_key?(level)
+      end
+    end
+    alias :logger_level? :level?
 
-    Method.define(self, level)
+    def add_level(level, &message_formatter)
+      return nil if logger_level?(level)
 
-    message_formatter = Log::Format::Defaults.message_formatter unless block_given?
+      Method.define(self, level)
 
-    levels[level] = LevelInfo.new(level, levels.length, message_formatter)
-  end
+      message_formatter = Log::Format::Defaults.message_formatter unless block_given?
 
-  def remove_level(level)
-    return nil unless logger_level?(level)
-    Method.remove(self, level)
-    levels.delete(level)
-  end
+      levels[level] = LevelInfo.new(level, levels.length, message_formatter)
+    end
 
-  def assure_level(level)
-    if level.nil?
-      return
+    def remove_level(level)
+      return nil unless logger_level?(level)
+      Method.remove(self, level)
+      levels.delete(level)
     end
 
-    unless level == :_none
-      if !levels?
-        raise Log::Error, "Level #{level.inspect} cannot be set. The logger has no levels."
+    def assure_level(level)
+      if level.nil?
+        return
       end
 
-      if !level?(level)
-        raise Log::Error, "Level #{level.inspect} must be one of: #{levels.keys.join(', ')}"
+      unless level == :_none
+        if !levels?
+          raise Log::Error, "Level #{level.inspect} cannot be set. The logger has no levels."
+        end
+
+        if !level?(level)
+          raise Log::Error, "Level #{level.inspect} must be one of: #{levels.keys.join(', ')}"
+        end
       end
     end
-  end
 
-  def ordinal(level=nil)
-    level ||= logger_level
+    def ordinal(level=nil)
+      level ||= logger_level
 
-    if level == :_none
-      return -1
-    end
+      if level == :_none
+        return -1
+      end
 
-    level = levels[level]
-    return no_ordinal if level.nil?
-    level.ordinal
-  end
+      level = levels[level]
+      return no_ordinal if level.nil?
+      level.ordinal
+    end
 
-  def logger_ordinal
-    ordinal
-  end
+    def logger_ordinal
+      ordinal
+    end
 
-  def no_ordinal
-    -1
-  end
+    def no_ordinal
+      -1
+    end
 
-  def max_level
-    logger_levels.keys.last
-  end
+    def max_level
+      logger_levels.keys.last
+    end
 
-  def min_level
-    logger_levels.keys.first
-  end
+    def min_level
+      logger_levels.keys.first
+    end
 
-  def max_level!
-    self.logger_level = max_level
-  end
+    def max_level!
+      self.logger_level = max_level
+    end
 
-  def min_level!
-    self.logger_level = min_level
-  end
+    def min_level!
+      self.logger_level = min_level
+    end
 
-  def no_level!
-    self.logger_level = nil
-  end
+    def no_level!
+      self.logger_level = nil
+    end
 
-  module Method
-    def self.define(logger, level_name)
-      level = level_name
-      logger.define_singleton_method(level) do |message=nil, tag: nil, tags: nil, &blk|
-        self.(message, level, tag: tag, tags: tags, &blk)
+    module Method
+      def self.define(logger, level_name)
+        level = level_name
+        logger.define_singleton_method(level) do |message=nil, tag: nil, tags: nil, &blk|
+          self.(message, level, tag: tag, tags: tags, &blk)
+        end
       end
-    end
 
-    def self.remove(logger, level_name)
-      logger.instance_eval "undef #{level_name}"
+      def self.remove(logger, level_name)
+        logger.instance_eval "undef #{level_name}"
+      end
     end
   end
 end

data/lib/log/levels.rb

@@ -1,26 +1,28 @@
-module Log::Levels
-  def self.included(cls)
-    cls.extend AddLevels
-  end
+class Log
+  module Levels
+    def self.included(cls)
+      cls.extend AddLevels
+    end
 
-  def levels
-    @levels ||= {}
-  end
-  alias :logger_levels :levels
+    def levels
+      @levels ||= {}
+    end
+    alias :logger_levels :levels
 
-  def levels?
-    !levels.empty?
-  end
-  alias :logger_levels? :levels?
+    def levels?
+      !levels.empty?
+    end
+    alias :logger_levels? :levels?
 
-  def level_names
-    levels.keys.dup
-  end
+    def level_names
+      levels.keys.dup
+    end
 
-  module AddLevels
-    def add_levels(logger)
-      Log::Defaults.levels.each do |level|
-        logger.add_level(level, &Log::Defaults.level_formatters[level])
+    module AddLevels
+      def add_levels(logger)
+        Log::Defaults.levels.each do |level|
+          logger.add_level(level, &Log::Defaults.level_formatters[level])
+        end
       end
     end
   end

data/lib/log/registry.rb

@@ -1,22 +1,24 @@
-module Log::Registry
-  def get(subject)
-    register(subject)
-  end
+class Log
+  module Registry
+    def get(subject)
+      register(subject)
+    end
 
-  def register(subject)
-    subject_name = subject_name(subject)
+    def register(subject)
+      subject_name = subject_name(subject)
 
-    instance = registry[subject_name]
+      instance = registry[subject_name]
 
-    if instance.nil?
-      instance = build(subject)
-      registry[subject_name] = instance
-    end
+      if instance.nil?
+        instance = build(subject)
+        registry[subject_name] = instance
+      end
 
-    instance
-  end
+      instance
+    end
 
-  def registry
-    @registry ||= {}
+    def registry
+      @registry ||= {}
+    end
   end
 end

data/lib/log/subject_name.rb

@@ -1,14 +1,16 @@
-module Log::SubjectName
-  def subject_name(subject)
-    if subject.is_a?(Class) || subject.is_a?(Module)
-      name = subject.name
-    elsif subject.is_a? String
-      name = subject
-    elsif subject.is_a? Symbol
-      name = subject.to_s
-    else
-      name = subject.class.name
+class Log
+  module SubjectName
+    def subject_name(subject)
+      if subject.is_a?(Class) || subject.is_a?(Module)
+        name = subject.name
+      elsif subject.is_a? String
+        name = subject
+      elsif subject.is_a? Symbol
+        name = subject.to_s
+      else
+        name = subject.class.name
+      end
+      name
     end
-    name
   end
 end

data/lib/log/substitute.rb

@@ -1,28 +1,34 @@
-module Log::Substitute
-  def self.build
-    instance = Log.build(subject)
-    sink = Log.register_telemetry_sink(instance)
-    instance.telemetry_sink = sink
-    instance
-  end
+class Log
+  module Substitute
+    def self.build
+      instance = Log.build(subject)
+      sink = Log.register_telemetry_sink(instance)
+      instance.telemetry_sink = sink
+      instance
+    end
 
-  def self.subject
-    '(substitute logger)'
-  end
+    def self.subject
+      '(substitute logger)'
+    end
 
-  class Log < ::Log
-    attr_accessor :telemetry_sink
+    class Log < ::Log
+      attr_accessor :telemetry_sink
 
-    def clock
-      @clock ||= Clock::UTC::Substitute.build
-    end
+      def clock
+        @clock ||= Clock::UTC::Substitute.build
+      end
 
-    def device
-      @device ||= NullDevice
-    end
+      def device
+        @device ||= NullDevice
+      end
+
+      class NullDevice
+        def self.write(*)
+        end
 
-    class NullDevice
-      def self.write(*)
+        def self.tty?
+          true
+        end
       end
     end
   end

data/lib/log/tags.rb

@@ -1,49 +1,51 @@
-module Log::Tags
-  def tags
-    @tags ||= []
-  end
-  alias :logger_tags :tags
-
-  def included_tags
-    @included_tags ||= []
-  end
-  alias :logger_included_tags :included_tags
+class Log
+  module Tags
+    def tags
+      @tags ||= []
+    end
+    alias :logger_tags :tags
 
-  def excluded_tags
-    @excluded_tags ||= []
-  end
-  alias :logger_excluded_tags :excluded_tags
+    def included_tags
+      @included_tags ||= []
+    end
+    alias :logger_included_tags :included_tags
 
-  def tags=(tags)
-    if tags.nil?
-      @tags = nil
-      return
+    def excluded_tags
+      @excluded_tags ||= []
     end
+    alias :logger_excluded_tags :excluded_tags
+
+    def tags=(tags)
+      if tags.nil?
+        @tags = nil
+        return
+      end
 
-    tags = Array(tags)
+      tags = Array(tags)
 
-    tags.each do |tag|
-      unless tag.to_s.start_with?('-')
-        included_tags << tag
-      else
-        excluded_tags << tag[1..-1].to_sym
+      tags.each do |tag|
+        unless tag.to_s.start_with?('-')
+          included_tags << tag
+        else
+          excluded_tags << tag[1..-1].to_sym
+        end
       end
-    end
 
-    @tags = tags
-  end
+      @tags = tags
+    end
 
-  def tag=(tag)
-    self.tags = tag
-  end
+    def tag=(tag)
+      self.tags = tag
+    end
 
-  def tags?
-    !tags.empty?
-  end
-  alias :logger_tags? :tags?
+    def tags?
+      !tags.empty?
+    end
+    alias :logger_tags? :tags?
 
-  def tag?(tag)
-    tags.include?(tag)
+    def tag?(tag)
+      tags.include?(tag)
+    end
+    alias :logger_tag? :tag?
   end
-  alias :logger_tag? :tag?
 end

data/lib/log/telemetry.rb

@@ -1,21 +1,23 @@
-module Log::Telemetry
-  class Sink
-    include ::Telemetry::Sink
+class Log
+  module Telemetry
+    class Sink
+      include ::Telemetry::Sink
 
-    record :logged
-  end
+      record :logged
+    end
 
-  Data = Struct.new :subject_name, :message, :level, :tags, :line
+    Data = Struct.new :subject_name, :message, :level, :tags, :line
 
-  def self.sink
-    Sink.new
-  end
+    def self.sink
+      Sink.new
+    end
 
-  module Register
-    def register_telemetry_sink(logger)
-      sink = Log::Telemetry.sink
-      logger.telemetry.register sink
-      sink
+    module Register
+      def register_telemetry_sink(logger)
+        sink = Log::Telemetry.sink
+        logger.telemetry.register sink
+        sink
+      end
     end
   end
 end

data/lib/log/write.rb

@@ -1,15 +1,17 @@
-module Log::Write
-  def write(message, level, tags)
-    message = message.to_s
+class Log
+  module Write
+    def write(message, level, tags)
+      message = message.to_s
 
-    if message.length == 0
-      message = '(empty log message)'
-    end
+      if message.length == 0
+        message = '(empty log message)'
+      end
 
-    line = Log::Format.line(message, clock.iso8601(precision: 5), subject, level, &levels[level] &.message_formatter)
+      line = Log::Format.line(message, clock.iso8601(precision: 5), subject, level, device, &levels[level] &.message_formatter)
 
-    device.write "#{line}#{$INPUT_RECORD_SEPARATOR}"
+      device.write "#{line}#{$INPUT_RECORD_SEPARATOR}"
 
-    telemetry.record :logged, Log::Telemetry::Data.new(subject, message, level, tags, line)
+      telemetry.record :logged, Log::Telemetry::Data.new(subject, message, level, tags, line)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evt-log
 version: !ruby/object:Gem::Version
-  version: 0.4.3.5
+  version: 0.5.0.0
 platform: ruby
 authors:
 - The Eventide Project
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-01 00:00:00.000000000 Z
+date: 2018-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: evt-initializer
@@ -138,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Logging to STD IO with levels, tagging, and coloring