loglevel 0.4.6 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e79aa9c19b2851bcdee30c94c4bb1a011fb3db36
-  data.tar.gz: be838162ac2ae9e6c0115f364a8a8e7ca9f02701
+  metadata.gz: 2f7aa16f419c37f168c98409956cfa25b9cee845
+  data.tar.gz: 0ada2cc16ef1b3fa9527c438e26858d4dae83cea
 SHA512:
-  metadata.gz: a5d700d54652aae4b51630fe9f3f8efc152d8746579d07ca3594d271804154b358a9790b3696e3dfcb63eee085e2f18388ecaed686368ee2696757536fd86a98
-  data.tar.gz: d76b5d4acbc52b42b4a97b0aa7a3ab33ef5155738739b5cf74982865a071866e28fcf3f4f67b236f32016a8b040a19359168cfff943d10c9dc7c0aaffbf281ba
+  metadata.gz: dab91b3da3a07b99134fe9bec53ac2a2020d9edf37b7dcc1c94f0b254c90a4221aea2ea065545e19a4ec74b0b5e70775ff6071a090112d40358a418dfb941454
+  data.tar.gz: 0eff2e99f03b5d23abb3f65382996f5681fed4c53e5bad3e8514bcbc4bc0598eb1e29a996f7ab71f8a3f71580b96fde0c9be0c4cd9f68779d206bf9126517440

data/.rubocop.yml

@@ -1,49 +1,63 @@
----
-AllCops:
-  TargetRubyVersion: 2.0
-  DisplayCopNames: true
-  Exclude:
-    - 'tmp/**/*'
-
-Style/MixinGrouping:
-  Exclude:
-    - 'spec/**/*.rb'
-
-Metrics/BlockLength:
-  CountComments: false  # count full line comments?
-  Exclude:
-    - '**/*_spec.rb'
-
-StringLiterals:
-  EnforcedStyle: single_quotes
-  Enabled: true
-
-DotPosition:
-  Description: 'Checks the position of the dot in multi-line method calls.'
-  EnforcedStyle: leading
-  Enabled: true
-
-ClassAndModuleChildren:
-  Description: 'Checks style of children classes and modules.'
-  EnforcedStyle: nested
-  Enabled: true
-
-Documentation:
-  Description: 'Document classes and non-namespace modules.'
-  Enabled: false
-
-FileName:
-  Description: 'Use snake_case for source file names.'
-  Enabled: true
-
-LineLength:
-  Max: 120
-  Enabled: true
-
-Style/ExtraSpacing:
-  Description: 'Do not use unnecessary spacing.'
-  Enabled: true
-
-Lint/LiteralInInterpolation:
-  Description: 'Avoid interpolating literals in strings'
-  AutoCorrect: true
+---
+AllCops:
+  TargetRubyVersion: 2.0
+  DisplayCopNames: true
+  Exclude:
+    - 'tmp/**/*'
+
+Style/MixinGrouping:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Metrics/BlockLength:
+  CountComments: false  # count full line comments?
+  Exclude:
+    - '**/*_spec.rb'
+
+StringLiterals:
+  EnforcedStyle: single_quotes
+  Enabled: true
+
+DotPosition:
+  Description: 'Checks the position of the dot in multi-line method calls.'
+  EnforcedStyle: leading
+  Enabled: true
+
+ClassAndModuleChildren:
+  Description: 'Checks style of children classes and modules.'
+  EnforcedStyle: nested
+  Enabled: true
+
+Documentation:
+  Description: 'Document classes and non-namespace modules.'
+  Enabled: false
+
+FileName:
+  Description: 'Use snake_case for source file names.'
+  Enabled: true
+
+LineLength:
+  Max: 120
+  Enabled: true
+
+Style/ExtraSpacing:
+  Description: 'Do not use unnecessary spacing.'
+  Enabled: true
+
+Lint/LiteralInInterpolation:
+  Description: 'Avoid interpolating literals in strings'
+  AutoCorrect: true
+
+Style/ModuleFunction:
+  EnforcedStyle: extend_self # Allows us to have private methods too
+
+Style/PercentLiteralDelimiters:
+  # Hound and CodeClimate are currently using an old version of Rubocop with
+  # different defaults, so we set them explicitly here.
+  PreferredDelimiters:
+    default: ()
+    '%i': '[]'
+    '%I': '[]'
+    '%r': '{}'
+    '%w': '[]'
+    '%W': '[]'

