rails_semantic_logger 4.1.3 → 4.4.1

data/lib/rails_semantic_logger/engine.rb

@@ -1,3 +1,6 @@
+require 'action_controller/log_subscriber'
+require 'rails_semantic_logger/options'
+
 module RailsSemanticLogger
   class Engine < ::Rails::Engine
     # Make the SemanticLogger config available in the Rails application config
@@ -16,92 +19,7 @@ module RailsSemanticLogger
     #   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}
-
-    # 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::File.new(io: STDOUT, level: :warn)
-    config.rails_semantic_logger.add_file_appender = true
-
-    # Silence asset logging
-    config.rails_semantic_logger.quiet_assets      = 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
-
-    # DEPRECATED
-    # Instead, supply a Hash to config.log_tags
-    config.rails_semantic_logger.named_tags        = nil
-
-    # 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
+    config.rails_semantic_logger = RailsSemanticLogger::Options.new
 
     # Initialize SemanticLogger. In a Rails environment it will automatically
     # insert itself above the configured rails logger to add support for its
@@ -111,14 +29,18 @@ module RailsSemanticLogger
     Rails::Application::Bootstrap.initializers.delete_if { |i| i.name == :initialize_logger }
 
     initializer :initialize_logger, group: :all do
-      config                       = Rails.application.config
+      config = Rails.application.config
 
       # Set the default log level based on the Rails config
       SemanticLogger.default_level = config.log_level
 
+      if defined?(Rails::Rack::Logger) && config.rails_semantic_logger.semantic
+        config.middleware.swap(Rails::Rack::Logger, RailsSemanticLogger::Rack::Logger, config.log_tags)
+      end
+
       # 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
+      Rails.logger = config.logger = begin
         if config.rails_semantic_logger.add_file_appender
           path = config.paths['log'].first
           FileUtils.mkdir_p(File.dirname(path)) unless File.exist?(File.dirname(path))
@@ -130,16 +52,16 @@ module RailsSemanticLogger
           formatter  = {color: {ap: ap_options}} if (formatter == :default) && (config.colorize_logging != false)
 
           # Set internal logger to log to file only, in case another appender experiences errors during writes
-          appender                         = SemanticLogger::Appender::File.new(file_name: path, level: config.log_level, formatter: formatter)
+          appender = SemanticLogger::Appender::File.new(
+            file_name: path,
+            level:     config.log_level,
+            formatter: formatter
+          )
           appender.name                    = 'SemanticLogger'
           SemanticLogger::Processor.logger = appender
 
           # Check for previous file or stdout loggers
-          if SemanticLogger::VERSION.to_f >= 4.2
-            SemanticLogger.appenders.each { |appender| appender.formatter = formatter if appender.is_a?(SemanticLogger::Appender::File) }
-          elsif config.colorize_logging == false
-            SemanticLogger.appenders.each { |appender| appender.formatter = SemanticLogger::Formatters::Default.new if appender.is_a?(SemanticLogger::Appender::File) }
-          end
+          SemanticLogger.appenders.each { |app| app.formatter = formatter if app.is_a?(SemanticLogger::Appender::File) }
           SemanticLogger.add_appender(file_name: path, formatter: formatter, filter: config.rails_semantic_logger.filter)
         end
 
@@ -153,54 +75,29 @@ module RailsSemanticLogger
 
         logger = SemanticLogger[Rails]
         logger.warn(
-          "Rails Error: Unable to access log file. Please ensure that #{path} exists and is chmod 0666. " +
-            "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed.",
+          "Rails Error: Unable to access log file. Please ensure that #{path} exists and is chmod 0666. " \
+            'The log level has been raised to WARN and the output directed to STDERR until the problem is fixed.',
           exc
         )
         logger
       end
 
       # Replace Rails loggers
-      [:active_record, :action_controller, :action_mailer, :action_view].each do |name|
+      %i[active_record action_controller action_mailer action_view].each do |name|
         ActiveSupport.on_load(name) { include SemanticLogger::Loggable }
       end
       ActiveSupport.on_load(:action_cable) { self.logger = SemanticLogger['ActionCable'] }
     end
 
