rails_semantic_logger 4.2.1 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d56fd59e95eb5982a96ce3dd581a3249503c67e83751948648a50c575a357d24
-  data.tar.gz: bbe41e7f698388fd7b14ea3096f62d0316ef51e2ee4fd961f0a5046fe46ad97c
+  metadata.gz: b63806087ae37b6ed3da41a1caf8414dddb0509b067cadf4583720fd2b397d0c
+  data.tar.gz: 04a84700b26831870361b5664332f7bcade1d1e07a4c1cc0b2d243148adc9fff
 SHA512:
-  metadata.gz: fa8f0f7cd9da16e76a3c0803f249710185e1adda00475dc6b4f88605c3893064114f4d7d763a8638ea3dd83e054e42233f2736041b98a259f4f3a12d6df825cc
-  data.tar.gz: 3a025e94a795aabcf96e612eb02ecec265656f5f8939a81908abb48464703693bdd862de6d5a5dc9cd0163b4bdc473d14c534ad2d6ceb2e09f3a4c9cfd210247
+  metadata.gz: 59e6c6bdf21d7587b20d3250a00d6f212c99a2ad58c018c832662cf468167dd64a88148d48d19b77b8ea73b4725650124b1e596adc043bec7d5b289919fe7f18
+  data.tar.gz: 9836a2ccdd1107f38303e1180a2d6a2fc28945a8f963115126fd833fb4ff62a833bc78dc2ffb6209ee76f4794f5dd01e922ec000d5ada966201a03bd43b1d23b

data/README.md

@@ -1,7 +1,5 @@
-# rails_semantic_logger
-![](https://img.shields.io/gem/v/rails_semantic_logger.svg) ![](https://img.shields.io/gem/dt/semantic_logger.svg) ![](https://img.shields.io/badge/status-production%20ready-blue.svg)
-
-Next generation logging system for Rails to support highly concurrent, high throughput, low latency systems
+# Rails Semantic Logger
+[![Gem Version](https://img.shields.io/gem/v/rails_semantic_logger.svg)](https://rubygems.org/gems/rails_semantic_logger) [![Build Status](https://travis-ci.org/rocketjob/rails_semantic_logger.svg?branch=master)](https://travis-ci.org/rocketjob/rails_semantic_logger) [![Downloads](https://img.shields.io/gem/dt/rails_semantic_logger.svg)](https://rubygems.org/gems/rails_semantic_logger) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) ![](https://img.shields.io/badge/status-Production%20Ready-blue.svg) [![Gitter chat](https://img.shields.io/badge/IRC%20(gitter)-Support-brightgreen.svg)](https://gitter.im/rocketjob/support)
 
 Rails Semantic Logger replaces the Rails default logger with [Semantic Logger](http://github.com/rocketjob/semantic_logger)
 
@@ -13,8 +11,7 @@ For complete documentation see: http://rocketjob.github.io/semantic_logger/rails
 
 ## Supports
 
-- Ruby 2.1, 2.2 (or above) Or, JRuby 9.0 (or above)
-- Rails 4, 5 (or above)
+- Rails 3.2, 4, 5
 
 ## Author
 

data/Rakefile

@@ -9,7 +9,7 @@ task :gem do
   system 'gem build rails_semantic_logger.gemspec'
 end
 
-task :publish => :gem do
+task publish: :gem do
   system "git tag -a v#{RailsSemanticLogger::VERSION} -m 'Tagging #{RailsSemanticLogger::VERSION}'"
   system 'git push --tags'
   system "gem push rails_semantic_logger-#{RailsSemanticLogger::VERSION}.gem"
@@ -23,7 +23,7 @@ Rake::TestTask.new(:test) do |t|
 end
 
 # By default run tests against all appraisals
-if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
+if !ENV['APPRAISAL_INITIALIZED'] && !ENV['TRAVIS']
   require 'appraisal'
   task default: :appraisal
 else

data/lib/rails_semantic_logger.rb

@@ -3,4 +3,39 @@ require 'rails_semantic_logger/extensions/rails/server' if defined?(Rails::Serve
 require 'rails_semantic_logger/engine'
 
 module RailsSemanticLogger
+  module ActionController
+    autoload :LogSubscriber, 'rails_semantic_logger/action_controller/log_subscriber'
+  end
+  module ActionView
+    autoload :LogSubscriber, 'rails_semantic_logger/action_view/log_subscriber'
+  end
+  module ActiveRecord
+    autoload :LogSubscriber, 'rails_semantic_logger/active_record/log_subscriber'
+  end
+  module Rack
+    autoload :Logger, 'rails_semantic_logger/rack/logger'
+  end
+  module DelayedJob
+    autoload :Plugin, 'rails_semantic_logger/delayed_job/plugin.rb'
+  end
+
+  # Swap an existing subscriber with a new one
+  def self.swap_subscriber(old_class, new_class, notifier)
+    subscribers = ActiveSupport::LogSubscriber.subscribers.select { |s| s.is_a?(old_class) }
+    subscribers.each { |subscriber| unattach(subscriber) }
+
+    new_class.attach_to(notifier)
+  end
+
+  def self.unattach(subscriber)
+    subscriber.patterns.each do |event|
+      ActiveSupport::Notifications.notifier.listeners_for(event).each do |sub|
+        next unless sub.instance_variable_get(:@delegate) == subscriber
+        ActiveSupport::Notifications.unsubscribe(sub)
+      end
+    end
+
+    ActiveSupport::LogSubscriber.subscribers.delete(subscriber)
+  end
+  private_class_method :unattach
 end

data/lib/rails_semantic_logger/action_controller/log_subscriber.rb

@@ -0,0 +1,108 @@
+module RailsSemanticLogger
+  module ActionController
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      INTERNAL_PARAMS = %w[controller action format _method only_path].freeze
+
+      # 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.dup
+
+          # Unused, but needed for Devise 401 status code monkey patch to still work.
+          ::ActionController::Base.log_process_action(payload)
+
+          # According to PR https://github.com/rocketjob/rails_semantic_logger/pull/37/files
+          # payload[:params] is not always a Hash.
+          payload[:params] = payload[:params].to_unsafe_h unless payload[:params].is_a?(Hash)
+          payload[:params].except!(*INTERNAL_PARAMS)
+          payload.delete(:params) if payload[:params].empty?
+
+          format           = payload[:format]
+          payload[:format] = format.to_s.upcase if format.is_a?(Symbol)
+
+          payload[:path]   = extract_path(payload[:path]) if payload.key?(:path)
+
+          exception = payload.delete(:exception)
+          if payload[:status].nil? && exception.present?
+            exception_class_name = exception.first
+            payload[:status]     = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
+          end
+
+          # Rounds off the runtimes. For example, :view_runtime, :mongo_runtime, etc.
+          payload.keys.each do |key|
+            payload[key] = payload[key].to_f.round(2) if key.to_s =~ /(.*)_runtime/
+          end
+
+          payload[:status_message] = ::Rack::Utils::HTTP_STATUS_CODES[payload[:status]] if payload[:status].present?
+          # Causes excessive log output with Rails 5 RC1
+          payload.delete(:headers)
+
+          {
+            message:  "Completed ##{payload[:action]}",
+            duration: event.duration,
+            payload:  payload
+          }
+        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(message: 'Sent file', payload: {path: event.payload[:path]}, duration: event.duration)
+      end
+
+      def redirect_to(event)
+        controller_logger(event).info(message: 'Redirected to', payload: {location: event.payload[:location]})
+      end
+
+      def send_data(event)
+        controller_logger(event).info(message: 'Sent data', payload: {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)
+            # enable_fragment_cache_logging as of Rails 5
+            return if ::ActionController::Base.respond_to?(:enable_fragment_cache_logging) && !::ActionController::Base.enable_fragment_cache_logging
+            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)
+        controller = event.payload[:controller]
+        return ::ActionController::Base.logger unless controller
+
+        controller.constantize.logger || ::ActionController::Base.logger
+      rescue NameError
+        ::ActionController::Base.logger
+      end
+
+      def extract_path(path)
+        index = path.index('?')
+        index ? path[0, index] : path
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/action_view/log_subscriber.rb

@@ -0,0 +1,108 @@
+require 'active_support/log_subscriber'
+
+module RailsSemanticLogger
+  module ActionView
+    # Output Semantic logs from Action View.
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      VIEWS_PATTERN = /^app\/views\//
+
+      class << self
+        attr_reader :logger
+        attr_accessor :rendered_log_level
+      end
+
+      def initialize
+        @rails_root = nil
+        super
+      end
+
+      def render_template(event)
+        return unless should_log?
+
+        payload          = {
+          template: from_rails_root(event.payload[:identifier])
+        }
+        payload[:within] = from_rails_root(event.payload[:layout]) if event.payload[:layout]
+
+        logger.measure(
+          self.class.rendered_log_level,
+          'Rendered',
+          payload:  payload,
+          duration: event.duration
+        )
+      end
+
+      def render_partial(event)
+        return unless should_log?
+
+        payload          = {
+          partial: from_rails_root(event.payload[:identifier])
+        }
+        payload[:within] = from_rails_root(event.payload[:layout]) if event.payload[:layout]
+        payload[:cache]  = payload[:cache_hit] unless event.payload[:cache_hit].nil?
+
+        logger.measure(
+          self.class.rendered_log_level,
+          'Rendered',
+          payload:  payload,
+          duration: event.duration
+        )
+      end
+
+      def render_collection(event)
+        return unless should_log?
+
+        identifier = event.payload[:identifier] || 'templates'
+
+        payload              = {
+          template: from_rails_root(identifier),
+          count:    event.payload[:count]
+        }
+        payload[:cache_hits] = payload[:cache_hits] if payload[:cache_hits]
+
+        logger.measure(
+          self.class.rendered_log_level,
+          'Rendered',
+          payload:  payload,
+          duration: event.duration
+        )
+      end
+
+      def start(name, id, payload)
+        if (name == 'render_template.action_view') && should_log?
+          payload          = {template: from_rails_root(payload[:identifier])}
+          payload[:within] = from_rails_root(payload[:layout]) if payload[:layout]
+
+          logger.send(self.class.rendered_log_level, message: 'Rendering', payload:  payload)
+        end
+
+        super
+      end
+
+      private
+
+      @logger             = SemanticLogger['ActionView']
+      @rendered_log_level = :debug
+
+      EMPTY = ''.freeze
+
+      def should_log?
+        logger.send("#{self.class.rendered_log_level}?")
+      end
+
+      def from_rails_root(string)
+        string = string.sub(rails_root, EMPTY)
+        string.sub!(VIEWS_PATTERN, EMPTY)
+        string
+      end
+
+      def rails_root
+        @rails_root ||= "#{Rails.root}/"
+      end
+
+      def logger
+        self.class.logger
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/active_record/log_subscriber.rb

@@ -0,0 +1,186 @@
+module RailsSemanticLogger
+  module ActiveRecord
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      IGNORE_PAYLOAD_NAMES = %w[SCHEMA EXPLAIN].freeze
+
+      class << self
+        attr_reader :logger
+      end
+
+      def self.runtime=(value)
+        ::ActiveRecord::RuntimeRegistry.sql_runtime = value
+      end
+
+      def self.runtime
+        ::ActiveRecord::RuntimeRegistry.sql_runtime ||= 0
+      end
+
+      def self.reset_runtime
+        rt           = runtime
+        self.runtime = 0
+        rt
+      end
+
+      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_payload         = {sql: payload[:sql]}
+        log_payload[:binds] = bind_values(payload) unless (payload[:binds] || []).empty?
+
+        log = {
+          message:  name,
+          payload:  log_payload,
+          duration: event.duration
+        }
+
+        # Log the location of the query itself.
+        if logger.send(:level_index) >= SemanticLogger.backtrace_level_index
+          log[:backtrace] = SemanticLogger::Utils.strip_backtrace
+        end
+
+        logger.debug(log)
+      end
+
+      private
+
+      @logger = SemanticLogger['ActiveRecord']
+
+      # When multiple values are received for a single bound field, it is converted into an array
+      def add_bind_value(binds, key, value)
+        key        = key.downcase.to_sym
+        value      = (Array(binds[key]) << value) if binds.key?(key)
+        binds[key] = value
+      end
+
+      def logger
+        self.class.logger
+      end
+
+      #
+      # Rails 3,4,5 hell trying to get the bind values
+      #
+
+      def bind_values_v3(payload)
+        binds = {}
+        payload[:binds].each do |col, v|
+          if col
+            add_bind_value(binds, col.name, v)
+          else
+            binds[nil] = v
+          end
+        end
+        binds
+      end
+
+      def bind_values_v4(payload)
+        binds = {}
+        payload[:binds].each do |col, v|
+          attr_name, value = render_bind(col, v)
+          add_bind_value(binds, attr_name, value)
+        end
+        binds
+      end
+
+      def bind_values_v5_0_0(payload)
+        binds = {}
+        payload[:binds].each do |attr|
+          attr_name, value = render_bind(attr)
+          add_bind_value(binds, attr_name, value)
+        end
+        binds
+      end
+
+      def bind_values_v5_0_3(payload)
+        binds         = {}
+        casted_params = type_casted_binds(payload[:binds], payload[:type_casted_binds])
+        payload[:binds].zip(casted_params).map do |attr, value|
+          attr_name, value = render_bind(attr, value)
+          add_bind_value(binds, attr_name, value)
+        end
+        binds
+      end
+
+      def bind_values_v5_1_5(payload)
+        binds         = {}
+        casted_params = type_casted_binds(payload[:type_casted_binds])
+        payload[:binds].zip(casted_params).map do |attr, value|
+          attr_name, value = render_bind(attr, value)
+          add_bind_value(binds, attr_name, value)
+        end
+        binds
+      end
+
+      def render_bind_v4_2(column, value)
+        if column
+          if column.binary?
+            # This specifically deals with the PG adapter that casts bytea columns into a Hash.
+            value = value[:value] if value.is_a?(Hash)
+            value = value ? "<#{value.bytesize} bytes of binary data>" : '<NULL binary data>'
+          end
+
+          [column.name, value]
+        else
+          [nil, value]
+        end
+      end
+
+      def render_bind_v5_0_0(attribute)
+        value =
+          if attribute.type.binary? && attribute.value
+            if attribute.value.is_a?(Hash)
+              "<#{attribute.value_for_database.to_s.bytesize} bytes of binary data>"
+            else
+              "<#{attribute.value.bytesize} bytes of binary data>"
+            end
+          else
+            attribute.value_for_database
+          end
+
+        [attribute.name, value]
+      end
+
+      def render_bind_v5_0_3(attr, value)
+        if attr.is_a?(Array)
+          attr = attr.first
+        elsif attr.type.binary? && attr.value
+          value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        end
+
+        [attr&.name, value]
+      end
+
+      def type_casted_binds_v5_0_3(binds, casted_binds)
+        casted_binds || ActiveRecord::Base.connection.type_casted_binds(binds)
+      end
+
+      def type_casted_binds_v5_1_5(casted_binds)
+        casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
+      end
+
+      if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR.zero? && Rails::VERSION::TINY <= 2 # 5.0.0 - 5.0.2
+        alias bind_values bind_values_v5_0_0
+        alias render_bind render_bind_v5_0_0
+      elsif Rails::VERSION::MAJOR >= 5 &&
+            ((Rails::VERSION::MINOR.zero? && Rails::VERSION::TINY <= 6) ||
+              (Rails::VERSION::MINOR == 1 && Rails::VERSION::TINY <= 4)) # 5.0.3 - 5.0.6 && 5.1.0 - 5.1.4
+        alias bind_values bind_values_v5_0_3
+        alias render_bind render_bind_v5_0_3
+        alias type_casted_binds type_casted_binds_v5_0_3
+      elsif Rails::VERSION::MAJOR >= 5 # ~> 5.1.5 && ~> 5.0.7
+        alias bind_values bind_values_v5_1_5
+        alias render_bind render_bind_v5_0_3
+        alias type_casted_binds type_casted_binds_v5_1_5
+      elsif Rails.version.to_i >= 4 # 4.x
+        alias bind_values bind_values_v4
+        alias render_bind render_bind_v4_2
+      else # 3.x
+        alias bind_values bind_values_v3
+      end
+    end
+  end
+end