rails_semantic_logger 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d08b2b972eaf1186c52d9843aef02585f0f41b2c
-  data.tar.gz: 8dac75b9cbbc7f03bd7c90d25e293b3132810de3
+  metadata.gz: 6b67e5d8f28b2e51e0718ba6bb78836efffba19b
+  data.tar.gz: 8f255e0c6a0d030f40e45423db46187aae7fcd9f
 SHA512:
-  metadata.gz: 2d877c06b9d76c0b404e4c269e43b3d6e67d06c7d6e2e95f74b8d8676a94e944167d605403097886170a0c4e9d9ab841e58866ec42cd47d40afa5926190ccdbd
-  data.tar.gz: 30442065d1a273fde0a7166bb06b3074ac32ca7411441c8046a52386fa679bd194b28e30960651b12dbb79a11881ea8a66256ff8d776e225c0bf04f6f8340381
+  metadata.gz: b5202dc5e4bfcd755dfd1de312e3023ac4526d933094df2ded3495420fac0882df959f5a6a2be29054c3bb1d91cc1adb5eb81152a75766105e586caf082c597a
+  data.tar.gz: 9cf9187d55b5bb2a862be2c58e36aecec7cf318f91ca1f64287b9690c834e13ec503cbf22e943eabd49d70cc5f93e9dc38765c139b9dd5ef4bb89165f6cc5a7e

data/README.md

@@ -14,7 +14,7 @@ For complete documentation see: http://rocketjob.github.io/semantic_logger/rails
 ## Supports
 
 - Ruby 1.9.3, 2.0, 2.1, 2.2 (or above) Or, JRuby 1.7, 9.0 (or above)
-- Rails 3, 4, 5 (or above)
+- Rails 3.2, 4, 5 (or above)
 
 ## Author
 

data/lib/rails_semantic_logger/extensions/action_cable/tagged_logger_proxy.rb

@@ -0,0 +1,12 @@
+ActionCable::Connection::TaggedLoggerProxy
+
+module ActionCable
+  module Connection
+    class TaggedLoggerProxy
+      def tag(logger, &block)
+        current_tags = tags - logger.tags
+        logger.tagged(*current_tags, &block)
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/extensions/action_controller/live.rb

@@ -0,0 +1,7 @@
+# Log actual exceptions, not a string representation
+ActionController::Live
+module ActionController::Live
+  def log_error(exception)
+    logger.fatal(exception)
+  end
+end

data/lib/rails_semantic_logger/extensions/action_controller/log_subscriber.rb

