rails_semantic_logger 4.1.3 → 4.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 607046851ee5bfb0335e577fbb87f9c3ae6ab93f
-  data.tar.gz: 3375c64b102e5461ba50412a3495c898524f63df
+SHA256:
+  metadata.gz: 73a37ac27f2cf94d083cc75aa557a778f32e2de852b3be6447b072dc1da89047
+  data.tar.gz: 681f2145e71def6b336792fe3d581dfd89da6fd3ca471befcbd8ffa4f11abb50
 SHA512:
-  metadata.gz: 44f58b19256318c9fa3acb07fb08a862000acf7e15bfe27dda9fdb29052627da9c484da91fbefde02840cacdd8d7ec7556189a5297c898db39b9fde19fd1d491
-  data.tar.gz: 860b06c8b1083e12befe6b074e1a8d0281186fa30a3f02f5342465bd44c50905a3703f90071b376a04db8c01b897d6273ab6b4fac4d81a0d6115cbd6ca5b5322
+  metadata.gz: 8d299a14cb4c3eaf282e4bf502d8e60c2a36095b138c17969cf0a8f79b0431a731adbe8963ae2017bf429f12b7f42fe65d5c199a2c5f88e984a71d4605766bea
+  data.tar.gz: d837dc46c0dcd38b19dcf2a62c926c91ef1775542d55c8919d3a76db2e62764ab8675890238da78ab19b157f3b920e9d92257d5b2e347bb66d0c5a2bde60441f

data/README.md

@@ -1,26 +1,33 @@
-# 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)
+# 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://github.com/reidmorrison/rails_semantic_logger/workflows/build/badge.svg)](https://github.com/reidmorrison/rails_semantic_logger/actions?query=workflow%3Abuild) [![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)
 