data/README.md

@@ -16,6 +16,10 @@ Usage:
 LOGLEVEL=WARN rails server
 ```
 
+Loglevel will direct your logging to `STDOUT` (as suggested in
+[the 12-factor app](https://12factor.net/logs)). See the Log Device section
+below for how to control where your logging goes.
+
 ### Features
 
 Control which components create visible log entries by simply setting an
@@ -28,12 +32,6 @@ LOGLEVEL=DEBUG,NOAR,NOHTTP rails server
 would set the Rails logger level to `:debug` but would suppress messages from
 the ActiveRecord logger and the HttpLogger gem.
 
-The features are itemized if you use the `HELP` option:
-
-```sh
-LOGLEVEL=HELP rails console
-```
-
 Here are the available settings:
 
 | Option    | Description                                 |

data/lib/loglevel.rb

@@ -1,134 +1,29 @@
 require 'loglevel/exception'
-require 'loglevel/classes'
-require 'loglevel/active_record'
-require 'loglevel/http_logger'
-require 'loglevel/help'
-require 'loglevel/logger_analyzer'
+require 'loglevel/constants'
+require 'loglevel/loggable_classes'
 
-class Loglevel
-  ENV_VAR_LEVEL   = 'LOGLEVEL'.freeze
-  ENV_VAR_LOGGER  = 'LOGLEVEL_LOGGER'.freeze
-  ENV_VAR_DEVICE  = 'LOGLEVEL_DEVICE'.freeze
-  ENV_VAR_CLASSES = 'LOGLEVEL_CLASSES'.freeze
-  LOGLEVELS = %w[DEBUG INFO WARN ERROR FATAL UNKNOWN].freeze
-
-  LOGLEVELS.each_with_index { |k, v| const_set(k, v) }
-
-  class << self
-    def setup
-      new.setup
-    end
-
-    def inspect
-      new.inspect
-    end
-
-    def debug
-      new.debug
-    end
-  end
-
-  attr_reader :classes
-  attr_writer :logger
-
-  def logger
-    @logger ||= use_default_logger? ? default_logger : logger_class.new(device)
-  end
-
-  def level
-    @level ||= self.class.const_get level_name
-  end
+module Loglevel
+  extend self
 
   def setup
-    return self unless ENV[ENV_VAR_LEVEL]
-
-    @settings = nil
-    @logger = nil
-    @level = nil
-
-    setup_classes
-    announce
-    self
-  end
-
-  private
-
-  def initialize
-    @classes = Loglevel::Classes.new.classes
-  end
-
-  def setup_classes
-    @classes_to_setup = @classes.dup
-    setup_active_record
-    setup_http_logger
-    setup_remaining_classes
-  end
-
-  # Setup any other classes (e.g. Rails)
-  def setup_remaining_classes
-    @classes_to_setup.each do |klass|
-      klass.logger = logger
-      klass.logger.level = level
-    end
-  end
-
-  def announce
-    help if help?
-    puts inspect if level_name == 'DEBUG'
-    puts debug if lookup('__DEBUG')
-  end
-
-  def level_name
-    (LOGLEVELS & settings).first || 'WARN'
-  end
-
-  def logger_class
-    use_default_logger? ? default_logger.class : Object.const_get(logger_class_name)
-  rescue NameError
-    raise Loglevel::Exception::BadLoggerClass, "Can't find logger class #{logger_class_name} - have you required it?"
-  end
-
-  def logger_class_name
-    @logger_class_name ||= ENV.fetch(ENV_VAR_LOGGER, logger_class_name_default)
+    loggable_classes.each(&:setup)
   end
 
-  def logger_class_name_default
-    @logger_class_default ||= if default_logger.nil? || default_logger_not_instantiatable?
-                                'Logger'
-                              else
-                                default_logger.class.name
-                              end
-  end
-
-  def default_logger_not_instantiatable?
-    defined?(ActiveSupport::TaggedLogging) && default_logger.is_a?(ActiveSupport::TaggedLogging)
-  end
-
-  def use_default_logger?
-    !ENV[ENV_VAR_LOGGER] && !ENV[ENV_VAR_DEVICE] && !default_logger.nil?
-  end
-
-  def default_logger
-    @default_logger ||= ::Rails.logger if defined?(::Rails)
+  def debug
+    loggable_classes.map { |c| { name: c.class_name, logger: c.logger.class, level: c.level.level_name } }
   end
 
   def device
-    %w[STDOUT STDERR].include?(device_name) ? Object.const_get(device_name) : device_name
-  end
-
-  def device_name
-    ENV.fetch(ENV_VAR_DEVICE, 'STDOUT')
+    @device ||= ENV.fetch Loglevel::ENV_VAR_DEVICE, STDOUT
   end
 
-  def lookup(setting)
-    settings.include?(setting)
+  def loggable_classes
+    @loggable_classes ||= LoggableClasses.clone # More testable
   end
 
-  def settings
-    @settings ||= ENV.fetch(ENV_VAR_LEVEL, '').upcase.split(',')
+  def name_to_class(class_name, exception_class)
+    Object.const_get(class_name)
+  rescue NameError => exception
+    Loglevel::Exception.handle_bad_class(class_name, exception, exception_class)
   end
-
-  include Loglevel::ActiveRecord
-  include Loglevel::HttpLogger
-  include Loglevel::Help
 end

data/lib/loglevel/constants.rb

@@ -0,0 +1,11 @@
+module Loglevel
+  LOGLEVELS = %w[DEBUG INFO WARN ERROR FATAL UNKNOWN].freeze
+  LOGLEVELS.each_with_index { |k, v| const_set(k, v) }
+
+  ENV_VAR_LEVEL   = 'LOGLEVEL'.freeze
+  ENV_VAR_LOGGER  = 'LOGGER'.freeze
+  ENV_VAR_DEVICE  = 'LOGDEVICE'.freeze
+  ENV_VAR_CLASSES = 'LOGCLASSES'.freeze
+
+  SCOPE_RESOLUTION_OPERATOR = SRO = '::'.freeze
+end

data/lib/loglevel/exception.rb

@@ -1,6 +1,16 @@
-class Loglevel
+module Loglevel
   # Local exception classes to make handling exceptions easier
   class Exception < RuntimeError
-    BadLoggerClass = Class.new(self)
+    UnknownLoggableClass = Class.new(self)
+    UnknownLoggerClass = Class.new(self)
+    ClassNotLoggable = Class.new(self)
+
+    def self.handle_bad_class(class_name, exception, exception_class)
+      raise exception unless  exception.class == NameError &&
+                              class_name.respond_to?(:split) &&
+                              exception.message =~ /.+constant.+#{class_name.split(Loglevel::SRO).first}/
+
+      raise exception_class, class_name
+    end
   end
 end

data/lib/loglevel/loggable_class.rb

@@ -0,0 +1,62 @@
+require 'loglevel/loggable_class/level'
+require 'loglevel/loggable_class/smart_logger'
+
+module Loglevel
+  class LoggableClass
+    attr_reader :class_name, :logger
+    alias to_s class_name
+
+    def setup
+      self.logger = smart_logger.create
+      logger.level = level.value
+      klass.logger = logger
+      additional_http_setup
+    end
+
+    def level
+      @level ||= Level.new(self)
+    end
+
+    def active_record?
+      @active_record ||= canonical_name == '::ActiveRecord::Base'
+    end
+
+    def http?
+      @http ||= canonical_name == '::HttpLogger'
+    end
+
+    private
+
+    attr_writer :logger
+
+    def initialize(class_name)
+      @class_name = class_name
+      raise Loglevel::Exception::ClassNotLoggable, class_name unless klass.respond_to?(:logger=)
+    end
+
+    def additional_http_setup
+      return unless http?
+
+      klass.level = level.level_name.downcase.to_sym
+      klass.log_response_body = settings.response_body?
+      klass.log_headers = settings.request_headers?
+      klass.ignore = [/9200/, /7474/] # ignore Elasticsearch & Neo4J
+    end
+
+    def klass
+      @klass ||= Loglevel.name_to_class(canonical_name, Loglevel::Exception::UnknownLoggableClass)
+    end
+
+    def canonical_name
+      @canonical_name ||= class_name[0, 2] == Loglevel::SRO ? class_name : "#{Loglevel::SRO}#{class_name}"
+    end
+
+    def settings
+      @settings ||= Loglevel::Settings.clone # More testable
+    end
+
+    def smart_logger
+      @smart_logger ||= SmartLogger.clone # More testable
+    end
+  end
+end

data/lib/loglevel/loggable_class/level.rb

@@ -0,0 +1,44 @@
+require 'loglevel/settings'
+
+module Loglevel
+  class LoggableClass
+    class Level
+      def value
+        @value ||= Loglevel.const_get level_name
+      end
+
+      def level_name
+        @level_name ||= http_level_name || active_record_level_name || environment_level_name
+      end
+
+      private
+
+      extend Forwardable
+
+      def_delegators :loggable_class, :active_record?, :http?
+
+      attr_reader :loggable_class
+
+      def initialize(loggable_class, settings = nil)
+        @loggable_class = loggable_class
+        @settings = settings
+      end
+
+      def http_level_name
+        @http_level_name ||= 'FATAL' if loggable_class.http? && !settings.http?
+      end
+
+      def active_record_level_name
+        @active_record_level_name ||= 'FATAL' if loggable_class.active_record? && !settings.active_record?
+      end
+
+      def environment_level_name
+        @environment_level_name ||= settings.level
+      end
+
+      def settings
+        @settings ||= Loglevel::Settings.clone # More testable
+      end
+    end
+  end
+end

data/lib/loglevel/loggable_class/smart_logger.rb

@@ -0,0 +1,45 @@
+module Loglevel
+  class LoggableClass
+    class SmartLogger
+      class << self
+        def create
+          enhanced_logger || simple_logger
+        end
+
+        private
+
+        def simple_logger
+          logger_class.new device
+        end
+
+        def enhanced_logger
+          ActiveSupport::TaggedLogging.new(simple_logger) if defined?(ActiveSupport::TaggedLogging)
+        end
+
+        def logger_class
+          @logger_class ||= loglevel.name_to_class(class_name, Loglevel::Exception::UnknownLoggerClass)
+        end
+
+        def class_name
+          @class_name ||= environment_class_name || rails_class_name || 'Logger'
+        end
+
+        def environment_class_name
+          @environment_class_name ||= ENV[Loglevel::ENV_VAR_LOGGER]
+        end
+
+        def rails_class_name
+          'ActiveSupport::Logger' if defined?(ActiveSupport::Logger)
+        end
+
+        def device
+          @device ||= loglevel.device
+        end
+
+        def loglevel
+          @loglevel ||= Loglevel.clone # More testable
+        end
+      end
+    end
+  end
+end

data/lib/loglevel/loggable_classes.rb

@@ -0,0 +1,33 @@
+require 'loglevel/loggable_class'
+
+module Loglevel
+  module LoggableClasses
+    class << self
+      extend Forwardable
+
+      def_delegators :classes, :each, :map, :length
+
+      def classes
+        @classes ||= class_names.map { |class_name| class_from_name(class_name) }.compact
+      end
+
+      private
+
+      RAILS_LOGGABLE_CLASSES = %w[Rails ActiveRecord::Base HttpLogger].freeze
+
+      def class_names
+        @class_names ||= environment_class_names | RAILS_LOGGABLE_CLASSES
+      end
+
+      def environment_class_names
+        @environment_class_names ||= ENV.fetch(Loglevel::ENV_VAR_CLASSES, '').gsub(/[[:space:]]/, '').split(',')
+      end
+
+      def class_from_name(class_name)
+        LoggableClass.new class_name
+      rescue Loglevel::Exception
+        nil
+      end
+    end
+  end
+end

data/lib/loglevel/settings.rb

@@ -0,0 +1,35 @@
+module Loglevel
+  module Settings
+    extend self
+
+    def level
+      @level ||= (Loglevel::LOGLEVELS & settings).first || 'WARN'
+    end
+
+    def http?
+      !lookup('NOHTTP')
+    end
+
+    def active_record?
+      !lookup('NOAR')
+    end
+
+    def response_body?
+      !lookup('NOBODY')
+    end
+
+    def request_headers?
+      !lookup('NOHEADERS')
+    end
+
+    private
+
+    def lookup(setting)
+      settings.include?(setting)
+    end
+
+    def settings
+      @settings ||= ENV.fetch(ENV_VAR_LEVEL, '').upcase.split(',')
+    end
+  end
+end

data/lib/loglevel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-class Loglevel
-  VERSION = '0.4.6'.freeze
+module Loglevel
+  VERSION = '1.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loglevel
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 1.0.0
 platform: ruby
 authors:
 - Dominic Sayers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-11 00:00:00.000000000 Z
+date: 2017-04-12 00:00:00.000000000 Z
 dependencies: []
 description: A simple gem to control logging at runtime with an environment variable
 email:
@@ -32,12 +32,13 @@ files:
 - Rakefile
 - circle.yml
 - lib/loglevel.rb
-- lib/loglevel/active_record.rb
-- lib/loglevel/classes.rb
+- lib/loglevel/constants.rb
 - lib/loglevel/exception.rb
-- lib/loglevel/help.rb
-- lib/loglevel/http_logger.rb
-- lib/loglevel/logger_analyzer.rb
+- lib/loglevel/loggable_class.rb
+- lib/loglevel/loggable_class/level.rb
+- lib/loglevel/loggable_class/smart_logger.rb
+- lib/loglevel/loggable_classes.rb
+- lib/loglevel/settings.rb
 - lib/loglevel/version.rb
 - loglevel.gemspec
 - script/console

data/lib/loglevel/active_record.rb

@@ -1,24 +0,0 @@
-# ActiveRecord-specific settings
-class Loglevel
-  module ActiveRecord
-    private
-
-    def active_record?
-      !lookup('NOAR')
-    end
-
-    def setup_active_record
-      return unless defined?(::ActiveRecord::Base) && @classes_to_setup.delete(::ActiveRecord::Base)
-      active_record? ? setup_active_record_logger_to_log : setup_active_record_logger_not_to_log
-    end
-
-    def setup_active_record_logger_to_log
-      ::ActiveRecord::Base.logger = logger
-      ::ActiveRecord::Base.logger.level = level
-    end
-
-    def setup_active_record_logger_not_to_log
-      ::ActiveRecord::Base.logger.level = Loglevel::FATAL
-    end
-  end
-end

data/lib/loglevel/classes.rb

@@ -1,29 +0,0 @@
-class Loglevel
-  class Classes
-    attr_reader :classes
-
-    def stringify
-      @stringify ||= classes.map(&:name)
-    end
-
-    private
-
-    def initialize
-      @classes = class_names.map do |class_name|
-        begin
-          Object.const_get("::#{class_name}")
-        rescue NameError # Uninitialized constant
-          nil
-        end
-      end.compact
-    end
-
-    def class_names
-      @class_names ||= passed_class_names | %w[Rails ActiveRecord::Base HttpLogger]
-    end
-
-    def passed_class_names
-      @passed_class_names ||= ENV.fetch(Loglevel::ENV_VAR_CLASSES, '').gsub(/[[:space:]]/, '').split(',')
-    end
-  end
-end

data/lib/loglevel/help.rb

@@ -1,43 +0,0 @@
-# Help
-class Loglevel
-  module Help
-    def help
-      logger.info <<-HELP.gsub('        ', '')
-        Usage: LOGLEVEL=SETTING,SETTING,SETTING rails server
-
-        Available settings are as follows:
-        HELP      Show these options
-        FATAL     Equivalent to config.log_level = :fatal
-        ERROR     Equivalent to config.log_level = :error
-        WARN      Equivalent to config.log_level = :warn
-        INFO      Equivalent to config.log_level = :info
-        DEBUG     Equivalent to config.log_level = :debug
-        NOAR      Do not show ActiveRecord messages
-        NOHTTP    Do not show HTTP messages
-        NOHEADERS Do not include response headers in HTTP log
-        NOBODY    Do not include response body in HTTP log
-
-        HTTP messages will only be shown if http_logger gem is present
-      HELP
-    end
-
-    def inspect
-      "#<#{self.class}: logger=#{logger_class}, device=#{device_name}, level=#{level_name}, settings=#{settings}>"
-    end
-
-    def debug
-      debug = classes.map do |klass|
-        l = Loglevel::LoggerAnalyzer.new(klass)
-        "#{klass}: logger=#{l.logger_class}, device=#{l.device_name}, level=#{l.level_name}"
-      end
-
-      debug.join("\n")
-    end
-
-    private
-
-    def help?
-      lookup('HELP') || settings == ['TRUE']
-    end
-  end
-end

data/lib/loglevel/http_logger.rb

@@ -1,35 +0,0 @@
-# HttpLogger-specific settings
-class Loglevel
-  module HttpLogger
-    private
-
-    def http?
-      !lookup('NOHTTP')
-    end
-
-    def response_body?
-      !lookup('NOBODY')
-    end
-
-    def request_headers?
-      !lookup('NOHEADERS')
-    end
-
-    def setup_http_logger
-      return unless defined?(::HttpLogger) && @classes_to_setup.delete(::HttpLogger)
-      http? ? setup_http_logger_to_log : setup_http_logger_not_to_log
-    end
-
-    def setup_http_logger_to_log
-      ::HttpLogger.logger = logger
-      ::HttpLogger.level = level_name.downcase.to_sym
-      ::HttpLogger.log_response_body = response_body?
-      ::HttpLogger.log_headers = request_headers?
-      ::HttpLogger.ignore = [/9200/, /7474/] # ignore Elasticsearch & Neo4J
-    end
-
-    def setup_http_logger_not_to_log
-      ::HttpLogger.level = :fatal
-    end
-  end
-end

data/lib/loglevel/logger_analyzer.rb

@@ -1,40 +0,0 @@
-# Analyses the logger method of a class
-class Loglevel
-  class LoggerAnalyzer
-    def level_name
-      @level_name ||= Loglevel::LOGLEVELS[level]
-    end
-
-    def level
-      @level ||= logger_level.is_a?(0.class) ? logger_level : 5
-    end
-
-    def logger_level
-      @logger_level ||= logger.level
-    end
-
-    def device_name
-      @device_name ||= logdev.filename || logdev.dev.inspect || 'nil'
-    end
-
-    def logdev
-      @logdev ||= logger.instance_variable_get('@logdev') || Struct.new(:filename, :dev).new
-    end
-
-    def logger_class
-      @logger_class ||= logger.class
-    end
-
-    def logger
-      @logger ||= klass.logger || Struct.new(:level).new(0)
-    end
-
-    private
-
-    attr_reader :klass
-
-    def initialize(klass)
-      @klass = klass
-    end
-  end
-end