@@ -0,0 +1,101 @@
+ActionController::LogSubscriber
+
+module ActionController
+  class LogSubscriber
+    # Log as debug to hide Processing messages in production
+    def start_processing(event)
+      controller_logger(event).debug { "Processing ##{event.payload[:action]}" }
+    end
+
+    def process_action(event)
+      controller_logger(event).info do
+        payload = event.payload
+        params  = payload[:params].except(*INTERNAL_PARAMS)
+        format  = payload[:format]
+        format  = format.to_s.upcase if format.is_a?(Symbol)
+        status  = payload[:status]
+
+        if status.nil? && payload[:exception].present?
+          exception_class_name = payload[:exception].first
+          status               = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
+        end
+
+        log = {
+          message:        "Completed ##{payload[:action]}",
+          status:         status,
+          status_message: Rack::Utils::HTTP_STATUS_CODES[status],
+          format:         format,
+          path:           payload[:path],
+          action:         payload[:action],
+          method:         payload[:method],
+          duration:       event.duration
+        }
+        collect_runtimes(payload, log)
+        log[:params] = params unless params.empty?
+        log
+      end
+    end
+
+    def halted_callback(event)
+      controller_logger(event).info { "Filter chain halted as #{event.payload[:filter].inspect} rendered or redirected" }
+    end
+
+    def send_file(event)
+      controller_logger(event).info('Sent file') { {path: event.payload[:path], duration: event.duration} }
+    end
+
+    def redirect_to(event)
+      controller_logger(event).info('Redirected to') { {location: event.payload[:location]} }
+    end
+
+    def send_data(event)
+      controller_logger(event).info('Sent data') { {file_name: event.payload[:filename], duration: event.duration} }
+    end
+
+    def unpermitted_parameters(event)
+      controller_logger(event).debug do
+        unpermitted_keys = event.payload[:keys]
+        "Unpermitted parameter#{'s' if unpermitted_keys.size > 1}: #{unpermitted_keys.join(", ")}"
+      end
+    end
+
+    %w(write_fragment read_fragment exist_fragment?
+       expire_fragment expire_page write_page).each do |method|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{method}(event)
+          controller_logger(event).info do
+            key_or_path = event.payload[:key] || event.payload[:path]
+            {message: "#{method.to_s.humanize} \#{key_or_path}", duration: event.duration}
+          end
+        end
+      METHOD
+    end
+
+    private
+
+    # Returns the logger for the supplied event.
+    # Returns ActionController::Base.logger if no controller is present
+    def controller_logger(event)
+      if controller = event.payload[:controller]
+        begin
+          controller.constantize.logger
+        rescue NameError
+          ActionController::Base.logger
+        end
+      else
+        ActionController::Base.logger
+      end
+    end
+
+    # Returns [Hash] runtimes for all registered runtime collection subscribers
+    # For example, :view_runtime, :mongo_runtime, etc.
+    def collect_runtimes(payload, log)
+      payload.each_pair do |key, value|
+        if match = key.to_s.match(/(.*)_runtime/)
+          log[key] = value.to_f.round(2)
+        end
+      end
+    end
+
+  end
+end

data/lib/rails_semantic_logger/extensions/action_controller/log_subscriber_processing.rb

@@ -0,0 +1,27 @@
+ActionController::LogSubscriber
+
+module ActionController
+  class LogSubscriber
+    # Log as info to show Processing messages in production
+    def start_processing(event)
+      controller_logger(event).info { "Processing ##{event.payload[:action]}" }
+    end
+
+    private
+
+    # Returns the logger for the supplied event.
+    # Returns ActionController::Base.logger if no controller is present
+    def controller_logger(event)
+      if controller = event.payload[:controller]
+        begin
+          controller.constantize.logger
+        rescue NameError
+          ActionController::Base.logger
+        end
+      else
+        ActionController::Base.logger
+      end
+    end
+
+  end
+end

data/lib/rails_semantic_logger/extensions/action_dispatch/debug_exceptions.rb

@@ -0,0 +1,11 @@
+# Log actual exceptions, not a string representation
+ActionDispatch::DebugExceptions
+class ActionDispatch::DebugExceptions
+  private
+  def log_error(request, wrapper)
+    ActiveSupport::Deprecation.silence do
+      ActionController::Base.logger.fatal(wrapper.exception)
+    end
+  end
+end
+

data/lib/rails_semantic_logger/extensions/action_view/log_subscriber.rb

@@ -0,0 +1,12 @@
+ActionView::LogSubscriber
+module ActionView
+  class LogSubscriber
+    def info(message = nil, &block)
+      debug(message, &block)
+    end
+
+    def info?
+      debug?
+    end
+  end
+end

data/lib/rails_semantic_logger/extensions/action_view/streaming_template_renderer.rb

@@ -0,0 +1,11 @@
+# Log actual exceptions, not a string representation
+ActionView::StreamingTemplateRenderer
+
+class ActionView::StreamingTemplateRenderer
+  class Body
+    private
+    def log_error(exception) #:nodoc:
+      ActionView::Base.logger.fatal(exception)
+    end
+  end
+end

data/lib/rails_semantic_logger/extensions/active_job/logging.rb

@@ -0,0 +1,9 @@
+# Patch ActiveJob logger
+ActiveJob::Logging
+
+module ActiveJob::Logging
+  private
+  def tag_logger(*tags, &block)
+    logger.tagged(*tags, &block)
+  end
+end