-Next generation logging system for Rails to support highly concurrent, high throughput, low latency systems
+Rails Semantic Logger replaces the Rails default logger with [Semantic Logger](https://logger.rocketjob.io/)
 
-Rails Semantic Logger replaces the Rails default logger with [Semantic Logger](http://github.com/rocketjob/semantic_logger)
-
-* http://github.com/rocketjob/rails_semantic_logger
+* http://github.com/reidmorrison/rails_semantic_logger
 
 ## Documentation
 
-For complete documentation see: http://rocketjob.github.io/semantic_logger/rails
+For complete documentation see: https://logger.rocketjob.io/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)
+For the complete list of supported Ruby and Rails versions, see the [Testing file](https://github.com/reidmorrison/rails_semantic_logger/blob/master/.github/workflows/ci.yml).
 
 ## Author
 
 [Reid Morrison](https://github.com/reidmorrison)
 
-[Contributors](https://github.com/rocketjob/rails_semantic_logger/graphs/contributors)
+[Contributors](https://github.com/reidmorrison/rails_semantic_logger/graphs/contributors)
 
 ## Versioning
 

data/Rakefile

@@ -1,30 +1,30 @@
 # Setup bundler to avoid having to run bundle exec all the time.
-require 'rubygems'
-require 'bundler/setup'
+require "rubygems"
+require "bundler/setup"
 
-require 'rake/testtask'
-require_relative 'lib/rails_semantic_logger/version'
+require "rake/testtask"
+require_relative "lib/rails_semantic_logger/version"
 
 task :gem do
-  system 'gem build rails_semantic_logger.gemspec'
+  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 "git push --tags"
   system "gem push rails_semantic_logger-#{RailsSemanticLogger::VERSION}.gem"
   system "rm rails_semantic_logger-#{RailsSemanticLogger::VERSION}.gem"
 end
 
 Rake::TestTask.new(:test) do |t|
-  t.pattern = 'test/**/*_test.rb'
+  t.pattern = "test/**/*_test.rb"
   t.verbose = true
   t.warning = false
 end
 
 # By default run tests against all appraisals
 if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
-  require 'appraisal'
+  require "appraisal"
   task default: :appraisal
 else
   task default: :test

data/lib/rails_semantic_logger/action_controller/log_subscriber.rb

@@ -0,0 +1,125 @@
+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)
+          
+          params = payload[:params]
+
+          if params.kind_of?(Hash) || params.kind_of?(::ActionController::Parameters)
+            # According to PR https://github.com/reidmorrison/rails_semantic_logger/pull/37/files
+            # params is not always a Hash.
+            payload[:params] = params.to_unsafe_h unless params.is_a?(Hash)
+            payload[:params] = params.except(*INTERNAL_PARAMS)
+
+            if payload[:params].empty?
+              payload.delete(:params)
+            elsif params["file"]
+              # When logging to JSON the entire tempfile is logged, so convert it to a string.
+              payload[:params]["file"] = params["file"].inspect
+            end
+          end
+
+          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
+
+          # Rails 6+ includes allocation count
+          payload[:allocations] = event.allocations if event.respond_to?(:allocations)
+
+          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)
+          # Causes recursion in Rails 6.1.rc1
+          payload.delete(:request)
+          payload.delete(:response)
+
+          {
+            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_mailer/log_subscriber.rb

@@ -0,0 +1,135 @@
+require "active_support/log_subscriber"
+require "action_mailer"
+
+module RailsSemanticLogger
+  module ActionMailer
+    class LogSubscriber < ::ActiveSupport::LogSubscriber
+      def deliver(event)
+        ex = event.payload[:exception_object]
+        message_id = event.payload[:message_id]
+        duration = event.duration.round(1)
+        if ex
+          log_with_formatter event: event, log_duration: true, level: :error do |fmt|
+            {
+              message: "Error delivering mail #{message_id} (#{duration}ms)",
+              exception: ex
+            }
+          end
+        else
+          message = begin
+            if event.payload[:perform_deliveries]
+              "Delivered mail #{message_id} (#{duration}ms)"
+            else
+              "Skipped delivery of mail #{message_id} as `perform_deliveries` is false"
+            end
+          end
+          log_with_formatter event: event, log_duration: true do |fmt|
+            { message: message }
+          end
+        end
+      end
+
+      # An email was generated.
+      def process(event)
+        mailer   = event.payload[:mailer]
+        action   = event.payload[:action]
+        duration = event.duration.round(1)
+        log_with_formatter event: event do |fmt|
+          { message: "#{mailer}##{action}: processed outbound mail in #{duration}ms" }
+        end
+      end
+
+      private
+
+      class EventFormatter
+        def initialize(event:, log_duration: false)
+          @event = event
+          @log_duration = log_duration
+        end
+
+        def mailer
+          event.payload[:mailer]
+        end
+
+        def payload
+          {}.tap do |h|
+            h[:event_name]         = event.name
+            h[:mailer]             = mailer
+            h[:action]             = action
+            h[:message_id]         = event.payload[:message_id]
+            h[:perform_deliveries] = event.payload[:perform_deliveries]
+            h[:subject]            = event.payload[:subject]
+            h[:to]                 = event.payload[:to]
+            h[:from]               = event.payload[:from]
+            h[:bcc]                = event.payload[:bcc]
+            h[:cc]                 = event.payload[:cc]
+            h[:date]               = date
+            h[:duration]           = event.duration.round(2) if log_duration?
+            h[:args]               = formatted_args
+          end
+        end
+
+        def date
+          if event.payload[:date].respond_to?(:to_time)
+            event.payload[:date].to_time.utc
+          elsif event.payload[:date].is_a?(String)
+            Time.parse(date).utc
+          else
+            nil
+          end
+        end
+
+        private
+
+        attr_reader :event
+
+        def mailer
+          event.payload[:mailer]
+        end
+
+        def action
+          event.payload[:action]
+        end
+
+        def formatted_args
+          if defined?(mailer.contantize.log_arguments?) && !mailer.contantize.log_arguments?
+            ""
+          else
+            JSON.pretty_generate(event.payload[:args].map { |arg| format(arg) }) if event.payload[:args].present?
+          end
+        end
+
+        def format(arg)
+          case arg
+          when Hash
+            arg.transform_values { |value| format(value) }
+          when Array
+            arg.map { |value| format(value) }
+          when GlobalID::Identification
+            begin
+              arg.to_global_id
+            rescue StandardError
+              arg
+            end
+          else
+            arg
+          end
+        end
+
+        def log_duration?
+          @log_duration
+        end
+      end
+
+      def log_with_formatter(level: :info, **kw_args)
+        fmt = EventFormatter.new(**kw_args)
+        msg = yield fmt
+        logger.public_send(level, **msg, payload: fmt.payload)
+      end
+
+      def logger
+        ::ActionMailer::Base.logger
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/action_view/log_subscriber.rb

@@ -0,0 +1,111 @@
+require "active_support/log_subscriber"
+
+module RailsSemanticLogger
+  module ActionView
+    # Output Semantic logs from Action View.
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      VIEWS_PATTERN = %r{^app/views/}.freeze
+
+      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]
+        payload[:allocations] = event.allocations if event.respond_to?(:allocations)
+
+        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]  = event.payload[:cache_hit] unless event.payload[:cache_hit].nil?
+        payload[:allocations] = event.allocations if event.respond_to?(:allocations)
+
+        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] = event.payload[:cache_hits] if event.payload[:cache_hits]
+        payload[:allocations] = event.allocations if event.respond_to?(:allocations)
+
+        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_job/log_subscriber.rb

@@ -0,0 +1,126 @@
+require "active_job"
+
+module RailsSemanticLogger
+  module ActiveJob
+    class LogSubscriber < ::ActiveSupport::LogSubscriber
+      def enqueue(event)
+        log_with_formatter event: event do |fmt|
+          {message: "Enqueued #{fmt.job_info}"}
+        end
+      end
+
+      def enqueue_at(event)
+        log_with_formatter event: event do |fmt|
+          {message: "Enqueued #{fmt.job_info} at #{fmt.scheduled_at}"}
+        end
+      end
+
+      def perform_start(event)
+        log_with_formatter event: event do |fmt|
+          {message: "Performing #{fmt.job_info}"}
+        end
+      end
+
+      def perform(event)
+        ex = event.payload[:exception_object]
+        if ex
+          log_with_formatter event: event, log_duration: true, level: :error do |fmt|
+            {
+              message: "Error performing #{fmt.job_info} in #{event.duration.round(2)}ms",
+              exception: ex
+            }
+          end
+        else
+          log_with_formatter event: event, log_duration: true do |fmt|
+            {message: "Performed #{fmt.job_info} in #{event.duration.round(2)}ms"}
+          end
+        end
+      end
+
+      private
+
+      class EventFormatter
+        def initialize(event:, log_duration: false)
+          @event = event
+          @log_duration = log_duration
+        end
+
+        def job_info
+          "#{job.class.name} (Job ID: #{job.job_id}) to #{queue_name}"
+        end
+
+        def payload
+          {}.tap do |h|
+            h[:event_name]      = event.name
+            h[:adapter]         = adapter_name
+            h[:queue]           = job.queue_name
+            h[:job_class]       = job.class.name
+            h[:job_id]          = job.job_id
+            h[:provider_job_id] = job.try(:provider_job_id) # Not available in Rails 4.2
+            h[:duration]        = event.duration.round(2) if log_duration?
+            h[:arguments]       = formatted_args
+          end
+        end
+
+        def queue_name
+          adapter_name + "(#{job.queue_name})"
+        end
+
+        def scheduled_at
+          Time.at(event.payload[:job].scheduled_at).utc
+        end
+
+        private
+
+        attr_reader :event
+
+        def job
+          event.payload[:job]
+        end
+
+        def adapter_name
+          event.payload[:adapter].class.name.demodulize.remove("Adapter")
+        end
+
+        def formatted_args
+          if defined?(job.class.log_arguments?) && !job.class.log_arguments?
+            ""
+          else
+            JSON.pretty_generate(job.arguments.map { |arg| format(arg) })
+          end
+        end
+
+        def format(arg)
+          case arg
+          when Hash
+            arg.transform_values { |value| format(value) }
+          when Array
+            arg.map { |value| format(value) }
+          when GlobalID::Identification
+            begin
+              arg.to_global_id
+            rescue StandardError
+              arg
+            end
+          else
+            arg
+          end
+        end
+
+        def log_duration?
+          @log_duration
+        end
+      end
+
+      def log_with_formatter(level: :info, **kw_args)
+        fmt = EventFormatter.new(**kw_args)
+        msg = yield fmt
+        logger.public_send(level, **msg, payload: fmt.payload)
+      end
+
+      def logger
+        ::ActiveJob::Base.logger
+      end
+    end
+  end
+end