rails_semantic_logger 4.1.3 → 4.12.0

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

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

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

@@ -1,11 +1,15 @@
 # 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)
+require "action_dispatch"
+
+module ActionDispatch
+  class DebugExceptions
+    private
+
+    undef_method :log_error
+    def log_error(_request, wrapper)
+      ActiveSupport::Deprecation.silence do
+        ActionController::Base.logger.fatal(wrapper.exception)
+      end
     end
   end
 end
-

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

@@ -1,11 +1,15 @@
 # Log actual exceptions, not a string representation
-ActionView::StreamingTemplateRenderer
+require "action_view/renderer/streaming_template_renderer"
 
-class ActionView::StreamingTemplateRenderer
-  class Body
-    private
-    def log_error(exception) #:nodoc:
-      ActionView::Base.logger.fatal(exception)
+module ActionView
+  class StreamingTemplateRenderer
+    class Body
+      private
+
+      undef_method :log_error
+      def log_error(exception)
+        ActionView::Base.logger.fatal(exception)
+      end
     end
   end
 end

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

@@ -1,11 +1,15 @@
 # Patch ActiveJob logger
-require 'active_job/logging'
+require "active_job/logging"
 
-module ActiveJob::Logging
-  include SemanticLogger::Loggable
+module ActiveJob
+  module Logging
+    include SemanticLogger::Loggable
 
-  private
-  def tag_logger(*tags, &block)
-    logger.tagged(*tags, &block)
+    private
+
+    undef_method :tag_logger
+    def tag_logger(*tags, &block)
+      logger.tagged(*tags, &block)
+    end
   end
 end

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

@@ -1,15 +1,18 @@
 # Patch ActiveModelSerializers logger
-require 'active_model_serializers/logging'
+require "active_model_serializers/logging"
 
-module ActiveModelSerializers::Logging
-  include SemanticLogger::Loggable
+module ActiveModelSerializers
+  module Logging
+    include SemanticLogger::Loggable
 
-  private
-  def tag_logger(*tags, &block)
-    logger.tagged(*tags, &block)
+    private
+
+    def tag_logger(*tags, &block)
+      logger.tagged(*tags, &block)
+    end
   end
-end
 
-class ActiveModelSerializers::SerializableResource
-  include SemanticLogger::Loggable
+  class SerializableResource
+    include SemanticLogger::Loggable
+  end
 end

data/lib/rails_semantic_logger/extensions/active_support/logger.rb

@@ -0,0 +1,24 @@
+require "active_support/logger"
+
+module ActiveSupport
+  # More hacks to try and stop Rails from being it's own worst enemy.
+  class Logger
+    class << self
+      undef :logger_outputs_to?, :broadcast
+    end
+
+    # Prevent Console from trying to merge loggers
+    def self.logger_outputs_to?(*args)
+      true
+    end
+
+    # Prevent broadcasting since SemanticLogger already supports multiple loggers
+    def self.broadcast(logger)
+      Module.new
+    end
+
+    def self.new(*args, **kwargs)
+      SemanticLogger[self]
+    end
+  end
+end

data/lib/rails_semantic_logger/extensions/active_support/tagged_logging.rb

@@ -0,0 +1,8 @@
+module ActiveSupport
+  module TaggedLogging
+    # Semantic Logger already does tagged logging
+    def self.new(logger)
+      logger
+    end
+  end
+end

data/lib/rails_semantic_logger/extensions/mongoid/config.rb

@@ -0,0 +1,11 @@
+require "mongoid/config"
+
+module Mongoid
+  module Config
+    private
+
+    # Remove log overrides
+    def set_log_levels
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module RailsSemanticLogger
+  module Rack
+    module Server
+      def daemonize_app
+        super
+        SemanticLogger.reopen
+      end
+    end
+  end
+end
+
+Rack::Server.prepend(RailsSemanticLogger::Rack::Server)

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

@@ -1,11 +1,15 @@
 # Patch the Rails::Server log_to_stdout so that it logs via SemanticLogger
-Rails::Server
-module Rails #:nodoc:
-  class Server #:nodoc:
-    private
+require "rails"
 
+module Rails
+  class Server
+    private
+    
+    undef_method :log_to_stdout if method_defined?(:log_to_stdout)
     def log_to_stdout
-      SemanticLogger.add_appender(io: $stdout, formatter: :color)
+      wrapped_app # touch the app so the logger is set up
+
+      SemanticLogger.add_appender(io: $stdout, formatter: :color) unless SemanticLogger.appenders.console_output?
     end
   end
 end

data/lib/rails_semantic_logger/options.rb