data/lib/rails_semantic_logger/extensions/active_record/log_subscriber.rb

@@ -0,0 +1,37 @@
+ActiveRecord::LogSubscriber
+module ActiveRecord
+  class LogSubscriber
+    def sql(event)
+      self.class.runtime += event.duration
+
+      return unless logger.debug?
+
+      payload = event.payload
+      name    = payload[:name]
+      return if IGNORE_PAYLOAD_NAMES.include?(name)
+
+      log = {
+        message:  name,
+        sql:      payload[:sql],
+        duration: event.duration
+      }
+      unless (payload[:binds] || []).empty?
+        log[:binds] = binds = {}
+        # Changed with Rails 5
+        if Rails.version.to_i >= 5
+          payload[:binds].each do |attr|
+            attr_name, value = render_bind(attr)
+            binds[attr_name] = value
+          end
+        else
+          payload[:binds].each do |col, v|
+            attr_name, value = render_bind(col, v)
+            binds[attr_name] = value
+          end
+        end
+      end
+      debug(log)
+    end
+
+  end
+end

data/lib/rails_semantic_logger/extensions/rails/rack/logger.rb

@@ -0,0 +1,19 @@
+Rails::Rack::Logger
+
+# Replace rack started message with a semantic equivalent
+module Rails
+  module Rack
+    class Logger
+      def started_request_message(request)
+        {
+          message: 'Started',
+          method:  request.request_method,
+          path:    request.filtered_path,
+          ip:      request.ip
+        }
+      end
+
+    end
+  end
+end
+

data/lib/rails_semantic_logger/extensions/rails/rack/logger_info_as_debug.rb

@@ -0,0 +1,28 @@
+Rails::Rack::Logger
+
+# Drop rack Started message to debug level message
+module Rails
+  module Rack
+    class Logger
+      private
+
+      module LogInfoAsDebug
+        def info(*args, &block)
+          debug(*args, &block)
+        end
+        def info?
+          debug?
+        end
+      end
+
+      def logger
+        @logger ||= begin
+          logger = SemanticLogger['Rails']
+          logger.extend(LogInfoAsDebug)
+          logger
+        end
+      end
+
+    end
+  end
+end

data/lib/rails_semantic_logger/extensions/rails/server.rb

@@ -0,0 +1,11 @@
+# Patch the Rails::Server log_to_stdout so that it logs via SemanticLogger
+Rails::Server
+module Rails #:nodoc:
+  class Server #:nodoc:
+    private
+
+    def log_to_stdout
+      SemanticLogger.add_appender(io: $stdout, formatter: :color)
+    end
+  end
+end

data/lib/rails_semantic_logger/railtie.rb

@@ -1,5 +1,6 @@
-require 'logger'
-require 'rails/commands/server'
+require('rails_semantic_logger/extensions/rails/server') if defined?(Rails::Server)
+
+# Replace standard Rails logger
 module RailsSemanticLogger #:nodoc:
   class Railtie < Rails::Railtie #:nodoc:
     # Make the SemanticLogger config available in the Rails application config
@@ -10,13 +11,41 @@ module RailsSemanticLogger #:nodoc:
     #   Rails::Application.configure do
     #     # Add the MongoDB logger appender only once Rails is initialized
     #     config.after_initialize do
-    #       config.semantic_logger.add_appender SemanticLogger::Appender::Mongo.new(
-    #         :db => Mongo::Connection.new['development_development']
-    #        )
+    #       appender = SemanticLogger::Appender::Mongo.new(
+    #         db: Mongo::Connection.new['myapp_development']
+    #       )
+    #       config.semantic_logger.add_appender(appender: appender)
     #     end
     #   end
     config.semantic_logger = ::SemanticLogger
 
