evt-log 0.4.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c11a1528df9207238249d28f1152436f4f5fd60
+  data.tar.gz: 288278d234c160badf9540e0a29a3c840568eb5e
+SHA512:
+  metadata.gz: 62061cf117b80057c70d343c4852b01c92debef5fbb7bb5b99f070b3868ad881992a44988871f53b0418732fe34bd5d8ee8fd02b98f9dd594054ccd19dc1dd65
+  data.tar.gz: a43679c9bd21e02f8aa887e85ff2a2efa621c61ff0292e2836565f9ea0ac6ee1b95ce1adbf6e83241eab21483f4aa6d317f96953d0f3dac9ae0c20440e2aa5e6

data/lib/log.rb

@@ -0,0 +1,26 @@
+require 'English'
+
+require 'rainbow'; Rainbow.enabled = true
+
+require 'initializer'; Initializer.activate
+require 'dependency'; Dependency.activate
+require 'telemetry'
+require 'clock'
+
+class Log
+end
+
+require 'log/subject_name'
+require 'log/registry'
+require 'log/level'
+require 'log/levels'
+require 'log/tags'
+require 'log/filter'
+require 'log/telemetry'
+require 'log/substitute'
+require 'log/write'
+require 'log/format'
+require 'log/format/color'
+require 'log/defaults'
+require 'log/log'
+

data/lib/log/controls.rb

@@ -0,0 +1,5 @@
+require 'clock/controls'
+
+require 'log/controls/time'
+require 'log/controls/log'
+require 'log/controls/subject'

data/lib/log/controls/log.rb

@@ -0,0 +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
+
+      example
+    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.higher
+        :higher
+      end
+
+      def self.middle
+        :middle
+      end
+
+      def self.lower
+        :lower
+      end
+    end
+
+    module Operational
+      def self.example
+        ::Log.build(subject)
+      end
+
+      def self.subject
+        'some subject'
+      end
+    end
+
+    module Specialized
+      def self.example
+        example = Example.build('Specialized Logger')
+
+        sink = ::Log.register_telemetry_sink(example)
+        example.telemetry_sink = sink
+
+        example.device = ::Log::Substitute::Log::NullDevice
+
+        example.tags = :some_additional_tag
+
+        example
+      end
+
+      class Example < ::Log
+        attr_accessor :telemetry_sink
+
+        def tag!(tags)
+          tags << :some_additional_tag
+        end
+      end
+    end
+  end
+end

data/lib/log/controls/subject.rb

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

data/lib/log/controls/time.rb

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

data/lib/log/defaults.rb

@@ -0,0 +1,67 @@
+module Log::Defaults
+  def self.level
+    env_level = ENV['LOG_LEVEL']
+    return env_level.to_sym if !env_level.nil?
+
+    :info
+  end
+
+  def self.tags
+    env_tags = ENV['LOG_TAGS']
+
+    return [] if env_tags.nil?
+
+    tags = env_tags.split(',')
+
+    tags.map { |tag| tag.to_sym }
+  end
+
+  def self.device
+    env_device = ENV['CONSOLE_DEVICE']
+
+    device = nil
+
+    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 = STDERR
+    end
+
+    device
+  end
+
+  def self.formatters
+    env_formatters = ENV['LOG_FORMATTERS']
+
+    if env_formatters.nil?
+      env_formatters = :on
+    end
+
+    env_formatters.to_sym
+  end
+
+  def self.levels
+    [
+      :fatal,
+      :error,
+      :warn,
+      :info,
+      :debug,
+      :trace
+    ]
+  end
+
+  def self.level_formatters
+    {
+      error: proc { |message| Rainbow(message).bright.white.bg(:red) },
+      fatal: proc { |message| Rainbow(message).red.bg(:black) },
+      warn: proc { |message| Rainbow(message).yellow.bg(:black) },
+      debug: proc { |message| Rainbow(message).green },
+      trace: proc { |message| Rainbow(message).cyan }
+    }
+  end
+end

data/lib/log/filter.rb