-    # Support fork frameworks
-    config.after_initialize do
-      # Silence asset logging by applying a filter to the Rails logger itself, not any of the appenders.
-      if config.rails_semantic_logger.quiet_assets && config.assets.prefix #&& defined?(Rails::Rack::Logger)
-        assets_regex = %r(\A/{0,2}#{config.assets.prefix})
-        if Rails.version.to_i >= 5
-          Rails::Rack::Logger.logger.filter = -> log { log.payload[:path] !~ assets_regex if log.payload }
-        else
-          # Also strips the empty log lines
-          Rails::Rack::Logger.logger.filter = -> log { log.payload.nil? ? (log.message != '') : (log.payload[:path] !~ assets_regex) }
-        end
-      end
-
-      # Passenger provides the :starting_worker_process event for executing
-      # code after it has forked, so we use that and reconnect immediately.
-      if defined?(PhusionPassenger)
-        PhusionPassenger.on_event(:starting_worker_process) do |forked|
-          ::SemanticLogger.reopen if forked
-        end
-      end
-
-      # Re-open appenders after Resque has forked a worker
-      if defined?(Resque)
-        Resque.after_fork { |job| ::SemanticLogger.reopen }
-      end
+    # Before any initializers run, but after the gems have been loaded
+    config.before_initialize do
+      if config.respond_to?(:assets) && defined?(Rails::Rack::Logger) && config.rails_semantic_logger.semantic
+        config.rails_semantic_logger.quiet_assets = true if config.assets.quiet
 
-      # Re-open appenders after Spring has forked a process
-      if defined?(Spring)
-        Spring.after_fork { |job| ::SemanticLogger.reopen }
+        # Otherwise Sprockets can't find the Rails::Rack::Logger middleware
+        config.assets.quiet = false
       end
-    end
 
-    # Before any initializers run, but after the gems have been loaded
-    config.before_initialize do
       # Replace the Mongo Loggers
       Mongoid.logger          = SemanticLogger[Mongoid] if defined?(Mongoid)
       Moped.logger            = SemanticLogger[Moped] if defined?(Moped)
@@ -215,11 +112,20 @@ module RailsSemanticLogger
       # Replace the Sidetiq logger
       Sidetiq.logger          = SemanticLogger[Sidetiq] if defined?(Sidetiq)
 
+      # Replace the DelayedJob logger
+      if defined?(Delayed::Worker)
+        Delayed::Worker.logger = SemanticLogger[Delayed::Worker]
+        Delayed::Worker.plugins << RailsSemanticLogger::DelayedJob::Plugin
+      end
+
       # Replace the Bugsnag logger
       Bugsnag.configure { |config| config.logger = SemanticLogger[Bugsnag] } if defined?(Bugsnag)
+    end
 
-      # Set the logger for concurrent-ruby
-      Concurrent.global_logger = SemanticLogger[Concurrent] if defined?(Concurrent)
+    # After 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)
 
       # Rails Patches
       require('rails_semantic_logger/extensions/action_cable/tagged_logger_proxy') if defined?(ActionCable)
@@ -230,34 +136,59 @@ module RailsSemanticLogger
       require('rails_semantic_logger/extensions/active_model_serializers/logging') if defined?(ActiveModelSerializers)
 
       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)
-        require('rails_semantic_logger/extensions/active_record/log_subscriber') if defined?(ActiveRecord::LogSubscriber)
-      end
+        # Active Record
+        if defined?(::ActiveRecord)
+          require 'active_record/log_subscriber'
+
+          RailsSemanticLogger.swap_subscriber(
+            ::ActiveRecord::LogSubscriber,
+            RailsSemanticLogger::ActiveRecord::LogSubscriber,
+            :active_record
+          )
+        end
 
-      unless config.rails_semantic_logger.started
-        require('rails_semantic_logger/extensions/rails/rack/logger_info_as_debug') if defined?(Rails::Rack::Logger)
-      end
+        # Rack
+        RailsSemanticLogger::Rack::Logger.started_request_log_level = :info if config.rails_semantic_logger.started
 