+    config.rails_semantic_logger            = ActiveSupport::OrderedOptions.new
+
+    # Convert Action Controller and Active Record text messages to semantic data
+    #   Rails -- Started -- { :ip => "127.0.0.1", :method => "GET", :path => "/dashboards/inquiry_recent_activity" }
+    #   UserController -- Completed #index -- { :action => "index", :db_runtime => 54.64, :format => "HTML", :method => "GET", :mongo_runtime => 0.0, :path => "/users", :status => 200, :status_message => "OK", :view_runtime => 709.88 }
+    config.rails_semantic_logger.semantic   = true
+
+    # Change Rack started message to debug so that it does not appear in production
+    config.rails_semantic_logger.started    = false
+
+    # Change Processing message to debug so that it does not appear in production
+    config.rails_semantic_logger.processing = false
+
+    # Change Action View render log messages to debug so that they do not appear in production
+    #   ActionView::Base --   Rendered data/search/_user.html.haml (46.7ms)
+    config.rails_semantic_logger.rendered   = false
+
+    # Override the Awesome Print options for logging Hash data as text:
+    #
+    #  Any valid AwesomePrint option for rendering data.
+    #  The defaults can changed be creating a `~/.aprc` file.
+    #  See: https://github.com/michaeldv/awesome_print
+    #
+    #  Note: The option :multiline is set to false if not supplied.
+    #  Note: Has no effect if Awesome Print is not installed.
+    config.rails_semantic_logger.ap_options = {multiline: false}
+
     # Initialize SemanticLogger. In a Rails environment it will automatically
     # insert itself above the configured rails logger to add support for its
     # additional features
@@ -33,11 +62,8 @@ module RailsSemanticLogger #:nodoc:
       # Existing loggers are ignored because servers like trinidad supply their
       # own file loggers which would result in duplicate logging to the same log file
       Rails.logger                 = config.logger = begin
-        # First check for Rails 3.2 path, then fallback to pre-3.2
-        path = ((config.paths.log.to_a rescue nil) || config.paths['log']).first
-        unless File.exist? File.dirname path
-          FileUtils.mkdir_p File.dirname path
-        end
+        path = config.paths['log'].first
+        FileUtils.mkdir_p(File.dirname(path)) unless File.exist?(File.dirname(path))
 
         # Set internal logger to log to file only, in case another appender
         # experiences errors during writes
@@ -47,15 +73,18 @@ module RailsSemanticLogger #:nodoc:
 
         # Add the log file to the list of appenders
         # Use the colorized formatter if Rails colorized logs are enabled
-        formatter                     = SemanticLogger::Appender::Base.colorized_formatter unless config.colorize_logging == false
-        SemanticLogger.add_appender(path, nil, &formatter)
+        options                       = config.rails_semantic_logger.ap_options
+        formatter                     = config.colorize_logging == false ? :default : SemanticLogger::Formatters::Color.new(options)
+        # Check for previous file or stdout loggers
+        SemanticLogger.appenders.each { |appender| appender.formatter = formatter if appender.is_a?(SemanticLogger::Appender::File) }
+        SemanticLogger.add_appender(file_name: path, formatter: formatter)
         SemanticLogger[Rails]
       rescue StandardError => exc
         # If not able to log to file, log to standard error with warning level only
         SemanticLogger.default_level = :warn
 