@@ -0,0 +1,122 @@
+module RailsSemanticLogger
+  # Options for controlling Rails Semantic Logger behavior
+  #
+  # * 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}
+  #
+  # * Whether to automatically add an environment specific log file appender.
+  #     For Example: 'log/development.log'
+  #
+  #     Note:
+  #       When Semantic Logger fails to log to an appender it logs the error to an
+  #       internal logger, which by default writes to STDERR.
+  #       Example, change the default internal logger to log to stdout:
+  #         SemanticLogger::Processor.logger = SemanticLogger::Appender::IO.new($stdout, level: :warn)
+  #
+  #       config.rails_semantic_logger.add_file_appender = true
+  #
+  # * Silence asset logging
+  #
+  #     config.rails_semantic_logger.quiet_assets = false
+  #
+  # * Disable automatic logging to stderr when running a Rails console.
+  #
+  #     config.rails_semantic_logger.console_logger = false
+  #
+  # * Override the output format for the primary Rails log file.
+  #
+  #     Valid options:
+  #     * :default
+  #         Plain text output with no color.
+  #     * :color
+  #         Plain text output with color.
+  #     * :json
+  #         JSON output format.
+  #     * class
+  #
+  #     * Proc
+  #         A block that will be called to format the output.
+  #         It is supplied with the `log` entry and should return the formatted data.
+  #
+  #     Note:
+  #     * `:default` is automatically changed to `:color` if `config.colorize_logging` is `true`.
+  #
+  #     JSON Example, in `application.rb`:
+  #        config.rails_semantic_logger.format = :json
+  #
+  #     Custom Example, create `app/lib/my_formatter.rb`:
+  #
+  #       # My Custom colorized formatter
+  #       class MyFormatter < SemanticLogger::Formatters::Color
+  #         # Return the complete log level name in uppercase
+  #         def level
+  #           "#{color}log.level.upcase#{color_map.clear}"
+  #         end
+  #       end
+  #
+  #      # In application.rb:
+  #      config.rails_semantic_logger.format = MyFormatter.new
+  #
+  #
+  #      config.rails_semantic_logger.format = :default
+  #
+  # * Add a filter to the file logger [Regexp|Proc]
+  #   RegExp: Only include log messages where the class name matches the supplied
+  #           regular expression. All other messages will be ignored.
+  #   Proc: Only include log messages where the supplied Proc returns true.
+  #         The Proc must return true or false.
+  #
+  #     config.rails_semantic_logger.filter = nil
+  #
+  # * named_tags: *DEPRECATED*
+  #   Instead, supply a Hash to config.log_tags
+  #   config.rails_semantic_logger.named_tags = nil
+  class Options
+    attr_accessor :semantic, :started, :processing, :rendered, :ap_options, :add_file_appender,
+                  :quiet_assets, :format, :named_tags, :filter, :console_logger
+
+    # Setup default values
+    def initialize
+      @semantic          = true
+      @started           = false
+      @processing        = false
+      @rendered          = false
+      @ap_options        = {multiline: false}
+      @add_file_appender = true
+      @quiet_assets      = false
+      @format            = :default
+      @named_tags        = nil
+      @filter            = nil
+      @console_logger    = true
+    end
+  end
+end

data/lib/rails_semantic_logger/rack/logger.rb

@@ -0,0 +1,100 @@
+require "active_support/core_ext/time/conversions"
+require "active_support/core_ext/object/blank"
+require "active_support/log_subscriber"
+require "action_dispatch/http/request"
+require "rack/body_proxy"
+
+module RailsSemanticLogger
+  module Rack
+    class Logger < ActiveSupport::LogSubscriber
+      class << self
+        attr_reader :logger
+        attr_accessor :started_request_log_level
+      end
+
+      def initialize(app, taggers = nil)
+        @app     = app
+        @taggers = taggers || []
+      end
+
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+
+        # Check for named tags (Hash)
+        if @taggers && !@taggers.empty?
+          tags = @taggers.is_a?(Hash) ? compute_named_tags(request) : compute_tags(request)
+          logger.tagged(tags) { call_app(request, env) }
+        else
+          call_app(request, env)
+        end
+      end
+
+      private
+
+      @logger                    = SemanticLogger["Rack"]
+      @started_request_log_level = :debug
+
+      def call_app(request, env)
+        instrumenter        = ActiveSupport::Notifications.instrumenter
+        instrumenter_state  = instrumenter.start "request.action_dispatch", request: request
+        instrumenter_finish = -> () {
+          instrumenter.finish_with_state(instrumenter_state, "request.action_dispatch", request: request)
+        }
+
+        logger.send(self.class.started_request_log_level) { started_request_message(request) }
+        status, headers, body = @app.call(env)
+        body                  = ::Rack::BodyProxy.new(body, &instrumenter_finish)
+        [status, headers, body]
+      rescue Exception
+        instrumenter_finish.call
+        raise
+      end
+
+      def started_request_message(request)
+        {
+          message: "Started",
+          payload: {
+            method: request.request_method,
+            path:   request.filtered_path,
+            ip:     request.remote_ip
+          }
+        }
+      end
+
+      def compute_tags(request)
+        @taggers.collect do |tag|
+          case tag
+          when Proc
+            tag.call(request)
+          when Symbol
+            request.send(tag)
+          else
+            tag
+          end
+        end
+      end
+
+      # Leave out any named tags with a nil value
+      def compute_named_tags(request)
+        tagged = {}
+        @taggers.each_pair do |tag, value|
+          resolved    =
+            case value
+            when Proc
+              value.call(request)
+            when Symbol
+              request.send(value)
+            else
+              value
+            end
+          tagged[tag] = resolved unless resolved.nil?
+        end
+        tagged
+      end
+
+      def logger
+        self.class.logger
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/version.rb