-      unless config.rails_semantic_logger.rendered
-        require('rails_semantic_logger/extensions/action_view/log_subscriber') if defined?(ActionView::LogSubscriber)
-      end
+        # Silence asset logging by applying a filter to the Rails logger itself, not any of the appenders.
+        if config.rails_semantic_logger.quiet_assets && config.assets.prefix
+          assets_regex                                    = %r(\A/{0,2}#{config.assets.prefix})
+          RailsSemanticLogger::Rack::Logger.logger.filter = ->(log) { log.payload[:path] !~ assets_regex if log.payload }
+        end
 
-      if config.rails_semantic_logger.processing
-        require('rails_semantic_logger/extensions/action_controller/log_subscriber_processing') if defined?(ActionView::LogSubscriber)
+        # Action View
+        RailsSemanticLogger::ActionView::LogSubscriber.rendered_log_level = :info if config.rails_semantic_logger.rendered
+        RailsSemanticLogger.swap_subscriber(
+          ::ActionView::LogSubscriber,
+          RailsSemanticLogger::ActionView::LogSubscriber,
+          :action_view
+        )
+
+        # Action Controller
+        RailsSemanticLogger.swap_subscriber(
+          ::ActionController::LogSubscriber,
+          RailsSemanticLogger::ActionController::LogSubscriber,
+          :action_controller
+        )
       end
 
-      # Backward compatibility
-      if config.rails_semantic_logger.named_tags
-        config.log_tags = config.rails_semantic_logger.named_tags
+      #
+      # Forking Frameworks
+      #
+
+      # Passenger provides the :starting_worker_process event for executing
+      # code after it has forked, so we use that and reconnect immediately.
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          SemanticLogger.reopen if forked
+        end
       end
-    end
 
-    # After 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
+      # Re-open appenders after Resque has forked a worker
+      Resque.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Resque)
 
+      # Re-open appenders after Spring has forked a process
+      Spring.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Spring)
+    end
   end
 end

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

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

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

@@ -1,11 +1,13 @@
 # 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)
+module ActionDispatch
+  class DebugExceptions
+    private
+
+    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,14 @@
 # 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)
+module ActionView
+  class StreamingTemplateRenderer
+    class Body
+      private
+
+      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,135 @@
 # Patch ActiveJob logger
 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
+
+    def tag_logger(*tags, &block)
+      logger.tagged(*tags, &block)
+    end
+
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def enqueue(event)
+        log_with_formatter event: event do |fmt|
+          "Enqueued #{fmt.job_info}"
+        end
+      end
+
+      def enqueue_at(event)
+        log_with_formatter event: event do |fmt|
+          "Enqueued #{fmt.job_info} at #{fmt.scheduled_at}"
+        end
+      end
+
+      def perform_start(event)
+        log_with_formatter event: event do |fmt|
+          "Performing #{fmt.job_info}"
+        end
+      end
+
+      def perform(event)
+        ex = event.payload[:exception_object]
+        if ex
+          logger.error ex
+        else
+          log_with_formatter event: event, log_duration: true do |fmt|
+            "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
+          JSON.pretty_generate(job.arguments.map { |arg| format(arg) })
+        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(**kw_args)
+        fmt = EventFormatter.new(**kw_args)
+        msg = yield fmt
+        logger.info msg, fmt.payload
+      end
+
+      def logger
+        ActiveJob::Base.logger
+      end
+    end
   end
 end
+
+if defined?(ActiveSupport::Notifications)
+  ActiveSupport::Notifications.unsubscribe('perform_start.active_job')
+  ActiveSupport::Notifications.unsubscribe('perform.active_job')
+  ActiveSupport::Notifications.unsubscribe('enqueue_at.active_job')
+  ActiveSupport::Notifications.unsubscribe('enqueue.active_job')
+
+  ActiveJob::Logging::LogSubscriber.attach_to :active_job
+end

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

@@ -1,15 +1,18 @@
 # Patch ActiveModelSerializers logger
 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/rails/server.rb

@@ -1,7 +1,7 @@
 # Patch the Rails::Server log_to_stdout so that it logs via SemanticLogger
 Rails::Server
-module Rails #:nodoc:
-  class Server #:nodoc:
+module Rails
+  class Server
     private
 
     def log_to_stdout

data/lib/rails_semantic_logger/options.rb

@@ -0,0 +1,117 @@
+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::File.new(io: STDOUT, level: :warn)
+  #
+  #       config.rails_semantic_logger.add_file_appender = true
+  #
+  # * Silence asset logging
+  #
+  #     config.rails_semantic_logger.quiet_assets = 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
+
+    # 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
+    end
+  end
+end