-        SemanticLogger::Logger.logger = SemanticLogger::Appender::File.new(STDERR)
-        SemanticLogger.add_appender(STDERR)
+        SemanticLogger::Logger.logger = SemanticLogger::Appender::File.new(io: STDERR)
+        SemanticLogger.add_appender(io: STDERR)
 
         logger = SemanticLogger[Rails]
         logger.warn(
@@ -116,30 +145,35 @@ module RailsSemanticLogger #:nodoc:
 
       # Set the logger for concurrent-ruby
       Concurrent.global_logger = SemanticLogger[Concurrent] if defined?(Concurrent)
-    end
-
-  end
-end
 
-# Patch the Rails::Server log_to_stdout so that it logs via SemanticLogger
-module Rails #:nodoc:
-  class Server #:nodoc:
-    private
-
-    def log_to_stdout
-      SemanticLogger.add_appender($stdout, &SemanticLogger::Appender::Base.colorized_formatter)
+      # Rails Patches
+      require('rails_semantic_logger/extensions/action_cable/tagged_logger_proxy') if defined?(ActionCable::Connection::TaggedLoggerProxy)
+      require('rails_semantic_logger/extensions/action_controller/live') if defined?(ActionController::Live)
+      require('rails_semantic_logger/extensions/action_dispatch/debug_exceptions') if defined?(ActionDispatch::DebugExceptions)
+      require('rails_semantic_logger/extensions/action_view/streaming_template_renderer') if defined?(ActionView::StreamingTemplateRenderer::Body)
+      require('rails_semantic_logger/extensions/active_job/logging') if defined?(ActiveJob::Logging)
+
+      if config.rails_semantic_logger.semantic
+        require('rails_semantic_logger/extensions/rails/rack/logger') if defined?(Rails::Rack::Logger)
+        require('rails_semantic_logger/extensions/action_controller/log_subscriber') if defined?(ActionController::LogSubscriber)
+        require('rails_semantic_logger/extensions/active_record/log_subscriber') if defined?(ActiveRecord::LogSubscriber)
+      end
+      unless config.rails_semantic_logger.started
+        require('rails_semantic_logger/extensions/rails/rack/logger_info_as_debug') if defined?(Rails::Rack::Logger)
+      end
+      unless config.rails_semantic_logger.rendered
+        require('rails_semantic_logger/extensions/action_view/log_subscriber') if defined?(ActionView::LogSubscriber)
+      end
+      if config.rails_semantic_logger.processing
+        require('rails_semantic_logger/extensions/action_controller/log_subscriber_processing') if defined?(ActionView::LogSubscriber)
+      end
     end
-  end
-end
 
-# Patch ActiveJob logger
-if Rails.version.to_f >= 4.2
-  require 'active_job/logging'
-
-  module ActiveJob::Logging
-    private
-    def tag_logger(*tags, &block)
-      logger.tagged(*tags, &block)
+    # Before any initializers run, but after the gems have been loaded
+    config.after_initialize do
+      # Replace the Bugsnag logger
+      Bugsnag.configure { |config| config.logger = SemanticLogger[Bugsnag] } if defined?(Bugsnag)
     end
   end
 end
+

data/lib/rails_semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module RailsSemanticLogger #:nodoc
-  VERSION = '3.0.1'
+  VERSION = '3.1.0'
 end

metadata

@@ -1,29 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rails_semantic_logger
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-14 00:00:00.000000000 Z
+date: 2016-02-27 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: semantic_logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 description: Replaces the default Rails logger with SemanticLogger
 email:
 - reidmo@gmail.com
@@ -35,11 +49,23 @@ files:
 - README.md
 - Rakefile
 - lib/rails_semantic_logger.rb
+- lib/rails_semantic_logger/extensions/action_cable/tagged_logger_proxy.rb
+- lib/rails_semantic_logger/extensions/action_controller/live.rb
+- lib/rails_semantic_logger/extensions/action_controller/log_subscriber.rb
+- lib/rails_semantic_logger/extensions/action_controller/log_subscriber_processing.rb
+- lib/rails_semantic_logger/extensions/action_dispatch/debug_exceptions.rb
+- lib/rails_semantic_logger/extensions/action_view/log_subscriber.rb
+- lib/rails_semantic_logger/extensions/action_view/streaming_template_renderer.rb
+- lib/rails_semantic_logger/extensions/active_job/logging.rb
+- lib/rails_semantic_logger/extensions/active_record/log_subscriber.rb
+- lib/rails_semantic_logger/extensions/rails/rack/logger.rb
+- lib/rails_semantic_logger/extensions/rails/rack/logger_info_as_debug.rb
+- lib/rails_semantic_logger/extensions/rails/server.rb
 - lib/rails_semantic_logger/railtie.rb
 - lib/rails_semantic_logger/version.rb
 homepage: https://github.com/rocketjob/rails_semantic_logger
 licenses:
-- Apache License V2.0
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []