evt-telemetry-logger 0.5.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4fa78e17af434e16e3d6cb9cec295a3f6c613a45
+  data.tar.gz: 2e07f132799a4a90311c9847b6f2a20fac4b7f6f
+SHA512:
+  metadata.gz: b3827dc61365389e75c9079e5073e346f757d15532293970ddf69fbf0dfe95a609049ebdbd34355a427197027b0aae773c3fc2c0a864026023ddef07cd93e547
+  data.tar.gz: 81b83031ec93965b4c7d136ca74a6d5951ae50ac02672fbac7b8f0a304a40c1dfb46ed29c2e114cacf0fc536895d83f363f27b3ac9130cbada4349e61e5124b2

data/lib/telemetry/logger/ad_hoc.rb

@@ -0,0 +1,18 @@
+class Telemetry
+  module Logger
+    module AdHoc
+      def self.activate(target_class=nil)
+        target_class ||= Object
+
+        return if target_class.is_a? self
+
+        target_class.send :include, self
+      end
+
+      def __logger(subject=nil)
+        subject ||= caller[0].split('/').last
+        Telemetry::Logger.build subject
+      end
+    end
+  end
+end

data/lib/telemetry/logger/color.rb

@@ -0,0 +1,75 @@
+class Telemetry
+  module Logger
+    module Color
+      extend self
+
+      def apply(level, message)
+        if respond_to? level
+          send level, message
+        else
+          message
+        end
+      end
+
+      def metadata(text)
+        Rainbow(text).yellow
+      end
+
+      def todo(message)
+        Rainbow(message).bright.white.bg(:white)
+      end
+
+      def fubar(message)
+        Rainbow(message).red.bg(:yellow)
+      end
+
+      def obsolete(message)
+        Rainbow(message).bright.white
+      end
+
+      def opt_data(message)
+        data(message)
+      end
+
+      def data(message)
+        Rainbow(message).cyan
+      end
+
+      def opt_trace(message)
+        trace(message)
+      end
+
+      def trace(message)
+        Rainbow(message).white
+      end
+
+      def info(message)
+        Rainbow(message).green
+      end
+
+      def pass(message)
+        Rainbow(message).black.bg(:green)
+      end
+
+      def fail(message)
+        Rainbow(message).black.bg(:red)
+      end
+
+      def focus(message)
+        Rainbow(message).bright.white.bg(:blue)
+      end
+
+      def warn(message)
+        Rainbow(message).yellow.bg(:black)
+      end
+
+      def error(message)
+        Rainbow(message).red.bg(:black)
+      end
+
+      def fatal(message)
+        Rainbow(message).white.bg(:black)
+      end
+    end
+  end
+end

data/lib/telemetry/logger/console_logger.rb

@@ -0,0 +1,115 @@
+class Telemetry
+  module Logger
+    class ConsoleLogger
+      include Levels
+
+      attr_reader :name
+      attr_reader :device
+
+      attr_reader :level
+      attr_reader :level_number
+
+      dependency :clock, Clock::Local
+
+      def self.build(subject)
+        name = logger_name(subject)
+        device = Defaults.device
+        instance = new(name, device)
+        instance.level = Defaults.level
+        Clock::Local.configure instance
+        instance
+      end
+
+      def self.logger_name(subject)
+        if subject.is_a?(Class) || subject.is_a?(Module)
+          name = subject.name
+        elsif subject.is_a? String
+          name = subject
+        else
+          name = subject.class.name
+        end
+        name
+      end
+
+      def initialize(name, device)
+        @name = name
+        @device = device
+      end
+
+      def write(message)
+        return if Defaults.activation == 'off'
+        device.write "#{message}#{$INPUT_RECORD_SEPARATOR}"
+      end
+
+      def format(message, level)
+        return message if Defaults.color == 'off'
+        Telemetry::Logger::Color.apply(level, message)
+      end
+
+      def format_metadata(text)
+        return text if Defaults.color == 'off'
+        Telemetry::Logger::Color.metadata(text)
+      end
+
+      def level=(level)
+        index = ordinal(level)
+
+        raise "Unknown logger level: #{level}" unless index
+
+        @level_number = index
+        @level = level
+      end
+
+      module Defaults
+        def self.level
+          level = ENV['LOG_LEVEL']
+          return level.to_sym if level
+
+          :info
+        end
+
+        def self.device
+          setting = ENV['CONSOLE_DEVICE']
+          device = nil
+          if setting && !['stderr', 'stdout'].include?(setting)
+            raise "The CONSOLE_DEVICE should be either 'stderr' (default) or 'stdout'"
+          elsif setting
+            device = setting == 'stderr' ? STDERR : STDOUT
+          else
+            device = STDERR
+          end
+          device.sync = true
+          device
+        end
+
+        def self.activation
+          activation = ENV['LOGGER']
+          return activation if activation
+
+          'on'
+        end
+
+        def self.color
+          color = ENV['LOG_COLOR']
+
+          # CONSOLE_COLOR is obsolete. It is here for backwards compatibility
+          if color.nil?
+            color = ENV['CONSOLE_COLOR']
+
+            unless color.nil?
+              puts '*** WARNING: The CONSOLE_COLOR environment variable is obsolete. Use LOG_COLOR instead. Support for CONSOLE_COLOR will be discontinued.'
+            end
+          end
+
+          return color if color
+
+          if device.tty?
+            'on'
+          else
+            'off'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/telemetry/logger/dependency.rb

@@ -0,0 +1,15 @@
+class Telemetry
+  module Logger
+    module Dependency
+      def self.included(cls)
+        cls.class_exec do
+          dependency :logger, Telemetry::Logger
+
+          def logger
+            @logger ||= Logger.configure self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/telemetry/logger/levels.rb

@@ -0,0 +1,141 @@
+class Telemetry
+  module Logger
+    module Levels
+      def self.levels
+        [
+          :todo,
+          :fubar,
+          :obsolete,
+          :data,
+          :trace,
+          :debug,
+          :opt_data,
+          :opt_trace,
+          :opt_debug,
+          :info,
+          :pass,
+          :fail,
+          :focus,
+          :warn,
+          :error,
+          :fatal
+        ]
+      end
+
+      def self.included(cls)
+        levels.each do |level|
+          define_level level, cls
+        end
+      end
+
+      def self.define_level(level, cls)
+        cls.send :define_method, level do |message|
+          write_level(__method__, message)
+        end
+      end
+
+      def self.level_index
+        @level_index ||= build_level_index
+      end
+
+      def self.build_level_index
+        table = {}
+
+        levels.each_with_index do |level, index|
+          table[level] = index
+        end
+
+        table
+      end
+
+      def level_index
+        Levels.level_index
+      end
+
+      def ordinal(level)
+        if [:_min, :_max].include?(level)
+          if level == :_min
+            return level_index.values.last
+          else
+            return level_index.values.first
+          end
+        end
+
+        level_index[level]
+      end
+
+      def write_level(level, message)
+        level_ordinal = ordinal(level)
+        write_message(message, level) if sufficient_level?(level_ordinal) && !omit?(level)
+      end
+
+      def write_message(message, level)
+        message = message.to_s
+
+        if message.length == 0
+          message = '(empty log message)'
+        end
+
+        message.each_line do |line|
+          line = line.chomp("\n") unless line.end_with?("\r\n") || line == "\n"
+          line = line.gsub("\r", "\\r")
+          line = line.gsub("\n", "\\n")
+
+          message = implementer.format(line, level)
+          metadata = metadata(level)
+          header = implementer.format_metadata(metadata)
+
+          implementer.write "#{header}#{message}"
+        end
+      end
+
+      def metadata(level)
+        if Defaults.metadata == 'off'
+          return nil
+        elsif Defaults.metadata == 'minimal'
+          return "#{name.split('::').last}: "
+        else
+          level = String(level)
+
+          if level.start_with?('opt_')
+            level = "(#{level.split('_').last})"
+          end
+
+          return "[#{implementer.clock.iso8601}] #{name} #{level.upcase}: "
+        end
+      end
+
+      def sufficient_level?(level_ordinal)
+        level_ordinal >= level_number
+      end
+
+      def omit?(level)
+        Defaults.optional == 'off' && optional_level?(level)
+      end
+
+      def optional_level?(level)
+        String(level).start_with?('opt_')
+      end
+
+      def implementer
+        self
+      end
+
+      module Defaults
+        def self.metadata
+          metadata = ENV['LOG_METADATA']
+          return metadata if metadata
+
+          'on'
+        end
+
+        def self.optional
+          optional = ENV['LOG_OPTIONAL']
+          return optional if optional
+
+          'off'
+        end
+      end
+    end
+  end
+end

data/lib/telemetry/logger/logger.rb

@@ -0,0 +1,47 @@
+class Telemetry
+  module Logger
+    extend self
+
+    def build(subject, implementation=nil)
+      implementation ||= Defaults.implementation
+      logger = implementation.build(subject)
+      logger
+    end
+
+    def get(subject, implementation=nil)
+      build(subject, implementation)
+    end
+
+    def register(subject, implementation=nil)
+      logger = Logger.build self
+      logger.obsolete "The \"register\" method is obsolete (#{caller[0]}). It is replaced with the \"build\" method."
+
+      build(subject, implementation)
+    end
+
+    def configure(receiver, implementation=nil)
+      logger = build(receiver, implementation)
+      receiver.logger = logger
+      logger
+    end
+
+    def self.debug(message)
+      write message
+    end
+
+    def self.write(message, level=nil, subject=nil, implementation=nil)
+      level ||= :debug
+      subject ||= '***'
+
+      logger = build subject, implementation
+
+      logger.write_message message, level
+    end
+
+    module Defaults
+      def self.implementation
+        ConsoleLogger
+      end
+    end
+  end
+end

data/lib/telemetry/logger/null_object.rb

@@ -0,0 +1,18 @@
+class Telemetry
+  module Logger
+    class NullLogger
+      include Levels
+    end
+
+    module NullObject
+      def self.build
+        cls = Naught.build do |config|
+          config.singleton
+          config.mimic NullLogger
+        end
+
+        cls.get
+      end
+    end
+  end
+end

data/lib/telemetry/logger.rb

@@ -0,0 +1,15 @@
+require 'English'
+
+require 'rainbow'; Rainbow.enabled = true
+
+require 'pathname'
+require 'clock'
+require 'dependency'; Dependency.activate
+
+require 'telemetry/logger/logger'
+require 'telemetry/logger/levels'
+require 'telemetry/logger/color'
+require 'telemetry/logger/null_object'
+require 'telemetry/logger/console_logger'
+require 'telemetry/logger/ad_hoc'
+require 'telemetry/logger/dependency'

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: evt-telemetry-logger
+version: !ruby/object:Gem::Version
+  version: 0.5.1.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-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: 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: 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/telemetry/logger.rb
+- lib/telemetry/logger/ad_hoc.rb
+- lib/telemetry/logger/color.rb
+- lib/telemetry/logger/console_logger.rb
+- lib/telemetry/logger/dependency.rb
+- lib/telemetry/logger/levels.rb
+- lib/telemetry/logger/logger.rb
+- lib/telemetry/logger/null_object.rb
+homepage: https://github.com/eventide-project/telemetry-logger
+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 STDERR with coloring and levels of severity
+test_files: []