rails_semantic_logger 4.1.3 → 4.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 607046851ee5bfb0335e577fbb87f9c3ae6ab93f
-  data.tar.gz: 3375c64b102e5461ba50412a3495c898524f63df
+SHA256:
+  metadata.gz: c831151af372b8348f982154c5a02da3e3373f0156f36952dcebc421667f91fc
+  data.tar.gz: 82e796f801009b66c39daf81b9526d5be20f48ecf81cd5159a7d659ba64f0cdc
 SHA512:
-  metadata.gz: 44f58b19256318c9fa3acb07fb08a862000acf7e15bfe27dda9fdb29052627da9c484da91fbefde02840cacdd8d7ec7556189a5297c898db39b9fde19fd1d491
-  data.tar.gz: 860b06c8b1083e12befe6b074e1a8d0281186fa30a3f02f5342465bd44c50905a3703f90071b376a04db8c01b897d6273ab6b4fac4d81a0d6115cbd6ca5b5322
+  metadata.gz: 564d2e2b9a0bdb7140dd37a9be1aaaccbeed5c06f60cd7c4c31a7d886502d0e77433da3887e8262b4d614752c8a7f2b677fc8be8d9796e8e8af772252c84c2e2
+  data.tar.gz: 1a22dc7a52079a3845a5453f85eafda8edda153166afc44fe973cbe02f4e5d5b0f145c8bd506da972afcf942b0f9ccbbc802c1c18aab20424d54fa37b3bef685

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)
 
@@ -11,10 +9,19 @@ Rails Semantic Logger replaces the Rails default logger with [Semantic Logger](h
 
 For complete documentation see: http://rocketjob.github.io/semantic_logger/rails
 
+## Upgrading to Semantic Logger v4.4
+
+With some forking frameworks it is necessary to call `reopen` after the fork. With v4.4 the
+workaround for Ruby 2.5 crashes is no longer needed. 
+I.e. Please remove the following line if being called anywhere:
+
+~~~ruby
+SemanticLogger::Processor.instance.instance_variable_set(:@queue, Queue.new)
+~~~
+
 ## Supports
 
-- Ruby 1.9.3, 2.0, 2.1, 2.2 (or above) Or, JRuby 1.7, 9.0 (or above)
-- Rails 3.2, 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/action_controller/log_subscriber.rb

@@ -0,0 +1,114 @@
+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)
+
+          params = payload[:params]
+          if params
+            # When logging to JSON the entire tempfile is logged, so convert it to a string.
+            params['file'] = params['file'].inspect if params['file']
+          end
+
+          {
+            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

data/lib/rails_semantic_logger/delayed_job/plugin.rb

@@ -0,0 +1,11 @@
+module RailsSemanticLogger
+  module DelayedJob
+    class Plugin < Delayed::Plugin
+      callbacks do |lifecycle|
+        lifecycle.before(:execute) do |job, &block|
+          ::SemanticLogger.reopen
+        end
+      end
+    end
+  end
+end