@@ -1,3 +1,3 @@
-module RailsSemanticLogger #:nodoc
-  VERSION = '4.1.3'
+module RailsSemanticLogger
+  VERSION = "4.12.0".freeze
 end

data/lib/rails_semantic_logger.rb

@@ -1,6 +1,61 @@
-require 'semantic_logger'
-require 'rails_semantic_logger/extensions/rails/server' if defined?(Rails::Server)
-require 'rails_semantic_logger/engine'
+require "semantic_logger"
+require "rails_semantic_logger/extensions/rails/server" if defined?(Rails::Server)
+require "rails_semantic_logger/engine"
 
 module RailsSemanticLogger
+  module ActionController
+    autoload :LogSubscriber, "rails_semantic_logger/action_controller/log_subscriber"
+  end
+  module ActionMailer
+    autoload :LogSubscriber, "rails_semantic_logger/action_mailer/log_subscriber"
+  end
+  module ActionView
+    autoload :LogSubscriber, "rails_semantic_logger/action_view/log_subscriber"
+  end
+  module ActiveJob
+    autoload :LogSubscriber, "rails_semantic_logger/active_job/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"
+  end
+
+  autoload :Options, "rails_semantic_logger/options"
+
+  # 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(subscriber).each do |pattern|
+      ActiveSupport::Notifications.notifier.listeners_for(pattern).each do |sub|
+        next unless sub.instance_variable_get(:@delegate) == subscriber
+
+        ActiveSupport::Notifications.unsubscribe(sub)
+      end
+    end
+
+    ActiveSupport::LogSubscriber.subscribers.delete(subscriber)
+  end
+
+  def self.subscriber_patterns(subscriber)
+    subscriber.patterns.respond_to?(:keys) ?
+      subscriber.patterns.keys :
+      subscriber.patterns
+  end
+
+  private_class_method :subscriber_patterns, :unattach
 end
+
+require("rails_semantic_logger/extensions/mongoid/config") if defined?(Mongoid)
+require("rails_semantic_logger/extensions/active_support/logger") if defined?(ActiveSupport::Logger)
+require("rails_semantic_logger/extensions/rack/server") if defined?(Rack::Server)

metadata

@@ -1,46 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: rails_semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.1.3
+  version: 4.12.0
 platform: ruby
 authors:
 - Reid Morrison
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-06-16 00:00:00.000000000 Z
+date: 2023-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: semantic_logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4.13'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
-description: Replaces the default Rails logger with SemanticLogger
+        version: '4.13'
+description:
 email:
-- reidmo@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -49,26 +62,36 @@ files:
 - README.md
 - Rakefile
 - lib/rails_semantic_logger.rb
+- lib/rails_semantic_logger/action_controller/log_subscriber.rb
+- lib/rails_semantic_logger/action_mailer/log_subscriber.rb
+- lib/rails_semantic_logger/action_view/log_subscriber.rb
+- lib/rails_semantic_logger/active_job/log_subscriber.rb
+- lib/rails_semantic_logger/active_record/log_subscriber.rb
+- lib/rails_semantic_logger/delayed_job/plugin.rb
 - lib/rails_semantic_logger/engine.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_model_serializers/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/active_support/logger.rb
+- lib/rails_semantic_logger/extensions/active_support/tagged_logging.rb
+- lib/rails_semantic_logger/extensions/mongoid/config.rb
+- lib/rails_semantic_logger/extensions/rack/server.rb
 - lib/rails_semantic_logger/extensions/rails/server.rb
+- lib/rails_semantic_logger/options.rb
+- lib/rails_semantic_logger/rack/logger.rb
 - lib/rails_semantic_logger/version.rb
-homepage: https://github.com/rocketjob/rails_semantic_logger
+homepage: https://logger.rocketjob.io
 licenses:
 - Apache-2.0
-metadata: {}
-post_install_message: 
+metadata:
+  bug_tracker_uri: https://github.com/reidmorrison/rails_semantic_logger/issues
+  documentation_uri: https://logger.rocketjob.io
+  source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/4.12.0
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -76,16 +99,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
-signing_key: 
+rubygems_version: 3.4.9
+signing_key:
 specification_version: 4
-summary: Scalable, next generation enterprise logging for Rails
+summary: Feature rich logging framework that replaces the Rails logger.
 test_files: []