@@ -0,0 +1,58 @@
+module Log::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
+
+  def precedent?(message_level)
+    ordinal(message_level) <= logger_ordinal
+  end
+
+  def write_tag?(message_tags)
+    message_tags ||= []
+
+    if message_tags.empty? && !logger_tags?
+      return true
+    end
+
+    if log_all_tags?
+      return true
+    end
+
+    if message_tags.empty? && log_untagged?
+      return true
+    end
+
+    if !message_tags.empty? && logger_tags?
+      if logger_tags_intersect?(message_tags)
+        return true
+      end
+    end
+
+    false
+  end
+
+  def log_all_tags?
+    logger_tag?(:_all)
+  end
+
+  def log_untagged?
+    logger_tag?(:_untagged)
+  end
+
+  def tags_intersect?(message_tags)
+    if !(message_tags & logger_excluded_tags).empty?
+      return false
+    end
+
+    !(logger_included_tags & message_tags).empty?
+  end
+  alias :logger_tags_intersect? :tags_intersect?
+end

data/lib/log/format.rb

@@ -0,0 +1,29 @@
+module Log::Format
+  def self.line(message, time, subject, level, &message_formatter)
+    "#{header(time, subject, level)} #{message(message, &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
+    end
+  end
+
+  def self.header(time, subject, level)
+    header = "[#{time}] #{subject}"
+    unless level.nil?
+      header << " #{level.to_s.upcase}"
+    end
+    header << ':'
+    Color.header(header)
+  end
+
+  module Defaults
+    def self.message_formatter
+      proc {|message| message }
+    end
+  end
+end

data/lib/log/format/color.rb

@@ -0,0 +1,5 @@
+module Log::Format::Color
+  def self.header(text)
+    Rainbow(text).white
+  end
+end

data/lib/log/level.rb

@@ -0,0 +1,116 @@
+module Log::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
+    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)
+    end
+  end
+  alias :logger_level? :level?
+
+  def add_level(level, &message_formatter)
+    return nil if logger_level?(level)
+
+    Method.define(self, level)
+
+    message_formatter = Log::Format::Defaults.message_formatter unless block_given?
+
+    levels[level] = LevelInfo.new(level, levels.length, message_formatter)
+  end
+
+  def remove_level(level)
+    return nil unless logger_level?(level)
+    Method.remove(self, level)
+    levels.delete(level)
+  end
+
+  def assure_level(level)
+    if level.nil?
+      return
+    end
+
+    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
+
+  def ordinal(level=nil)
+    level ||= logger_level
+
+    if level == :_none
+      return -1
+    end
+
+    level = levels[level]
+    return no_ordinal if level.nil?
+    level.ordinal
+  end
+
+  def logger_ordinal
+    ordinal
+  end
+
+  def no_ordinal
+    -1
+  end
+
+  def max_level
+    logger_levels.keys.last
+  end
+
+  def min_level
+    logger_levels.keys.first
+  end
+
+  def max_level!
+    self.logger_level = max_level
+  end
+
+  def min_level!
+    self.logger_level = min_level
+  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)
+      end
+    end
+
+    def self.remove(logger, level_name)
+      logger.instance_eval "undef #{level_name}"
+    end
+  end
+end

data/lib/log/levels.rb

@@ -0,0 +1,27 @@
+module Log::Levels
+  def self.included(cls)
+    cls.extend AddLevels
+  end
+
+  def levels
+    @levels ||= {}
+  end
+  alias :logger_levels :levels
+
+  def levels?
+    !levels.empty?
+  end
+  alias :logger_levels? :levels?
+
+  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])
+      end
+    end
+  end
+end

data/lib/log/log.rb

@@ -0,0 +1,111 @@
+class Log
+  class Error < RuntimeError; end
+
+  extend Registry
+  include Levels
+  include Level
+  include Tags
+  include Filter
+  include Write
+  extend SubjectName
+  extend Telemetry::Register
+
+  def self.inherited(cls)
+    cls.class_exec do
+      dependency_module = Module.new do
+        define_singleton_method :included do |reciever_class|
+          reciever_class.class_exec do
+            dependency :logger, cls
+
+            define_method :logger do
+              @logger ||= cls.configure self
+            end
+          end
+        end
+      end
+
+      const_set :Dependency, dependency_module
+    end
+  end
+
+  self.inherited(self)
+
+  dependency :clock, Clock::UTC
+
+  initializer :subject
+
+  attr_writer :device
+
+  def device
+    @device ||= Defaults.device
+  end
+
+  def telemetry
+    @telemetry ||= ::Telemetry.build
+  end
+
+  def self.build(subject)
+    subject = subject_name(subject)
+    instance = new(subject)
+    Clock::UTC.configure(instance)
+    set_defaults(instance)
+    instance
+  end
+
+  def self.no_defaults(subject)
+    instance = new(subject)
+    Clock::UTC.configure(instance)
+    instance
+  end
+
+  def self.bare(subject)
+    no_defaults(subject)
+  end
+
+  def self.configure(receiver, attr_name: nil)
+    attr_name ||= :logger
+    instance = get(receiver)
+    receiver.public_send("#{attr_name}=", instance)
+    instance
+  end
+
+  def call(message=nil, level=nil, tag: nil, tags: nil, &blk)
+    tag = Array(tag)
+    tags = Array(tags)
+    tags = tags + tag
+
+    assure_level(level)
+
+    tag!(tags)
+
+    if write?(level, tags)
+      if block_given?
+        message = blk.call
+      end
+      raise ArgumentError, "Log message not provided" if message.nil?
+
+      write(message, level, tags)
+    end
+  end
+
+  def tag!(tags)
+    tags
+  end
+
+  def write?(message_level, message_tags)
+    write_level?(message_level) && write_tag?(message_tags)
+  end
+
+  def clear
+    level_names.each do |level_name|
+      remove_level(level_name)
+    end
+    self.level = nil
+  end
+
+  def self.set_defaults(logger)
+    logger.class.add_levels(logger)
+    logger.level = Defaults.level
+    logger.tags = Defaults.tags
+  end
+end

data/lib/log/registry.rb

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

data/lib/log/subject_name.rb

@@ -0,0 +1,14 @@
+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
+    end
+    name
+  end
+end

data/lib/log/substitute.rb

@@ -0,0 +1,29 @@
+module Log::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
+
+  class Log < ::Log
+    attr_accessor :telemetry_sink
+
+    def clock
+      @clock ||= Clock::UTC::Substitute.build
+    end
+
+    def device
+      @device ||= NullDevice
+    end
+
+    class NullDevice
+      def self.write(*)
+      end
+    end
+  end
+end

data/lib/log/tags.rb

@@ -0,0 +1,49 @@
+module Log::Tags
+  def tags
+    @tags ||= []
+  end
+  alias :logger_tags :tags
+
+  def included_tags
+    @included_tags ||= []
+  end
+  alias :logger_included_tags :included_tags
+
+  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.each do |tag|
+      unless tag.to_s.start_with?('-')
+        included_tags << tag
+      else
+        excluded_tags << tag[1..-1].to_sym
+      end
+    end
+
+    @tags = tags
+  end
+
+  def tag=(tag)
+    self.tags = tag
+  end
+
+  def tags?
+    !tags.empty?
+  end
+  alias :logger_tags? :tags?
+
+  def tag?(tag)
+    tags.include?(tag)
+  end
+  alias :logger_tag? :tag?
+end

data/lib/log/telemetry.rb

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

data/lib/log/write.rb

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

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: evt-log
+version: !ruby/object:Gem::Version
+  version: 0.4.3.2
+platform: ruby
+authors:
+- The Eventide Project
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: evt-initializer
+  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: evt-dependency
+  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: evt-telemetry
+  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: evt-clock
+  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: rainbow
+  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: ntl-test_bench
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: " "
+email: opensource@eventide-project.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/log.rb
+- lib/log/controls.rb
+- lib/log/controls/log.rb
+- lib/log/controls/subject.rb
+- lib/log/controls/time.rb
+- lib/log/defaults.rb
+- lib/log/filter.rb
+- lib/log/format.rb
+- lib/log/format/color.rb
+- lib/log/level.rb
+- lib/log/levels.rb
+- lib/log/log.rb
+- lib/log/registry.rb
+- lib/log/subject_name.rb
+- lib/log/substitute.rb
+- lib/log/tags.rb
+- lib/log/telemetry.rb
+- lib/log/write.rb
+homepage: https://github.com/eventide-project/log
+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.3.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Logging to STD IO with levels, tagging, and coloring
+test_files: []